@kubb/core 5.0.0-alpha.5 → 5.0.0-alpha.50

package/package.json

@@ -1,50 +1,29 @@
 {
   "name": "@kubb/core",
-  "version": "5.0.0-alpha.5",
+  "version": "5.0.0-alpha.50",
   "description": "Core functionality for Kubb's plugin-based code generation system, providing the foundation for transforming OpenAPI specifications.",
   "keywords": [
-    "typescript",
-    "plugins",
-    "plugin-system",
-    "plugin-framework",
+    "ast",
     "code-generator",
     "codegen",
-    "ast",
+    "core-library",
     "file-system",
+    "kubb",
+    "oas",
     "openapi",
+    "plugin-framework",
+    "plugin-system",
+    "plugins",
     "swagger",
-    "oas",
-    "core-library",
-    "kubb"
+    "typescript"
   ],
+  "license": "MIT",
+  "author": "stijnvanhulle",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/kubb-labs/kubb.git",
     "directory": "packages/core"
   },
-  "license": "MIT",
-  "author": "stijnvanhulle",
-  "sideEffects": false,
-  "type": "module",
-  "exports": {
-    ".": {
-      "import": "./dist/index.js",
-      "require": "./dist/index.cjs"
-    },
-    "./hooks": {
-      "import": "./dist/hooks.js",
-      "require": "./dist/hooks.cjs"
-    },
-    "./package.json": "./package.json"
-  },
-  "types": "./dist/index.d.ts",
-  "typesVersions": {
-    "*": {
-      "hooks": [
-        "./dist/hooks.d.ts"
-      ]
-    }
-  },
   "files": [
     "src",
     "schemas",
@@ -56,41 +35,56 @@
     "!/**/__tests__/**",
     "!/**/__snapshots__/**"
   ],
-  "size-limit": [
-    {
-      "path": "./dist/*.js",
-      "limit": "510 KiB",
-      "gzip": true
+  "type": "module",
+  "sideEffects": false,
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "typesVersions": {
+    "*": {
+      "mocks": [
+        "./dist/mocks.d.ts"
+      ]
     }
-  ],
+  },
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs"
+    },
+    "./mocks": {
+      "import": "./dist/mocks.js",
+      "require": "./dist/mocks.cjs"
+    },
+    "./package.json": "./package.json"
+  },
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  },
   "dependencies": {
-    "@kubb/fabric-core": "0.14.0",
-    "@kubb/react-fabric": "0.14.0",
-    "empathic": "^2.0.0",
     "fflate": "^0.8.2",
-    "remeda": "^2.33.6",
-    "semver": "^7.7.4",
-    "tinyexec": "^1.0.4",
-    "@kubb/ast": "5.0.0-alpha.5"
+    "tinyexec": "^1.1.1",
+    "@kubb/ast": "5.0.0-alpha.50"
   },
   "devDependencies": {
-    "@types/semver": "^7.7.1",
     "p-limit": "^7.3.0",
-    "@internals/utils": "0.0.0"
+    "@internals/utils": "0.0.0",
+    "@kubb/renderer-jsx": "5.0.0-alpha.50"
   },
   "peerDependencies": {
-    "@kubb/fabric-core": "0.14.0",
-    "@kubb/react-fabric": "0.14.0"
+    "@kubb/renderer-jsx": "5.0.0-alpha.50"
   },
+  "size-limit": [
+    {
+      "path": "./dist/*.js",
+      "limit": "510 KiB",
+      "gzip": true
+    }
+  ],
   "engines": {
     "node": ">=22"
   },
