@kubb/core 5.0.0-alpha.4 → 5.0.0-alpha.41

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kubb/core",
-  "version": "5.0.0-alpha.4",
+  "version": "5.0.0-alpha.41",
   "description": "Core functionality for Kubb's plugin-based code generation system, providing the foundation for transforming OpenAPI specifications.",
   "keywords": [
     "typescript",
@@ -31,17 +31,17 @@
       "import": "./dist/index.js",
       "require": "./dist/index.cjs"
     },
-    "./hooks": {
-      "import": "./dist/hooks.js",
-      "require": "./dist/hooks.cjs"
+    "./mocks": {
+      "import": "./dist/mocks.js",
+      "require": "./dist/mocks.cjs"
     },
     "./package.json": "./package.json"
   },
   "types": "./dist/index.d.ts",
   "typesVersions": {
     "*": {
-      "hooks": [
-        "./dist/hooks.d.ts"
+      "mocks": [
+        "./dist/mocks.d.ts"
       ]
     }
   },
@@ -64,14 +64,12 @@
     }
   ],
   "dependencies": {
-    "@kubb/fabric-core": "0.13.3",
-    "@kubb/react-fabric": "0.13.3",
-    "empathic": "^2.0.0",
     "fflate": "^0.8.2",
-    "remeda": "^2.33.6",
+    "remeda": "^2.33.7",
     "semver": "^7.7.4",
-    "tinyexec": "^1.0.4",
-    "@kubb/ast": "5.0.0-alpha.4"
+    "tinyexec": "^1.1.1",
+    "@kubb/ast": "5.0.0-alpha.41",
+    "@kubb/renderer-jsx": "5.0.0-alpha.41"
   },
   "devDependencies": {
     "@types/semver": "^7.7.1",
@@ -79,8 +77,7 @@
     "@internals/utils": "0.0.0"
   },
   "peerDependencies": {
-    "@kubb/fabric-core": "0.13.3",
-    "@kubb/react-fabric": "0.13.3"
+    "@kubb/renderer-jsx": "5.0.0-alpha.41"
   },
   "engines": {
     "node": ">=22"

package/src/FileManager.ts

@@ -0,0 +1,131 @@
+import { trimExtName } from '@internals/utils'
+import type { FileNode } from '@kubb/ast'
+import { createFile } from '@kubb/ast'
+
+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>()
+
+    files.forEach((file) => {
+      const existing = mergedFiles.get(file.path)
+      if (existing) {
+        mergedFiles.set(file.path, mergeFile(existing, file))
+      } else {
+        mergedFiles.set(file.path, file)
+      }
+    })
+
+    for (const file of mergedFiles.values()) {
+      const resolvedFile = createFile(file)
+      this.#cache.set(resolvedFile.path, resolvedFile)
+      this.#filesCache = null
+      resolvedFiles.push(resolvedFile)
+    }
+
+    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>()
+
+    files.forEach((file) => {
+      const existing = mergedFiles.get(file.path)
+      if (existing) {
+        mergedFiles.set(file.path, mergeFile(existing, file))
+      } else {
+        mergedFiles.set(file.path, 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)
+      this.#filesCache = null
+      resolvedFiles.push(resolvedFile)
+    }
+
+    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
+    }
+
+    const keys = [...this.#cache.keys()].sort((a, b) => {
+      if (a.length !== b.length) return a.length - b.length
+      const aIsIndex = trimExtName(a).endsWith('index')
+      const bIsIndex = trimExtName(b).endsWith('index')
+      if (aIsIndex !== bIsIndex) return aIsIndex ? 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,84 @@
+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.
+ */
+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
+  }
+}