目录 (14)
【博客简介】前端 - 架构
为了搭建这个博客,我尝试了好几次项目配置,过程中也放弃过好几次。经过各种尝试,我得出的结论是:采用 monorepo 结构,既能最清晰地拆分项目,用起来也最方便。只靠文件夹结构来划分功能时,文件夹会被拆得过细;可如果把各个包拆分成不同的 repo,管理起来、应用到其他应用上又很烦人。尤其是因为要包含编辑器功能,代码量变大,领域和代码很容易混在一起。相反,在一个仓库中按模块拆分的方式,自然而然地就能把领域和代码分开,还能兼顾可复用性和易用性(开发者体验),我确实感受到了它的优势。
1. 微前端(Micro Frontend)架构与配置
下面是我搭建博客时使用的 Monorepo 结构。

过去的文件夹结构(使用 tsconfig Reference 功能)
公共配置放在 eslint.base.js 和 tsconfig.base.json 中,各个应用和包通过 extends 来使用它们。为了优化,还利用 references 属性建立了依赖关系。不过,由于是用最新版本(eslint v9.16)来配置的,参考资料不足,有一部分配置得有些乱七八糟。
├── apps/│ ├── storyBook/ # storybook│ ├── carrotBlogFront/ # Next.js 应用 (主前端)│ └── carrotMobileApp/ # React Native 应用 ├── packages/│ ├── designSystem/ # 基于 tailwind 的设计系统│ ├── editor/ # 编辑器│ ├── domain/ # 领域 [Entity, FetchApi, Util]│ └── utils/ # 公共工具├── preinstall.js # preinstall 脚本├── pnpm-workspace.yaml # pnpm 用单独的文件定义工作区├── package.json ├── turbo.json # 构建流水线、task 配置├── eslint.config.js # root eslint├── tsconfig.json # root tsconfig├── eslint.config.base.js # 公共 eslint└── tsconfig.base.json # 公共 tsconfig现在的文件夹结构(采用 Just in Time packages)
我把 tsconfig 和 eslint 配置中的公共部分分别做成了包,以便更直观地查找和管理。
另外,原来的 tsconfig 利用 references 字段做了优化,但由于是一个人开发,项目很难变得特别庞大,所以改成了在易用性方面更好的 just in time packages 方式。(删除了 references)
我最初配置 eslint 时用的是最新版本的 eslint,一边查用法一边应用,所以配置得有些混乱。因此,我把大部分配置改成了通过 dlx 创建 turboRepo 时生成的默认配置。
├── apps/│ ├── storyBook/ # storybook│ ├── carrotBlogFront/ # Next.js 应用 (主前端)│ └── carrotMobileApp/ # React Native 应用 ├── packages/│ ├── designSystem/ # 基于 tailwind 的设计系统│ ├── editor/ # 编辑器│ ├── domain/ # 领域 [Entity, FetchApi, Util]│ ├── utils/ # 公共工具│ ├── eslintConfig/ # eslint 配置│ └── tsConfig/ # TypeScript 配置├── preinstall.js # preinstall 脚本├── pnpm-workspace.yaml # pnpm 用单独的文件定义工作区├── package.json └── turbo.json # 构建流水线、task 配置// apps/*/package.json// pacckages/*/package.json{ "devDependencies": { "@yooncarrot/eslint-config": "workspace:*", "@yooncarrot/ts-config": "workspace:*", "eslint": "9.16.0" }}// packages/typescript-config/tsconfig.base.json{ "$schema": "https://json.schemastore.org/tsconfig", "compilerOptions": { "declaration": true, "declarationMap": true, "esModuleInterop": true, "isolatedModules": true, "composite": true, "lib": ["es2022", "DOM", "DOM.Iterable"], "module": "NodeNext", "moduleDetection": "force", "moduleResolution": "nodenext", "noUncheckedIndexedAccess": false, // 即使通过 index 访问也不会出现 undefined "resolveJsonModule": true, "skipLibCheck": true, "strict": true, "forceConsistentCasingInFileNames": true, "allowImportingTsExtensions": true, "emitDeclarationOnly": true, "target": "ES2022" }}// packages/exlint-config/base.jsimport js from "@eslint/js";import eslintConfigPrettier from "eslint-config-prettier";import turboPlugin from "eslint-plugin-turbo";import tseslint from "typescript-eslint";import onlyWarn from "eslint-plugin-only-warn";/** * A shared ESLint configuration for the repository. * * @type {import("eslint").Linter.Config[]} * */export const config = [ js.configs.recommended, eslintConfigPrettier, ...tseslint.configs.recommended, { plugins: { turbo: turboPlugin, }, rules: { "turbo/no-undeclared-env-vars": "off", "no-unused-vars": "off", "@typescript-eslint/no-unused-vars": [ // 未使用的变量加上下划线前缀就不会报错 "error", { args: "all", argsIgnorePattern: "^_", caughtErrors: "all", caughtErrorsIgnorePattern: "^_", destructuredArrayIgnorePattern: "^_", varsIgnorePattern: "^_", ignoreRestSiblings: true, }, ], }, }, { plugins: { onlyWarn, }, }, { ignores: ["dist/**"], },];1.1 App 与 Package
博客项目中的 App 有 Storybook、React Web、React Native 三个。包则由 Design System、Editor、Domain、Utils 四个,以及用于 ts 和 esLint 配置的 tsConfig、eslintConfig 两个组成。
App
React Web
React Native
Storybook
Package
DesignSystem
Editor
Domain
Utils
tsConfig
esLintConfig
这里单独拆分出 Domain 的目的,是为了更有条理地使用 API。(并不是按领域驱动开发的思路来考虑的。)Domain 包的作用有以下三个。
定义前端要使用的 Article、Category 等 Entity,同时定义从后端接收的 DTO,再把 DTO 加工成 Entity,让 App 可以直接以 Entity 的形式使用。
另外,API 是按 RESTful 风格设计的(成熟度大约 2 级),为了在使用 [Get, /articles] 这样的 api 时能更有条理地利用查询参数,我把它和 App 分离开了。因此,公共的查询参数可以通过 QueryStringFactory 这样的对象进行规范化管理。
ex) [Get, /articles?q=博客&sort=+createdAt-likes&category=Typescript&page=0&size=9] 这个 api 会搜索“博客”,返回按创建时间升序、点赞数降序排序的数据,并且只获取分类为 Typescript 的内容。正因为查询字符串这么多,我觉得如果能在多个 api 中统一管理会更好。最后,因为还要用 React Native 开发 App,它让 API 可以被复用。
1.2 tsconfig 共享方法
下面来介绍一下在 Monorepo 中各模块之间共享 tsconfig 的方法。下面的示例其实是使用 Nx 时的示例。不过使用 turboRepo 时配置方式也完全一样,所以就直接沿用了同样的示例。我按 tsconfig 的共享方法整理了它们之间的区别,相信在搭建 Monorepo 时会有很大的帮助。
类别 | 说明 | 类型推断速度 | 构建方式 | 类型文件 | 发布 |
|---|---|---|---|---|---|
Project Reference | 由 ts 追踪包之间的依赖/构建顺序 | 🟡 一般 (使用 .tsbuildInfo) | tsc --build tsc --watch(实时) | .d.ts .tsbuildinfo | ❌ |
Internal Package | 无需构建,直接使用 .ts 文件 | 🟡 一般 | 使用 consumer 的构建工具 | .ts | ❌ |
Compiled Package | 构建源代码,输出 .js + .d.ts | 🟢 快 | 使用构建工具 | .d.ts, .js | ✅ |
Publish Package | 为对外发布而构建的包 | 🟢 快 | 使用构建工具 | .d.ts, .js | ✅ |
Relative Imports(最直观的方法)
└─ . ├─ apps │ └─ exampleApp │ ├─ src │ │ └─ index.ts │ └─ tsconfig.json ├─ packages │ └─ exampleLib │ ├─ src │ │ └─ index.ts │ └─ tsconfig.json └─ tsconfig.base.json// apps/exampleApp/src/index.tsimport { add } from '../../../packages/exampleLib/src/index.ts';console.log(add(1,3));// tsconfig.base.json{ "compilerOptions": { "target": "ES2020", "module": "NodeNext", "strict": true, "moduleResolution": "NodeNext", "baseUrl": ".", "rootDir": "." }}// apps/exampleApp/tsconfig.json{ "extends": "../../tsconfig.base.json", "compilerOptions": { "outDir": "../../dist", "declaration": true }, "include": ["src/**/*"]}// packages/exampleLib/tsconfig.json{ "extends": "../../tsconfig.base.json", "compilerOptions": { "outDir": "../../dist", "declaration": true }, "include": ["src/**/*"]}依赖解析
这是利用相对路径来连接包与包之间最简单的方法。
但是,一旦代码库结构发生变化,就必须逐一修改 extends 路径。在大型工作区中,这个缺点会更加明显。
模块化
它可以把应用和库分别拆分到各自的文件夹中,实现模块化。因此可维护性更好,也更容易浏览工作区。
但从 TypeScript 的角度来看,整个工作区会成为一个统一的项目,在类型检查时包与包之间就不存在边界了。
性能
从 TypeScript 的角度来看,整体会成为一个统一的项目,所以工作区一大就可能出问题。由于类型检查和编译都是以全部模块为对象进行的,构建速度会变慢,编辑器的响应速度也可能下降。
将 Relative Imports 转换为 Path Aliases。(提升可读性)
与 Relative Import 的区别
tsconfig.base.json
添加 paths 字段
结论
缩短 import path,提升可读性
└─ . ├─ apps │ └─ exampleApp │ ├─ src │ │ └─ index.ts │ └─ tsconfig.json ├─ packages │ └─ exampleLib │ ├─ src │ │ └─ index.ts │ └─ tsconfig.json └─ tsconfig.base.json// tsconfig.base.json{ "compilerOptions": { "target": "ES2020", "module": "NodeNext", "strict": true, "moduleResolution": "NodeNext", "baseUrl": ".", "rootDir": "." "paths": { "@text-package/exampleLib": ["packages/exampleLib/src/index.ts"] } }}// apps/exampleApp/src/index.tsimport { add } from '@test-package/exampleLib';console.log(add(1,3));依赖解析
使用 Path alias 后就不需要再使用相对路径,即使代码库结构发生变化,也只需修改 tsconfig.base.json 中的 paths 即可。
模块化和性能方面没有变化。
使用 tsconfig 的 Reference
要求:typescript v3.0 及以上
与 Relative Import + Path Alias 的区别
root - package.json
在 scripts 中改用 tsc --build
tsconfig.base.json
删除 rootUrl
在 compilerOptions 中设置 composite:true => incremental 会变为 true,构建时会生成 .tsbuildinfo
添加 declaration 相关配置
root - tsconfig.json
添加文件
添加 references 字段
app - tsconfig.json
删除 declaration、outDir 字段
添加 references 字段
packages - tsconfig.json
删除 declaration、outDir 字段
结论
TypeScript 按模块分别管理
性能提升
生成类型依赖(会产生构建依赖,由 ts 自动计算)
└─ . ├─ apps │ └─ exampleApp │ ├─ src │ │ └─ index.ts │ └─ tsconfig.json ├─ packages │ └─ exampleLib │ ├─ src │ │ └─ index.ts │ └─ tsconfig.json ├─ tsconfig.json └─ tsconfig.base.json// apps/exampleApp/src/index.tsimport { add } from '@test-package/exampleLib';console.log(add(1,3));// tsconfig.base.json// 关键是删除 rootUrl。{ "compilerOptions": { "target": "ES2020", "module": "NodeNext", "strict": true, "moduleResolution": "NodeNext", "composite": true, "declaration": true, "declarationMap": true, "sourceMap": true, "baseUrl": ".", "paths": { "@text-package/exampleLib": ["packages/exampleLib/src/index.ts"] } }}// tsconfig.json{ "files": [], "references": [{ "path": "./packages/exampleLib" }, { "path": "./apps/exampleApp" }]}// apps/exampleApp/tsconfig.json{ "extends": "../../tsconfig.base.json", "compilerOptions": { "rootDir": "src", }, "references": [{ "path": "../../packages/exampleLib" }], "include": ["src/**/*"]}// packages/exampleLib/tsconfig.json{ "extends": "../../tsconfig.base.json", "compilerOptions": { "rootDir": "src", }, "include": ["src/**/*"]}// packages/exampleLib/package.json{ "name": "test-package", ... "scripts": { "dev": "tsx --tsconfig tsconfig.base.json apps/exampleApp/src/index.ts", "build": "tsc --build", "clean": "tsc --build --clean", "typecheck": "tsc --build --emitDeclarationOnly" }}模块化
使用项目引用(Project References)可以让每个模块独立,并强制组件之间在逻辑上相互分离。由此,包之间的隔离程度得到提升,依赖会以包为单位进行类型检查。
性能
使用增量构建(incremental build)。由于只重新编译发生变化的包,所以不需要反复进行全量构建。TypeScript 会生成 .tsbuildinfo 文件来追踪变更,并借此提升类型检查和编译的速度。这在大型工作区或 CI 流水线中很有用。(为了开发方便,使用 --watch 选项进行实时更新)
Reference + package manager
要求:Node.js v13.2.0 及以上
这种方式是由 app(consumer)直接引用 package 的 ts 文件。所以 transpiling 的责任在 consumer 一方。如果 consumer 无法编译 Typescript 来使用,就无法使用该 package。
与使用 tsconfig Reference 的区别
tsconfig.base.json
删除 baseUrl
删除 paths
app - package.json
添加 private 字段
将 package 添加到 dependency 中
app - tsconfig.json
添加 baseUrl 字段
package - package.json
添加 private 字段(可单独使用)
添加 exports 字段
package - tsconfig.json
添加 composite 字段
添加 declaration 字段
添加 main、type
添加 workspace
pnpm 使用 pnpm-workspace.yaml 文件
npm、yarn 则在 root - package.json 中添加 workspaces 字段。
结论
app 与包之间通过 package manager 而不是 typescript path alias 连接
将各个模块分别打包管理
更严格的环境隔离
app 需要单独转译 + 打包(构建 app 时连 packages 也要一起处理)
└─ . ├─ apps │ └─ exampleApp │ ├─ src │ │ └─ index.ts │ └─ tsconfig.json ├─ packages │ └─ exampleLib │ ├─ src │ │ └─ index.ts │ └─ tsconfig.json ├─ pnpm-workspace.yaml ├─ tsconfig.json └─ tsconfig.base.json// pnpm-workspace.yamlpackages: - 'apps/*' - 'packages/*'// apps/exampleApp/tsconfig.json{ "compilerOptions": { "target": "ES2020", "module": "NodeNext", "strict": true, "moduleResolution": "NodeNext", "composite": true, "declaration": true, "declarationMap": true, "sourceMap": true, }}// apps/exampleApp/tsconfig.json{ "extends": "../../tsconfig.base.json", "compilerOptions": { "outDir": "dist", "rootDir": "src", "baseUrl": ".", "tsBuildInfoFile": "dist/tsconfig.tsbuildinfo" }, "references": [{ "path": "../../packages/exampleLib" }], "include": ["src/**/*"]}// packages/exampleLib/tsconfig.json{ "extends": "../../tsconfig.base.json", "compilerOptions": { "baseUrl": ".", "rootDir": "src", "outDir": "dist", "tsBuildInfoFile": "dist/tsconfig.tsbuildinfo" }, "include": ["src/**/*"]}// packages/exampleLib/package.json{ "name": "@text-package/exampleLib", ... "type": "module", "exports": { ".": { "types": "./src/index.ts", "import": "./src/index.ts", "default": "./src/index.ts" }, "./package.json": "./package.json" }, "main": "./src/index.ts", "types": "./src/index.ts", "module": "./src/index.ts"}// apps/exampleApp/package.json{ "name": "@yooncarrot/exampleApp", ... "dependencies": { "@test-package/exampleLib": "workspace:*" // 使用 NPM 时是可选的,但在 pnpm 中必须明确写出来。 }}依赖解析
使用包管理器的 workspace,把包的解析委托给包管理器,从而独立于 typescript 运作。
模块化
每个包的依赖都由 package.json 明确定义,变得直观易懂。而且因为明确指定了要 export 的文件,由 import 该文件的包来承担转译和打包的责任,模块化也就更加彻底。
性能与之前的 Reference 方式相同。
使用 Reference + package manager + Pre-building(Compiled Packages)
与 Reference + Package Manager 方法的区别
package - package.json
将 exports 路径修改为构建产物路径(src/index.ts => dist/index.d.js..)
适当修改 package.json 或 exampleLib 的 package.json 中的构建脚本。
如果使用 nx 或 turboRepo,则按照对应 monorepo 库的方式修改流水线。
结论
打包的责任可以由各个模块分别承担。(因为是预先构建好再提供的)
Compiled Packages 必须构建后类型才会更新,所以可能会比较麻烦。(可能降低开发便利性)
在大型项目中,pre-compile 方式的开发便利性可能更好(IDE 类型推断的延迟会减少)
└─ . ├─ apps │ └─ exampleApp │ ├─ ... │ ├─ package.json │ └─ tsconfig.json ├─ package.json ├─ packages │ └─ exampleLib │ ├─ dist │ │ ├─ index.d.ts │ │ ├─ index.d.ts.map │ │ ├─ index.js │ │ ├─ index.js.map │ │ └─ tsconfig.tsbuildinfo │ ├─ package.json │ ├─ src │ │ └─ index.ts │ └─ tsconfig.json ├─ pnpm-workspace.yaml ├─ tsconfig.base.json └─ tsconfig.json// packages/exampleApp/package.json{ "name": "@test-package/exampleLib", "version": "0.0.0", // 新增的字段 "private": true, // 新增的字段 "type": "module", "exports": { ".": { "types": "./dist/index.d.ts", // 所有 ./src/* => 改为 ./dist/*(构建后的文件) "import": "./dist/index.js", "default": "./dist/index.js" }, "./package.json": "./package.json" }, "main": "./dist/index.js", "types": "./dist/index.d.ts", "module": "./dist/index.js"}依赖解析
通过预先编译依赖包,app 的打包工具可以直接使用预先构建好的产物。此外,在打包应用的过程中也不再需要编译包依赖。编写任务流水线时,确保包被预先编译,就能让工作流更加高效。
模块化
与之前直接引用 TypeScript 源文件的方式相比,模块化程度更高。如果把包预先编译并打包,还可以发布到 monorepo 外部。
性能
可以提升类型检查的性能。通过预先编译好的 .d.ts 文件,类型信息已经提前生成,因此可以直接利用这些类型信息文件,而不必通过项目引用去处理 TypeScript 源文件。
Reference + package manager + package use path alias + (Just-in-TIme Packages)
要求:typescript 5.4 及以上,NodeJs 14.6 及以上
package(包)的 tsconfig 选项中,compilerOptions.paths 对 consumer 不生效。因为它是按照“会由 app 的 TypeScript 来转译”这一预期来运作的。
所以在包中使用 path alias 就会出问题,而从 TypeScript 5.0 开始,可以利用 nodejs 14.6 版本中新增的 subPath 功能来解决这个问题。
在 monorepo 中,Just-in-Time 包是由 app 直接引用包的 ts 文件的方式。也就是说,它不引用类型定义文件(.d.ts)或 .tsbuildInfo 文件。优点是无需持续 build,修改会实时生效。
└─ . ├─ apps │ └─ exampleApp │ ├─ ... │ ├─ package.json │ └─ tsconfig.json ├─ package.json ├─ packages │ └─ exampleLib │ ├─ package.json │ ├─ src │ │ ├─ add.ts │ │ ├─ sub.ts │ │ └─ index.ts │ └─ tsconfig.json ├─ pnpm-workspace.yaml ├─ tsconfig.base.json └─ tsconfig.json// packages/exampleLib/package.json{ "name": "@test-package/exampleLib", "version": "0.0.0", // 新增的字段 "type": "module", "imports": { // 新增的字段 "#*": "./src/*" // 在 package 内部使用 path alias 时。(node 配置中不能用 @) }, "exports": { // 新增的字段 ".": "./src/index.ts", "./add": "./src/add.ts", "./sub": "./src/sub.ts", }, ...}// packages/exampleLib/tsconfig.json{ "extends": ["../../tsconfig.base.json"], "compilerOptions": { "baseUrl": ".", "paths": { "#*": ["./src/*"] // 在 package 内部使用 path alias 时,Just-in-Time 包中不能用 @。 } }, "include": ["src/**/*"] ...}依赖解析
Package 模块即使使用 path alias 也能进行类型引用了。(解决了由 path alias 引起的依赖问题)
性能
与在 app 中以 compiled packages 方式使用包相比,性能要差一些。但只要不是那种在 IDE 中显示类型就需要大量资源的大型项目,开发者的开发体验反而会更好。
1.3 eslint 共享方法
EsLint 配置比 tsConfig 配置要好管理得多,因为它与编译和打包没有太大关系。我只是在 eslintConfig 包中创建了公共的 eslint 配置,然后在 App 和 Package 中 import 使用。
// NextJs App 的 eslint.config.jsimport {nextJsConfig} from "@yooncarrot/eslintConfig/next";/** @type {import("eslint").Linter.Config} */export default nextJsConfig;// esLintPackage 包的 base.jsexport const config = [ js.configs.recommended, eslintConfigPrettier, ...tseslint.configs.recommended, { plugins: { turbo: turboPlugin, }, rules: { "turbo/no-undeclared-env-vars": "off", "no-unused-vars": "off", "@typescript-eslint/no-unused-vars": [ "error", { args: "all", argsIgnorePattern: "^_", caughtErrors: "all", caughtErrorsIgnorePattern: "^_", destructuredArrayIgnorePattern: "^_", varsIgnorePattern: "^_", ignoreRestSiblings: true, }, ], }, }, { plugins: { onlyWarn, }, }, { ignores: ["dist/**"], },];// esLintConfig 包的 nextjs.eslint.jsexport const nextJsConfig = [ ...baseConfig, js.configs.recommended, eslintConfigPrettier, ...tseslint.configs.recommended, { ...pluginReact.configs.flat.recommended, languageOptions: { ...pluginReact.configs.flat.recommended.languageOptions, globals: { ...globals.serviceworker, }, }, }, { plugins: { "@next/next": pluginNext, }, rules: { ...pluginNext.configs.recommended.rules, ...pluginNext.configs["core-web-vitals"].rules, // 允许自定义字体 "@next/next/no-page-custom-font": "off", }, }, { plugins: { "react-hooks": pluginReactHooks, }, settings: {react: {version: "detect"}}, rules: { ...pluginReactHooks.configs.recommended.rules, // React scope no longer necessary with new JSX transform. "react/react-in-jsx-scope": "off", }, },];2. 内部包的编译策略
turborepo 将 internal packages 的编译策略大致分为 3 种:不编译的 Just-in-Time Packages、进行 ts 编译的 Compiled Packages,以及发布到 NPM 的 Publishable Packages。
2.1 Just-in-Time Packages
Just-in-Time 包只需要最少的配置。因为包本身不单独构建,而是和 App 一起由 App 的编译器和打包工具构建。也就是说,编译和打包的配置会受到 App 配置的影响。而且即使不单独编译,也能直接根据 ts 文件进行类型推断。
优点
因为直接 export TypeScript 来使用,app 会直接引用包的 ts 文件。所以修改包文件后,变更会立即生效并进行类型推断。
因为 app 直接引用包,所以不需要单独的 build 脚本或配置。
缺点/局限
因为是直接引用 ts 文件的方式,consumer(主要是 app)必须能理解 ts,并且能够构建它。如果 app 只能使用 js,就必须改为 compiled packages 方式。
包无法在 tsconfig 中使用 path alias。因为 typescript 认为代码会在编写它的包内部被转译,所以无法单独识别 path alias。因此,如果想使用 path alias,就必须使用 nodeJs 的 subPath 功能。
缺点是 turborepo 无法缓存 package 的构建结果,因为 package 并不单独构建。所以一旦 package 发生变化,app 也必须重新构建。
由于包直接以 ts 形式使用,如果其中有类型错误,app 可能就不得不面对一些本来没必要知道的类型错误。
2.2 Compiled Packages
Compiled 包是把 ts 文件编译成 js 和 d.ts 文件来使用的包。通常会把编译结果输出到 /dist 文件夹,并将其设置为入口点(entry point)来使用。因为会进行编译,所以可以利用 turborepo 的构建缓存功能。因此,无论是 app 还是 package,构建时都能更快。
优点
可以利用 turborepo 的构建缓存功能。
缺点/局限
通常只用 tsc 进行编译处理,因为会使用 app 的 bundler。不过,如果 package 中偶尔要用到静态文件,可能就需要单独的打包工作。
比 Just-in-Time 包需要更多的配置。例如,如果是需要做 polyfill 的包,就必须在 package.json 中添加 sideEffect 属性。
2.3 Publishable Packages
Publishable 包是发布到 NPM 仓库上使用的包。所以必须能用单独的 builder 进行构建,compile 和 bundle 的责任也就在包自身。这是构建包最稳健的方式。app 则通过 npm registry 下载包来使用。
3. 文件夹结构
文件夹结构采用了一般常用的结构(Layered Architecture)。我觉得 NextJS 应用和 FSD 也挺搭的,所以考虑过 FSD 架构,但要新尝试的东西实在太多,就先默默搁置了。下面整理了部分应用和包的文件夹结构。
3.1 NextJS(App Router)
└─ blog ├─ src │ ├─ app │ │ ... │ │ ├─ layout.ts │ │ ├─ page.ts │ │ ├─ action.ts │ │ ├─ error.ts │ │ ├─ loading.ts │ │ ├─ robots.ts │ │ └─ sitemap.ts │ ├─ components │ │ ├─ client │ │ └─ server │ └─ provider ├─ after_build.js ├─ eslint.config.js ├─ tsconfig.json ├─ postcss.config.js ├─ next.config.ts └─ package.json3.2 design-system 包的文件夹结构
└─ design-system ├─ src │ ├─ globals.css │ ├─ palette.css │ ├─ components │ │ ... │ │ ├─ Backdrop │ │ └─ BentoCard │ └─ motion ├─ eslint.config.js ├─ tsconfig.json ├─ postcss.config.js ├─ vite.config.ts └─ package.json3.3 editor 包的文件夹结构
└─ editor ├─ src │ ├─ extensions │ ├─ hooks │ ├─ plugins │ └─ utils ├─ eslint.config.js ├─ tsconfig.json ├─ vite.config.ts └─ package.json参考资料
https://turbo.build/blog/you-might-not-need-typescript-project-references
