diff --git a/config/docusaurus/i18n.js b/config/docusaurus/i18n.js
index 2cef5f905..6ff7baf75 100644
--- a/config/docusaurus/i18n.js
+++ b/config/docusaurus/i18n.js
@@ -3,7 +3,7 @@ const { DEFAULT_LOCALE } = require("./consts");
/** @type {import('@docusaurus/types').DocusaurusConfig["i18n"]} */
const i18n = {
defaultLocale: DEFAULT_LOCALE,
- locales: ["ru", "en", "uz", "kr", "ja"],
+ locales: ["ru", "en", "uz", "kr", "ja", "zh"],
localeConfigs: {
ru: {
label: "Русский",
@@ -20,6 +20,9 @@ const i18n = {
ja: {
label: "日本語",
},
+ zh: {
+ label: "中文",
+ },
},
};
diff --git a/i18n/zh/code.json b/i18n/zh/code.json
new file mode 100644
index 000000000..26fdb6399
--- /dev/null
+++ b/i18n/zh/code.json
@@ -0,0 +1,386 @@
+{
+ "pages.home.features.title": {
+ "message": "特性",
+ "description": "Features"
+ },
+ "pages.home.features.logic.title": {
+ "message": "明确的业务逻辑",
+ "description": "Feature title"
+ },
+ "pages.home.features.logic.description": {
+ "message": "通过领域范围实现易于发现的架构",
+ "description": "Feature description"
+ },
+ "pages.home.features.adaptability.title": {
+ "message": "适应性",
+ "description": "Feature title"
+ },
+ "pages.home.features.adaptability.description": {
+ "message": "架构组件可以灵活地替换和添加以满足新需求",
+ "description": "Feature description"
+ },
+ "pages.home.features.debt.title": {
+ "message": "技术债务与重构",
+ "description": "Feature title"
+ },
+ "pages.home.features.debt.description": {
+ "message": "每个模块都可以独立修改/重写而不产生副作用",
+ "description": "Feature description"
+ },
+ "pages.home.features.shared.title": {
+ "message": "明确的代码复用",
+ "description": "Feature title"
+ },
+ "pages.home.features.shared.description": {
+ "message": "在 DRY 原则和本地定制之间保持平衡",
+ "description": "Feature description"
+ },
+ "pages.home.concepts.title": {
+ "message": "概念",
+ "description": "Concepts"
+ },
+ "pages.home.concepts.public.title": {
+ "message": "公共 API",
+ "description": "Concept title"
+ },
+ "pages.home.concepts.public.description": {
+ "message": "每个模块必须在顶层声明其公共 API",
+ "description": "Concept description"
+ },
+ "pages.home.concepts.isolation.title": {
+ "message": "隔离",
+ "description": "Concept title"
+ },
+ "pages.home.concepts.isolation.description": {
+ "message": "模块不应直接依赖于同一层级或上层的其他模块",
+ "description": "Concept description"
+ },
+ "pages.home.concepts.needs.title": {
+ "message": "需求驱动",
+ "description": "Concept title"
+ },
+ "pages.home.concepts.needs.description": {
+ "message": "面向业务和用户需求",
+ "description": "Concept description"
+ },
+ "pages.home.scheme.title": {
+ "message": "架构图",
+ "description": "Scheme"
+ },
+ "pages.home.companies.using": {
+ "message": "使用 FSD 的公司",
+ "description": "Companies using FSD"
+ },
+ "pages.home.companies.add_me": {
+ "message": "您的公司正在使用 FSD?",
+ "description": "FSD is used in your company?"
+ },
+ "pages.home.companies.tell_us": {
+ "message": "告诉我们",
+ "description": "Tell us"
+ },
+ "pages.examples.title": {
+ "message": "示例",
+ "description": "Page title"
+ },
+ "pages.examples.subtitle": {
+ "message": "使用 Feature-Sliced Design 构建的网站列表",
+ "description": "Page subtitle"
+ },
+ "pages.versions.title": {
+ "message": "Feature-Sliced Design 版本",
+ "description": "Feature-Sliced Design versions"
+ },
+ "pages.versions.current": {
+ "message": "当前已发布版本的文档可以在这里找到",
+ "description": "Description for current version"
+ },
+ "pages.versions.legacy": {
+ "message": "{of} 旧版本的文档可以在这里找到",
+ "description": "Description for legacy version"
+ },
+ "pages.nav.title": {
+ "message": "🧭 导航",
+ "description": "NavPage title"
+ },
+ "pages.nav.legacy.title": {
+ "message": "旧版路由",
+ "description": "NavPage section=legacy title"
+ },
+ "pages.nav.legacy.details": {
+ "message": "在文档重构后,一些路由已经更改。下面您可以找到可能正在寻找的页面。",
+ "description": "NavPage section=legacy details"
+ },
+ "pages.nav.legacy.subdetails": {
+ "message": "但为了兼容性,旧链接会有重定向",
+ "description": "NavPage section=legacy subdetails"
+ },
+ "features.feedback-badge.label": {
+ "message": "分享您对文档的反馈 🤙",
+ "description": "Feedback share button label"
+ },
+ "features.feedback-badge.url": {
+ "message": "https://forms.gle/nsYua6bMMG5iBB3v7",
+ "description": "Feedback share form url"
+ },
+ "features.feedback-doc.button-text": {
+ "message": "反馈",
+ "description": "The text on a floating button to leave feedback about the docs"
+ },
+ "features.feedback-doc.email-placeholder": {
+ "message": "您的邮箱(可选)",
+ "description": "The placeholder for email input"
+ },
+ "features.feedback-doc.error-message": {
+ "message": "出了点问题。请稍后再试。",
+ "description": "The error message displayed when feedback form submission fails"
+ },
+ "features.feedback-doc.modal-title-error-403": {
+ "message": "请求 URL 与该项目在 PushFeedback 中定义的 URL 不匹配。",
+ "description": "The title of the modal displayed when feedback form submission fails with 403 error"
+ },
+ "features.feedback-doc.modal-title-error-404": {
+ "message": "我们在 PushFeedback 中找不到提供的项目 ID。",
+ "description": "The title of the modal displayed when feedback form submission fails with 404 error"
+ },
+ "features.feedback-doc.message-placeholder": {
+ "message": "评论",
+ "description": "The placeholder for message input"
+ },
+ "features.feedback-doc.modal-title": {
+ "message": "分享您的反馈",
+ "description": "The title of the modal to leave feedback about the docs"
+ },
+ "features.feedback-doc.modal-title-error": {
+ "message": "糟糕!",
+ "description": "The title of the modal displayed when feedback form submission fails"
+ },
+ "features.feedback-doc.modal-title-success": {
+ "message": "感谢您的反馈!",
+ "description": "The title of the modal displayed when feedback form submission succeeds"
+ },
+ "features.feedback-doc.screenshot-button-text": {
+ "message": "截图",
+ "description": "The text on a button to take a screenshot"
+ },
+ "features.feedback-doc.screenshot-topbar-text": {
+ "message": "选择页面上的一个元素",
+ "description": "The text displayed in the top bar when selecting an element to take a screenshot"
+ },
+ "features.feedback-doc.send-button-text": {
+ "message": "发送",
+ "description": "The text on a button to send feedback"
+ },
+ "features.feedback-doc.rating-placeholder": {
+ "message": "这个页面有帮助吗?",
+ "description": "The placeholder for rating input"
+ },
+ "features.feedback-doc.rating-stars-placeholder": {
+ "message": "您如何评价这个页面",
+ "description": "The placeholder for rating stars input"
+ },
+ "features.hero.tagline": {
+ "message": "前端项目的架构方法论",
+ "description": "Architectural methodology for frontend projects"
+ },
+ "features.hero.get_started": {
+ "message": "开始使用",
+ "description": "Get Started"
+ },
+ "features.hero.examples": {
+ "message": "示例",
+ "description": "Examples"
+ },
+ "features.hero.previous": {
+ "message": "旧版本",
+ "description": "Previous version"
+ },
+ "shared.wip.title": {
+ "message": "文章正在编写中",
+ "description": "Admonition title"
+ },
+ "shared.wip.subtitle": {
+ "message": "为了使文章更快发布,您可以:",
+ "description": "Admonition subtitle"
+ },
+ "shared.wip.var.feedback.base": {
+ "message": "📢 分享您的反馈",
+ "description": "Variant for contribute (base)"
+ },
+ "shared.wip.var.feedback.link": {
+ "message": "在文章中(评论/表情反应)",
+ "description": "Variant for contribute (link)"
+ },
+ "shared.wip.var.material.base": {
+ "message": "💬 收集相关的",
+ "description": "Variant for contribute (base)"
+ },
+ "shared.wip.var.material.link": {
+ "message": "来自聊天的主题相关资料",
+ "description": "Variant for contribute (link)"
+ },
+ "shared.wip.var.contribute.base": {
+ "message": "⚒️ 贡献",
+ "description": "Variant for contribute (base)"
+ },
+ "shared.wip.var.contribute.link": {
+ "message": "以任何其他方式",
+ "description": "Variant for contribute (link)"
+ },
+ "theme.NotFound.title": {
+ "message": "页面未找到",
+ "description": "The title of the 404 page"
+ },
+ "theme.NotFound.p1": {
+ "message": "我们找不到您要查找的内容。",
+ "description": "The first paragraph of the 404 page"
+ },
+ "theme.NotFound.p2": {
+ "message": "请联系链接到原始 URL 的网站所有者,告知他们链接已损坏。",
+ "description": "The 2nd paragraph of the 404 page"
+ },
+ "theme.AnnouncementBar.closeButtonAriaLabel": {
+ "message": "关闭",
+ "description": "The ARIA label for close button of announcement bar"
+ },
+ "theme.blog.paginator.navAriaLabel": {
+ "message": "博客列表页面导航",
+ "description": "The ARIA label for the blog pagination"
+ },
+ "theme.blog.paginator.newerEntries": {
+ "message": "较新的条目",
+ "description": "The label used to navigate to the newer blog posts page (previous page)"
+ },
+ "theme.blog.paginator.olderEntries": {
+ "message": "较旧的条目",
+ "description": "The label used to navigate to the older blog posts page (next page)"
+ },
+ "theme.blog.post.readingTime.plurals": {
+ "message": "阅读时间 1 分钟|阅读时间 {readingTime} 分钟",
+ "description": "Pluralized label for \"{readingTime} min read\". Use as much plural forms (separated by \"|\") as your language support (see https://www.unicode.org/cldr/cldr-aux/charts/34/supplemental/language_plural_rules.html)"
+ },
+ "theme.tags.tagsListLabel": {
+ "message": "标签:",
+ "description": "The label alongside a tag list"
+ },
+ "theme.blog.post.readMore": {
+ "message": "阅读更多",
+ "description": "The label used in blog post item excerpts to link to full blog posts"
+ },
+ "theme.blog.post.paginator.navAriaLabel": {
+ "message": "博客文章页面导航",
+ "description": "The ARIA label for the blog posts pagination"
+ },
+ "theme.blog.post.paginator.newerPost": {
+ "message": "较新的文章",
+ "description": "The blog post button label to navigate to the newer/previous post"
+ },
+ "theme.blog.post.paginator.olderPost": {
+ "message": "较旧的文章",
+ "description": "The blog post button label to navigate to the older/next post"
+ },
+ "theme.tags.tagsPageTitle": {
+ "message": "标签",
+ "description": "The title of the tag list page"
+ },
+ "theme.blog.post.plurals": {
+ "message": "1 篇文章|{count} 篇文章",
+ "description": "Pluralized label for \"{count} posts\". Use as much plural forms (separated by \"|\") as your language support (see https://www.unicode.org/cldr/cldr-aux/charts/34/supplemental/language_plural_rules.html)"
+ },
+ "theme.blog.tagTitle": {
+ "message": "{nPosts} 篇标记为 \"{tagName}\" 的文章",
+ "description": "The title of the page for a blog tag"
+ },
+ "theme.tags.tagsPageLink": {
+ "message": "查看所有标签",
+ "description": "The label of the link targeting the tag list page"
+ },
+ "theme.CodeBlock.copyButtonAriaLabel": {
+ "message": "复制代码到剪贴板",
+ "description": "The ARIA label for copy code blocks button"
+ },
+ "theme.CodeBlock.copied": {
+ "message": "已复制",
+ "description": "The copied button label on code blocks"
+ },
+ "theme.CodeBlock.copy": {
+ "message": "复制",
+ "description": "The copy button label on code blocks"
+ },
+ "theme.docs.sidebar.expandButtonTitle": {
+ "message": "展开侧边栏",
+ "description": "The ARIA label and title attribute for expand button of doc sidebar"
+ },
+ "theme.docs.sidebar.expandButtonAriaLabel": {
+ "message": "展开侧边栏",
+ "description": "The ARIA label and title attribute for expand button of doc sidebar"
+ },
+ "theme.docs.paginator.navAriaLabel": {
+ "message": "文档页面导航",
+ "description": "The ARIA label for the docs pagination"
+ },
+ "theme.docs.paginator.previous": {
+ "message": "上一页",
+ "description": "The label used to navigate to the previous doc"
+ },
+ "theme.docs.paginator.next": {
+ "message": "下一页",
+ "description": "The label used to navigate to the next doc"
+ },
+ "theme.docs.sidebar.collapseButtonTitle": {
+ "message": "收起侧边栏",
+ "description": "The title attribute for collapse button of doc sidebar"
+ },
+ "theme.docs.sidebar.collapseButtonAriaLabel": {
+ "message": "收起侧边栏",
+ "description": "The title attribute for collapse button of doc sidebar"
+ },
+ "theme.docs.sidebar.responsiveCloseButtonLabel": {
+ "message": "关闭菜单",
+ "description": "The ARIA label for close button of mobile doc sidebar"
+ },
+ "theme.docs.sidebar.responsiveOpenButtonLabel": {
+ "message": "打开菜单",
+ "description": "The ARIA label for open button of mobile doc sidebar"
+ },
+ "theme.docs.versions.unreleasedVersionLabel": {
+ "message": "这是 {siteTitle} {versionLabel} 版本的未发布文档。",
+ "description": "The label used to tell the user that he's browsing an unreleased doc version"
+ },
+ "theme.docs.versions.unmaintainedVersionLabel": {
+ "message": "这是 {siteTitle} {versionLabel} 的文档,该版本不再积极维护。",
+ "description": "The label used to tell the user that he's browsing an unmaintained doc version"
+ },
+ "theme.docs.versions.latestVersionSuggestionLabel": {
+ "message": "如需最新文档,请参阅 {latestVersionLink}({versionLabel})。",
+ "description": "The label userd to tell the user that he's browsing an unmaintained doc version"
+ },
+ "theme.docs.versions.latestVersionLinkLabel": {
+ "message": "最新版本",
+ "description": "The label used for the latest version suggestion link label"
+ },
+ "theme.common.editThisPage": {
+ "message": "编辑此页面",
+ "description": "The link label to edit the current page"
+ },
+ "theme.common.headingLinkTitle": {
+ "message": "标题的直接链接",
+ "description": "Title for link to heading"
+ },
+ "theme.lastUpdated.atDate": {
+ "message": " 于 {date}",
+ "description": "The words used to describe on which date a page has been last updated"
+ },
+ "theme.lastUpdated.byUser": {
+ "message": " 由 {user}",
+ "description": "The words used to describe by who the page has been last updated"
+ },
+ "theme.lastUpdated.lastUpdatedAtBy": {
+ "message": "最后更新{atDate}{byUser}",
+ "description": "The sentence used to display when a page has been last updated, and by who"
+ },
+ "theme.common.skipToMainContent": {
+ "message": "跳转到主要内容",
+ "description": "The skip to content label used for accessibility, allowing to rapidly navigate to main content with keyboard tab/enter navigation"
+ }
+}
diff --git a/i18n/zh/docusaurus-plugin-content-docs/community/index.mdx b/i18n/zh/docusaurus-plugin-content-docs/community/index.mdx
new file mode 100644
index 000000000..cc2989ead
--- /dev/null
+++ b/i18n/zh/docusaurus-plugin-content-docs/community/index.mdx
@@ -0,0 +1,40 @@
+---
+hide_table_of_contents: true
+---
+
+# 💫 社区
+
+
+社区资源,补充材料
+
+
+## 主要资源
+
+import NavCard from "@site/src/shared/ui/nav-card/tmpl.mdx"
+import { StarOutlined, SearchOutlined, TeamOutlined, VerifiedOutlined } from "@ant-design/icons";
+
+
+
+
+
diff --git a/i18n/zh/docusaurus-plugin-content-docs/community/team.mdx b/i18n/zh/docusaurus-plugin-content-docs/community/team.mdx
new file mode 100644
index 000000000..12fce9675
--- /dev/null
+++ b/i18n/zh/docusaurus-plugin-content-docs/community/team.mdx
@@ -0,0 +1,18 @@
+---
+sidebar_class_name: sidebar-item--wip
+sidebar_position: 2
+---
+
+import WIP from '@site/src/shared/ui/wip/tmpl.mdx'
+
+# 团队
+
+
+
+## 核心团队
+
+### 倡导者
+
+## 贡献者
+
+## 公司
diff --git a/i18n/zh/docusaurus-plugin-content-docs/current.json b/i18n/zh/docusaurus-plugin-content-docs/current.json
new file mode 100644
index 000000000..a33a0a94c
--- /dev/null
+++ b/i18n/zh/docusaurus-plugin-content-docs/current.json
@@ -0,0 +1,38 @@
+{
+ "version.label": {
+ "message": "v2.1",
+ "description": "The label for version current"
+ },
+ "sidebar.getstartedSidebar.category.Tutorials": {
+ "message": "教程",
+ "description": "The label for category Tutorials in sidebar getstartedSidebar"
+ },
+ "sidebar.aboutSidebar.category.Alternatives": {
+ "message": "替代方案",
+ "description": "The label for category Alternatives in sidebar aboutSidebar"
+ },
+ "sidebar.aboutSidebar.category.Promote": {
+ "message": "推广",
+ "description": "The label for category Promote in sidebar aboutSidebar"
+ },
+ "sidebar.guidesSidebar.category.Examples": {
+ "message": "示例",
+ "description": "The label for category Examples in sidebar guidesSidebar"
+ },
+ "sidebar.guidesSidebar.category.Migration": {
+ "message": "迁移",
+ "description": "The label for category Migration in sidebar guidesSidebar"
+ },
+ "sidebar.guidesSidebar.category.Tech": {
+ "message": "技术",
+ "description": "The label for category Tech in sidebar guidesSidebar"
+ },
+ "sidebar.conceptsSidebar.category.Issues": {
+ "message": "问题",
+ "description": "The label for category Issues in sidebar conceptsSidebar"
+ },
+ "sidebar.referenceSidebar.category.Layer": {
+ "message": "层",
+ "description": "The label for category Layer in sidebar referenceSidebar"
+ }
+}
diff --git a/i18n/zh/docusaurus-plugin-content-docs/current/about/alternatives.mdx b/i18n/zh/docusaurus-plugin-content-docs/current/about/alternatives.mdx
new file mode 100644
index 000000000..558d36f15
--- /dev/null
+++ b/i18n/zh/docusaurus-plugin-content-docs/current/about/alternatives.mdx
@@ -0,0 +1,153 @@
+---
+sidebar_class_name: sidebar-item--wip
+sidebar_position: 3
+---
+
+import WIP from '@site/src/shared/ui/wip/tmpl.mdx'
+
+# Alternatives
+
+
+
+History of architecture approaches
+
+## Big Ball of Mud
+
+
+
+> What is it; Why is it so common; When it starts to bring problems; What to do and how does FSD help in this
+
+- [(Article) Oleg Isonen - Last words on UI architecture before an AI takes over](https://oleg008.medium.com/last-words-on-ui-architecture-before-an-ai-takes-over-468c78f18f0d)
+- [(Report) Julia Nikolaeva, iSpring - Big Ball of Mud and other problems of the monolith, we have handled](http://youtu.be/gna4Ynz1YNI)
+- [(Article) DD - Big Ball of mud](https://thedomaindrivendesign.io/big-ball-of-mud/)
+
+
+## Smart & Dumb components
+
+
+
+> About the approach; About applicability in the frontend; Methodology position
+
+About obsolescence, about a new view from the methodology
+
+Why component-containers approach is evil?
+
+- [(Article) Den Abramov-Presentation and Container Components (TLDR: deprecated)](https://medium.com/@dan_abramov/smart-and-dumb-components-7ca2f9a7c7d0)
+
+
+## Design Principles
+
+
+
+> What are we talking about; FSD position
+
+SOLID, GRASP, KISS, YAGNI, ... - and why they don't work well together in practice
+
+And how does it aggregate these practices
+
+- [(Talk) Ilya Azin - Feature-Sliced Design (fragment about Design Principles)](https://youtu.be/SnzPAr_FJ7w?t=380)
+
+
+## DDD
+
+
+
+> About the approach; Why does it work poorly in practice
+
+What is the difference, how does it improve applicability, where does it adopt practices
+
+- [(Article) DDD, Hexagonal, Onion, Clean, CQRS, ... How I put it all together](https://herbertograca.com/2017/11/16/explicit-architecture-01-ddd-hexagonal-onion-clean-cqrs-how-i-put-it-all-together/)
+- [(Talk) Ilya Azin - Feature-Sliced Design (fragment about Clean Architecture, DDD)](https://youtu.be/SnzPAr_FJ7w?t=528)
+
+
+## Clean Architecture
+
+
+
+> About the approach; About applicability in the frontend; FSD position
+
+How are they similar (to many), how are they different
+
+- [(Thread) About use-case/interactor in the methodology](https://t.me/feature_sliced/3897)
+- [(Thread) About DI in the methodology](https://t.me/feature_sliced/4592)
+- [(Article) Alex Bespoyasov - Clean Architecture on frontend](https://bespoyasov.me/blog/clean-architecture-on-frontend/)
+- [(Article) DDD, Hexagonal, Onion, Clean, CQRS, ... How I put it all together](https://herbertograca.com/2017/11/16/explicit-architecture-01-ddd-hexagonal-onion-clean-cqrs-how-i-put-it-all-together/)
+- [(Talk) Ilya Azin - Feature-Sliced Design (fragment about Clean Architecture, DDD)](https://youtu.be/SnzPAr_FJ7w?t=528)
+- [(Article) Misconceptions of Clean Architecture](http://habr.com/ru/company/mobileup/blog/335382/)
+
+
+## Frameworks
+
+
+
+> About applicability in the frontend; Why frameworks do not solve problems; why there is no single approach; FSD position
+
+Framework-agnostic, conventional-approach
+
+- [(Article) About the reasons for creating the methodology (fragment about frameworks)](/docs/about/motivation)
+- [(Thread) About the applicability of the methodology for different frameworks](https://t.me/feature_sliced/3867)
+
+
+## Atomic Design
+
+### What is it?
+In Atomic Design, the scope of responsibility is divided into standardized layers.
+
+Atomic Design is broken down into **5 layers** (from top to bottom):
+
+1. `pages` - Functionality similar to the `pages` layer in FSD.
+2. `templates` - Components that define the structure of a page without tying to specific content.
+3. `organisms` - Modules consisting of molecules that have business logic.
+4. `molecules` - More complex components that generally do not contain business logic.
+5. `atoms` - UI components without business logic.
+
+Modules at one layer interact only with modules in the layers below, similar to FSD.
+That is, molecules are built from atoms, organisms from molecules, templates from organisms, and pages from templates.
+Atomic Design also implies the use of Public API within modules for isolation.
+
+### Applicability to frontend
+
+Atomic Design is relatively common in projects. Atomic Design is more popular among web designers than in development.
+Web designers often use Atomic Design to create scalable and easily maintainable designs.
+In development, Atomic Design is often mixed with other architectural methodologies.
+
+However, since Atomic Design focuses on UI components and their composition, a problem arises with implementing
+business logic within the architecture.
+
+The problem is that Atomic Design does not provide a clear level of responsibility for business logic,
+leading to its distribution across various components and levels, complicating maintenance and testing.
+The business logic becomes blurred, making it difficult to clearly separate responsibilities and rendering
+the code less modular and reusable.
+
+### How does it relate to FSD?
+
+In the context of FSD, some elements of Atomic Design can be applied to create flexible and scalable UI components.
+The `atoms` and `molecules` layers can be implemented in `shared/ui` in FSD, simplifying the reuse and
+maintenance of basic UI elements.
+
+```
+├── shared
+│ ├── ui
+│ │ ├── atoms
+│ │ ├── molecules
+│ ...
+```
+A comparison of FSD and Atomic Design shows that both methodologies strive for modularity and reusability
+but focus on different aspects. Atomic Design is oriented towards visual components and their composition.
+FSD focuses on dividing the application's functionality into independent modules and their interconnections.
+
+- [Atomic Design Methodology](https://atomicdesign.bradfrost.com/table-of-contents/)
+- [(Thread) About applicability in shared / ui](https://t.me/feature_sliced/1653)
+- [(Video) Briefly about Atomic Design](https://youtu.be/Yi-A20x2dcA)
+- [(Talk) Ilya Azin - Feature-Sliced Design (fragment about Atomic Design)](https://youtu.be/SnzPAr_FJ7w?t=587)
+
+## Feature Driven
+
+
+
+> About the approach; About applicability in the frontend; FSD position
+
+About compatibility, historical development and comparison
+
+- [(Talk) Oleg Isonen - Feature Driven Architecture](https://youtu.be/BWAeYuWFHhs)
+- [Feature Driven-Short specification (from the point of view of FSD)](https://github.com/feature-sliced/documentation/tree/rc/feature-driven)
diff --git a/i18n/zh/docusaurus-plugin-content-docs/current/about/index.mdx b/i18n/zh/docusaurus-plugin-content-docs/current/about/index.mdx
new file mode 100644
index 000000000..0dd119a9b
--- /dev/null
+++ b/i18n/zh/docusaurus-plugin-content-docs/current/about/index.mdx
@@ -0,0 +1,44 @@
+---
+hide_table_of_contents: true
+pagination_prev: reference/index
+---
+
+# 🍰 关于
+
+背景导向
+
+
+关于方法论、团队、社区和开发历史的一般信息
+
+
+## Main
+
+import NavCard from "@site/src/shared/ui/nav-card/tmpl.mdx"
+import { StarOutlined, TrophyOutlined, BulbOutlined, TeamOutlined } from "@ant-design/icons";
+
+
+
+
+
diff --git a/i18n/zh/docusaurus-plugin-content-docs/current/about/mission.md b/i18n/zh/docusaurus-plugin-content-docs/current/about/mission.md
new file mode 100644
index 000000000..39bdec79d
--- /dev/null
+++ b/i18n/zh/docusaurus-plugin-content-docs/current/about/mission.md
@@ -0,0 +1,51 @@
+---
+sidebar_position: 1
+---
+
+# 使命
+
+在这里我们描述方法论适用性的目标和限制——这是我们在开发该方法论时所遵循的指导原则
+
+- 我们的目标是在理念和简单性之间取得平衡
+- 我们无法制造一个适合所有人的银弹
+
+**尽管如此,该方法论应该对相当广泛的开发者群体来说是亲近且可访问的**
+
+## 目标
+
+### 对广泛开发者的直观清晰度
+
+该方法论应该是可访问的 - 对于项目中的大部分团队成员
+
+*因为即使有了所有未来的工具,如果只有经验丰富的高级开发者/领导者才能理解该方法论,那也是不够的*
+
+### 解决日常问题
+
+该方法论应该阐述我们在开发项目时遇到的日常问题的原因和解决方案
+
+**并且还要为所有这些提供工具(cli、linters)**
+
+让开发者可以使用一种*经过实战检验*的方法,让他们能够绕过架构和开发中的长期问题
+
+> *@sergeysova: 想象一下,一个开发者在该方法论的框架内编写代码,他遇到问题的频率减少了10倍,仅仅因为其他人已经考虑并解决了许多问题。*
+
+## 限制
+
+我们不想*强加我们的观点*,同时我们理解*作为开发者,我们的许多习惯每天都在干扰我们*
+
+每个人在设计和开发系统方面都有自己的经验水平,**因此,值得理解以下几点:**
+
+- **不会起作用**:非常简单、非常清晰、适用于所有人
+ > *@sergeysova: 某些概念在你遇到问题并花费多年时间解决它们之前,是无法直观理解的。*
+ >
+ > - *在数学世界中:是图论。*
+ > - *在物理学中:量子力学。*
+ > - *在编程中:应用程序架构。*
+
+- **可能且期望的**:简单性、可扩展性
+
+## 参见
+
+- [架构问题][refs-architecture--problems]
+
+[refs-architecture--problems]: /docs/about/understanding/architecture#problems
diff --git a/i18n/zh/docusaurus-plugin-content-docs/current/about/motivation.md b/i18n/zh/docusaurus-plugin-content-docs/current/about/motivation.md
new file mode 100644
index 000000000..999836bc7
--- /dev/null
+++ b/i18n/zh/docusaurus-plugin-content-docs/current/about/motivation.md
@@ -0,0 +1,148 @@
+---
+sidebar_position: 2
+---
+
+# Motivation
+
+The main idea of **Feature-Sliced Design** is to facilitate and reduce the cost of developing complex and developing projects, based on [combining research results, discussing the experience of various kinds of a wide range of developers][ext-discussions].
+
+Obviously, this will not be a silver bullet, and of course, the methodology will have its own [limits of applicability][refs-mission].
+
+Nevertheless, there are reasonable questions regarding *the feasibility of such a methodology as a whole*
+
+:::note
+
+More details [discussed in the discussion][disc-src]
+
+:::
+
+## Why are there not enough existing solutions?
+
+> It usually, these arguments:
+>
+> - *"Why you need some new methodology, if you already have long-established approaches and principles of design such as `SOLID`, `KISS`, `YAGNI`, `DDD`, `GRASP`, `DRY`, etc."*
+> - *"All the problems are solved by good project documentation, tests, and structured processes"*
+> - *"Problems would not have happened if all developers are following all the above"*
+> - *"Everything was invented before you, you just can't use it"*
+> - *"Take \{FRAMEWORK_NAME\} - everything has already been decided for you there"*
+
+### Principles alone are not enough
+
+**The existence of principles alone is not enough to design a good architecture**
+
+Not everyone knows them completely, even fewer understand and apply them correctly
+
+*The design principles are too general, and do not give a specific answer to the question: "How to design the structure and architecture of a scalable and flexible application?"*
+
+### Processes don't always work
+
+*Documentation/Tests/Processes* are, of course, good, but alas, even at high costs for them - **they do not always solve the problems posed by the architecture and the introduction of new people into the project**
+
+- The time of entry of each developer into the project is not greatly reduced, because the documentation will most often come out huge / outdated
+- Constantly make sure that everyone understands architecture in the same way-it also requires a huge amount of resources
+- Do not forget about the bus-factor
+
+### Existing frameworks cannot be applied everywhere
+
+- Existing solutions usually have a high entry threshold, which makes it difficult to find new developers
+- Also, most often, the choice of technology has already been determined before the onset of serious problems in the project, and therefore you need to be able to "work with what is" - **without being tied to the technology**
+
+> Q: *"In my project `React/Vue/Redux/Effector/Mobx/{YOUR_TECH}` - how can I better build the structure of entities and the relationships between them?"*
+
+### As a result
+
+We get *"unique as snowflakes"* projects, each of which requires a long immersion of the employee, and knowledge that is unlikely to be applicable on another project
+
+> @sergeysova: *"This is exactly the situation that currently exists in our field of frontend development: each lead will invent different architectures and project structures, while it is not a fact that these structures will pass the test of time, as a result, a maximum of two people can develop the project besides him, and each new developer needs to be immersed again."*
+
+## Why do developers need the methodology?
+
+### Focus on business features, not on architecture problems
+
+The methodology allows you to save resources on designing a scalable and flexible architecture, instead directing the attention of developers to the development of the main functionality. At the same time, the architectural solutions themselves are standardized from project to project.
+
+*A separate question is that the methodology should earn the trust of the community, so that another developer can get acquainted with it and rely on it in solving the problems of his project within the time available to him*
+
+### An experience-proven solution
+
+The methodology is designed for developers who are aimed at *a proven solution for designing complex business logic*
+
+*However, it is clear that the methodology is generally about a set of best-practices, articles that address certain problems and cases during development. Therefore, the methodology will also be useful for the rest of the developers-who somehow face problems during development and design*
+
+### Project Health
+
+The methodology will allow *to solve and track the problems of the project in advance, without requiring a huge amount of resources*
+
+**Most often, technical debt accumulates and accumulates over time, and the responsibility for its resolution lies on both the lead and the team**
+
+The methodology will allow you to *warn* possible problems in the scaling and development of the project in advance
+
+## Why does a business need a methodology?
+
+### Fast onboarding
+
+With the methodology, you can hire a person to the project who **is already previously familiar with this approach, and not train again**
+
+*People start to understand and benefit the project faster, and there are additional guarantees to find people for the next iterations of the project*
+
+### An experience-proven solution
+
+With the methodology, the business will get *a solution for most of the issues that arise during the development of systems*
+
+Since most often a business wants to get a framework / solution that would solve the lion's share of problems during the development of the project
+
+### Applicability for different stages of the project
+
+The methodology can benefit the project *both at the stage of project support and development, and at the MVP stage*
+
+Yes, the most important thing for MVP is *"features, not the architecture laid down for the future"*. But even in conditions of limited deadlines, knowing the best-practices from the methodology, you can *"do with little blood"*, when designing the MVP version of the system, finding a reasonable compromise
+(rather than modeling features "at random")
+
+*The same can be said about testing*
+
+## When is our methodology not needed?
+
+- If the project will live for a short time
+- If the project does not need a supported architecture
+- If the business does not perceive the connection between the code base and the speed of feature delivery
+- If it is more important for the business to close orders as soon as possible, without further support
+
+### Business Size
+
+- **Small business** - most often needs a ready-made and very fast solution. Only when the business grows (at least to almost average), he understands that in order for customers to continue using, it is necessary, among other things, to devote time to the quality and stability of the solutions being developed
+- **Medium-sized business** - usually understands all the problems of development, and even if it is necessary to *"arrange a race for features"*, he still spends time on quality improvements, refactoring and tests (and of course-on an extensible architecture)
+- **Big business** - usually already has an extensive audience, staff, and a much more extensive set of its practices, and probably even its own approach to architecture, so the idea of taking someone else's comes to them not so often
+
+## Plans
+
+The main part of the goals [is set out here][refs-mission--goals], but in addition, it is worth talking about our expectations from the methodology in the future
+
+### Combining experience
+
+Now we are trying to combine all our diverse experience of the `core-team`, and get a methodology hardened by practice as a result
+
+Of course, we can get Angular 3.0 as a result, but it is much more important here to **investigate the very problem of designing the architecture of complex systems**
+
+*And yes - we have complaints about the current version of the methodology, but we want to work together to come to a single and optimal solution (taking into account, among other things, the experience of the community)*
+
+### Life outside the specification
+
+If everything goes well, then the methodology will not be limited only to the specification and the toolkit
+
+- Perhaps there will be reports, articles
+- There may be `CODE_MODEs` for migrations to other technologies of projects written according to the methodology
+- It is possible that as a result we will be able to reach the maintainers of large technological solutions
+ - *Especially for React, compared to other frameworks - this is the main problem, because it does not say how to solve certain problems*
+
+## See also
+
+- [(Discussion) Don't need a methodology?][disc-src]
+- [About the methodology's mission: goals and limitations][refs-mission]
+- [Types of knowledge in the project][refs-knowledge]
+
+[refs-mission]: /docs/about/mission
+[refs-mission--goals]: /docs/about/mission#goals
+[refs-knowledge]: /docs/about/understanding/knowledge-types
+
+[disc-src]: https://github.com/feature-sliced/documentation/discussions/27
+[ext-discussions]: https://github.com/feature-sliced/documentation/discussions
diff --git a/i18n/zh/docusaurus-plugin-content-docs/current/about/promote/_category_.yaml b/i18n/zh/docusaurus-plugin-content-docs/current/about/promote/_category_.yaml
new file mode 100644
index 000000000..ac0af8d34
--- /dev/null
+++ b/i18n/zh/docusaurus-plugin-content-docs/current/about/promote/_category_.yaml
@@ -0,0 +1,3 @@
+label: 推广
+position: 11
+collapsed: true
diff --git a/i18n/zh/docusaurus-plugin-content-docs/current/about/promote/for-company.mdx b/i18n/zh/docusaurus-plugin-content-docs/current/about/promote/for-company.mdx
new file mode 100644
index 000000000..caa383bdc
--- /dev/null
+++ b/i18n/zh/docusaurus-plugin-content-docs/current/about/promote/for-company.mdx
@@ -0,0 +1,18 @@
+---
+sidebar_position: 4
+sidebar_class_name: sidebar-item--wip
+---
+
+import WIP from '@site/src/shared/ui/wip/tmpl.mdx'
+
+# Promote in company
+
+
+
+## Do the project and the company need a methodology?
+
+> About the justification of the application, Those duty
+
+## How can I submit a methodology to a business?
+
+## How to prepare and justify a plan to move to the methodology?
\ No newline at end of file
diff --git a/i18n/zh/docusaurus-plugin-content-docs/current/about/promote/for-team.mdx b/i18n/zh/docusaurus-plugin-content-docs/current/about/promote/for-team.mdx
new file mode 100644
index 000000000..ee05767d4
--- /dev/null
+++ b/i18n/zh/docusaurus-plugin-content-docs/current/about/promote/for-team.mdx
@@ -0,0 +1,18 @@
+---
+sidebar_position: 3
+sidebar_class_name: sidebar-item--wip
+---
+
+import WIP from '@site/src/shared/ui/wip/tmpl.mdx'
+
+# 在团队中推广
+
+
+
+- 入职新成员
+- 开发指南("在哪里搜索 N 模块"等...)
+- 任务的新方法
+
+## 参见
+- [(线程) 旧方法的简单性和正念的重要性](https://t.me/feature_sliced/3360)
+- [(线程) 关于按 layers 搜索的便利性](https://t.me/feature_sliced/1918)
\ No newline at end of file
diff --git a/i18n/zh/docusaurus-plugin-content-docs/current/about/promote/integration.mdx b/i18n/zh/docusaurus-plugin-content-docs/current/about/promote/integration.mdx
new file mode 100644
index 000000000..45e9f44ea
--- /dev/null
+++ b/i18n/zh/docusaurus-plugin-content-docs/current/about/promote/integration.mdx
@@ -0,0 +1,25 @@
+---
+sidebar_position: 1
+---
+
+# 集成方面
+
+## 总结
+
+前 5 分钟(俄语):
+
+
+
+## 另外
+
+**优势:**
+- [概览](/docs/get-started/overview)
+- 代码审查
+- 入职
+
+
+**缺点:**
+- 心理复杂性
+- 高准入门槛
+- "Layers 地狱"
+- 基于 feature 方法的典型问题
diff --git a/i18n/zh/docusaurus-plugin-content-docs/current/about/promote/partial-application.mdx b/i18n/zh/docusaurus-plugin-content-docs/current/about/promote/partial-application.mdx
new file mode 100644
index 000000000..38a7b0136
--- /dev/null
+++ b/i18n/zh/docusaurus-plugin-content-docs/current/about/promote/partial-application.mdx
@@ -0,0 +1,12 @@
+---
+sidebar_position: 2
+sidebar_class_name: sidebar-item--wip
+---
+
+import WIP from '@site/src/shared/ui/wip/tmpl.mdx'
+
+# Partial Application
+
+
+
+> How to partially apply the methodology? Does it make sense? What if I ignore it?
diff --git a/i18n/zh/docusaurus-plugin-content-docs/current/about/understanding/_category_.yaml b/i18n/zh/docusaurus-plugin-content-docs/current/about/understanding/_category_.yaml
new file mode 100644
index 000000000..5690b49cf
--- /dev/null
+++ b/i18n/zh/docusaurus-plugin-content-docs/current/about/understanding/_category_.yaml
@@ -0,0 +1,2 @@
+label: 理解
+position: 3
diff --git a/i18n/zh/docusaurus-plugin-content-docs/current/about/understanding/abstractions.mdx b/i18n/zh/docusaurus-plugin-content-docs/current/about/understanding/abstractions.mdx
new file mode 100644
index 000000000..47e469143
--- /dev/null
+++ b/i18n/zh/docusaurus-plugin-content-docs/current/about/understanding/abstractions.mdx
@@ -0,0 +1,26 @@
+---
+sidebar_position: 6
+sidebar_class_name: sidebar-item--wip
+---
+
+import WIP from '@site/src/shared/ui/wip/tmpl.mdx'
+
+# Abstractions
+
+
+
+## The law of leaky abstractions
+
+## Why are there so many abstractions
+
+> Abstractions help to cope with the complexity of the project. The question is - will these abstractions be specific only for this project, or will we try to derive general abstractions based on the specifics of the frontend
+
+> Architecture and applications in general are inherently complex, and the only question is how to better distribute and describe this complexity
+
+## About scopes of responsibility
+
+> About optional abstractions
+
+## See also
+- [About the need for new layers](https://t.me/feature_sliced/2801)
+- [About the difficulty in understanding the methodology and layers](https://t.me/feature_sliced/2619)
diff --git a/i18n/zh/docusaurus-plugin-content-docs/current/about/understanding/architecture.md b/i18n/zh/docusaurus-plugin-content-docs/current/about/understanding/architecture.md
new file mode 100644
index 000000000..5e873c508
--- /dev/null
+++ b/i18n/zh/docusaurus-plugin-content-docs/current/about/understanding/architecture.md
@@ -0,0 +1,97 @@
+---
+sidebar_position: 1
+---
+
+# 关于架构
+
+## 问题
+
+通常,当由于项目中的某些问题导致开发停止时,就会提出关于架构的讨论。
+
+### Bus-factor 和入职
+
+只有有限的人数理解项目及其架构
+
+**示例:**
+
+- *"很难将一个人加入开发中"*
+- *"对于每个问题,每个人都有自己的解决方案意见"(让我们嫌妒 angular)*
+- *"我不理解这个大型单体块中发生了什么"*
+
+### 隐式和不可控制的后果
+
+开发/重构过程中有很多隐式的副作用 *("一切都依赖于一切")*
+
+**示例:**
+
+- *"feature 导入 feature"*
+- *"我更新了一个页面的 store,另一个页面的功能就失效了"*
+- *"逻辑散布在整个应用程序中,无法追踪哪里是开始,哪里是结束"*
+
+### 不可控制的逻辑重用
+
+很难重用/修改现有逻辑
+
+同时,通常存在[两个极端](https://github.com/feature-sliced/documentation/discussions/14):
+
+- 要么为每个模块完全从头开始编写逻辑 *(在现有代码库中可能存在重复)*
+- 要么倾向于将所有实现的模块转移到 `shared` 文件夹,从而创建一个大型的模块转储场 *(其中大多数只在一个地方使用)*
+
+**示例:**
+
+- *"我的项目中有 **N** 个相同业务逻辑的实现,我仍然在为此付出代价"*
+- *"项目中有 6 个不同的按钮/弹窗/... 组件"*
+- *"helpers 的转储场"*
+
+## 需求
+
+因此,提出*理想架构的期望需求*似乎是合乎逻辑的:
+
+:::note
+
+无论何处提到"容易",都意味着"对广泛的开发者来说相对容易",因为很明显[不可能为绝对所有人制作理想的解决方案](/docs/about/mission#limitations)
+
+:::
+
+### 明确性
+
+- 应该**易于掌握和解释**项目及其架构给团队
+- 结构应该反映项目的真实**业务价值**
+- 抽象之间必须有明确的**副作用和连接**
+- 应该**易于检测重复逻辑**而不干扰独特实现
+- 项目中不应该有**逻辑分散**
+- 对于良好的架构,不应该有**太多异构抽象和规则**
+
+### 控制
+
+- 良好的架构应该**加速任务解决和功能引入**
+- 应该能够控制项目的开发
+- 应该易于**扩展、修改、删除代码**
+- 必须遵守功能的**分解和隔离**
+- 系统的每个组件都必须**易于替换和移除**
+ - *[无需为变更优化][ext-kof-not-modification] - 我们无法预测未来*
+ - *[更好地为删除优化][ext-kof-but-removing] - 基于已存在的上下文*
+
+### 适应性
+
+- 良好的架构应该适用于**大多数项目**
+ - *具有现有基础设施解决方案*
+ - *在开发的任何阶段*
+- 不应该依赖于框架和平台
+- 应该能够**轻松扩展项目和团队**,具有开发并行化的可能性
+- 应该易于**适应不断变化的需求和环境**
+
+## 参见
+
+- [(React Berlin Talk) Oleg Isonen - Feature Driven Architecture][ext-kof]
+- [(React SPB Meetup #1) Sergey Sova - Feature Slices][ext-slices-spb]
+- [(文章) 关于项目模块化][ext-medium]
+- [(文章) 关于关注点分离和按功能构建][ext-ryanlanciaux]
+
+[ext-kof-not-modification]: https://youtu.be/BWAeYuWFHhs?t=1631
+[ext-kof-but-removing]: https://youtu.be/BWAeYuWFHhs?t=1666
+
+[ext-slices-spb]: https://t.me/feature_slices
+[ext-kof]: https://youtu.be/BWAeYuWFHhs
+[ext-medium]: https://alexmngn.medium.com/why-react-developers-should-modularize-their-applications-d26d381854c1
+[ext-ryanlanciaux]: https://ryanlanciaux.com/blog/2017/08/20/a-feature-based-approach-to-react-development/
diff --git a/i18n/zh/docusaurus-plugin-content-docs/current/about/understanding/knowledge-types.md b/i18n/zh/docusaurus-plugin-content-docs/current/about/understanding/knowledge-types.md
new file mode 100644
index 000000000..53ea83fb9
--- /dev/null
+++ b/i18n/zh/docusaurus-plugin-content-docs/current/about/understanding/knowledge-types.md
@@ -0,0 +1,29 @@
+---
+sidebar_position: 3
+sidebar_label: Knowledge types
+---
+
+# Knowledge types in the project
+
+The following "types of knowledge" can be distinguished in any project:
+
+* **Fundamental knowledge**
+ Knowledge that does not change much over time, such as algorithms, computer science, programming language mechanisms and its APIs.
+
+* **Technology stack**
+ Knowledge of the set of technical solutions used in a project, including programming languages, frameworks, and libraries.
+
+* **Project knowledge**
+ Knowledge that is specific to the current project and not valuable outside of it. This knowledge is essential for newly-onboarded developers to be able to contribute effectively.
+
+:::note
+
+**Feature-Sliced Design** is designed to reduce reliance on "project knowledge", take more responsibility, and make it easier to onboard new team members.
+
+:::
+
+## See also {#see-also}
+
+- [(Video 🇷🇺) Ilya Klimov - On Types of Knowledge][ext-klimov]
+
+[ext-klimov]: https://youtu.be/4xyb_tA-uw0?t=249
diff --git a/i18n/zh/docusaurus-plugin-content-docs/current/about/understanding/naming.md b/i18n/zh/docusaurus-plugin-content-docs/current/about/understanding/naming.md
new file mode 100644
index 000000000..5a86f8ef0
--- /dev/null
+++ b/i18n/zh/docusaurus-plugin-content-docs/current/about/understanding/naming.md
@@ -0,0 +1,48 @@
+---
+sidebar_position: 4
+---
+
+# 命名
+
+不同的开发者有不同的经验和上下文,当相同的实体被不同地命名时,这可能导致团队中的误解。例如:
+
+- 用于显示的组件可以被称为 "ui"、"components"、"ui-kit"、"views"…
+- 在整个应用程序中重用的代码可以被称为 "core"、"shared"、"app"…
+- 业务逻辑代码可以被称为 "store"、"model"、"state"…
+
+## Feature-Sliced Design 中的命名 {#naming-in-fsd}
+
+该方法论使用特定的术语,例如:
+
+- "app"、"process"、"page"、"feature"、"entity"、"shared" 作为 layer 名称,
+- "ui"、"model"、"lib"、"api"、"config" 作为 segment 名称。
+
+坚持使用这些术语非常重要,以防止团队成员和加入项目的新开发者之间的混淆。使用标准名称也有助于向社区寻求帮助。
+
+## 命名冲突 {#when-can-naming-interfere}
+
+当 FSD 方法论中使用的术语与业务中使用的术语重叠时,可能发生命名冲突:
+
+- `FSD#process` vs 应用程序中的模拟进程,
+- `FSD#page` vs 日志页面,
+- `FSD#model` vs 汽车型号。
+
+例如,开发者在代码中看到 "process" 这个词时,会花费额外的时间试图弄清楚指的是哪个进程。这样的**冲突可能会破坏开发过程**。
+
+当项目术语表包含 FSD 特有的术语时,在与团队和技术不相关的各方讨论这些术语时要格外小心。
+
+为了与团队有效沟通,建议使用缩写 "FSD" 作为方法论术语的前缀。例如,在谈论进程时,您可能会说:"我们可以将这个进程放在 FSD features layer 上。"
+
+相反,在与非技术利益相关者沟通时,最好限制使用 FSD 术语,并避免提及代码库的内部结构。
+
+## 参见 {#see-also}
+
+- [(讨论) 命名的适应性][disc-src]
+- [(讨论) Entity 命名调查][disc-naming]
+- [(讨论) "processes" vs "flows" vs ...][disc-processes]
+- [(讨论) "model" vs "store" vs ...][disc-model]
+
+[disc-model]: https://github.com/feature-sliced/documentation/discussions/68
+[disc-naming]: https://github.com/feature-sliced/documentation/discussions/31#discussioncomment-464894
+[disc-processes]: https://github.com/feature-sliced/documentation/discussions/20
+[disc-src]: https://github.com/feature-sliced/documentation/discussions/16
diff --git a/i18n/zh/docusaurus-plugin-content-docs/current/about/understanding/needs-driven.md b/i18n/zh/docusaurus-plugin-content-docs/current/about/understanding/needs-driven.md
new file mode 100644
index 000000000..9a06ff0bb
--- /dev/null
+++ b/i18n/zh/docusaurus-plugin-content-docs/current/about/understanding/needs-driven.md
@@ -0,0 +1,162 @@
+---
+sidebar_position: 2
+---
+
+# Needs driven
+
+:::note TL;DR
+
+— _Can't you formulate the goal that the new feature will solve? Or maybe the problem is that the task itself is not formulated? **The point is also that the methodology helps to pull out the problematic definition of tasks and goals**_
+
+— _project does not live in static - requirements and functionality are constantly changing. Over time, the code turns into mush, because at the start the project was designed only for the initial impression of wishes. **And the task of a good architecture is also to be sharpened for changing development conditions.**_
+
+:::
+
+
+
+
+## Why?
+
+To choose a clear name for an entity and understand its components, **you need to clearly understand what task will be solved with the help of all this code.**
+
+> _@sergeysova: During development, we try to give each entity or function a name that clearly reflects the intentions and meaning of the code being executed._
+
+_After all, without understanding the task, it is impossible to write the right tests that cover the most important cases, put down errors that help the user in the right places, even it is banal not to interrupt the user's flow because of fixable non-critical errors._
+
+## What tasks are we talking about?
+
+Frontend develops applications and interfaces for end users, so we solve the tasks of these consumers.
+
+When a person comes to us, **he wants to solve some of his pain or close a need.**
+
+_The task of managers and analysts is to formulate this need, and implement developers taking into account the features of web development (loss of communication, backend error, typo, missed the cursor or finger)._
+
+**This very goal, with which the user came, is the task of the developers.**
+
+> _One small solved problem is a feature in the Feature-Sliced Design methodology — you need to cut the entire scope of project tasks into small goals._
+
+## How does this affect development?
+
+### Task decomposition
+
+When a developer begins to implement a task, in order to simplify the understanding and support of the code, he mentally **cuts it into stages**:
+
+* first _split into top-level entities_ and _implement them_,
+* then these entities _split into smaller ones_
+* and so on
+
+_In the process of splitting into entities, the developer is forced to give them a name that would clearly reflect his idea and help to understand what task the code solves when reading the listing_
+_At the same time, we do not forget that we are trying to help the user reduce pain or realize needs_
+
+### Understanding the essence of the task
+
+But to give a clear name to an entity, **the developer must know enough about its purpose**
+
+* how is he going to use this entity,
+* what part of the user's task does it implement, where else can this entity be applied,
+* in what other tasks can it participate,
+* and so on
+
+It is not difficult to draw a conclusion: **while the developer will reflect on the name of entities within the framework of the methodology, he will be able to find poorly formulated tasks even before writing the code.**
+
+> How to give a name to an entity if you do not understand well what tasks it can solve, how can you even divide a task into entities if you do not understand it well?
+
+## How to formulate it?
+
+**To formulate a task that is solved by features, you need to understand the task itself**, and this is already the responsibility of the project manager and analysts.
+
+_The methodology can only tell the developer what tasks the product manager should pay close attention to._
+
+> _@sergeysova: the Whole frontend is primarily a display of information, any component in the first turn, displays, and then the task "to show the user something" has no practical value._
+>
+> _Even without taking into account the specifics of the frontend can ask, "why do I have to show you", so you can continue to ask until't get out of pain or the need of the consumer._
+
+As soon as we were able to get to the basic needs or pains, we can go back and figure out **how exactly your product or service can help the user with his goals**
+
+Any new task in your tracker is aimed at solving business problems, and the business tries to solve the user's tasks at the same time earning money on it. This means that each task has certain goals, even if they are not spelled out in the description text.
+
+_**The developer must clearly understand what goal this or that task is pursuing**, but not every company can afford to build processes perfectly, although this is a separate conversation, nevertheless, the developer may well "ping" the right managers himself to find out this and do his part of the work effectively._
+
+## And what is the benefit?
+
+Now let's look at the whole process from beginning to end.
+
+### 1. Understanding user tasks
+
+When a developer understands his pain and how the business closes them, he can offer solutions that are not available to the business due to the specifics of web development.
+
+> But of course, all this can work only if the developer is not indifferent to what he is doing and for what, otherwise _why then the methodology and some approaches?_
+
+### 2. Structuring and ordering
+
+With the understanding of tasks comes **a clear structure both in the head and in the tasks along with the code**
+
+### 3. Understanding the feature and its components
+
+**One feature is one useful functionality for the user**
+
+* When several features are implemented in one feature, this is **a violation of borders**
+* The feature can be indivisible and growing - **and this is not bad**
+* **Bad** - when the feature does not answer the question _"What is the business value for the user?"_
+* There can be no "map-office" feature
+ * But `booking-meeting-on-the-map`, `search-for-an-employee`, `change-of-workplace` - **yes**
+
+> _@sergeysova: The point is that the feature contains only code that implements the functionality itself_, without unnecessary details and internal solutions (ideally)*
+>
+> *Open the feature code **and see only what relates to the task** - no more*
+
+### 4. Profit
+
+Business very rarely turns its course radically in the other direction, which means **the reflection of business tasks in the frontend application code is a very significant profit.**
+
+_Then you don't have to explain to each new team member what this or that code does, and in general why it was added - **everything will be explained through the business tasks that are already reflected in the code.**_
+
+> What is called ["Business Language" in Domain Driven Development][ext-ubiq-lang]
+
+---
+
+## Back to reality
+
+If business processes are understood and good names are given at the design stage - _then it is not particularly problematic to transfer this understanding and logic to the code._
+
+**However, in practice**, tasks and functionality are usually developed "too" iteratively and (or) there is no time to think through the design.
+
+**As a result, the feature makes sense today, and if you expand this feature in a month, you can rewrite the gender of the project.**
+
+> *[[From the discussion][disc-src]]: The developer tries to think 2-3 steps ahead, taking into account future wishes, but here he rests on his own experience*
+>
+> _Burns experience engineer usually immediately looking 10 steps ahead, and understand where one feature to divide and combine with the other_
+>
+> _But sometimes that comes the task which had to face the experience, and nowhere to take the understanding of how literacy to decompose, with the least unfortunate consequences in the future_
+
+## The role of methodology
+
+**The methodology helps to solve the problems of developers, so that it is easier to solve the problems of users.**
+
+There is no solution to the problems of developers only for the sake of developers
+
+But in order for the developer to solve his tasks, **you need to understand the user's tasks** - on the contrary, it will not work
+
+### Methodology requirements
+
+It becomes clear that you need to identify at least two requirements for **Feature-Sliced Design**:
+
+1. The methodology should tell **how to create features, processes and entities**
+
+ * Which means it should clearly explain _how to divide the code between them_, which means that the naming of these entities should also be laid down in the specification.
+
+2. The methodology should help the architecture **[easily adapt to the changing requirements of the project][refs-arch--adaptability]**
+
+## See also
+
+* [(Post) Stimulation for a clear formulation of tasks (+ discussion)][disc-src]
+ > _**The current article** is an adaptation of this discussion, you can read the full uncut version at the link_
+* [(Discussion) How to break the functionality and what it is][tg-src]
+* [(Article) "How to better organize your applications"][ext-medium]
+
+[refs-arch--adaptability]: architecture#adaptability
+
+[ext-medium]: https://alexmngn.medium.com/how-to-better-organize-your-react-applications-2fd3ea1920f1
+[disc-src]: https://t.me/sergeysova/318
+[tg-src]: https://t.me/atomicdesign/18972
+[ext-ubiq-lang]: https://thedomaindrivendesign.io/developing-the-ubiquitous-language
diff --git a/i18n/zh/docusaurus-plugin-content-docs/current/about/understanding/signals.mdx b/i18n/zh/docusaurus-plugin-content-docs/current/about/understanding/signals.mdx
new file mode 100644
index 000000000..2a85ecc80
--- /dev/null
+++ b/i18n/zh/docusaurus-plugin-content-docs/current/about/understanding/signals.mdx
@@ -0,0 +1,21 @@
+---
+sidebar_position: 5
+sidebar_class_name: sidebar-item--wip
+---
+
+import WIP from '@site/src/shared/ui/wip/tmpl.mdx'
+
+# Signals of architecture
+
+
+
+> If there is a limitation on the part of the architecture, then there are obvious reasons for this, and consequences if they are ignored
+
+> The methodology and architecture gives signals, and how to deal with it depends on what risks you are ready to take on and what is most suitable for your team)
+
+## See also
+
+- [(Thread) About signals from architecture and dataflow](https://t.me/feature_sliced/2070)
+- [(Thread) About the fundamental nature of architecture](https://t.me/feature_sliced/2492)
+- [(Thread) About highlighting weak points](https://t.me/feature_sliced/3979)
+- [(Thread) How to understand that the data model is swollen](https://t.me/feature_sliced/4228)
diff --git a/i18n/zh/docusaurus-plugin-content-docs/current/branding.md b/i18n/zh/docusaurus-plugin-content-docs/current/branding.md
new file mode 100644
index 000000000..1efe978a3
--- /dev/null
+++ b/i18n/zh/docusaurus-plugin-content-docs/current/branding.md
@@ -0,0 +1,82 @@
+import useBaseUrl from '@docusaurus/useBaseUrl';
+
+# 品牌指南
+
+FSD 的视觉身份基于其核心概念:`分层`、`切片式自包含部分`、`部分和组合`、`分段`。
+但我们也倾向于设计简单、美丽的身份,它应该传达 FSD 的哲学并易于识别。
+
+**请按原样使用 FSD 的身份,不要更改,但可以使用我们的资产以方便您使用。**此品牌指南将帮助您正确使用 FSD 的身份。
+
+:::caution 兼容性
+
+FSD 以前有[另一个遗留身份](https://drive.google.com/drive/folders/11Y-3qZ_C9jOFoW2UbSp11YasOhw4yBdl?usp=sharing)。旧设计不能代表方法论的核心概念。此外,它是作为纯粹的草稿创建的,应该被实现。
+
+为了兼容和长期使用品牌,我们在一年内(2021-2022)进行了谨慎的重新品牌化。**这样您在使用 FSD 身份时可以放心 🍰**
+
+*但请优先使用实际身份,而不是旧的!*
+
+:::
+
+## 标题
+
+- ✅ **正确:** `Feature-Sliced Design`、`FSD`
+- ❌ **错误:** `Feature-Sliced`、`Feature Sliced`、`FeatureSliced`、`feature-sliced`、`feature sliced`、`FS`
+
+## Emoji
+
+蛋糕 🍰 图像很好地代表了 FSD 的核心概念,所以它被选为我们的标志性 emoji
+
+> 示例:*"🍰 前端项目的架构设计方法论"*
+
+## Logo 和调色板
+
+FSD 有几种适用于不同上下文的 logo 变体,但建议优先使用 **primary**
+
+
+
+
+
+ >
+ );
+}
+```
+
+现在,API 部分。loader 应该查看 URL,如果它包含文章 slug,那意味着我们正在编辑现有文章,应该加载其数据。否则,返回空。让我们创建该 loader:
+
+```ts title="pages/article-edit/api/loader.ts"
+import { json, type LoaderFunctionArgs } from "@remix-run/node";
+import type { FetchResponse } from "openapi-fetch";
+
+import { GET, requireUser } from "shared/api";
+
+async function throwAnyErrors(
+ responsePromise: Promise>,
+) {
+ const { data, error, response } = await responsePromise;
+
+ if (error !== undefined) {
+ throw json(error, { status: response.status });
+ }
+
+ return data as NonNullable;
+}
+
+export const loader = async ({ params, request }: LoaderFunctionArgs) => {
+ const currentUser = await requireUser(request);
+
+ if (!params.slug) {
+ return { article: null };
+ }
+
+ return throwAnyErrors(
+ GET("/articles/{slug}", {
+ params: { path: { slug: params.slug } },
+ headers: { Authorization: `Token ${currentUser.token}` },
+ }),
+ );
+};
+```
+
+action 将获取新的字段值,通过我们的数据模式运行它们,如果一切都正确,就将这些更改提交到后端,通过更新现有文章或创建新文章:
+
+```tsx title="pages/article-edit/api/action.ts"
+import { json, redirect, type ActionFunctionArgs } from "@remix-run/node";
+
+import { POST, PUT, requireUser } from "shared/api";
+import { parseAsArticle } from "../model/parseAsArticle";
+
+export const action = async ({ request, params }: ActionFunctionArgs) => {
+ try {
+ const { body, description, title, tags } = parseAsArticle(
+ await request.formData(),
+ );
+ const tagList = tags?.split(",") ?? [];
+
+ const currentUser = await requireUser(request);
+ const payload = {
+ body: {
+ article: {
+ title,
+ description,
+ body,
+ tagList,
+ },
+ },
+ headers: { Authorization: `Token ${currentUser.token}` },
+ };
+
+ const { data, error } = await (params.slug
+ ? PUT("/articles/{slug}", {
+ params: { path: { slug: params.slug } },
+ ...payload,
+ })
+ : POST("/articles", payload));
+
+ if (error) {
+ return json({ errors: error }, { status: 422 });
+ }
+
+ return redirect(`/article/${data.article.slug ?? ""}`);
+ } catch (errors) {
+ return json({ errors }, { status: 400 });
+ }
+};
+```
+
+模式同时作为 `FormData` 的解析函数,这使我们可以方便地获取干净的字段或只是抛出错误在末尾处理。这里是该解析函数的样子:
+
+```tsx title="pages/article-edit/model/parseAsArticle.ts"
+export function parseAsArticle(data: FormData) {
+ const errors = [];
+
+ const title = data.get("title");
+ if (typeof title !== "string" || title === "") {
+ errors.push("Give this article a title");
+ }
+
+ const description = data.get("description");
+ if (typeof description !== "string" || description === "") {
+ errors.push("Describe what this article is about");
+ }
+
+ const body = data.get("body");
+ if (typeof body !== "string" || body === "") {
+ errors.push("Write the article itself");
+ }
+
+ const tags = data.get("tags");
+ if (typeof tags !== "string") {
+ errors.push("The tags must be a string");
+ }
+
+ if (errors.length > 0) {
+ throw errors;
+ }
+
+ return { title, description, body, tags: data.get("tags") ?? "" } as {
+ title: string;
+ description: string;
+ body: string;
+ tags: string;
+ };
+}
+```
+
+可以说,它有点凗长和重复,但这是我们为人类可读错误付出的代价。这也可以是一个 Zod 模式,例如,但然后我们必须在前端渲染错误消息,这个表单不值得复杂化。
+
+最后一步 — 将页面、loader 和 action 连接到路由。由于我们巧妙地支持创建和编辑,我们可以从 `editor._index.tsx` 和 `editor.$slug.tsx` 两者导出相同的东西:
+
+```tsx title="pages/article-edit/index.ts"
+export { ArticleEditPage } from "./ui/ArticleEditPage";
+export { loader } from "./api/loader";
+export { action } from "./api/action";
+```
+
+```tsx title="app/routes/editor._index.tsx, app/routes/editor.$slug.tsx (same content)"
+import { ArticleEditPage } from "pages/article-edit";
+
+export { loader, action } from "pages/article-edit";
+
+export default ArticleEditPage;
+```
+
+我们现在完成了!登录并尝试创建一篇新文章。或者“忘记”编写文章并看到验证生效。
+
+
+ 
+
+ The Conduit article editor, with the title field saying “New article” and the rest of the fields empty. Above the form there are two errors: **“Describe what this article is about”** and **“Write the article itself”**.
+
+
+资料和设置页面与文章阅读器和编辑器非常相似,它们留作读者的练习,这就是您 :)
diff --git a/i18n/zh/docusaurus-plugin-content-docs/current/guides/examples/_category_.yaml b/i18n/zh/docusaurus-plugin-content-docs/current/guides/examples/_category_.yaml
new file mode 100644
index 000000000..f11e3a954
--- /dev/null
+++ b/i18n/zh/docusaurus-plugin-content-docs/current/guides/examples/_category_.yaml
@@ -0,0 +1,2 @@
+label: 示例
+position: 1
diff --git a/i18n/zh/docusaurus-plugin-content-docs/current/guides/examples/api-requests.mdx b/i18n/zh/docusaurus-plugin-content-docs/current/guides/examples/api-requests.mdx
new file mode 100644
index 000000000..038525e51
--- /dev/null
+++ b/i18n/zh/docusaurus-plugin-content-docs/current/guides/examples/api-requests.mdx
@@ -0,0 +1,141 @@
+---
+sidebar_position: 4
+---
+
+import Tabs from '@theme/Tabs';
+import TabItem from '@theme/TabItem';
+
+# 处理 API 请求 {#handling-api-requests}
+
+## 共享 API 请求 {#shared-api-requests}
+
+首先将通用的 API 请求逻辑放在 `shared/api` 目录中。这使得在应用程序中重用请求变得容易,并有助于更快的原型开发。对于许多项目来说,这就是 API 调用所需的全部内容。
+
+典型的文件结构是:
+- 📂 shared
+ - 📂 api
+ - 📄 client.ts
+ - 📄 index.ts
+ - 📂 endpoints
+ - 📄 login.ts
+
+`client.ts` 文件集中了您的 HTTP 请求设置。它包装您选择的方法(如 `fetch()` 或 `axios` 实例)并处理常见配置,例如:
+
+- 后端基础 URL。
+- 默认头部(例如,用于身份验证)。
+- 数据序列化。
+
+以下是 `axios` 和 `fetch` 的示例:
+
+
+
+
+```ts title="shared/api/client.ts"
+// Example using axios
+import axios from 'axios';
+
+export const client = axios.create({
+ baseURL: 'https://your-api-domain.com/api/',
+ timeout: 5000,
+ headers: { 'X-Custom-Header': 'my-custom-value' }
+});
+```
+
+
+
+```ts title="shared/api/client.ts"
+export const client = {
+ async post(endpoint: string, body: any, options?: RequestInit) {
+ const response = await fetch(`https://your-api-domain.com/api${endpoint}`, {
+ method: 'POST',
+ body: JSON.stringify(body),
+ ...options,
+ headers: {
+ 'Content-Type': 'application/json',
+ 'X-Custom-Header': 'my-custom-value',
+ ...options?.headers,
+ },
+ });
+ return response.json();
+ }
+ // ... other methods like put, delete, etc.
+};
+```
+
+
+
+
+在 `shared/api/endpoints` 中组织您的单个 API 请求函数,按 API 端点分组。
+
+:::note
+
+为了保持示例的重点,我们省略了表单交互和验证。有关 Zod 或 Valibot 等库的详细信息,请参阅[类型验证和 Schemas](/docs/guides/examples/types#type-validation-schemas-and-zod) 文章。
+
+:::
+
+```ts title="shared/api/endpoints/login.ts"
+import { client } from '../client';
+
+export interface LoginCredentials {
+ email: string;
+ password: string;
+}
+
+export function login(credentials: LoginCredentials) {
+ return client.post('/login', credentials);
+}
+```
+在 `shared/api` 中使用 `index.ts` 文件来导出您的请求函数。
+
+```ts title="shared/api/index.ts"
+export { client } from './client'; // 如果您想导出客户端本身
+export { login } from './endpoints/login';
+export type { LoginCredentials } from './endpoints/login';
+```
+
+## 特定 Slice 的 API 请求 {#slice-specific-api-requests}
+
+如果 API 请求仅由特定 slice(如单个页面或功能)使用且不会被重用,请将其放在该 slice 的 api segment 中。这样可以保持特定 slice 的逻辑整齐地包含在内。
+
+- 📂 pages
+ - 📂 login
+ - 📄 index.ts
+ - 📂 api
+ - 📄 login.ts
+ - 📂 ui
+ - 📄 LoginPage.tsx
+
+```ts title="pages/login/api/login.ts"
+import { client } from 'shared/api';
+
+interface LoginCredentials {
+ email: string;
+ password: string;
+}
+
+export function login(credentials: LoginCredentials) {
+ return client.post('/login', credentials);
+}
+```
+
+您不需要在页面的公共 API 中导出 `login()` 函数,因为应用程序中的其他地方不太可能需要这个请求。
+
+:::note
+
+避免过早地将 API 调用和响应类型放在 `entities` 层中。后端响应可能与您的前端实体需要的不同。`shared/api` 或 slice 的 `api` segment 中的 API 逻辑允许您适当地转换数据,保持实体专注于前端关注点。
+
+:::
+
+## 使用客户端生成器 {#client-generators}
+
+如果您的后端有 OpenAPI 规范,像 [orval](https://orval.dev/) 或 [openapi-typescript](https://openapi-ts.dev/) 这样的工具可以为您生成 API 类型和请求函数。将生成的代码放在,例如 `shared/api/openapi` 中。确保包含 `README.md` 来记录这些类型是什么,以及如何生成它们。
+
+## 与服务器状态库集成 {#server-state-libraries}
+
+当使用像 [TanStack Query (React Query)](https://tanstack.com/query/latest) 或 [Pinia Colada](https://pinia-colada.esm.dev/) 这样的服务器状态库时,您可能需要在 slices 之间共享类型或缓存键。将以下内容使用 `shared` 层:
+
+- API 数据类型
+- 缓存键
+- 通用查询/变更选项
+
+有关如何使用服务器状态库的更多详细信息,请参阅 [React Query 文章](/docs/guides/tech/with-react-query)
\ No newline at end of file
diff --git a/i18n/zh/docusaurus-plugin-content-docs/current/guides/examples/auth.md b/i18n/zh/docusaurus-plugin-content-docs/current/guides/examples/auth.md
new file mode 100644
index 000000000..01c922576
--- /dev/null
+++ b/i18n/zh/docusaurus-plugin-content-docs/current/guides/examples/auth.md
@@ -0,0 +1,173 @@
+---
+sidebar_position: 1
+---
+
+# 身份验证
+
+广义上,身份验证包含以下步骤:
+
+1. 从用户获取凭据
+1. 将它们发送到后端
+1. 存储 token 以进行经过身份验证的请求
+
+## 如何从用户获取凭据
+
+我们假设您的应用程序负责获取凭据。如果您通过 OAuth 进行身份验证,您可以简单地创建一个登录页面,其中包含指向 OAuth 提供商登录页面的链接,然后跳转到[步骤 3](#how-to-store-the-token-for-authenticated-requests)。
+
+### 专用登录页面
+
+通常,网站有专用的登录页面,您在其中输入用户名和密码。这些页面相当简单,所以不需要分解。登录和注册表单在外观上相当相似,所以它们甚至可以被组合在一个页面中。在 Pages layer 上为您的登录/注册页面创建一个 slice:
+
+- 📂 pages
+ - 📂 login
+ - 📂 ui
+ - 📄 LoginPage.tsx (or your framework's component file format)
+ - 📄 RegisterPage.tsx
+ - 📄 index.ts
+ - other pages…
+
+在这里我们创建了两个组件并在 slice 的 index 文件中导出它们。这些组件将包含表单,负责为用户提供可理解的控件来获取他们的凭据。
+
+### 登录对话框
+
+如果您的应用程序有一个可以在任何页面上使用的登录对话框,请考虑将该对话框设为 widget。这样,您仍然可以避免过多的分解,但可以自由地在任何页面上重用此对话框。
+
+- 📂 widgets
+ - 📂 login-dialog
+ - 📂 ui
+ - 📄 LoginDialog.tsx
+ - 📄 index.ts
+ - other widgets…
+
+本指南的其余部分是为专用页面方法编写的,但相同的原则也适用于对话框 widget。
+
+### 客户端验证
+
+有时,特别是对于注册,执行客户端验证是有意义的,可以让用户快速知道他们犯了错误。验证可以在登录页面的 `model` segment 中进行。使用 schema 验证库,例如 JS/TS 的 [Zod][ext-zod],并将该 schema 暴露给 `ui` segment:
+
+```ts title="pages/login/model/registration-schema.ts"
+import { z } from "zod";
+
+export const registrationData = z.object({
+ email: z.string().email(),
+ password: z.string().min(6),
+ confirmPassword: z.string(),
+}).refine((data) => data.password === data.confirmPassword, {
+ message: "Passwords do not match",
+ path: ["confirmPassword"],
+});
+```
+
+然后,在 `ui` segment 中,您可以使用此 schema 来验证用户输入:
+
+```tsx title="pages/login/ui/RegisterPage.tsx"
+import { registrationData } from "../model/registration-schema";
+
+function validate(formData: FormData) {
+ const data = Object.fromEntries(formData.entries());
+ try {
+ registrationData.parse(data);
+ } catch (error) {
+ // TODO: Show error message to the user
+ }
+}
+
+export function RegisterPage() {
+ return (
+
+ )
+}
+```
+
+## 如何将凭据发送到后端
+
+创建一个向后端登录端点发出请求的函数。此函数可以使用 mutation 库(例如 TanStack Query)直接在组件代码中调用,也可以作为状态管理器中的副作用调用。如 [API 请求指南][examples-api-requests] 中所述,您可以将请求放在 `shared/api` 中或登录页面的 `api` segment 中。
+
+### 双因素认证
+
+如果您的应用程序支持双因素认证(2FA),您可能需要重定向到另一个页面,用户可以在其中输入一次性密码。通常,您的 `POST /login` 请求会返回带有标志的用户对象,指示用户已启用 2FA。如果设置了该标志,请将用户重定向到 2FA 页面。
+
+由于此页面与登录密切相关,您也可以将其保留在 Pages layer 上的同一个 slice `login` 中。
+
+您还需要另一个请求函数,类似于我们上面创建的 `login()`。将它们放在一起,要么在 Shared 中,要么在 `login` 页面的 `api` segment 中。
+
+## 如何存储 token 以进行经过身份验证的请求 {#how-to-store-the-token-for-authenticated-requests}
+
+无论您使用哪种身份验证方案,无论是简单的登录和密码、OAuth 还是双因素认证,最终您都会收到一个 token。应该存储此 token,以便后续请求可以识别自己。
+
+Web 应用程序的理想 token 存储是 **cookie** — 它不需要手动 token 存储或处理。因此,cookie 存储几乎不需要从前端架构方面考虑。如果您的前端框架有服务器端(例如 [Remix][ext-remix]),那么您应该将服务器端 cookie 基础设施存储在 `shared/api` 中。在[教程的身份验证部分][tutorial-authentication]中有一个如何使用 Remix 做到这一点的示例。
+
+但是,有时 cookie 存储不是一个选项。在这种情况下,您将必须手动存储 token。除了存储 token 之外,您可能还需要设置在 token 过期时刷新 token 的逻辑。使用 FSD,有几个地方可以存储 token,以及几种方法可以使其对应用程序的其余部分可用。
+
+### 在 Shared 中
+
+这种方法与在 `shared/api` 中定义的 API 客户端配合得很好,因为 token 可以自由地用于其他需要身份验证才能成功的请求函数。您可以让 API 客户端保持状态,无论是使用响应式存储还是简单的模块级变量,并在您的 `login()`/`logout()` 函数中更新该状态。
+
+自动 token 刷新可以作为 API 客户端中的中间件实现 — 每次您发出任何请求时都可以执行的东西。它可以这样工作:
+
+- 认证并存储访问 token 以及刷新 token
+- 发出任何需要身份验证的请求
+- 如果请求失败并返回指示 token 过期的状态码,并且存储中有 token,则发出刷新请求,存储新的 token,并重试原始请求
+
+One of the drawbacks of this approach is that the logic of managing and refreshing the token doesn't have a dedicated place. This can be fine for some apps or teams, but if the token management logic is more complex, it may be preferable to separate responsibilities of making requests and managing tokens. You can do that by keeping your requests and API client in `shared/api`, but the token store and management logic in `shared/auth`.
+
+Another drawback of this approach is that if your backend returns an object of your current user's information along with the token, you have to store that somewhere or discard that information and request it again from an endpoint like `/me` or `/users/current`.
+
+### 在 Entities 中
+
+FSD 项目通常有一个用户实体和/或当前用户实体。甚至可以是同一个实体。
+
+:::note
+
+**当前用户**有时也被称为"viewer"或"me"。这是为了区分具有权限和私人信息的单个经过身份验证的用户与具有公开可访问信息的所有用户列表。
+
+:::
+
+To store the token in the User entity, create a reactive store in the `model` segment. That store can contain both the token and the user object.
+
+Since the API client is usually defined in `shared/api` or spreaded across the entities, the main challenge to this approach is making the token available to other requests that need it without breaking [the import rule on layers][import-rule-on-layers]:
+
+> A module (file) in a slice can only import other slices when they are located on layers strictly below.
+
+There are several solutions to this challenge:
+
+1. **Pass the token manually every time you make a request**
+ This is the simplest solution, but it quickly becomes cumbersome, and if you don't have type safety, it's easy to forget. It's also not compatible with middlewares pattern for the API client in Shared.
+1. **Expose the token to the entire app with a context or a global store like `localStorage`**
+ The key to retrieve the token will be kept in `shared/api` so that the API client can access it. The reactive store of the token will be exported from the User entity, and the context provider (if needed) will be set up on the App layer. This gives more freedom for designing the API client, however, this creates an implicit dependency on higher layers to provide context. When following this approach, consider providing helpful error messages if the context or `localStorage` are not set up correctly.
+1. **Inject the token into the API client every time it changes**
+ If your store is reactive, you can create a subscription that will update the API client's token store every time the store in the entity changes. This is similar to the previous solution in that they both create an implicit dependency on higher layers, but this one is more imperative ("push"), while the previous one is more declarative ("pull").
+
+Once you overcome the challenge of exposing the token that is stored in the entity's model, you can encode more business logic related to token management. For example, the `model` segment can contain logic to invalidate the token after a certain period of time, or to refresh the token when it expires. To actually make requests to the backend, use the `api` segment of the User entity or `shared/api`.
+
+### In Pages/Widgets (not recommended)
+
+It is discouraged to store app-wide state like an access token in pages or widgets. Avoid placing your token store in the `model` segment of the login page, instead choose from the first two solutions, Shared or Entities.
+
+## 登出和 token 失效
+
+通常,应用程序没有专门的登出页面,但登出功能仍然非常重要。它包括对后端的经过身份验证的请求和对 token 存储的更新。
+
+如果您将所有请求存储在 `shared/api` 中,请将登出请求函数保留在那里,靠近登录函数。否则,请考虑将登出请求函数保留在触发它的按钮旁边。例如,如果您有一个出现在每个页面上并包含登出链接的头部 widget,请将该请求放在该 widget 的 `api` segment 中。
+
+token 存储的更新必须从登出按钮的位置触发,比如头部 widget。您可以在该 widget 的 `model` segment 中组合请求和存储更新。
+
+### 自动登出
+
+不要忘记为登出请求失败或刷新登录 token 请求失败时构建故障保护。在这两种情况下,您都应该清除 token 存储。如果您将 token 保存在 Entities 中,此代码可以放在 `model` segment 中,因为它是纯业务逻辑。如果您将 token 保存在 Shared 中,将此逻辑放在 `shared/api` 中可能会使 segment 膨胀并稀释其目的。如果您注意到您的 API segment 包含几个不相关的东西,请考虑将 token 管理逻辑拆分到另一个 segment 中,例如 `shared/auth`。
+
+[tutorial-authentication]: /docs/get-started/tutorial#authentication
+[import-rule-on-layers]: /docs/reference/layers#import-rule-on-layers
+[examples-api-requests]: /docs/guides/examples/api-requests
+[ext-remix]: https://remix.run
+[ext-zod]: https://zod.dev
+
diff --git a/i18n/zh/docusaurus-plugin-content-docs/current/guides/examples/autocompleted.mdx b/i18n/zh/docusaurus-plugin-content-docs/current/guides/examples/autocompleted.mdx
new file mode 100644
index 000000000..fc36f87c5
--- /dev/null
+++ b/i18n/zh/docusaurus-plugin-content-docs/current/guides/examples/autocompleted.mdx
@@ -0,0 +1,18 @@
+---
+sidebar_position: 5
+sidebar_class_name: sidebar-item--wip
+unlisted: true
+---
+
+import WIP from '@site/src/shared/ui/wip/tmpl.mdx'
+
+# 自动完成
+
+
+
+
+
+> 关于按层分解
+
+## 另请参阅
+- [(讨论) 关于将方法论应用于加载字典的选择](https://github.com/feature-sliced/documentation/discussions/65#discussioncomment-480807)
diff --git a/i18n/zh/docusaurus-plugin-content-docs/current/guides/examples/browser-api.mdx b/i18n/zh/docusaurus-plugin-content-docs/current/guides/examples/browser-api.mdx
new file mode 100644
index 000000000..e9a135403
--- /dev/null
+++ b/i18n/zh/docusaurus-plugin-content-docs/current/guides/examples/browser-api.mdx
@@ -0,0 +1,14 @@
+---
+sidebar_class_name: sidebar-item--wip
+unlisted: true
+---
+
+import WIP from '@site/src/shared/ui/wip/tmpl.mdx'
+
+# 浏览器 API
+
+
+
+> 关于使用浏览器 API:localStorage、音频 API、蓝牙 API 等。
+>
+> 您可以向 [@alex_novi](https://t.me/alex_novich) 询问更多详细信息
diff --git a/i18n/zh/docusaurus-plugin-content-docs/current/guides/examples/cms.mdx b/i18n/zh/docusaurus-plugin-content-docs/current/guides/examples/cms.mdx
new file mode 100644
index 000000000..808c2c0b1
--- /dev/null
+++ b/i18n/zh/docusaurus-plugin-content-docs/current/guides/examples/cms.mdx
@@ -0,0 +1,22 @@
+---
+sidebar_class_name: sidebar-item--wip
+unlisted: true
+---
+
+import WIP from '@site/src/shared/ui/wip/tmpl.mdx'
+
+# CMS
+
+
+
+## 功能可能不同
+
+在一些项目中,所有功能都集中在来自服务器的数据中
+
+> https://github.com/feature-sliced/documentation/discussions/65#discussioncomment-480785
+
+## 如何更正确地使用 CMS 标记
+
+> https://t.me/feature_sliced/1557
+
+> https://t.me/feature_sliced/1553
diff --git a/i18n/zh/docusaurus-plugin-content-docs/current/guides/examples/feedback.mdx b/i18n/zh/docusaurus-plugin-content-docs/current/guides/examples/feedback.mdx
new file mode 100644
index 000000000..1014a4328
--- /dev/null
+++ b/i18n/zh/docusaurus-plugin-content-docs/current/guides/examples/feedback.mdx
@@ -0,0 +1,12 @@
+---
+sidebar_class_name: sidebar-item--wip
+unlisted: true
+---
+
+import WIP from '@site/src/shared/ui/wip/tmpl.mdx'
+
+# 反馈
+
+
+
+> 错误、警告、通知……
diff --git a/i18n/zh/docusaurus-plugin-content-docs/current/guides/examples/i18n.mdx b/i18n/zh/docusaurus-plugin-content-docs/current/guides/examples/i18n.mdx
new file mode 100644
index 000000000..78a3e76d2
--- /dev/null
+++ b/i18n/zh/docusaurus-plugin-content-docs/current/guides/examples/i18n.mdx
@@ -0,0 +1,17 @@
+---
+sidebar_position: 6
+sidebar_class_name: sidebar-item--wip
+unlisted: true
+---
+
+import WIP from '@site/src/shared/ui/wip/tmpl.mdx'
+
+# 国际化
+
+
+
+## 在哪里放置它?如何使用它?
+
+- https://t.me/feature_sliced/4425
+- https://t.me/feature_sliced/2325
+- https://t.me/feature_sliced/1867
diff --git a/i18n/zh/docusaurus-plugin-content-docs/current/guides/examples/index.mdx b/i18n/zh/docusaurus-plugin-content-docs/current/guides/examples/index.mdx
new file mode 100644
index 000000000..77885004f
--- /dev/null
+++ b/i18n/zh/docusaurus-plugin-content-docs/current/guides/examples/index.mdx
@@ -0,0 +1,36 @@
+---
+hide_table_of_contents: true
+---
+
+# 示例
+
+
+
+
+## 在您开始之前 {#before-you-start}
+
+The most important question to ask your team when considering to switch to Feature-Sliced Design is — _do you really need it?_ We love Feature-Sliced Design, but even we recognize that some projects are perfectly fine without it.
+
+Here are some reasons to consider making the switch:
+
+1. New team members are complaining that it's hard to get to a productive level
+2. Making modifications to one part of the code **often** causes another unrelated part to break
+3. Adding new functionality is difficult due to the sheer amount of things you need to think about
+
+**Avoid switching to FSD against the will of your teammates**, even if you are the lead.
+First, convince your teammates that the benefits outweigh the cost of migration and the cost of learning a new architecture instead of the established one.
+
+Also keep in mind that any kind of architectural changes are not immediately observable to the management. Make sure they are on board with the switch before starting and explain to them why it might benefit the project.
+
+:::tip
+
+If you need help convincing the project manager that FSD is beneficial, consider some of these points:
+1. Migration to FSD can happen incrementally, so it will not halt the development of new features
+2. A good architecture can significantly decrease the time that a new developer needs to get productive
+3. FSD is a documented architecture, so the team doesn't have to continuously spend time on maintaining their own documentation
+
+:::
+
+---
+
+If you made the decision to start migrating, then the first thing you want to do is to set up an alias for `📁 src`. It will be helpful later to refer to top-level folders. We will consider `@` as an alias for `./src` for the rest of this guide.
+
+## Step 1. Divide the code by pages {#divide-code-by-pages}
+
+Most custom architectures already have a division by pages, however small or large in logic. If you already have `📁 pages`, you may skip this step.
+
+If you only have `📁 routes`, create `📁 pages` and try to move as much component code from `📁 routes` as possible. Ideally, you would have a tiny route and a larger page. As you're moving code, create a folder for each page and add an index file:
+
+:::note
+
+For now, it's okay if your pages reference each other. You can tackle that later, but for now, focus on establishing a prominent division by pages.
+
+:::
+
+Route file:
+
+```js title="src/routes/products.[id].js"
+export { ProductPage as default } from "@/pages/product"
+```
+
+Page index file:
+
+```js title="src/pages/product/index.js"
+export { ProductPage } from "./ProductPage.jsx"
+```
+
+Page component file:
+
+```jsx title="src/pages/product/ProductPage.jsx"
+export function ProductPage(props) {
+ return ;
+}
+```
+
+## Step 2. Separate everything else from the pages {#separate-everything-else-from-pages}
+
+Create a folder `📁 src/shared` and move everything that doesn't import from `📁 pages` or `📁 routes` there. Create a folder `📁 src/app` and move everything that does import the pages or routes there, including the routes themselves.
+
+Remember that the Shared layer doesn't have slices, so it's fine if segments import from each other.
+
+You should end up with a file structure like this:
+
+
+ 📁 src
+
+
+
+ 📁 app
+
+
+
+ 📁 routes
+
+
📄 products.jsx
+
📄 products.[id].jsx
+
+
+
+
📄 App.jsx
+
📄 index.js
+
+
+
+
+
+ 📁 pages
+
+
+
+ 📁 product
+
+
+
+ 📁 ui
+
+
📄 ProductPage.jsx
+
+
+
+
📄 index.js
+
+
+
+
📁 catalog
+
+
+
+
+
+ 📁 shared
+
+
📁 actions
+
📁 api
+
📁 components
+
📁 containers
+
📁 constants
+
📁 i18n
+
📁 modules
+
📁 helpers
+
📁 utils
+
📁 reducers
+
📁 selectors
+
📁 styles
+
+
+
+
+
+
+## Step 3. Tackle cross-imports between pages {#tackle-cross-imports-between-pages}
+
+
+
+
+Find all instances where one page is importing from the other and do one of the two things:
+
+1. Copy-paste the imported code into the depending page to remove the dependency
+2. Move the code to a proper segment in Shared:
+ - if it's a part of the UI kit, move it to `📁 shared/ui`;
+ - if it's a configuration constant, move it to `📁 shared/config`;
+ - if it's a backend interaction, move it to `📁 shared/api`.
+
+:::note
+
+**Copy-pasting isn't architecturally wrong**, in fact, sometimes it may be more correct to duplicate than to abstract into a new reusable module. The reason is that sometimes the shared parts of pages start drifting apart, and you don't want dependencies getting in your way in these cases.
+
+However, there is still sense in the DRY ("don't repeat yourself") principle, so make sure you're not copy-pasting business logic. Otherwise you will need to remember to fix bugs in several places at once.
+
+:::
+
+## Step 4. Unpack the Shared layer {#unpack-shared-layer}
+
+You might have a lot of stuff in the Shared layer on this step, and you generally want to avoid that. The reason is that the Shared layer may be a dependency for any other layer in your codebase, so making changes to that code is automatically more prone to unintended consequences.
+
+Find all the objects that are only used on one page and move it to the slice of that page. And yes, _that applies to actions, reducers, and selectors, too_. There is no benefit in grouping all actions together, but there is benefit in colocating relevant actions close to their usage.
+
+You should end up with a file structure like this:
+
+
+ 📁 src
+
+
📁 app (unchanged)
+
+
+ 📁 pages
+
+
+
+ 📁 product
+
+
📁 actions
+
📁 reducers
+
📁 selectors
+
+
+ 📁 ui
+
+
📄 Component.jsx
+
📄 Container.jsx
+
📄 ProductPage.jsx
+
+
+
+
📄 index.js
+
+
+
+
📁 catalog
+
+
+
+
+
+ 📁 shared (only objects that are reused)
+
+
📁 actions
+
📁 api
+
📁 components
+
📁 containers
+
📁 constants
+
📁 i18n
+
📁 modules
+
📁 helpers
+
📁 utils
+
📁 reducers
+
📁 selectors
+
📁 styles
+
+
+
+
+
+
+## Step 5. Organize code by technical purpose {#organize-by-technical-purpose}
+
+In FSD, division by technical purpose is done with _segments_. There are a few common ones:
+
+- `ui` — everything related to UI display: UI components, date formatters, styles, etc.
+- `api` — backend interactions: request functions, data types, mappers, etc.
+- `model` — the data model: schemas, interfaces, stores, and business logic.
+- `lib` — library code that other modules on this slice need.
+- `config` — configuration files and feature flags.
+
+You can create your own segments, too, if you need. Make sure not to create segments that group code by what it is, like `components`, `actions`, `types`, `utils`. Instead, group the code by what it's for.
+
+Reorganize your pages to separate code by segments. You should already have a `ui` segment, now it's time to create other segments, like `model` for your actions, reducers, and selectors, or `api` for your thunks and mutations.
+
+Also reorganize the Shared layer to remove these folders:
+- `📁 components`, `📁 containers` — most of it should become `📁 shared/ui`;
+- `📁 helpers`, `📁 utils` — if there are some reused helpers left, group them together by function, like dates or type conversions, and move theses groups to `📁 shared/lib`;
+- `📁 constants` — again, group by function and move to `📁 shared/config`.
+
+## Optional steps {#optional-steps}
+
+### Step 6. Form entities/features from Redux slices that are used on several pages {#form-entities-features-from-redux}
+
+Usually, these reused Redux slices will describe something relevant to the business, for example, products or users, so these can be moved to the Entities layer, one entity per one folder. If the Redux slice is related to an action that your users want to do in your app, like comments, then you can move it to the Features layer.
+
+Entities and features are meant to be independent from each other. If your business domain contains inherent connections between entities, refer to the [guide on business entities][business-entities-cross-relations] for advice on how to organize these connections.
+
+The API functions related to these slices can stay in `📁 shared/api`.
+
+### Step 7. Refactor your modules {#refactor-your-modules}
+
+The `📁 modules` folder is commonly used for business logic, so it's already pretty similar in nature to the Features layer from FSD. Some modules might also be describe large chunks of the UI, like an app header. In that case, you should migrate them to the Widgets layer.
+
+### Step 8. Form a clean UI foundation in `shared/ui` {#form-clean-ui-foundation}
+
+`📁 shared/ui` should ideally contain a set of UI elements that don't have any business logic encoded in them. They should also be highly reusable.
+
+Refactor the UI components that used to be in `📁 components` and `📁 containers` to separate out the business logic. Move that business logic to the higher layers. If it's not used in too many places, you could even consider copy-pasting.
+
+## See also {#see-also}
+
+- [(Talk in Russian) Ilya Klimov — Крысиные бега бесконечного рефакторинга: как не дать техническому долгу убить мотивацию и продукт](https://youtu.be/aOiJ3k2UvO4)
+
+[ext-steiger]: https://github.com/feature-sliced/steiger
+[business-entities-cross-relations]: /docs/guides/examples/types#business-entities-and-their-cross-references
diff --git a/i18n/zh/docusaurus-plugin-content-docs/current/guides/migration/from-v1.md b/i18n/zh/docusaurus-plugin-content-docs/current/guides/migration/from-v1.md
new file mode 100644
index 000000000..e8e4b88b1
--- /dev/null
+++ b/i18n/zh/docusaurus-plugin-content-docs/current/guides/migration/from-v1.md
@@ -0,0 +1,171 @@
+---
+sidebar_position: 2
+---
+
+# 从 v1 到 v2 的迁移
+
+## 为什么是 v2?
+
+**feature-slices** 的原始概念于 2018 年[被宣布][ext-tg-spb]。
+
+从那时起,该方法论发生了许多变化,但同时**[基本原则得到了保留][ext-v1]**:
+
+- 使用*标准化*的前端项目结构
+- 首先按照*业务逻辑*分割应用程序
+- 使用*隔离的 features* 来防止隐式副作用和循环依赖
+- 使用 *Public API* 并禁止深入模块的"内部"
+
+同时,在方法论的上一个版本中,仍然存在**薄弱环节**:
+
+- 有时会导致样板代码
+- 有时会导致代码库的过度复杂化和抽象之间不明显的规则
+- 有时会导致隐式的架构解决方案,这阻止了项目的提升和新人的入职
+
+方法论的新版本([v2][ext-v2])旨在**消除这些缺点,同时保留该方法的现有优势**。
+
+Since 2018, [has also developed][ext-fdd-issues] another similar methodology - [**feature-driven**][ext-fdd], which was first announced by [Oleg Isonen][ext-kof].
+
+After merging of the two approaches, we have **improved and refined existing practices** - towards greater flexibility, clarity and efficiency in application.
+
+> As a result, this has even affected the name of the methodology - *"feature-slice**d**"*
+
+## Why does it make sense to migrate the project to v2?
+
+> `WIP:` The current version of the methodology is under development and some details *may change*
+
+#### 🔍 More transparent and simple architecture
+
+The methodology (v2) offers **more intuitive and more common abstractions and ways of separating logic among developers.**
+
+All this has an extremely positive effect on attracting new people, as well as studying the current state of the project, and distributing the business logic of the application.
+
+#### 📦 More flexible and honest modularity
+
+The methodology (v2) allows **to distribute logic in a more flexible way:**
+
+- With the ability to refactor isolated parts from scratch
+- With the ability to rely on the same abstractions, but without unnecessary interweaving of dependencies
+- With simpler requirements for the location of the new module *(layer => slice => segment)*
+
+#### 🚀 More specifications, plans, community
+
+At the moment, the `core-team` is actively working on the latest (v2) version of the methodology
+
+So it is for her:
+
+- there will be more described cases / problems
+- there will be more guides on the application
+- there will be more real examples
+- in general, there will be more documentation for onboarding new people and studying the concepts of the methodology
+- the toolkit will be developed in the future to comply with the concepts and conventions on architecture
+
+> Of course, there will be user support for the first version as well - but the latest version is still a priority for us
+>
+> In the future, with the next major updates, you will still have access to the current version (v2) of the methodology, **without risks for your teams and projects**
+
+## Changelog
+
+### `BREAKING` Layers
+
+Now the methodology assumes explicit allocation of layers at the top level
+
+- `/app` > `/processes` > **`/pages`** > **`/features`** > `/entities` > `/shared`
+- *That is, not everything is now treated as features/pages*
+- This approach allows you to [explicitly set rules for layers][ext-tg-v2-draft]:
+- The **higher the layer** of the module is located , the more **context** it has
+
+ *(in other words-each module of the layer - can import only the modules of the underlying layers, but not higher)*
+
+- The **lower the layer of the** module is located , the more **danger and responsibility** to make changes to it
+
+ *(because it is usually the underlying layers that are more overused)*
+
+### `BREAKING` Shared
+
+The infrastructure abstractions `/ui`, `/lib`, `/api`, which used to lie in the src root of the project, are now separated by a separate directory `/src/shared`
+
+- `shared/ui` - Still the same general uikit of the application (optional)
+ - *At the same time, no one forbids using `Atomic Design` here as before*
+- `shared/lib` - A set of auxiliary libraries for implementing logic
+ - *Still - without a dump of helpers*
+- `shared/api` - A common entry point for accessing the API
+ - *Can also be registered locally in each feature / page - but it is not recommended*
+- As before - there should be no explicit binding to business logic in `shared`
+ - *If necessary, you need to take this relationship to the `entities` level or even higher*
+
+### `NEW` Entities, Processes
+
+In v2 **, other new abstractions** have been added to eliminate the problems of logic complexity and high coupling.
+
+- `/entities` - layer **business entities** containing slices that are related directly to the business models or synthetic entities required only on frontend
+ - *Examples: `user`, `i18n`, `order`, `blog`*
+- `/processes` - layer **business processes**, penetrating app
+ - **The layer is optional**, it is usually recommended to use it when *the logic grows and begins to blur in several pages*
+ - *Examples: `payment`, `auth`, `quick-tour`*
+
+### `BREAKING` Abstractions & Naming
+
+Now specific abstractions and [clear recommendations for naming them][refs-adaptability]are defined
+
+[disc-process]: https://github.com/feature-sliced/documentation/discussions/20
+[disc-features]: https://github.com/feature-sliced/documentation/discussions/23
+[disc-entities]: https://github.com/feature-sliced/documentation/discussions/18#discussioncomment-422649
+[disc-shared]: https://github.com/feature-sliced/documentation/discussions/31#discussioncomment-453020
+
+[disc-ui]: https://github.com/feature-sliced/documentation/discussions/31#discussioncomment-453132
+[disc-model]: https://github.com/feature-sliced/documentation/discussions/31#discussioncomment-472645
+[disc-api]: https://github.com/feature-sliced/documentation/discussions/66
+
+#### Layers
+
+- `/app` — **application initialization layer**
+ - *Previous versions: `app`, `core`,`init`, `src/index` (and this happens)*
+- `/processes` — [**business process layer**][disc-process]
+ - *Previous versions: `processes`, `flows`, `workflows`*
+- `/pages` — **application page layer**
+ - *Previous versions: `pages`, `screens`, `views`, `layouts`, `components`, `containers`*
+- `/features` — [**functionality parts layer**][disc-features]
+ - *Previous versions: `features`, `components`, `containers`*
+- `/entities` — [**business entity layer**][disc-entities]
+ - *Previous versions: `entities`, `models`, `shared`*
+- `/shared` — [**layer of reused infrastructure code**][disc-shared] 🔥
+ - *Previous versions: `shared`, `common`, `lib`*
+
+#### Segments
+
+- `/ui` — [**UI segment**][disc-ui] 🔥
+ - *Previous versions: `ui`, `components`, `view`*
+- `/model` — [**BL-segment**][disc-model] 🔥
+ - *Previous versions: `model`, `store`, `state`, `services`, `controller`*
+- `/lib` — segment **of auxiliary code**
+ - *Previous versions: `lib`, `libs`, `utils`, `helpers`*
+- `/api` — [**API segment**][disc-api]
+ - *Previous versions: `api`, `service`, `requests`, `queries`*
+- `/config` — **application configuration segment**
+ - *Previous versions: `config`, `env`, `get-env`*
+
+### `REFINED` Low coupling
+
+Now it is much easier to [observe the principle of low coupling][refs-low-coupling] between modules, thanks to the new layers.
+
+*At the same time, it is still recommended to avoid as much as possible cases where it is extremely difficult to "uncouple" modules*
+
+## See also
+
+- [Notes from the report "React SPB Meetup #1"][ext-tg-spb]
+- [React Berlin Talk - Oleg Isonen "Feature Driven Architecture"][ext-kof-fdd]
+- [Comparison with v1 (community-chat)](https://t.me/feature_sliced/493)
+- [New ideas v2 with explanations (atomicdesign-chat)][ext-tg-v2-draft]
+- [Discussion of abstractions and naming for the new version of the methodology (v2)](https://github.com/feature-sliced/documentation/discussions/31)
+
+[refs-low-coupling]: /docs/reference/slices-segments#zero-coupling-high-cohesion
+[refs-adaptability]: /docs/about/understanding/naming
+
+[ext-v1]: https://feature-sliced.github.io/featureslices.dev/v1.0.html
+[ext-tg-spb]: https://t.me/feature_slices
+[ext-fdd]: https://github.com/feature-sliced/documentation/tree/rc/feature-driven
+[ext-fdd-issues]: https://github.com/kof/feature-driven-architecture/issues
+[ext-v2]: https://github.com/feature-sliced/documentation
+[ext-kof]: https://github.com/kof
+[ext-kof-fdd]: https://www.youtube.com/watch?v=BWAeYuWFHhs
+[ext-tg-v2-draft]: https://t.me/atomicdesign/18708
diff --git a/i18n/zh/docusaurus-plugin-content-docs/current/guides/migration/from-v2-0.md b/i18n/zh/docusaurus-plugin-content-docs/current/guides/migration/from-v2-0.md
new file mode 100644
index 000000000..af057a421
--- /dev/null
+++ b/i18n/zh/docusaurus-plugin-content-docs/current/guides/migration/from-v2-0.md
@@ -0,0 +1,45 @@
+---
+sidebar_position: 3
+---
+
+# Migration from v2.0 to v2.1
+
+The main change in v2.1 is the new mental model for decomposing an interface — pages first.
+
+In v2.0, FSD would recommend identifying entities and features in your interface, considering even the smallest bits of entity representation and interactivity for decomposition. Then you would build widgets and pages from entities and features. In this model of decomposition, most of the logic was in entities and features, and pages were just compositional layers that didn't have much significance on their own.
+
+In v2.1, we recommend starting with pages, and possibly even stopping there. Most people already know how to separate the app into individual pages, and pages are also a common starting point when trying to locate a component in the codebase. In this new model of decomposition, you keep most of the UI and logic in each individual page, maintaining a reusable foundation in Shared. If a need arises to reuse business logic across several pages, you can move it to a layer below.
+
+Another addition to Feature-Sliced Design is the standardization of cross-imports between entities with the `@x`-notation.
+
+## How to migrate {#how-to-migrate}
+
+There are no breaking changes in v2.1, which means that a project written with FSD v2.0 is also a valid project in FSD v2.1. However, we believe that the new mental model is more beneficial for teams and especially onboarding new developers, so we recommend making minor adjustments to your decomposition.
+
+### Merge slices
+
+A simple way to start is by running our linter, [Steiger][steiger], on the project. Steiger is built with the new mental model, and the most helpful rules will be:
+
+- [`insignificant-slice`][insignificant-slice] — if an entity or feature is only used in one page, this rule will suggest merging that entity or feature into the page entirely.
+- [`excessive-slicing`][excessive-slicing] — if a layer has too many slices, it's usually a sign that the decomposition is too fine-grained. This rule will suggest merging or grouping some slices to help project navigation.
+
+```bash
+npx steiger src
+```
+
+This will help you identify which slices are only used once, so that you could reconsider if they are really necessary. In such considerations, keep in mind that a layer forms some kind of global namespace for all the slices inside of it. Just as you wouldn't pollute the global namespace with variables that are only used once, you should treat a place in the namespace of a layer as valuable, to be used sparingly.
+
+### Standardize cross-imports
+
+If you had cross-imports between in your project before (we don't judge!), you may now take advantage of a new notation for cross-importing in Feature-Sliced Design — the `@x`-notation. It looks like this:
+
+```ts title="entities/B/some/file.ts"
+import type { EntityA } from "entities/A/@x/B";
+```
+
+For more details, check out the [Public API for cross-imports][public-api-for-cross-imports] section in the reference.
+
+[insignificant-slice]: https://github.com/feature-sliced/steiger/tree/master/packages/steiger-plugin-fsd/src/insignificant-slice
+[steiger]: https://github.com/feature-sliced/steiger
+[excessive-slicing]: https://github.com/feature-sliced/steiger/tree/master/packages/steiger-plugin-fsd/src/excessive-slicing
+[public-api-for-cross-imports]: /docs/reference/public-api#public-api-for-cross-imports
diff --git a/i18n/zh/docusaurus-plugin-content-docs/current/guides/tech/_category_.yaml b/i18n/zh/docusaurus-plugin-content-docs/current/guides/tech/_category_.yaml
new file mode 100644
index 000000000..fbd193502
--- /dev/null
+++ b/i18n/zh/docusaurus-plugin-content-docs/current/guides/tech/_category_.yaml
@@ -0,0 +1,2 @@
+label: 技术
+position: 3
diff --git a/i18n/zh/docusaurus-plugin-content-docs/current/guides/tech/with-electron.mdx b/i18n/zh/docusaurus-plugin-content-docs/current/guides/tech/with-electron.mdx
new file mode 100644
index 000000000..dc779d722
--- /dev/null
+++ b/i18n/zh/docusaurus-plugin-content-docs/current/guides/tech/with-electron.mdx
@@ -0,0 +1,134 @@
+---
+sidebar_position: 10
+---
+# Usage with Electron
+
+Electron applications have a special architecture consisting of multiple processes with different responsibilities. Applying FSD in such a context requires adapting the structure to the Electron specifics.
+
+```sh
+└── src
+ ├── app # Common app layer
+ │ ├── main # Main process
+ │ │ └── index.ts # Main process entry point
+ │ ├── preload # Preload script and Context Bridge
+ │ │ └── index.ts # Preload entry point
+ │ └── renderer # Renderer process
+ │ └── index.html # Renderer process entry point
+ ├── main
+ │ ├── features
+ │ │ └── user
+ │ │ └── ipc
+ │ │ ├── get-user.ts
+ │ │ └── send-user.ts
+ │ ├── entities
+ │ └── shared
+ ├── renderer
+ │ ├── pages
+ │ │ ├── settings
+ │ │ │ ├── ipc
+ │ │ │ │ ├── get-user.ts
+ │ │ │ │ └── save-user.ts
+ │ │ │ ├── ui
+ │ │ │ │ └── user.tsx
+ │ │ │ └── index.ts
+ │ │ └── home
+ │ │ ├── ui
+ │ │ │ └── home.tsx
+ │ │ └── index.ts
+ │ ├── widgets
+ │ ├── features
+ │ ├── entities
+ │ └── shared
+ └── shared # Common code between main and renderer
+ └── ipc # IPC description (event names, contracts)
+```
+
+## Public API rules
+Each process must have its own public API. For example, you can't import modules from `main` to `renderer`.
+Only the `src/shared` folder is public for both processes.
+It's also necessary for describing contracts for process interaction.
+
+## Additional changes to the standard structure
+It's suggested to use a new `ipc` segment, where interaction between processes takes place.
+The `pages` and `widgets` layers, based on their names, should not be present in `src/main`. You can use `features`, `entities` and `shared`.
+The `app` layer in `src` contains entry points for `main` and `renderer`, as well as the IPC.
+It's not desirable for segments in the `app` layer to have intersection points
+
+## Interaction example
+
+```typescript title="src/shared/ipc/channels.ts"
+export const CHANNELS = {
+ GET_USER_DATA: 'GET_USER_DATA',
+ SAVE_USER: 'SAVE_USER',
+} as const;
+
+export type TChannelKeys = keyof typeof CHANNELS;
+```
+
+```typescript title="src/shared/ipc/events.ts"
+import { CHANNELS } from './channels';
+
+export interface IEvents {
+ [CHANNELS.GET_USER_DATA]: {
+ args: void,
+ response?: { name: string; email: string; };
+ };
+ [CHANNELS.SAVE_USER]: {
+ args: { name: string; };
+ response: void;
+ };
+}
+```
+
+```typescript title="src/shared/ipc/preload.ts"
+import { CHANNELS } from './channels';
+import type { IEvents } from './events';
+
+type TOptionalArgs = T extends void ? [] : [args: T];
+
+export type TElectronAPI = {
+ [K in keyof typeof CHANNELS]: (...args: TOptionalArgs) => IEvents[typeof CHANNELS[K]]['response'];
+};
+```
+
+```typescript title="src/app/preload/index.ts"
+import { contextBridge, ipcRenderer } from 'electron';
+import { CHANNELS, type TElectronAPI } from 'shared/ipc';
+
+const API: TElectronAPI = {
+ [CHANNELS.GET_USER_DATA]: () => ipcRenderer.sendSync(CHANNELS.GET_USER_DATA),
+ [CHANNELS.SAVE_USER]: args => ipcRenderer.invoke(CHANNELS.SAVE_USER, args),
+} as const;
+
+contextBridge.exposeInMainWorld('electron', API);
+```
+
+```typescript title="src/main/features/user/ipc/send-user.ts"
+import { ipcMain } from 'electron';
+import { CHANNELS } from 'shared/ipc';
+
+export const sendUser = () => {
+ ipcMain.on(CHANNELS.GET_USER_DATA, ev => {
+ ev.returnValue = {
+ name: 'John Doe',
+ email: 'john.doe@example.com',
+ };
+ });
+};
+```
+
+```typescript title="src/renderer/pages/user-settings/ipc/get-user.ts"
+import { CHANNELS } from 'shared/ipc';
+
+export const getUser = () => {
+ const user = window.electron[CHANNELS.GET_USER_DATA]();
+
+ return user ?? { name: 'John Donte', email: 'john.donte@example.com' };
+};
+```
+
+## See also
+- [Process Model Documentation](https://www.electronjs.org/docs/latest/tutorial/process-model)
+- [Context Isolation Documentation](https://www.electronjs.org/docs/latest/tutorial/context-isolation)
+- [Inter-Process Communication Documentation](https://www.electronjs.org/docs/latest/tutorial/ipc)
+- [Example](https://github.com/feature-sliced/examples/tree/master/examples/electron)
\ No newline at end of file
diff --git a/i18n/zh/docusaurus-plugin-content-docs/current/guides/tech/with-nextjs.mdx b/i18n/zh/docusaurus-plugin-content-docs/current/guides/tech/with-nextjs.mdx
new file mode 100644
index 000000000..70eba9ee8
--- /dev/null
+++ b/i18n/zh/docusaurus-plugin-content-docs/current/guides/tech/with-nextjs.mdx
@@ -0,0 +1,197 @@
+---
+sidebar_position: 1
+---
+
+import Tabs from '@theme/Tabs';
+import TabItem from '@theme/TabItem';
+
+# Usage with Next.js
+
+FSD is compatible with Next.js in both the App Router version and the Pages Router version if you solve the main conflict — the `app` and `pages` folders.
+
+## App Router {#app-router}
+
+### Conflict between FSD and Next.js in the `app` layer {#conflict-between-fsd-and-nextjs-in-the-app-layer}
+
+Next.js suggests using the `app` folder to define application routes. It expects files in the `app` folder to correspond to pathnames. This routing mechanism **does not align** with the FSD concept, as it's not possible to maintain a flat slice structure.
+
+The solution is to move the Next.js `app` folder to the project root and import FSD pages from `src`, where the FSD layers are, into the Next.js `app` folder.
+
+You will also need to add a `pages` folder to the project root, otherwise Next.js will try to use `src/pages` as the Pages Router even if you use the App Router, which will break the build. It's also a good idea to put a `README.md` file inside this root `pages` folder describing why it is necessary, even though it's empty.
+
+```sh
+├── app # App folder (Next.js)
+│ ├── api
+│ │ └── get-example
+│ │ └── route.ts
+│ └── example
+│ └── page.tsx
+├── pages # Empty pages folder (Next.js)
+│ └── README.md
+└── src
+ ├── app
+ │ └── api-routes # API routes
+ ├── pages
+ │ └── example
+ │ ├── index.ts
+ │ └── ui
+ │ └── example.tsx
+ ├── widgets
+ ├── features
+ ├── entities
+ └── shared
+```
+
+Example of re-exporting a page from `src/pages` in the Next.js `app`:
+
+```tsx title="app/example/page.tsx"
+export { ExamplePage as default, metadata } from '@/pages/example';
+```
+
+### Middleware {#middleware}
+
+If you use middleware in your project, it must be located in the project root alongside the Next.js `app` and `pages` folders.
+
+### Instrumentation {#instrumentation}
+
+The `instrumentation.js` file allows you to monitor the performance and behavior of your application. If you use it, it must be located in the project root, similar to `middleware.js`.
+
+## Pages Router {#pages-router}
+
+### Conflict between FSD and Next.js in the `pages` layer {#conflict-between-fsd-and-nextjs-in-the-pages-layer}
+
+Routes should be placed in the `pages` folder in the root of the project, similar to `app` folder for the App Router. The structure inside `src` where the layer folders are located remains unchanged.
+
+```sh
+├── pages # Pages folder (Next.js)
+│ ├── _app.tsx
+│ ├── api
+│ │ └── example.ts # API route re-export
+│ └── example
+│ └── index.tsx
+└── src
+ ├── app
+ │ ├── custom-app
+ │ │ └── custom-app.tsx # Custom App component
+ │ └── api-routes
+ │ └── get-example-data.ts # API route
+ ├── pages
+ │ └── example
+ │ ├── index.ts
+ │ └── ui
+ │ └── example.tsx
+ ├── widgets
+ ├── features
+ ├── entities
+ └── shared
+```
+
+Example of re-exporting a page from `src/pages` in the Next.js `pages`:
+
+```tsx title="pages/example/index.tsx"
+export { Example as default } from '@/pages/example';
+```
+
+### Custom `_app` component {#custom-_app-component}
+
+You can place your Custom App component in `src/app/_app` or `src/app/custom-app`:
+
+```tsx title="src/app/custom-app/custom-app.tsx"
+import type { AppProps } from 'next/app';
+
+export const MyApp = ({ Component, pageProps }: AppProps) => {
+ return (
+ <>
+
My Custom App component
+
+ >
+ );
+};
+```
+
+```tsx title="pages/_app.tsx"
+export { App as default } from '@/app/custom-app';
+```
+
+## Route Handlers (API routes) {#route-handlers-api-routes}
+
+Use the `api-routes` segment in the `app` layer to work with Route Handlers.
+
+Be mindful when writing backend code in the FSD structure — FSD is primarily intended for frontends, meaning that's what people will expect to find.
+If you need a lot of endpoints, consider separating them into a different package in a monorepo.
+
+
+
+
+
+```tsx title="src/app/api-routes/get-example-data.ts"
+import { getExamplesList } from '@/shared/db';
+
+export const getExampleData = () => {
+ try {
+ const examplesList = getExamplesList();
+
+ return Response.json({ examplesList });
+ } catch {
+ return Response.json(null, {
+ status: 500,
+ statusText: 'Ouch, something went wrong',
+ });
+ }
+};
+```
+
+```tsx title="app/api/example/route.ts"
+export { getExampleData as GET } from '@/app/api-routes';
+```
+
+
+
+
+
+```tsx title="src/app/api-routes/get-example-data.ts"
+import type { NextApiRequest, NextApiResponse } from 'next';
+
+const config = {
+ api: {
+ bodyParser: {
+ sizeLimit: '1mb',
+ },
+ },
+ maxDuration: 5,
+};
+
+const handler = (req: NextApiRequest, res: NextApiResponse) => {
+ res.status(200).json({ message: 'Hello from FSD' });
+};
+
+export const getExampleData = { config, handler } as const;
+```
+
+```tsx title="src/app/api-routes/index.ts"
+export { getExampleData } from './get-example-data';
+```
+
+```tsx title="app/api/example.ts"
+import { getExampleData } from '@/app/api-routes';
+
+export const config = getExampleData.config;
+export default getExampleData.handler;
+```
+
+
+
+
+
+## Additional recommendations {#additional-recommendations}
+
+- Use the `db` segment in the `shared` layer to describe database queries and their further use in higher layers.
+- Caching and revalidating queries logic is better kept in the same place as the queries themselves.
+
+## See also {#see-also}
+
+- [Next.js Project Structure](https://nextjs.org/docs/app/getting-started/project-structure)
+- [Next.js Page Layouts](https://nextjs.org/docs/app/getting-started/layouts-and-pages)
+
+[project-knowledge]: /docs/about/understanding/knowledge-types
+[ext-app-router-stackblitz]: https://stackblitz.com/edit/stackblitz-starters-aiez55?file=README.md
diff --git a/i18n/zh/docusaurus-plugin-content-docs/current/guides/tech/with-nuxtjs.mdx b/i18n/zh/docusaurus-plugin-content-docs/current/guides/tech/with-nuxtjs.mdx
new file mode 100644
index 000000000..929bdcaf5
--- /dev/null
+++ b/i18n/zh/docusaurus-plugin-content-docs/current/guides/tech/with-nuxtjs.mdx
@@ -0,0 +1,179 @@
+---
+sidebar_position: 10
+---
+# Usage with NuxtJS
+
+It is possible to implement FSD in a NuxtJS project, but conflicts arise due to the differences between NuxtJS project structure requirements and FSD principles:
+
+- Initially, NuxtJS offers a project file structure without a `src` folder, i.e. in the root of the project.
+- The file routing is in the `pages` folder, while in FSD this folder is reserved for the flat slice structure.
+
+
+## Adding an alias for the `src` directory
+
+Add an `alias` object to your config:
+```ts title="nuxt.config.ts"
+export default defineNuxtConfig({
+ devtools: { enabled: true }, // Not FSD related, enabled at project startup
+ alias: {
+ "@": '../src'
+ },
+})
+```
+## Choose how to configure the router
+
+In NuxtJS, there are two ways to customize the routing - using a config and using a file structure.
+In the case of file-based routing, you will create index.vue files in folders inside the app/routes directory, and in the case of configure, you will configure the routers in the `router.options.ts` file.
+
+
+### Routing using config
+
+In the `app` layer, create a `router.options.ts` file, and export a config object from it:
+```ts title="app/router.options.ts"
+import type { RouterConfig } from '@nuxt/schema';
+
+export default {
+ routes: (_routes) => [],
+};
+
+```
+
+To add a `Home` page to your project, you need to do the following steps:
+- Add a page slice inside the `pages` layer
+- Add the appropriate route to the `app/router.config.ts` config
+
+
+To create a page slice, let's use the [CLI](https://github.com/feature-sliced/cli):
+
+```shell
+fsd pages home
+```
+
+Create a ``home-page.vue`` file inside the ui segment, access it using the Public API
+
+```ts title="src/pages/home/index.ts"
+export { default as HomePage } from './ui/home-page';
+```
+
+Thus, the file structure will look like this:
+```sh
+|── src
+│ ├── app
+│ │ ├── router.config.ts
+│ ├── pages
+│ │ ├── home
+│ │ │ ├── ui
+│ │ │ │ ├── home-page.vue
+│ │ │ ├── index.ts
+```
+Finally, let's add a route to the config:
+
+```ts title="app/router.config.ts"
+import type { RouterConfig } from '@nuxt/schema'
+
+export default {
+ routes: (_routes) => [
+ {
+ name: 'home',
+ path: '/',
+ component: () => import('@/pages/home.vue').then(r => r.default || r)
+ }
+ ],
+}
+```
+
+### File Routing
+
+First of all, create a `src` directory in the root of your project, and create app and pages layers inside this directory and a routes folder inside the app layer.
+Thus, your file structure should look like this:
+
+```sh
+├── src
+│ ├── app
+│ │ ├── routes
+│ ├── pages # Pages folder, related to FSD
+```
+
+In order for NuxtJS to use the routes folder inside the `app` layer for file routing, you need to modify `nuxt.config.ts` as follows:
+```ts title="nuxt.config.ts"
+export default defineNuxtConfig({
+ devtools: { enabled: true }, // Not FSD related, enabled at project startup
+ alias: {
+ "@": '../src'
+ },
+ dir: {
+ pages: './src/app/routes'
+ }
+})
+```
+
+Now, you can create routes for pages within `app` and connect pages from `pages` to them.
+
+For example, to add a `Home` page to your project, you need to do the following steps:
+- Add a page slice inside the `pages` layer
+- Add the corresponding route inside the `app` layer
+- Connect the page from the slice with the route
+
+To create a page slice, let's use the [CLI](https://github.com/feature-sliced/cli):
+
+```shell
+fsd pages home
+```
+
+Create a ``home-page.vue`` file inside the ui segment, access it using the Public API
+
+```ts title="src/pages/home/index.ts"
+export { default as HomePage } from './ui/home-page';
+```
+
+Create a route for this page inside the `app` layer:
+
+```sh
+
+├── src
+│ ├── app
+│ │ ├── routes
+│ │ │ ├── index.vue
+│ ├── pages
+│ │ ├── home
+│ │ │ ├── ui
+│ │ │ │ ├── home-page.vue
+│ │ │ ├── index.ts
+```
+
+Add your page component inside the `index.vue` file:
+
+```html title="src/app/routes/index.vue"
+
+
+
+
+
+```
+
+## What to do with `layouts`?
+
+You can place layouts inside the `app` layer, to do this you need to modify the config as follows:
+
+```ts title="nuxt.config.ts"
+export default defineNuxtConfig({
+ devtools: { enabled: true }, // Not related to FSD, enabled at project startup
+ alias: {
+ "@": '../src'
+ },
+ dir: {
+ pages: './src/app/routes',
+ layouts: './src/app/layouts'
+ }
+})
+```
+
+
+## See also
+
+- [Documentation on changing directory config in NuxtJS](https://nuxt.com/docs/api/nuxt-config#dir)
+- [Documentation on changing router config in NuxtJS](https://nuxt.com/docs/guide/recipes/custom-routing#router-config)
+- [Documentation on changing aliases in NuxtJS](https://nuxt.com/docs/api/nuxt-config#alias)
+
diff --git a/i18n/zh/docusaurus-plugin-content-docs/current/guides/tech/with-react-query.mdx b/i18n/zh/docusaurus-plugin-content-docs/current/guides/tech/with-react-query.mdx
new file mode 100644
index 000000000..88931cfa3
--- /dev/null
+++ b/i18n/zh/docusaurus-plugin-content-docs/current/guides/tech/with-react-query.mdx
@@ -0,0 +1,436 @@
+---
+sidebar_position: 10
+---
+# Usage with React Query
+
+## The problem of “where to put the keys”
+
+### Solution — break down by entities
+
+If the project already has a division into entities, and each request corresponds to a single entity,
+the purest division will be by entity. In this case, we suggest using the following structure:
+```sh
+└── src/ #
+ ├── app/ #
+ | ... #
+ ├── pages/ #
+ | ... #
+ ├── entities/ #
+ | ├── {entity}/ #
+ | ... └── api/ #
+ | ├── `{entity}.query` # Query-factory where are the keys and functions
+ | ├── `get-{entity}` # Entity getter function
+ | ├── `create-{entity}` # Entity creation function
+ | ├── `update-{entity}` # Entity update function
+ | ├── `delete-{entity}` # Entity delete function
+ | ... #
+ | #
+ ├── features/ #
+ | ... #
+ ├── widgets/ #
+ | ... #
+ └── shared/ #
+ ... #
+```
+
+If there are connections between the entities (for example, the Country entity has a field-list of City entities),
+then you can use the [public API for cross-imports][public-api-for-cross-imports] or consider the alternative solution below.
+
+### Alternative solution — keep it in shared
+
+In cases where entity separation is not appropriate, the following structure can be considered:
+
+```sh
+└── src/ #
+ ... #
+ └── shared/ #
+ ├── api/ #
+ ... ├── `queries` # Query-factories
+ | ├── `document.ts` #
+ | ├── `background-jobs.ts` #
+ | ... #
+ └── index.ts #
+```
+
+Then in `@/shared/api/index.ts`:
+
+```ts title="@/shared/api/index.ts"
+export { documentQueries } from "./queries/document";
+```
+
+## The problem of “Where to insert mutations?”
+
+It is not recommended to mix mutations with queries. There are two options:
+
+### 1. Define a custom hook in the `api` segment near the place of use
+
+```tsx title="@/features/update-post/api/use-update-title.ts"
+export const useUpdateTitle = () => {
+ const queryClient = useQueryClient();
+
+ return useMutation({
+ mutationFn: ({ id, newTitle }) =>
+ apiClient
+ .patch(`/posts/${id}`, { title: newTitle })
+ .then((data) => console.log(data)),
+
+ onSuccess: (newPost) => {
+ queryClient.setQueryData(postsQueries.ids(id), newPost);
+ },
+ });
+};
+```
+
+### 2. Define a mutation function somewhere else (Shared or Entities) and use `useMutation` directly in the component
+
+```tsx
+const { mutateAsync, isPending } = useMutation({
+ mutationFn: postApi.createPost,
+});
+```
+
+```tsx title="@/pages/post-create/ui/post-create-page.tsx"
+export const CreatePost = () => {
+ const { classes } = useStyles();
+ const [title, setTitle] = useState("");
+
+ const { mutate, isPending } = useMutation({
+ mutationFn: postApi.createPost,
+ });
+
+ const handleChange = (e: ChangeEvent) =>
+ setTitle(e.target.value);
+ const handleSubmit = (e: FormEvent) => {
+ e.preventDefault();
+ mutate({ title, userId: DEFAULT_USER_ID });
+ };
+
+ return (
+
+ );
+};
+```
+
+## Organization of requests
+
+### Query factory
+
+A query factory is an object where the key values are functions that return a list of query keys. Here's how to use it:
+
+```ts
+const keyFactory = {
+ all: () => ["entity"],
+ lists: () => [...postQueries.all(), "list"],
+};
+```
+
+:::info
+`queryOptions` is a built-in utility in react-query@v5 (optional)
+
+```ts
+queryOptions({
+ queryKey,
+ ...options,
+});
+```
+
+For greater type safety, further compatibility with future versions of react-query, and easy access to functions and query keys,
+you can use the built-in queryOptions function from “@tanstack/react-query”
+[(More details here)](https://tkdodo.eu/blog/the-query-options-api#queryoptions).
+:::
+
+### 1. Creating a Query Factory
+
+```tsx title="@/entities/post/api/post.queries.ts"
+import { keepPreviousData, queryOptions } from "@tanstack/react-query";
+import { getPosts } from "./get-posts";
+import { getDetailPost } from "./get-detail-post";
+import { PostDetailQuery } from "./query/post.query";
+
+export const postQueries = {
+ all: () => ["posts"],
+
+ lists: () => [...postQueries.all(), "list"],
+ list: (page: number, limit: number) =>
+ queryOptions({
+ queryKey: [...postQueries.lists(), page, limit],
+ queryFn: () => getPosts(page, limit),
+ placeholderData: keepPreviousData,
+ }),
+
+ details: () => [...postQueries.all(), "detail"],
+ detail: (query?: PostDetailQuery) =>
+ queryOptions({
+ queryKey: [...postQueries.details(), query?.id],
+ queryFn: () => getDetailPost({ id: query?.id }),
+ staleTime: 5000,
+ }),
+};
+```
+
+### 2. Using Query Factory in application code
+```tsx
+import { useParams } from "react-router-dom";
+import { postApi } from "@/entities/post";
+import { useQuery } from "@tanstack/react-query";
+
+type Params = {
+ postId: string;
+};
+
+export const PostPage = () => {
+ const { postId } = useParams();
+ const id = parseInt(postId || "");
+ const {
+ data: post,
+ error,
+ isLoading,
+ isError,
+ } = useQuery(postApi.postQueries.detail({ id }));
+
+ if (isLoading) {
+ return
+ );
+};
+```
+
+### Benefits of using a Query Factory
+- **Request structuring:** A factory allows you to organize all API requests in one place, making your code more readable and maintainable.
+- **Convenient access to queries and keys:** The factory provides convenient methods for accessing different types of queries and their keys.
+- **Query Refetching Ability:** The factory allows easy refetching without the need to change query keys in different parts of the application.
+
+## Pagination
+
+In this section, we'll look at an example of the `getPosts` function, which makes an API request to retrieve post entities using pagination.
+
+### 1. Creating a function `getPosts`
+The getPosts function is located in the `get-posts.ts` file, which is located in the `api` segment
+
+```tsx title="@/pages/post-feed/api/get-posts.ts"
+import { apiClient } from "@/shared/api/base";
+
+import { PostWithPaginationDto } from "./dto/post-with-pagination.dto";
+import { PostQuery } from "./query/post.query";
+import { mapPost } from "./mapper/map-post";
+import { PostWithPagination } from "../model/post-with-pagination";
+
+const calculatePostPage = (totalCount: number, limit: number) =>
+ Math.floor(totalCount / limit);
+
+export const getPosts = async (
+ page: number,
+ limit: number,
+): Promise => {
+ const skip = page * limit;
+ const query: PostQuery = { skip, limit };
+ const result = await apiClient.get("/posts", query);
+
+ return {
+ posts: result.posts.map((post) => mapPost(post)),
+ limit: result.limit,
+ skip: result.skip,
+ total: result.total,
+ totalPages: calculatePostPage(result.total, limit),
+ };
+};
+```
+
+### 2. Query factory for pagination
+The `postQueries` query factory defines various query options for working with posts,
+including requesting a list of posts with a specific page and limit.
+
+```tsx
+import { keepPreviousData, queryOptions } from "@tanstack/react-query";
+import { getPosts } from "./get-posts";
+
+export const postQueries = {
+ all: () => ["posts"],
+ lists: () => [...postQueries.all(), "list"],
+ list: (page: number, limit: number) =>
+ queryOptions({
+ queryKey: [...postQueries.lists(), page, limit],
+ queryFn: () => getPosts(page, limit),
+ placeholderData: keepPreviousData,
+ }),
+};
+```
+
+
+### 3. Use in application code
+
+```tsx title="@/pages/home/ui/index.tsx"
+export const HomePage = () => {
+ const itemsOnScreen = DEFAULT_ITEMS_ON_SCREEN;
+ const [page, setPage] = usePageParam(DEFAULT_PAGE);
+ const { data, isFetching, isLoading } = useQuery(
+ postApi.postQueries.list(page, itemsOnScreen),
+ );
+ return (
+ <>
+ setPage(page)}
+ page={page}
+ count={data?.totalPages}
+ variant="outlined"
+ color="primary"
+ />
+
+ >
+ );
+};
+```
+:::note
+The example is simplified, the full version is available on [GitHub](https://github.com/ruslan4432013/fsd-react-query-example)
+:::
+
+## `QueryProvider` for managing queries
+In this guide, we will look at how to organize a `QueryProvider`.
+
+### 1. Creating a `QueryProvider`
+The file `query-provider.tsx` is located at the path `@/app/providers/query-provider.tsx`.
+
+```tsx title="@/app/providers/query-provider.tsx"
+import { QueryClient, QueryClientProvider } from "@tanstack/react-query";
+import { ReactQueryDevtools } from "@tanstack/react-query-devtools";
+import { ReactNode } from "react";
+
+type Props = {
+ children: ReactNode;
+ client: QueryClient;
+};
+
+export const QueryProvider = ({ client, children }: Props) => {
+ return (
+
+ {children}
+
+
+ );
+};
+```
+
+### 2. Creating a `QueryClient`
+`QueryClient` is an instance used to manage API requests.
+The `query-client.ts` file is located at `@/shared/api/query-client.ts`.
+`QueryClient` is created with certain settings for query caching.
+
+```tsx title="@/shared/api/query-client.ts"
+import { QueryClient } from "@tanstack/react-query";
+
+export const queryClient = new QueryClient({
+ defaultOptions: {
+ queries: {
+ staleTime: 5 * 60 * 1000,
+ gcTime: 5 * 60 * 1000,
+ },
+ },
+});
+```
+
+## Code generation
+
+There are tools that can generate API code for you, but they are less flexible than the manual approach described above.
+If your Swagger file is well-structured,
+and you're using one of these tools, it might make sense to generate all the code in the `@/shared/api` directory.
+
+
+## Additional advice for organizing RQ
+### API Client
+
+Using a custom API client class in the shared layer,
+you can standardize the configuration and work with the API in the project.
+This allows you to manage logging,
+headers and data exchange format (such as JSON or XML) from one place.
+This approach makes it easier to maintain and develop the project because it simplifies changes and updates to interactions with the API.
+
+```tsx title="@/shared/api/api-client.ts"
+import { API_URL } from "@/shared/config";
+
+export class ApiClient {
+ private baseUrl: string;
+
+ constructor(url: string) {
+ this.baseUrl = url;
+ }
+
+ async handleResponse(response: Response): Promise {
+ if (!response.ok) {
+ throw new Error(`HTTP error! Status: ${response.status}`);
+ }
+
+ try {
+ return await response.json();
+ } catch (error) {
+ throw new Error("Error parsing JSON response");
+ }
+ }
+
+ public async get(
+ endpoint: string,
+ queryParams?: Record,
+ ): Promise {
+ const url = new URL(endpoint, this.baseUrl);
+
+ if (queryParams) {
+ Object.entries(queryParams).forEach(([key, value]) => {
+ url.searchParams.append(key, value.toString());
+ });
+ }
+ const response = await fetch(url.toString(), {
+ method: "GET",
+ headers: {
+ "Content-Type": "application/json",
+ },
+ });
+
+ return this.handleResponse(response);
+ }
+
+ public async post>(
+ endpoint: string,
+ body: TData,
+ ): Promise {
+ const response = await fetch(`${this.baseUrl}${endpoint}`, {
+ method: "POST",
+ headers: {
+ "Content-Type": "application/json",
+ },
+ body: JSON.stringify(body),
+ });
+
+ return this.handleResponse(response);
+ }
+}
+
+export const apiClient = new ApiClient(API_URL);
+```
+
+## See also {#see-also}
+
+- [(GitHub) Sample Project](https://github.com/ruslan4432013/fsd-react-query-example)
+- [(CodeSandbox) Sample Project](https://codesandbox.io/p/github/ruslan4432013/fsd-react-query-example/main)
+- [About the query factory](https://tkdodo.eu/blog/the-query-options-api)
+
+[public-api-for-cross-imports]: /docs/reference/public-api#public-api-for-cross-imports
diff --git a/i18n/zh/docusaurus-plugin-content-docs/current/guides/tech/with-sveltekit.mdx b/i18n/zh/docusaurus-plugin-content-docs/current/guides/tech/with-sveltekit.mdx
new file mode 100644
index 000000000..886b2381e
--- /dev/null
+++ b/i18n/zh/docusaurus-plugin-content-docs/current/guides/tech/with-sveltekit.mdx
@@ -0,0 +1,100 @@
+---
+sidebar_position: 10
+---
+# Usage with SvelteKit
+
+It is possible to implement FSD in a SvelteKit project, but conflicts arise due to the differences between the structure requirements of a SvelteKit project and the principles of FSD:
+
+- Initially, SvelteKit offers a file structure inside the `src/routes` folder, while in FSD the routing must be part of the `app` layer.
+- SvelteKit suggests putting everything not related to routing in the `src/lib` folder.
+
+
+## Let's set up the config
+
+```ts title="svelte.config.ts"
+import adapter from '@sveltejs/adapter-auto';
+import { vitePreprocess } from '@sveltejs/vite-plugin-svelte';
+
+/** @type {import('@sveltejs/kit').Config}*/
+const config = {
+ preprocess: [vitePreprocess()],
+ kit: {
+ adapter: adapter(),
+ files: {
+ routes: 'src/app/routes', // move routing inside the app layer
+ lib: 'src',
+ appTemplate: 'src/app/index.html', // Move the application entry point inside the app layer
+ assets: 'public'
+ },
+ alias: {
+ '@/*': 'src/*' // Create an alias for the src directory
+ }
+ }
+};
+export default config;
+```
+
+## Move file routing to `src/app`.
+
+Let's create an app layer, move the app's entry point `index.html` into it, and create a routes folder.
+Thus, your file structure should look like this:
+
+```sh
+├── src
+│ ├── app
+│ │ ├── index.html
+│ │ ├── routes
+│ ├── pages # FSD Pages folder
+```
+
+Now, you can create routes for pages within `app` and connect pages from `pages` to them.
+
+For example, to add a home page to your project, you need to do the following steps:
+- Add a page slice inside the `pages` layer
+- Add the corresponding rooute to the `routes` folder from the `app` layer
+- Align the page from the slice with the rooute
+
+To create a page slice, let's use the [CLI](https://github.com/feature-sliced/cli):
+
+```shell
+fsd pages home
+```
+
+Create a ``home-page.svelte`` file inside the ui segment, access it using the Public API
+
+```ts title="src/pages/home/index.ts"
+export { default as HomePage } from './ui/home-page.svelte';
+```
+
+Create a route for this page inside the `app` layer:
+
+```sh
+
+├── src
+│ ├── app
+│ │ ├── routes
+│ │ │ ├── +page.svelte
+│ │ ├── index.html
+│ ├── pages
+│ │ ├── home
+│ │ │ ├── ui
+│ │ │ │ ├── home-page.svelte
+│ │ │ ├── index.ts
+```
+
+Add your page component inside the `+page.svelte` file:
+
+```html title="src/app/routes/+page.svelte"
+
+
+
+
+```
+
+## See also.
+
+- [Documentation on changing directory config in SvelteKit](https://kit.svelte.dev/docs/configuration#files)
+
+
diff --git a/i18n/zh/docusaurus-plugin-content-docs/current/intro.mdx b/i18n/zh/docusaurus-plugin-content-docs/current/intro.mdx
new file mode 100644
index 000000000..7f08f72a0
--- /dev/null
+++ b/i18n/zh/docusaurus-plugin-content-docs/current/intro.mdx
@@ -0,0 +1,69 @@
+---
+sidebar_position: 1
+slug: /
+pagination_next: get-started/index
+---
+
+# 文档
+
+
+
+**Feature-Sliced Design**(FSD)是一种用于构建前端应用程序的架构方法论。简单来说,它是组织代码的规则和约定的汇编。该方法论的主要目的是在不断变化的业务需求面前,使项目更加易于理解和结构化。
+
+import NavCard from "@site/src/shared/ui/nav-card/tmpl.mdx"
+import { RocketOutlined, ThunderboltOutlined, FundViewOutlined } from "@ant-design/icons";
+import Link from "@docusaurus/Link";
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/i18n/zh/docusaurus-plugin-content-docs/current/reference/index.mdx b/i18n/zh/docusaurus-plugin-content-docs/current/reference/index.mdx
new file mode 100644
index 000000000..dc904866c
--- /dev/null
+++ b/i18n/zh/docusaurus-plugin-content-docs/current/reference/index.mdx
@@ -0,0 +1,33 @@
+---
+sidebar_position: 0
+hide_table_of_contents: true
+pagination_prev: guides/index
+---
+
+import NavCard from "@site/src/shared/ui/nav-card/tmpl.mdx"
+import { ApiOutlined, GroupOutlined, AppstoreOutlined, NodeIndexOutlined } from "@ant-design/icons";
+
+# 📚 参考
+
+