@kubb/fabric-core 0.1.0 → 0.1.1

package/dist/{parser-QF8j8-pj.cjs → typescript-Z90jN87k.cjs}

@@ -21,14 +21,15 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 }) : target, mod));
 
 //#endregion
-let typescript = require("typescript");
-typescript = __toESM(typescript);
+const require_createFileParser = require('./createFileParser-BD8yn0LT.cjs');
 let node_path = require("node:path");
 node_path = __toESM(node_path);
 let fs_extra = require("fs-extra");
 fs_extra = __toESM(fs_extra);
 let js_runtime = require("js-runtime");
 js_runtime = __toESM(js_runtime);
+let typescript = require("typescript");
+typescript = __toESM(typescript);
 
 //#region src/fs.ts
 async function write(path$1, data, options = {}) {
@@ -142,7 +143,7 @@ function createExport({ path: path$1, asAlias, isTypeOnly = false, name }) {
 		return factory.createExportSpecifier(false, void 0, typeof propertyName === "string" ? factory.createIdentifier(propertyName) : propertyName);
 	})), factory.createStringLiteral(path$1), void 0);
 }
-const typeScriptParser = createFileParser({ async print(file, options = { extname: ".ts" }) {
+const typeScriptParser = require_createFileParser.createFileParser({ async print(file, options = { extname: ".ts" }) {
 	const source = file.sources.map((item) => item.value).join("\n\n");
 	const importNodes = file.imports.map((item) => {
 		const importPath = item.root ? getRelativePath(item.root, item.path) : item.path;
@@ -171,37 +172,6 @@ const typeScriptParser = createFileParser({ async print(file, options = { extnam
 	].join("\n");
 } });
 
-//#endregion
-//#region src/parsers/tsx.ts
-const tsxParser = createFileParser({ async print(file, options = { extname: ".tsx" }) {
-	return typeScriptParser.print(file, options);
-} });
-
-//#endregion
-//#region src/parsers/parser.ts
-function createFileParser(parser) {
-	return parser;
-}
-const defaultParser = createFileParser({ async print(file) {
-	return file.sources.map((item) => item.value).join("\n\n");
-} });
-const parsers = {
-	".ts": typeScriptParser,
-	".js": typeScriptParser,
-	".jsx": tsxParser,
-	".tsx": tsxParser,
-	".json": defaultParser
-};
-async function parseFile(file, { extname } = {}) {
-	async function getFileParser(extname$1) {
-		if (!extname$1) return defaultParser;
-		const parser = parsers[extname$1];
-		if (!parser) console.warn(`[parser] No parser found for ${extname$1}, default parser will be used`);
-		return parser || defaultParser;
-	}
-	return (await getFileParser(file.extname)).print(file, { extname });
-}
-
 //#endregion
 Object.defineProperty(exports, '__toESM', {
   enumerable: true,
@@ -221,12 +191,6 @@ Object.defineProperty(exports, 'createImport', {
     return createImport;
   }
 });
-Object.defineProperty(exports, 'parseFile', {
-  enumerable: true,
-  get: function () {
-    return parseFile;
-  }
-});
 Object.defineProperty(exports, 'print', {
   enumerable: true,
   get: function () {
@@ -239,12 +203,6 @@ Object.defineProperty(exports, 'trimExtName', {
     return trimExtName;
   }
 });
-Object.defineProperty(exports, 'tsxParser', {
-  enumerable: true,
-  get: function () {
-    return tsxParser;
-  }
-});
 Object.defineProperty(exports, 'typeScriptParser', {
   enumerable: true,
   get: function () {
@@ -257,4 +215,4 @@ Object.defineProperty(exports, 'write', {
     return write;
   }
 });
-//# sourceMappingURL=parser-QF8j8-pj.cjs.map
+//# sourceMappingURL=typescript-Z90jN87k.cjs.map

package/dist/typescript-Z90jN87k.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"typescript-Z90jN87k.cjs","names":["fs","path","data","ts","output: string","path","importPropertyName: ts.Identifier | undefined","importName: ts.NamedImportBindings | undefined","createFileParser"],"sources":["../src/fs.ts","../src/parsers/typescript.ts"],"sourcesContent":["import { normalize, relative, resolve } from 'node:path'\nimport fs from 'fs-extra'\nimport { switcher } from 'js-runtime'\n\ntype Options = { sanity?: boolean }\n\nexport async function write(path: string, data: string, options: Options = {}): Promise<string | undefined> {\n  if (data.trim() === '') {\n    return undefined\n  }\n  return switcher(\n    {\n      node: async (path: string, data: string, { sanity }: Options) => {\n        try {\n          const oldContent = await fs.readFile(resolve(path), {\n            encoding: 'utf-8',\n          })\n          if (oldContent?.toString() === data?.toString()) {\n            return\n          }\n        } catch (_err) {\n          /* empty */\n        }\n\n        await fs.outputFile(resolve(path), data, { encoding: 'utf-8' })\n\n        if (sanity) {\n          const savedData = await fs.readFile(resolve(path), {\n            encoding: 'utf-8',\n          })\n\n          if (savedData?.toString() !== data?.toString()) {\n            throw new Error(`Sanity check failed for ${path}\\n\\nData[${data.length}]:\\n${data}\\n\\nSaved[${savedData.length}]:\\n${savedData}\\n`)\n          }\n\n          return savedData\n        }\n\n        return data\n      },\n      bun: async (path: string, data: string, { sanity }: Options) => {\n        try {\n          await Bun.write(resolve(path), data)\n\n          if (sanity) {\n            const file = Bun.file(resolve(path))\n            const savedData = await file.text()\n\n            if (savedData?.toString() !== data?.toString()) {\n              throw new Error(`Sanity check failed for ${path}\\n\\nData[${path.length}]:\\n${path}\\n\\nSaved[${savedData.length}]:\\n${savedData}\\n`)\n            }\n\n            return savedData\n          }\n\n          return data\n        } catch (e) {\n          console.error(e)\n        }\n      },\n    },\n    'node',\n  )(path, data.trim(), options)\n}\n\nexport async function read(path: string): Promise<string> {\n  return switcher(\n    {\n      node: async (path: string) => {\n        return fs.readFile(path, { encoding: 'utf8' })\n      },\n      bun: async (path: string) => {\n        const file = Bun.file(path)\n\n        return file.text()\n      },\n    },\n    'node',\n  )(path)\n}\n\nexport function readSync(path: string): string {\n  return switcher(\n    {\n      node: (path: string) => {\n        return fs.readFileSync(path, { encoding: 'utf8' })\n      },\n      bun: () => {\n        throw new Error('Bun cannot read sync')\n      },\n    },\n    'node',\n  )(path)\n}\n\nexport async function exists(path: string): Promise<boolean> {\n  return switcher(\n    {\n      node: async (path: string) => {\n        return fs.pathExists(path)\n      },\n      bun: async (path: string) => {\n        const file = Bun.file(path)\n\n        return file.exists()\n      },\n    },\n    'node',\n  )(path)\n}\n\nexport function existsSync(path: string): boolean {\n  return switcher(\n    {\n      node: (path: string) => {\n        return fs.pathExistsSync(path)\n      },\n      bun: () => {\n        throw new Error('Bun cannot read sync')\n      },\n    },\n    'node',\n  )(path)\n}\n\nexport async function clean(path: string): Promise<void> {\n  return fs.remove(path)\n}\n\nexport async function unlink(path: string): Promise<void> {\n  return fs.unlink(path)\n}\n\nfunction slash(path: string, platform: 'windows' | 'mac' | 'linux' = 'linux') {\n  const isWindowsPath = /^\\\\\\\\\\?\\\\/.test(path)\n  const normalizedPath = normalize(path)\n\n  if (['linux', 'mac'].includes(platform) && !isWindowsPath) {\n    // linux and mac\n    return normalizedPath.replaceAll(/\\\\/g, '/').replace('../', '')\n  }\n\n  // windows\n  return normalizedPath.replaceAll(/\\\\/g, '/').replace('../', '')\n}\n\nexport function trimExtName(text: string): string {\n  return text.replace(/\\.[^/.]+$/, '')\n}\n\nexport function getRelativePath(rootDir?: string | null, filePath?: string | null, platform: 'windows' | 'mac' | 'linux' = 'linux'): string {\n  if (!rootDir || !filePath) {\n    throw new Error(`Root and file should be filled in when retrieving the relativePath, ${rootDir || ''} ${filePath || ''}`)\n  }\n\n  const relativePath = relative(rootDir, filePath)\n\n  // On Windows, paths are separated with a \"\\\"\n  // However, web browsers use \"/\" no matter the platform\n  const slashedPath = slash(relativePath, platform)\n\n  if (slashedPath.startsWith('../')) {\n    return slashedPath\n  }\n\n  return `./${slashedPath}`\n}\n","import ts from 'typescript'\nimport { getRelativePath, trimExtName } from '../fs.ts'\nimport path from 'node:path'\nimport { createFileParser } from './createFileParser.ts'\n\nconst { factory } = ts\n\ntype PrintOptions = {\n  source?: string\n  baseName?: string\n  scriptKind?: ts.ScriptKind\n}\n\n/**\n * Escaped new lines in code with block comments so they can be restored by {@link restoreNewLines}\n */\nconst escapeNewLines = (code: string) => code.replace(/\\n\\n/g, '\\n/* :newline: */')\n\n/**\n * Reverses {@link escapeNewLines} and restores new lines\n */\nconst restoreNewLines = (code: string) => code.replace(/\\/\\* :newline: \\*\\//g, '\\n')\n\n/**\n * Convert AST TypeScript/TSX nodes to a string based on the TypeScript printer.\n * Ensures consistent output across environments.\n * Also works as a formatter when `source` is provided without `elements`.\n */\nexport function print(elements: Array<ts.Node> = [], { source = '', baseName = 'print.tsx', scriptKind = ts.ScriptKind.TSX }: PrintOptions = {}): string {\n  const sourceFile = ts.createSourceFile(baseName, escapeNewLines(source), ts.ScriptTarget.ES2022, true, scriptKind)\n\n  const printer = ts.createPrinter({\n    omitTrailingSemicolon: true,\n    newLine: ts.NewLineKind.LineFeed,\n    removeComments: false,\n    noEmitHelpers: true,\n  })\n\n  let output: string\n\n  if (elements.length > 0) {\n    // Print only provided nodes\n    const nodes = elements.filter(Boolean).sort((a, b) => (a.pos ?? 0) - (b.pos ?? 0))\n    output = printer.printList(ts.ListFormat.MultiLine, factory.createNodeArray(nodes), sourceFile)\n  } else {\n    // Format the whole file\n    output = printer.printFile(sourceFile)\n  }\n\n  return restoreNewLines(output).replace(/\\r\\n/g, '\\n')\n}\n\nexport function createImport({\n  name,\n  path,\n  root,\n  isTypeOnly = false,\n  isNameSpace = false,\n}: {\n  name: string | Array<string | { propertyName: string; name?: string }>\n  path: string\n  root?: string\n  isTypeOnly?: boolean\n  isNameSpace?: boolean\n}) {\n  const resolvePath = root ? getRelativePath(root, path) : path\n\n  if (!Array.isArray(name)) {\n    let importPropertyName: ts.Identifier | undefined = factory.createIdentifier(name)\n    let importName: ts.NamedImportBindings | undefined\n\n    if (isNameSpace) {\n      importPropertyName = undefined\n      importName = factory.createNamespaceImport(factory.createIdentifier(name))\n    }\n\n    return factory.createImportDeclaration(\n      undefined,\n      factory.createImportClause(isTypeOnly, importPropertyName, importName),\n      factory.createStringLiteral(resolvePath),\n      undefined,\n    )\n  }\n\n  return factory.createImportDeclaration(\n    undefined,\n    factory.createImportClause(\n      isTypeOnly,\n      undefined,\n      factory.createNamedImports(\n        name.map((item) => {\n          if (typeof item === 'object') {\n            const obj = item as { propertyName: string; name?: string }\n            if (obj.name) {\n              return factory.createImportSpecifier(false, factory.createIdentifier(obj.propertyName), factory.createIdentifier(obj.name))\n            }\n\n            return factory.createImportSpecifier(false, undefined, factory.createIdentifier(obj.propertyName))\n          }\n\n          return factory.createImportSpecifier(false, undefined, factory.createIdentifier(item))\n        }),\n      ),\n    ),\n    factory.createStringLiteral(resolvePath),\n    undefined,\n  )\n}\n\nexport function createExport({\n  path,\n  asAlias,\n  isTypeOnly = false,\n  name,\n}: {\n  path: string\n  asAlias?: boolean\n  isTypeOnly?: boolean\n  name?: string | Array<ts.Identifier | string>\n}) {\n  if (name && !Array.isArray(name) && !asAlias) {\n    console.warn(`When using name as string, asAlias should be true ${name}`)\n  }\n\n  if (!Array.isArray(name)) {\n    const parsedName = name?.match(/^\\d/) ? `_${name?.slice(1)}` : name\n\n    return factory.createExportDeclaration(\n      undefined,\n      isTypeOnly,\n      asAlias && parsedName ? factory.createNamespaceExport(factory.createIdentifier(parsedName)) : undefined,\n      factory.createStringLiteral(path),\n      undefined,\n    )\n  }\n\n  return factory.createExportDeclaration(\n    undefined,\n    isTypeOnly,\n    factory.createNamedExports(\n      name.map((propertyName) => {\n        return factory.createExportSpecifier(false, undefined, typeof propertyName === 'string' ? factory.createIdentifier(propertyName) : propertyName)\n      }),\n    ),\n    factory.createStringLiteral(path),\n    undefined,\n  )\n}\n\nexport const typeScriptParser = createFileParser({\n  async print(file, options = { extname: '.ts' }) {\n    const source = file.sources.map((item) => item.value).join('\\n\\n')\n\n    const importNodes = file.imports\n      .map((item) => {\n        const importPath = item.root ? getRelativePath(item.root, item.path) : item.path\n        const hasExtname = !!path.extname(importPath)\n\n        return createImport({\n          name: item.name,\n          path: options.extname && hasExtname ? `${trimExtName(importPath)}${options.extname}` : item.root ? trimExtName(importPath) : importPath,\n          isTypeOnly: item.isTypeOnly,\n        })\n      })\n      .filter(Boolean)\n\n    const exportNodes = file.exports\n      .map((item) => {\n        const exportPath = item.path\n\n        const hasExtname = !!path.extname(exportPath)\n\n        return createExport({\n          name: item.name,\n          path: options.extname && hasExtname ? `${trimExtName(item.path)}${options.extname}` : trimExtName(item.path),\n          isTypeOnly: item.isTypeOnly,\n          asAlias: item.asAlias,\n        })\n      })\n      .filter(Boolean)\n\n    return [file.banner, print([...importNodes, ...exportNodes]), source, file.footer].join('\\n')\n  },\n})\n"],"mappings":"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"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kubb/fabric-core",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "description": "Core functionality for Kubb's plugin-based code generation system, providing the foundation for transforming OpenAPI specifications.",
   "keywords": [
     "typescript",
@@ -26,6 +26,10 @@
       "import": "./dist/index.js",
       "require": "./dist/index.cjs"
     },
+    "./parsers/default": {
+      "import": "./dist/parsers/default.js",
+      "require": "./dist/parsers/default.cjs"
+    },
     "./parsers/tsx": {
       "import": "./dist/parsers/tsx.js",
       "require": "./dist/parsers/tsx.cjs"
@@ -51,6 +55,9 @@
       "parsers/tsx": [
         "./dist/parsers/tsx.d.ts"
       ],
+      "parsers/default": [
+        "./dist/parsers/default.d.ts"
+      ],
       "types": [
         "./dist/types.d.ts"
       ]

package/src/FileManager.ts

@@ -1,25 +1,11 @@
-import pLimit from 'p-limit'
-
 import type * as KubbFile from './KubbFile.ts'
-import { parseFile } from './parsers/parser.ts'
 import { Cache } from './utils/Cache.ts'
-import { trimExtName, write } from './fs.ts'
-import { createHash } from 'node:crypto'
-import path from 'node:path'
+import { trimExtName } from './fs.ts'
 import { orderBy } from 'natural-orderby'
-import { isDeepEqual, uniqueBy } from 'remeda'
-
-type WriteFilesProps = {
-  extension?: Record<KubbFile.Extname, KubbFile.Extname | ''>
-  dryRun?: boolean
-}
+import { createFile } from './createFile.ts'
+import { FileProcessor, type ProcessFilesProps } from './FileProcessor.ts'
 
-function hashObject(obj: Record<string, unknown>): string {
-  const str = JSON.stringify(obj, Object.keys(obj).sort())
-  return createHash('sha256').update(str).digest('hex')
-}
-
-export function mergeFile<TMeta extends object = object>(a: KubbFile.File<TMeta>, b: KubbFile.File<TMeta>): KubbFile.File<TMeta> {
+function mergeFile<TMeta extends object = object>(a: KubbFile.File<TMeta>, b: KubbFile.File<TMeta>): KubbFile.File<TMeta> {
   return {
     ...a,
     sources: [...(a.sources || []), ...(b.sources || [])],
@@ -28,165 +14,9 @@ export function mergeFile<TMeta extends object = object>(a: KubbFile.File<TMeta>
   }
 }
 
-export function combineSources(sources: Array<KubbFile.Source>): Array<KubbFile.Source> {
-  return uniqueBy(sources, (obj) => [obj.name, obj.isExportable, obj.isTypeOnly] as const)
-}
-
-export function combineExports(exports: Array<KubbFile.Export>): Array<KubbFile.Export> {
-  return orderBy(exports, [
-    (v) => !!Array.isArray(v.name),
-    (v) => !v.isTypeOnly,
-    (v) => v.path,
-    (v) => !!v.name,
-    (v) => (Array.isArray(v.name) ? orderBy(v.name) : v.name),
-  ]).reduce(
-    (prev, curr) => {
-      const name = curr.name
-      const prevByPath = prev.findLast((imp) => imp.path === curr.path)
-      const prevByPathAndIsTypeOnly = prev.findLast((imp) => imp.path === curr.path && isDeepEqual(imp.name, name) && imp.isTypeOnly)
-
-      if (prevByPathAndIsTypeOnly) {
-        // we already have an export that has the same path but uses `isTypeOnly` (export type ...)
-        return prev
-      }
-
-      const uniquePrev = prev.findLast(
-        (imp) => imp.path === curr.path && isDeepEqual(imp.name, name) && imp.isTypeOnly === curr.isTypeOnly && imp.asAlias === curr.asAlias,
-      )
-
-      // we already have an item that was unique enough or name field is empty or prev asAlias is set but current has no changes
-      if (uniquePrev || (Array.isArray(name) && !name.length) || (prevByPath?.asAlias && !curr.asAlias)) {
-        return prev
-      }
-
-      if (!prevByPath) {
-        return [
-          ...prev,
-          {
-            ...curr,
-            name: Array.isArray(name) ? [...new Set(name)] : name,
-          },
-        ]
-      }
-
-      // merge all names when prev and current both have the same isTypeOnly set
-      if (prevByPath && Array.isArray(prevByPath.name) && Array.isArray(curr.name) && prevByPath.isTypeOnly === curr.isTypeOnly) {
-        prevByPath.name = [...new Set([...prevByPath.name, ...curr.name])]
-
-        return prev
-      }
-
-      return [...prev, curr]
-    },
-    [] as Array<KubbFile.Export>,
-  )
-}
-
-export function combineImports(imports: Array<KubbFile.Import>, exports: Array<KubbFile.Export>, source?: string): Array<KubbFile.Import> {
-  return orderBy(imports, [
-    (v) => !!Array.isArray(v.name),
-    (v) => !v.isTypeOnly,
-    (v) => v.path,
-    (v) => !!v.name,
-    (v) => (Array.isArray(v.name) ? orderBy(v.name) : v.name),
-  ]).reduce(
-    (prev, curr) => {
-      let name = Array.isArray(curr.name) ? [...new Set(curr.name)] : curr.name
-
-      const hasImportInSource = (importName: string) => {
-        if (!source) {
-          return true
-        }
-
-        const checker = (name?: string) => {
-          return name && source.includes(name)
-        }
-
-        return checker(importName) || exports.some(({ name }) => (Array.isArray(name) ? name.some(checker) : checker(name)))
-      }
-
-      if (curr.path === curr.root) {
-        // root and path are the same file, remove the "./" import
-        return prev
-      }
-
-      // merge all names and check if the importName is being used in the generated source and if not filter those imports out
-      if (Array.isArray(name)) {
-        name = name.filter((item) => (typeof item === 'string' ? hasImportInSource(item) : hasImportInSource(item.propertyName)))
-      }
-
-      const prevByPath = prev.findLast((imp) => imp.path === curr.path && imp.isTypeOnly === curr.isTypeOnly)
-      const uniquePrev = prev.findLast((imp) => imp.path === curr.path && isDeepEqual(imp.name, name) && imp.isTypeOnly === curr.isTypeOnly)
-      const prevByPathNameAndIsTypeOnly = prev.findLast((imp) => imp.path === curr.path && isDeepEqual(imp.name, name) && imp.isTypeOnly)
-
-      if (prevByPathNameAndIsTypeOnly) {
-        // we already have an export that has the same path but uses `isTypeOnly` (import type ...)
-        return prev
-      }
-
-      // already unique enough or name is empty
-      if (uniquePrev || (Array.isArray(name) && !name.length)) {
-        return prev
-      }
-
-      // new item, append name
-      if (!prevByPath) {
-        return [
-          ...prev,
-          {
-            ...curr,
-            name,
-          },
-        ]
-      }
-
-      // merge all names when prev and current both have the same isTypeOnly set
-      if (prevByPath && Array.isArray(prevByPath.name) && Array.isArray(name) && prevByPath.isTypeOnly === curr.isTypeOnly) {
-        prevByPath.name = [...new Set([...prevByPath.name, ...name])]
-
-        return prev
-      }
-
-      // no import was found in the source, ignore import
-      if (!Array.isArray(name) && name && !hasImportInSource(name)) {
-        return prev
-      }
-
-      return [...prev, curr]
-    },
-    [] as Array<KubbFile.Import>,
-  )
-}
-
-/**
- * Helper to create a file with name and id set
- */
-export function createFile<TMeta extends object = object>(file: KubbFile.File<TMeta>): KubbFile.ResolvedFile<TMeta> {
-  const extname = path.extname(file.baseName) as KubbFile.Extname
-  if (!extname) {
-    throw new Error(`No extname found for ${file.baseName}`)
-  }
-
-  const source = file.sources.map((item) => item.value).join('\n\n')
-  const exports = file.exports?.length ? combineExports(file.exports) : []
-  const imports = file.imports?.length && source ? combineImports(file.imports, exports, source) : []
-  const sources = file.sources?.length ? combineSources(file.sources) : []
-
-  return {
-    ...file,
-    id: hashObject({ path: file.path }),
-    name: trimExtName(file.baseName),
-    extname,
-    imports: imports,
-    exports: exports,
-    sources: sources,
-    meta: file.meta || ({} as TMeta),
-  }
-}
-
 export class FileManager {
   #cache = new Cache<KubbFile.ResolvedFile>()
-  #limit = pLimit(100)
+  #processor = new FileProcessor()
 
   constructor() {
     return this
@@ -237,7 +67,7 @@ export class FileManager {
     this.#cache.clear()
   }
 
-  getFiles(): Array<KubbFile.ResolvedFile> {
+  get files(): Array<KubbFile.ResolvedFile> {
     const cachedKeys = this.#cache.keys()
 
     // order by path length and if file is a barrel file
@@ -248,23 +78,14 @@ export class FileManager {
     return files.filter(Boolean)
   }
 
-  async processFiles({ dryRun, extension }: WriteFilesProps): Promise<Array<KubbFile.ResolvedFile>> {
-    const files = this.getFiles()
-
-    const promises = files.map((resolvedFile) => {
-      return this.#limit(async () => {
-        const extname = extension ? extension[resolvedFile.extname] || undefined : resolvedFile.extname
+  get processor() {
+    const files = this.files
+    const processor = this.#processor
 
-        if (!dryRun) {
-          const source = await parseFile(resolvedFile, { extname })
-
-          await write(resolvedFile.path, source, { sanity: false })
-        }
-      })
-    })
-
-    await Promise.all(promises)
-
-    return files
+    return {
+      async run(options: ProcessFilesProps) {
+        return processor.run(files, options)
+      },
+    }
   }
 }

package/src/FileProcessor.ts

@@ -0,0 +1,86 @@
+import type * as KubbFile from './KubbFile.ts'
+import { EventEmitter } from './utils/EventEmitter.ts'
+import { write } from './fs.ts'
+import pLimit from 'p-limit'
+import type { Parser } from './parsers/types.ts'
+import { typeScriptParser } from './parsers/typescript.ts'
+import { tsxParser } from './parsers/tsx.ts'
+import { defaultParser } from './parsers/default.ts'
+
+type FileProcessorEvents = {
+  start: [{ files: KubbFile.ResolvedFile[] }]
+  finish: [{ files: KubbFile.ResolvedFile[] }]
+  'file:start': [{ file: KubbFile.ResolvedFile }]
+  'file:finish': [{ file: KubbFile.ResolvedFile }]
+}
+
+export type ProcessFilesProps = {
+  extension?: Record<KubbFile.Extname, KubbFile.Extname | ''>
+  dryRun?: boolean
+}
+
+type GetSourceOptions = {
+  extname?: KubbFile.Extname
+}
+
+async function getParser<TMeta extends object = object>(extname: KubbFile.Extname | undefined): Promise<Parser<TMeta>> {
+  const parsers: Record<KubbFile.Extname, Parser<any>> = {
+    '.ts': typeScriptParser,
+    '.js': typeScriptParser,
+    '.jsx': tsxParser,
+    '.tsx': tsxParser,
+    '.json': defaultParser,
+  }
+
+  if (!extname) {
+    return defaultParser
+  }
+
+  const parser = parsers[extname]
+
+  if (!parser) {
+    console.warn(`[parser] No parser found for ${extname}, default parser will be used`)
+  }
+
+  return parser || defaultParser
+}
+
+export async function parseFile(file: KubbFile.ResolvedFile, { extname }: GetSourceOptions = {}): Promise<string> {
+  const parser = await getParser(file.extname)
+
+  return parser.print(file, { extname })
+}
+
+export class FileProcessor extends EventEmitter<FileProcessorEvents> {
+  #limit = pLimit(100)
+
+  constructor(maxListener = 1000) {
+    super(maxListener)
+    return this
+  }
+
+  async run(files: Array<KubbFile.ResolvedFile>, { dryRun, extension }: ProcessFilesProps): Promise<KubbFile.ResolvedFile[]> {
+    this.emit('start', { files })
+
+    const promises = files.map((resolvedFile) =>
+      this.#limit(async () => {
+        const extname = extension?.[resolvedFile.extname] || undefined
+
+        this.emit('file:start', { file: resolvedFile })
+
+        if (!dryRun) {
+          const source = await parseFile(resolvedFile, { extname })
+          await write(resolvedFile.path, source, { sanity: false })
+        }
+
+        this.emit('file:finish', { file: resolvedFile })
+      }),
+    )
+
+    await Promise.all(promises)
+
+    this.emit('finish', { files })
+
+    return files
+  }
+}

package/src/createFile.ts

@@ -0,0 +1,167 @@
+import type * as KubbFile from './KubbFile.ts'
+import { trimExtName } from './fs.ts'
+import { createHash } from 'node:crypto'
+import path from 'node:path'
+import { isDeepEqual, uniqueBy } from 'remeda'
+import { orderBy } from 'natural-orderby'
+
+function hashObject(obj: Record<string, unknown>): string {
+  const str = JSON.stringify(obj, Object.keys(obj).sort())
+  return createHash('sha256').update(str).digest('hex')
+}
+
+export function combineSources(sources: Array<KubbFile.Source>): Array<KubbFile.Source> {
+  return uniqueBy(sources, (obj) => [obj.name, obj.isExportable, obj.isTypeOnly] as const)
+}
+
+export function combineExports(exports: Array<KubbFile.Export>): Array<KubbFile.Export> {
+  return orderBy(exports, [
+    (v) => !!Array.isArray(v.name),
+    (v) => !v.isTypeOnly,
+    (v) => v.path,
+    (v) => !!v.name,
+    (v) => (Array.isArray(v.name) ? orderBy(v.name) : v.name),
+  ]).reduce(
+    (prev, curr) => {
+      const name = curr.name
+      const prevByPath = prev.findLast((imp) => imp.path === curr.path)
+      const prevByPathAndIsTypeOnly = prev.findLast((imp) => imp.path === curr.path && isDeepEqual(imp.name, name) && imp.isTypeOnly)
+
+      if (prevByPathAndIsTypeOnly) {
+        // we already have an export that has the same path but uses `isTypeOnly` (export type ...)
+        return prev
+      }
+
+      const uniquePrev = prev.findLast(
+        (imp) => imp.path === curr.path && isDeepEqual(imp.name, name) && imp.isTypeOnly === curr.isTypeOnly && imp.asAlias === curr.asAlias,
+      )
+
+      // we already have an item that was unique enough or name field is empty or prev asAlias is set but current has no changes
+      if (uniquePrev || (Array.isArray(name) && !name.length) || (prevByPath?.asAlias && !curr.asAlias)) {
+        return prev
+      }
+
+      if (!prevByPath) {
+        return [
+          ...prev,
+          {
+            ...curr,
+            name: Array.isArray(name) ? [...new Set(name)] : name,
+          },
+        ]
+      }
+
+      // merge all names when prev and current both have the same isTypeOnly set
+      if (prevByPath && Array.isArray(prevByPath.name) && Array.isArray(curr.name) && prevByPath.isTypeOnly === curr.isTypeOnly) {
+        prevByPath.name = [...new Set([...prevByPath.name, ...curr.name])]
+
+        return prev
+      }
+
+      return [...prev, curr]
+    },
+    [] as Array<KubbFile.Export>,
+  )
+}
+
+export function combineImports(imports: Array<KubbFile.Import>, exports: Array<KubbFile.Export>, source?: string): Array<KubbFile.Import> {
+  return orderBy(imports, [
+    (v) => !!Array.isArray(v.name),
+    (v) => !v.isTypeOnly,
+    (v) => v.path,
+    (v) => !!v.name,
+    (v) => (Array.isArray(v.name) ? orderBy(v.name) : v.name),
+  ]).reduce(
+    (prev, curr) => {
+      let name = Array.isArray(curr.name) ? [...new Set(curr.name)] : curr.name
+
+      const hasImportInSource = (importName: string) => {
+        if (!source) {
+          return true
+        }
+
+        const checker = (name?: string) => {
+          return name && source.includes(name)
+        }
+
+        return checker(importName) || exports.some(({ name }) => (Array.isArray(name) ? name.some(checker) : checker(name)))
+      }
+
+      if (curr.path === curr.root) {
+        // root and path are the same file, remove the "./" import
+        return prev
+      }
+
+      // merge all names and check if the importName is being used in the generated source and if not filter those imports out
+      if (Array.isArray(name)) {
+        name = name.filter((item) => (typeof item === 'string' ? hasImportInSource(item) : hasImportInSource(item.propertyName)))
+      }
+
+      const prevByPath = prev.findLast((imp) => imp.path === curr.path && imp.isTypeOnly === curr.isTypeOnly)
+      const uniquePrev = prev.findLast((imp) => imp.path === curr.path && isDeepEqual(imp.name, name) && imp.isTypeOnly === curr.isTypeOnly)
+      const prevByPathNameAndIsTypeOnly = prev.findLast((imp) => imp.path === curr.path && isDeepEqual(imp.name, name) && imp.isTypeOnly)
+
+      if (prevByPathNameAndIsTypeOnly) {
+        // we already have an export that has the same path but uses `isTypeOnly` (import type ...)
+        return prev
+      }
+
+      // already unique enough or name is empty
+      if (uniquePrev || (Array.isArray(name) && !name.length)) {
+        return prev
+      }
+
+      // new item, append name
+      if (!prevByPath) {
+        return [
+          ...prev,
+          {
+            ...curr,
+            name,
+          },
+        ]
+      }
+
+      // merge all names when prev and current both have the same isTypeOnly set
+      if (prevByPath && Array.isArray(prevByPath.name) && Array.isArray(name) && prevByPath.isTypeOnly === curr.isTypeOnly) {
+        prevByPath.name = [...new Set([...prevByPath.name, ...name])]
+
+        return prev
+      }
+
+      // no import was found in the source, ignore import
+      if (!Array.isArray(name) && name && !hasImportInSource(name)) {
+        return prev
+      }
+
+      return [...prev, curr]
+    },
+    [] as Array<KubbFile.Import>,
+  )
+}
+
+/**
+ * Helper to create a file with name and id set
+ */
+export function createFile<TMeta extends object = object>(file: KubbFile.File<TMeta>): KubbFile.ResolvedFile<TMeta> {
+  const extname = path.extname(file.baseName) as KubbFile.Extname
+  if (!extname) {
+    throw new Error(`No extname found for ${file.baseName}`)
+  }
+
+  const source = file.sources.map((item) => item.value).join('\n\n')
+  const exports = file.exports?.length ? combineExports(file.exports) : []
+  const imports = file.imports?.length && source ? combineImports(file.imports, exports, source) : []
+  const sources = file.sources?.length ? combineSources(file.sources) : []
+
+  return {
+    ...file,
+    id: hashObject({ path: file.path }),
+    name: trimExtName(file.baseName),
+    extname,
+    imports: imports,
+    exports: exports,
+    sources: sources,
+    meta: file.meta || ({} as TMeta),
+  }
+}

package/src/defineApp.ts

@@ -40,7 +40,7 @@ export interface App {
   _component: Component
   render(): Promise<void>
   renderToString(): Promise<string>
-  getFiles(): Promise<Array<KubbFile.ResolvedFile>>
+  files: Array<KubbFile.ResolvedFile>
   use<Options>(plugin: Plugin<Options>, options: NoInfer<Options>): this
   write(options?: WriteOptions): Promise<void>
   addFile(...files: Array<KubbFile.File>): Promise<void>
@@ -63,7 +63,7 @@ export function defineApp<THostElement, TContext extends AppContext>(instance: R
         context.fileManager.clear()
       },
       get files() {
-        return fileManager.getFiles()
+        return fileManager.files
       },
     } as TContext
 
@@ -81,8 +81,8 @@ export function defineApp<THostElement, TContext extends AppContext>(instance: R
       async renderToString() {
         return renderToString()
       },
-      async getFiles() {
-        return fileManager.getFiles()
+      get files() {
+        return fileManager.files
       },
       waitUntilExit,
       addFile: context.addFile,
@@ -92,7 +92,7 @@ export function defineApp<THostElement, TContext extends AppContext>(instance: R
           dryRun: false,
         },
       ) {
-        await fileManager.processFiles({
+        await fileManager.processor.run({
           extension: options.extension,
           dryRun: options.dryRun,
         })