feat: workspace generator (#1795)

* feat: workspace generator

* chore: fix

* chore: fix

* chore: update tsconfig

* chore: update package json

* chore: adjust test script

* feat: use vite only for theme and crepe

* chore: adjust export

* chore: fix lock

* chore: optimize changelog script

* chore: remove unused lib

* chore: adjust logger

* [autofix.ci] apply automated fixes

---------

Co-authored-by: autofix-ci[bot] <114827586+autofix-ci[bot]@users.noreply.github.com>

Author: Saul-Mirone

Diff for: dev/package.json

@@ -10,9 +10,24 @@
     "./vite": {
       "import": "./lib/vite.js",
       "types": "./lib/vite.d.ts"
+    },
+    "./logger": {
+      "import": "./lib/logger.js",
+      "types": "./lib/logger.d.ts"
+    },
+    "./exec": {
+      "import": "./lib/exec.js",
+      "types": "./lib/exec.d.ts"
+    },
+    "./generate": {
+      "import": "./lib/generate.js",
+      "types": "./lib/generate.d.ts"
     }
   },
-  "scripts": {
-    "build": "rimraf './lib' && tsc"
+  "dependencies": {
+    "@types/lodash-es": "^4.17.12",
+    "chalk": "^5.4.1",
+    "jsonc-parser": "^3.3.1",
+    "lodash-es": "^4.17.21"
   }
 }

Diff for: dev/src/exec.ts

@@ -0,0 +1,15 @@
+import { execSync } from 'node:child_process'
+
+import { Logger } from './logger'
+
+export function exec(
+  tag: string,
+  cmd: string,
+  { silent }: { silent: boolean } = { silent: false }
+): string {
+  const logger = new Logger(tag)
+  !silent && logger.info(cmd)
+  const result = execSync(cmd, { encoding: 'utf8' }).trim()
+  !silent && logger.log(result)
+  return result
+}

Diff for: dev/src/generate.ts

@@ -0,0 +1,94 @@
+import { applyEdits, modify } from 'jsonc-parser'
+import { Workspace } from './workspace'
+import type { Path } from './path'
+import { type BuiltInParserName, format } from 'prettier'
+import { readFileSync, writeFileSync } from 'node:fs'
+import { Logger } from './logger'
+import type { Package } from './package'
+
+export function generateTsConfig() {
+  const generator = new Generator()
+  generator.run()
+}
+
+export class Generator {
+  workspace: Workspace
+  logger: Logger
+
+  constructor() {
+    this.workspace = new Workspace()
+    this.workspace.join('tsconfig.json')
+    this.logger = new Logger('TS Config')
+  }
+
+  async run() {
+    this.logger.info('Generating workspace files')
+    await this.generateWorkspaceFiles()
+    this.logger.info('Workspace files generated')
+  }
+
+  generateWorkspaceFiles = async () => {
+    const filesToGenerate: [
+      Path,
+      (prev: string) => string,
+      BuiltInParserName?,
+    ][] = [
+      [this.workspace.join('tsconfig.json'), this.genProjectTsConfig, 'json'],
+      ...this.workspace.packages
+        .filter((p) => p.isTsProject)
+        .map(
+          (p) =>
+            [
+              p.join('tsconfig.json'),
+              this.genPackageTsConfig.bind(this, p),
+              'json',
+            ] as any
+        ),
+    ]
+
+    for (const [path, content, formatter] of filesToGenerate) {
+      this.logger.info(`Generating: ${path}`)
+      const previous = readFileSync(path.value, 'utf-8')
+      let file = content(previous)
+      if (formatter) {
+        file = await this.format(file, formatter)
+      }
+      writeFileSync(path.value, file)
+    }
+  }
+
+  format = (content: string, parser: BuiltInParserName) => {
+    const config = JSON.parse(
+      readFileSync(this.workspace.join('.prettierrc').value, 'utf-8')
+    )
+    return format(content, { parser, ...config })
+  }
+
+  genProjectTsConfig = (prev: string) => {
+    return applyEdits(
+      prev,
+      modify(
+        prev,
+        ['references'],
+        this.workspace.packages
+          .filter((p) => p.isTsProject)
+          .map((p) => ({ path: p.path.relativePath })),
+        {}
+      )
+    )
+  }
+
+  genPackageTsConfig = (pkg: Package, prev: string) => {
+    return applyEdits(
+      prev,
+      modify(
+        prev,
+        ['references'],
+        pkg.deps
+          .filter((p) => p.isTsProject)
+          .map((d) => ({ path: pkg.path.relative(d.path.value) })),
+        {}
+      )
+    )
+  }
+}

Diff for: dev/src/logger.ts

@@ -0,0 +1,46 @@
+import chalk from 'chalk'
+import { identity } from 'lodash-es'
+
+export const newLineSeparator = /\r\n|[\n\r\x85\u2028\u2029]/g
+
+interface StringLike {
+  toString: () => string
+}
+
+export class Logger {
+  log = this.getLineLogger(console.log.bind(console))
+  info = this.getLineLogger(console.info.bind(console), chalk.blue)
+  warn = this.getLineLogger(
+    console.warn.bind(console),
+    chalk.bgHex('#322b08').hex('#fadea6')
+  )
+  error = this.getLineLogger(
+    console.error.bind(console),
+    chalk.bgHex('#250201').hex('#ef8784')
+  )
+  success = this.getLineLogger(console.log.bind(console), chalk.green)
+
+  constructor(private readonly tag: string = '') {}
+
+  getLineLogger(
+    logLine: (...line: string[]) => void,
+    color: (...text: string[]) => string = identity
+  ) {
+    return (...args: StringLike[]) => {
+      args.forEach((arg) => {
+        arg
+          .toString()
+          .split(newLineSeparator)
+          .forEach((line) => {
+            if (line.length !== 0) {
+              if (this.tag) {
+                logLine(color(`[${this.tag}] ${line}`))
+              } else {
+                logLine(color(line))
+              }
+            }
+          })
+      })
+    }
+  }
+}

