@kubb/fabric-core 0.0.1 → 0.1.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kubb/fabric-core",
-  "version": "0.0.1",
+  "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"
@@ -34,6 +38,10 @@
       "import": "./dist/parsers/typescript.js",
       "require": "./dist/parsers/typescript.cjs"
     },
+    "./types": {
+      "import": "./dist/types.js",
+      "require": "./dist/types.cjs"
+    },
     "./package.json": "./package.json"
   },
   "main": "./dist/index.cjs",
@@ -46,6 +54,12 @@
       ],
       "parsers/tsx": [
         "./dist/parsers/tsx.d.ts"
+      ],
+      "parsers/default": [
+        "./dist/parsers/default.d.ts"
+      ],
+      "types": [
+        "./dist/types.d.ts"
       ]
     }
   },

package/src/FileManager.ts

@@ -1,22 +1,22 @@
-import pLimit from 'p-limit'
-
-import type * as KubbFile from './types.ts'
-import { parseFile } from './parsers/parser.ts'
+import type * as KubbFile from './KubbFile.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'
+import { createFile } from './createFile.ts'
+import { FileProcessor, type ProcessFilesProps } from './FileProcessor.ts'
 
-type WriteFilesProps = {
-  extension?: Record<KubbFile.Extname, KubbFile.Extname | ''>
-  dryRun?: boolean
+function mergeFile<TMeta extends object = object>(a: KubbFile.File<TMeta>, b: KubbFile.File<TMeta>): KubbFile.File<TMeta> {
+  return {
+    ...a,
+    sources: [...(a.sources || []), ...(b.sources || [])],
+    imports: [...(a.imports || []), ...(b.imports || [])],
+    exports: [...(a.exports || []), ...(b.exports || [])],
+  }
 }
 
 export class FileManager {
   #cache = new Cache<KubbFile.ResolvedFile>()
-  #limit = pLimit(100)
+  #processor = new FileProcessor()
 
   constructor() {
     return this
@@ -67,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
@@ -78,193 +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
-
-        if (!dryRun) {
-          const source = await parseFile(resolvedFile, { extname })
-
-          await write(resolvedFile.path, source, { sanity: false })
-        }
-      })
-    })
-
-    await Promise.all(promises)
-
-    return files
-  }
-}
-
-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> {
-  return {
-    ...a,
-    sources: [...(a.sources || []), ...(b.sources || [])],
-    imports: [...(a.imports || []), ...(b.imports || [])],
-    exports: [...(a.exports || []), ...(b.exports || [])],
-  }
-}
-
-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) : []
+  get processor() {
+    const files = this.files
+    const processor = this.#processor
 
-  return {
-    ...file,
-    id: hashObject({ path: file.path }),
-    name: trimExtName(file.baseName),
-    extname,
-    imports: imports,
-    exports: exports,
-    sources: sources,
-    meta: file.meta || ({} as TMeta),
+    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/KubbFile.ts

@@ -0,0 +1,132 @@
+type BasePath<T extends string = string> = `${T}/`
+
+export type Import = {
+  /**
+   * Import name to be used
+   * @example ["useState"]
+   * @example "React"
+   */
+  name:
+    | string
+    | Array<
+        | string
+        | {
+            propertyName: string
+            name?: string
+          }
+      >
+  /**
+   * Path for the import
+   * @example '@kubb/core'
+   */
+  path: string
+  /**
+   * Add `type` prefix to the import, this will result in: `import type { Type } from './path'`.
+   */
+  isTypeOnly?: boolean
+
+  isNameSpace?: boolean
+  /**
+   * When root is set it will get the path with relative getRelativePath(root, path).
+   */
+  root?: string
+}
+
+export type Source = {
+  name?: string
+  value?: string
+  isTypeOnly?: boolean
+  /**
+   * Has const or type 'export'
+   * @default false
+   */
+  isExportable?: boolean
+  /**
+   * When set, barrel generation will add this
+   * @default false
+   */
+  isIndexable?: boolean
+}
+
+export type Export = {
+  /**
+   * Export name to be used.
+   * @example ["useState"]
+   * @example "React"
+   */
+  name?: string | Array<string>
+  /**
+   * Path for the import.
+   * @example '@kubb/core'
+   */
+  path: string
+  /**
+   * Add `type` prefix to the export, this will result in: `export type { Type } from './path'`.
+   */
+  isTypeOnly?: boolean
+  /**
+   * Make it possible to override the name, this will result in: `export * as aliasName from './path'`.
+   */
+  asAlias?: boolean
+}
+
+export type Extname = '.ts' | '.js' | '.tsx' | '.json' | `.${string}`
+
+export type Mode = 'single' | 'split'
+
+/**
+ * Name to be used to dynamicly create the baseName(based on input.path)
+ * Based on UNIX basename
+ * @link https://nodejs.org/api/path.html#pathbasenamepath-suffix
+ */
+export type BaseName = `${string}.${string}`
+
+/**
+ * Path will be full qualified path to a specified file
+ */
+export type Path = string
+
+export type AdvancedPath<T extends BaseName = BaseName> = `${BasePath}${T}`
+
+export type OptionalPath = Path | undefined | null
+
+export type File<TMeta extends object = object> = {
+  /**
+   * Name to be used to create the path
+   * Based on UNIX basename, `${name}.extname`
+   * @link https://nodejs.org/api/path.html#pathbasenamepath-suffix
+   */
+  baseName: BaseName
+  /**
+   * Path will be full qualified path to a specified file
+   */
+  path: AdvancedPath<BaseName> | Path
+  sources: Array<Source>
+  imports?: Array<Import>
+  exports?: Array<Export>
+  /**
+   * Use extra meta, this is getting used to generate the barrel/index files.
+   */
+  meta?: TMeta
+  banner?: string
+  footer?: string
+}
+
+export type ResolvedImport = Import
+
+export type ResolvedExport = Export
+
+export type ResolvedFile<TMeta extends object = object> = File<TMeta> & {
+  /**
+   * @default hash
+   */
+  id: string
+  /**
+   * Contains the first part of the baseName, generated based on baseName
+   * @link  https://nodejs.org/api/path.html#pathformatpathobject
+   */
+  name: string
+  extname: Extname
+  imports: Array<ResolvedImport>
+  exports: Array<ResolvedExport>
+}

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),
+  }
+}