-  "publishConfig": {
-    "access": "public",
-    "registry": "https://registry.npmjs.org/"
-  },
-  "main": "./dist/index.cjs",
-  "module": "./dist/index.js",
   "inlinedDependencies": {
     "p-limit": "7.3.0",
     "yocto-queue": "1.2.2"
@@ -98,8 +92,8 @@
   "scripts": {
     "build": "tsdown && size-limit",
     "clean": "npx rimraf ./dist",
-    "lint": "bun biome lint .",
-    "lint:fix": "bun biome lint --fix --unsafe .",
+    "lint": "oxlint .",
+    "lint:fix": "oxlint --fix .",
     "release": "pnpm publish --no-git-check",
     "release:canary": "bash ../../.github/canary.sh && node ../../scripts/build.js canary && pnpm publish --no-git-check",
     "start": "tsdown --watch",

package/src/FileManager.ts

@@ -0,0 +1,133 @@
+import { trimExtName } from '@internals/utils'
+import type { FileNode } from '@kubb/ast'
+import { createFile } from '@kubb/ast'
+import { BARREL_BASENAME } from './constants.ts'
+
+function mergeFile<TMeta extends object = object>(a: FileNode<TMeta>, b: FileNode<TMeta>): FileNode<TMeta> {
+  return {
+    ...a,
+    sources: [...(a.sources || []), ...(b.sources || [])],
+    imports: [...(a.imports || []), ...(b.imports || [])],
+    exports: [...(a.exports || []), ...(b.exports || [])],
+  }
+}
+
+/**
+ * In-memory file store for generated files.
+ *
+ * Files with the same `path` are merged — sources, imports, and exports are concatenated.
+ * The `files` getter returns all stored files sorted by path length (shortest first).
+ *
+ * @example
+ * ```ts
+ * import { FileManager } from '@kubb/core'
+ *
+ * const manager = new FileManager()
+ * manager.upsert(myFile)
+ * console.log(manager.files) // all stored files
+ * ```
+ */
+export class FileManager {
+  readonly #cache = new Map<string, FileNode>()
+  #filesCache: Array<FileNode> | null = null
+
+  /**
+   * Adds one or more files. Files with the same path are merged — sources, imports,
+   * and exports from all calls with the same path are concatenated together.
+   */
+  add(...files: Array<FileNode>): Array<FileNode> {
+    const resolvedFiles: Array<FileNode> = []
+    const mergedFiles = new Map<string, FileNode>()
+
+    for (const file of files) {
+      const existing = mergedFiles.get(file.path)
+      mergedFiles.set(file.path, existing ? mergeFile(existing, file) : file)
+    }
+
+    for (const file of mergedFiles.values()) {
+      const resolvedFile = createFile(file)
+      this.#cache.set(resolvedFile.path, resolvedFile)
+      resolvedFiles.push(resolvedFile)
+    }
+    this.#filesCache = null
+
+    return resolvedFiles
+  }
+
+  /**
+   * Adds or merges one or more files.
+   * If a file with the same path already exists, its sources/imports/exports are merged together.
+   */
+  upsert(...files: Array<FileNode>): Array<FileNode> {
+    const resolvedFiles: Array<FileNode> = []
+    const mergedFiles = new Map<string, FileNode>()
+
+    for (const file of files) {
+      const existing = mergedFiles.get(file.path)
+      mergedFiles.set(file.path, existing ? mergeFile(existing, file) : file)
+    }
+
+    for (const file of mergedFiles.values()) {
+      const existing = this.#cache.get(file.path)
+      const merged = existing ? mergeFile(existing, file) : file
+      const resolvedFile = createFile(merged)
+      this.#cache.set(resolvedFile.path, resolvedFile)
+      resolvedFiles.push(resolvedFile)
+    }
+    this.#filesCache = null
+
+    return resolvedFiles
+  }
+
+  getByPath(path: string): FileNode | null {
+    return this.#cache.get(path) ?? null
+  }
+
+  deleteByPath(path: string): void {
+    this.#cache.delete(path)
+    this.#filesCache = null
+  }
+
+  clear(): void {
+    this.#cache.clear()
+    this.#filesCache = null
+  }
+
+  /**
+   * All stored files, sorted by path length (shorter paths first).
+   * Barrel/index files (e.g. index.ts) are sorted last within each length bucket.
+   */
+  get files(): Array<FileNode> {
+    if (this.#filesCache) {
+      return this.#filesCache
+    }
+
+    // Precompute the barrel-file flag per key so the comparator avoids repeated string work.
+    const keys = [...this.#cache.keys()]
+    const meta = new Map<string, { length: number; isIndex: boolean }>()
+    for (const key of keys) {
+      meta.set(key, {
+        length: key.length,
+        isIndex: trimExtName(key).endsWith(BARREL_BASENAME),
+      })
+    }
+    keys.sort((a, b) => {
+      const ma = meta.get(a)!
+      const mb = meta.get(b)!
+      if (ma.length !== mb.length) return ma.length - mb.length
+      if (ma.isIndex !== mb.isIndex) return ma.isIndex ? 1 : -1
+      return 0
+    })
+
+    const files: Array<FileNode> = []
+    for (const key of keys) {
+      const file = this.#cache.get(key)
+      if (file) {
+        files.push(file)
+      }
+    }
+
+    this.#filesCache = files
+    return files
+  }
+}

package/src/FileProcessor.ts

@@ -0,0 +1,86 @@
+import type { CodeNode, FileNode } from '@kubb/ast'
+import { extractStringsFromNodes } from '@kubb/ast'
+import pLimit from 'p-limit'
+import { PARALLEL_CONCURRENCY_LIMIT } from './constants.ts'
+import type { Parser } from './defineParser.ts'
+
+type ParseOptions = {
+  parsers?: Map<FileNode['extname'], Parser>
+  extension?: Record<FileNode['extname'], FileNode['extname'] | ''>
+}
+
+type RunOptions = ParseOptions & {
+  /**
+   * @default 'sequential'
+   */
+  mode?: 'sequential' | 'parallel'
+  onStart?: (files: Array<FileNode>) => Promise<void> | void
+  onEnd?: (files: Array<FileNode>) => Promise<void> | void
+  onUpdate?: (params: { file: FileNode; source?: string; processed: number; total: number; percentage: number }) => Promise<void> | void
+}
+
+function joinSources(file: FileNode): string {
+  return file.sources
+    .map((item) => extractStringsFromNodes(item.nodes as Array<CodeNode>))
+    .filter(Boolean)
+    .join('\n\n')
+}
+
+/**
+ * Converts a single file to a string using the registered parsers.
+ * Falls back to joining source values when no matching parser is found.
+ *
+ * @internal
+ */
+export class FileProcessor {
+  readonly #limit = pLimit(PARALLEL_CONCURRENCY_LIMIT)
+
+  async parse(file: FileNode, { parsers, extension }: ParseOptions = {}): Promise<string> {
+    const parseExtName = extension?.[file.extname] || undefined
+
+    if (!parsers || !file.extname) {
+      return joinSources(file)
+    }
+
+    const parser = parsers.get(file.extname)
+
+    if (!parser) {
+      return joinSources(file)
+    }
+
+    return parser.parse(file, { extname: parseExtName })
+  }
+
+  async run(files: Array<FileNode>, { parsers, mode = 'sequential', extension, onStart, onEnd, onUpdate }: RunOptions = {}): Promise<Array<FileNode>> {
+    await onStart?.(files)
+
+    const total = files.length
+    let processed = 0
+
+    const processOne = async (file: FileNode) => {
+      const source = await this.parse(file, { extension, parsers })
+      const currentProcessed = ++processed
+      const percentage = (currentProcessed / total) * 100
+
+      await onUpdate?.({
+        file,
+        source,
+        processed: currentProcessed,
+        percentage,
+        total,
+      })
+    }
+
+    if (mode === 'sequential') {
+      for (const file of files) {
+        await processOne(file)
+      }
+    } else {
+      await Promise.all(files.map((file) => this.#limit(() => processOne(file))))
+    }
+
+    await onEnd?.(files)
+
+    return files
+  }
+}