Diff for: dev/src/package.ts

@@ -0,0 +1,84 @@
+import { readFileSync } from 'node:fs'
+import { parse } from 'node:path'
+
+import { Path } from './path'
+import type { CommonPackageJsonContent } from './types'
+import type { Workspace } from './workspace'
+import type { PackageItem } from './pnpm'
+import { pnpmList } from './pnpm'
+
+export function readPackageJson(path: Path): CommonPackageJsonContent {
+  const content = readFileSync(path.join('package.json').toString(), 'utf-8')
+
+  return JSON.parse(content)
+}
+
+export class Package {
+  readonly name: string
+  readonly packageJson: CommonPackageJsonContent
+  readonly dirname: string
+  readonly path: Path
+  readonly srcPath: Path
+  readonly nodeModulesPath: Path
+  readonly libPath: Path
+  readonly distPath: Path
+  readonly version: string
+  readonly isTsProject: boolean
+  readonly workspaceDependencies: string[]
+  deps: Package[] = []
+  private _workspace: Workspace | null = null
+
+  get entry() {
+    return this.packageJson.main || this.packageJson.exports?.['.']
+  }
+
+  get dependencies() {
+    return this.packageJson.dependencies || {}
+  }
+
+  get devDependencies() {
+    return this.packageJson.devDependencies || {}
+  }
+
+  get workspace() {
+    if (!this._workspace) {
+      throw new Error('Workspace is not initialized')
+    }
+
+    return this._workspace
+  }
+
+  set workspace(workspace: Workspace) {
+    this._workspace = workspace
+  }
+
+  constructor(name: string, meta?: PackageItem) {
+    this.name = name
+    meta ??= pnpmList().find((item) => item.name === name)!
+
+    // parse paths
+    this.path = new Path(meta.path)
+    this.dirname = parse(meta.path).name
+    this.srcPath = this.path.join('src')
+    this.libPath = this.path.join('lib')
+    this.distPath = this.path.join('dist')
+    this.nodeModulesPath = this.path.join('node_modules')
+
+    // parse workspace
+    const packageJson = readPackageJson(this.path)
+    this.packageJson = packageJson
+    this.version = packageJson.version
+    this.workspaceDependencies = Object.keys(
+      packageJson.dependencies ?? {}
+    ).filter((dep) => dep.startsWith('@milkdown/'))
+    this.isTsProject = this.path.join('tsconfig.json').isFile()
+  }
+
+  get scripts() {
+    return this.packageJson.scripts || {}
+  }
+
+  join(...paths: string[]) {
+    return this.path.join(...paths)
+  }
+}

Diff for: dev/src/path.ts

@@ -0,0 +1,70 @@
+import { existsSync, statSync } from 'node:fs'
+import { join, relative, sep } from 'node:path'
+import { fileURLToPath, pathToFileURL } from 'node:url'
+
+export class Path {
+  static dir(url: string) {
+    return new Path(fileURLToPath(url)).join('..')
+  }
+
+  get value() {
+    return this.path
+  }
+
+  get relativePath() {
+    return './' + this.path.slice(ProjectRoot.path.length).replace(/\\/g, '/')
+  }
+
+  constructor(private readonly path: string) {}
+
+  join(...paths: string[]) {
+    return new Path(join(this.path, ...paths))
+  }
+
+  parent() {
+    return this.join('..')
+  }
+
+  toPosixString() {
+    if (sep === '\\') {
+      return this.path.replaceAll('\\', '/')
+    }
+
+    return this.path
+  }
+
+  toString() {
+    return this.path
+  }
+
+  exists() {
+    return existsSync(this.path)
+  }
+
+  stats() {
+    return statSync(this.path)
+  }
+
+  isFile() {
+    return this.exists() && this.stats().isFile()
+  }
+
+  isDirectory() {
+    return this.exists() && this.stats().isDirectory()
+  }
+
+  toFileUrl() {
+    return pathToFileURL(this.path)
+  }
+
+  relative(to: string) {
+    const re = relative(this.value, to)
+    if (sep === '\\') {
+      return re.replaceAll('\\', '/')
+    }
+
+    return re
+  }
+}
+
+export const ProjectRoot = Path.dir(import.meta.url).join('../../')

Diff for: dev/src/pnpm.ts

@@ -0,0 +1,24 @@
+import { once } from 'lodash-es'
+
+import { exec } from './exec'
+
+export type PackageItem = {
+  name: string
+  version: string
+  path: string
+  private: boolean
+}
+
+export const pnpmList = once(() => {
+  const command = `pnpm list --recursive --depth -1 --json`
+
+  const output = exec('', command, { silent: true })
+
+  let packageList = JSON.parse(output) as PackageItem[]
+
+  packageList.forEach((p) => {
+    p.path = p.path.replaceAll(/\\/g, '/')
+  })
+
+  return packageList.filter((p) => p.name !== '@milkdown/monorepo')
+})

Diff for: dev/src/types.ts

@@ -0,0 +1,12 @@
+export interface CommonPackageJsonContent {
+  name: string
+  version: string
+  private?: boolean
+  dependencies?: { [key: string]: string }
+  devDependencies?: { [key: string]: string }
+  scripts?: { [key: string]: string }
+  main?: string
+  exports?: {
+    [key: string]: string
+  }
+}