@kubb/fabric-core 0.2.15 → 0.2.17

package/dist/types.d.cts

@@ -1,3 +1,2 @@
-import { a as FabricOptions, i as FabricMode, m as KubbFile_d_exports, n as FabricConfig, r as FabricContext } from "./Fabric-0mXLgmur.cjs";
-import { t as DefineFabric } from "./defineFabric-Dkt2l0wC.cjs";
-export { type DefineFabric, type FabricConfig, type FabricContext, type FabricMode, type FabricOptions, KubbFile_d_exports as KubbFile };
+import { a as FabricOptions, i as FabricMode, m as KubbFile_d_exports, n as FabricConfig, r as FabricContext } from "./Fabric-BezqNTQ9.cjs";
+export { type FabricConfig, type FabricContext, type FabricMode, type FabricOptions, KubbFile_d_exports as KubbFile };

package/dist/types.d.ts

@@ -1,3 +1,2 @@
-import { a as FabricOptions, i as FabricMode, m as KubbFile_d_exports, n as FabricConfig, r as FabricContext } from "./Fabric-C-AqOkTA.js";
-import { t as DefineFabric } from "./defineFabric-D_m6CB1s.js";
-export { type DefineFabric, type FabricConfig, type FabricContext, type FabricMode, type FabricOptions, KubbFile_d_exports as KubbFile };
+import { a as FabricOptions, i as FabricMode, m as KubbFile_d_exports, n as FabricConfig, r as FabricContext } from "./Fabric-CVe8cc8b.js";
+export { type FabricConfig, type FabricContext, type FabricMode, type FabricOptions, KubbFile_d_exports as KubbFile };

package/dist/types.js.map

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

package/dist/{typescriptParser-By3ckLtc.d.ts → typescriptParser-B5SxjtvV.d.ts}

@@ -1,4 +1,4 @@
-import { u as Parser } from "./Fabric-C-AqOkTA.js";
+import { u as Parser } from "./Fabric-CVe8cc8b.js";
 import ts from "typescript";
 
 //#region src/parsers/typescriptParser.d.ts
@@ -47,4 +47,4 @@ declare function createExport({
 declare const typescriptParser: Parser<[], any>;
 //#endregion
 export { typescriptParser as i, createImport as n, print as r, createExport as t };
-//# sourceMappingURL=typescriptParser-By3ckLtc.d.ts.map
+//# sourceMappingURL=typescriptParser-B5SxjtvV.d.ts.map

package/dist/{typescriptParser-B4-y6QxR.d.cts → typescriptParser-PfAO0SSm.d.cts}

@@ -1,4 +1,4 @@
-import { u as Parser } from "./Fabric-0mXLgmur.cjs";
+import { u as Parser } from "./Fabric-BezqNTQ9.cjs";
 import ts from "typescript";
 
 //#region src/parsers/typescriptParser.d.ts
@@ -47,4 +47,4 @@ declare function createExport({
 declare const typescriptParser: Parser<[], any>;
 //#endregion
 export { typescriptParser as i, createImport as n, print as r, createExport as t };
-//# sourceMappingURL=typescriptParser-B4-y6QxR.d.cts.map
+//# sourceMappingURL=typescriptParser-PfAO0SSm.d.cts.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kubb/fabric-core",
-  "version": "0.2.15",
+  "version": "0.2.17",
   "description": "Core functionality for Kubb's plugin-based code generation system, providing the foundation for transforming OpenAPI specifications.",
   "keywords": [
     "typescript",

package/src/Fabric.ts

@@ -10,51 +10,63 @@ declare global {
   }
 }
 
+/**
+ * Component placeholder type.
+ * May later be extended to support specific runtime renderers.
+ */
 export type Component = any
 
-export type FabricOptions = {
+/**
+ * Defines core runtime options for Fabric.
+ */
+export interface FabricOptions {
   /**
+   * Determines how Fabric processes files.
+   * - `sequential`: files are processed one by one
+   * - `parallel`: files are processed concurrently
+   *
    * @default 'sequential'
    */
   mode?: FabricMode
 }
 
-export type FabricEvents = {
-  /**
-   * Called in the beginning of the app lifecycle.
-   */
+/**
+ * Available modes for file processing.
+ */
+export type FabricMode = 'sequential' | 'parallel'
+
+/**
+ * Event definitions emitted during the Fabric lifecycle.
+ */
+export interface FabricEvents {
+  /** Called at the beginning of the app lifecycle. */
   start: []
-  /**
-   * Called in the end of the app lifecycle.
-   */
+
+  /** Called at the end of the app lifecycle. */
   end: []
-  /**
-   * Called when being rendered
-   */
+
+  /** Called when Fabric is rendering. */
   render: [{ fabric: Fabric }]
-  /**
-   * Called once before processing any files.
-   */
+
+  /** Called once before any files are processed. */
   'process:start': [{ files: KubbFile.ResolvedFile[] }]
   /**
    * Called when FileManager is adding files to its cache
    */
-
   'file:add': [{ files: KubbFile.ResolvedFile[] }]
+  'file:resolve:path': [{ file: KubbFile.File }]
+  'file:resolve:name': [{ file: KubbFile.File }]
   'write:start': [{ files: KubbFile.ResolvedFile[] }]
   'write:end': [{ files: KubbFile.ResolvedFile[] }]
-  /**
-   * Called for each file when processing begins.
-   */
+
+  /** Called for each file when processing begins. */
   'file:start': [{ file: KubbFile.ResolvedFile; index: number; total: number }]
 
-  /**
-   * Called for each file when processing finishes.
-   */
+  /** Called for each file when processing completes. */
   'file:end': [{ file: KubbFile.ResolvedFile; index: number; total: number }]
 
   /**
-   * Called periodically (or after each file) to indicate progress.
+   * Called periodically (or per file) to indicate progress.
    * Useful for progress bars or logging.
    */
   'process:progress': [
@@ -67,51 +79,87 @@ export type FabricEvents = {
     },
   ]
 
-  /**
-   * Called once all files have been processed successfully.
-   */
+  /** Called once all files have been processed successfully. */
   'process:end': [{ files: KubbFile.ResolvedFile[] }]
 }
 
-export type FabricContext<TOptions extends FabricOptions = FabricOptions> = {
-  config?: FabricConfig<TOptions>
+/**
+ * Shared context passed to all plugins, parsers, and Fabric internals.
+ */
+export interface FabricContext<T extends FabricOptions = FabricOptions> extends AsyncEventEmitter<FabricEvents> {
+  /** The active Fabric configuration. */
+  config: FabricConfig<T>
+
+  /** The internal file manager handling file creation, merging, and writing. */
   fileManager: FileManager
-  files: Array<KubbFile.ResolvedFile>
-  addFile(...files: Array<KubbFile.File>): Promise<void>
+
+  /** List of files currently in memory. */
+  files: KubbFile.ResolvedFile[]
+
+  /** Add new files to the file manager. */
+  addFile(...files: KubbFile.File[]): Promise<void>
+
+  /** Track installed plugins and parsers to prevent duplicates. */
   installedPlugins: Set<Plugin>
   installedParsers: Set<Parser>
-} & AsyncEventEmitter<FabricEvents>
+}
 
-export type FabricMode = 'sequential' | 'parallel'
+/**
+ * Base configuration object for Fabric.
+ */
+export type FabricConfig<T extends FabricOptions = FabricOptions> = T
 
+/**
+ * Utility type that checks whether all properties of `T` are optional.
+ */
 type AllOptional<T> = {} extends T ? true : false
 
-export type FabricConfig<TOptions extends FabricOptions> = {
-  options: TOptions
-}
-
+/**
+ * Defines the signature of a plugin or parser's `install` function.
+ */
 export type Install<TOptions = unknown> = TOptions extends any[]
   ? (context: FabricContext, ...options: TOptions) => void | Promise<void>
   : AllOptional<TOptions> extends true
-    ? (context: FabricContext, options: TOptions | undefined) => void | Promise<void>
+    ? (context: FabricContext, options?: TOptions) => void | Promise<void>
     : (context: FabricContext, options: TOptions) => void | Promise<void>
 
-export type Inject<TOptions = unknown, TAppExtension extends Record<string, any> = {}> = TOptions extends any[]
-  ? (context: FabricContext, ...options: TOptions) => Partial<TAppExtension>
+/**
+ * Defines the signature of a plugin or parser's `inject` function.
+ * Returns an object that extends the Fabric instance.
+ */
+export type Inject<TOptions = unknown, TExtension extends Record<string, any> = {}> = TOptions extends any[]
+  ? (context: FabricContext, ...options: TOptions) => Partial<TExtension>
   : AllOptional<TOptions> extends true
-    ? (context: FabricContext, options: TOptions | undefined) => Partial<TAppExtension>
-    : (context: FabricContext, options: TOptions) => Partial<TAppExtension>
-
-export interface Fabric<TOptions extends FabricOptions = FabricOptions> extends Kubb.Fabric {
-  context: FabricContext<TOptions>
-  files: Array<KubbFile.ResolvedFile>
-  use<TPluginOptions = unknown, TMeta extends object = object, TAppExtension extends Record<string, any> = {}>(
-    pluginOrParser: Plugin<TPluginOptions, TAppExtension> | Parser<TPluginOptions, TMeta>,
+    ? (context: FabricContext, options?: TOptions) => Partial<TExtension>
+    : (context: FabricContext, options: TOptions) => Partial<TExtension>
+
+/**
+ * The main Fabric runtime interface.
+ * Provides access to the current context, registered plugins, files, and utility methods.
+ */
+export interface Fabric<T extends FabricOptions = FabricOptions> extends Kubb.Fabric {
+  /** The shared context for this Fabric instance. */
+  context: FabricContext<T>
+
+  /** The files managed by this Fabric instance. */
+  files: KubbFile.ResolvedFile[]
+
+  /**
+   * Install a plugin or parser into Fabric.
+   *
+   * @param target - The plugin or parser to install.
+   * @param options - Optional configuration or arguments for the target.
+   * @returns A Fabric instance extended by the plugin (if applicable).
+   */
+  use<TPluginOptions = unknown, TMeta extends object = object, TExtension extends Record<string, any> = {}>(
+    target: Plugin<TPluginOptions, TExtension> | Parser<TPluginOptions, TMeta>,
     ...options: TPluginOptions extends any[]
       ? NoInfer<TPluginOptions>
       : AllOptional<TPluginOptions> extends true
         ? [NoInfer<TPluginOptions>?] // Optional when all props are optional
         : [NoInfer<TPluginOptions>] // Required otherwise
-  ): (this & TAppExtension) | Promise<this & TAppExtension>
-  addFile(...files: Array<KubbFile.File>): Promise<void>
+  ): (this & TExtension) | Promise<this & TExtension>
+
+  /** Add one or more files to the Fabric file manager. */
+  addFile(...files: KubbFile.File[]): Promise<void>
 }

package/src/FileManager.ts

@@ -22,6 +22,7 @@ type Options = {
 
 export class FileManager {
   #cache = new Cache<KubbFile.ResolvedFile>()
+  #filesCache: Array<KubbFile.ResolvedFile> | null = null
   events: AsyncEventEmitter<FabricEvents>
   processor: FileProcessor
 
@@ -32,23 +33,27 @@ export class FileManager {
     return this
   }
 
-  async add(...files: Array<KubbFile.File>) {
-    const resolvedFiles: Array<KubbFile.ResolvedFile> = []
+  async #resolvePath(file: KubbFile.File): Promise<KubbFile.File> {
+    await this.events.emit('file:resolve:path', { file })
 
-    const mergedFiles = new Map<string, KubbFile.File>()
+    return file
+  }
 
-    files.forEach((file) => {
-      const existing = mergedFiles.get(file.path)
-      if (existing) {
-        mergedFiles.set(file.path, mergeFile(existing, file))
-      } else {
-        mergedFiles.set(file.path, file)
-      }
-    })
+  async #resolveName(file: KubbFile.File): Promise<KubbFile.File> {
+    await this.events.emit('file:resolve:name', { file })
+
+    return file
+  }
+
+  async add(...files: Array<KubbFile.File>) {
+    const resolvedFiles: Array<KubbFile.ResolvedFile> = []
 
-    for (const file of mergedFiles.values()) {
+    for (let file of files) {
       const existing = this.#cache.get(file.path)
 
+      file = await this.#resolveName(file)
+      file = await this.#resolvePath(file)
+
       const merged = existing ? mergeFile(existing, file) : file
       const resolvedFile = createFile(merged)
 
@@ -64,6 +69,7 @@ export class FileManager {
   }
 
   flush() {
+    this.#filesCache = null
     this.#cache.flush()
   }
 
@@ -73,21 +79,36 @@ export class FileManager {
 
   deleteByPath(path: KubbFile.Path): void {
     this.#cache.delete(path)
+    this.#filesCache = null
   }
 
   clear(): void {
     this.#cache.clear()
+    this.#filesCache = null
   }
 
   get files(): Array<KubbFile.ResolvedFile> {
+    if (this.#filesCache) {
+      return [...this.#filesCache]
+    }
+
     const cachedKeys = this.#cache.keys()
 
     // order by path length and if file is a barrel file
     const keys = orderBy(cachedKeys, [(v) => v.length, (v) => trimExtName(v).endsWith('index')])
 
-    const files = keys.map((key) => this.#cache.get(key))
+    const files: Array<KubbFile.ResolvedFile> = []
+
+    for (const key of keys) {
+      const file = this.#cache.get(key)
+      if (file) {
+        files.push(file)
+      }
+    }
+
+    this.#filesCache = files
 
-    return files.filter(Boolean)
+    return [...files]
   }
 
   //TODO add test and check if write of FileManager contains the newly added file

package/src/KubbFile.ts

@@ -88,8 +88,6 @@ 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

package/src/createFile.ts

@@ -5,11 +5,6 @@ import { isDeepEqual, uniqueBy } from 'remeda'
 import type * as KubbFile from './KubbFile.ts'
 import { trimExtName } from './utils/trimExtName.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 combineSources(sources: Array<KubbFile.Source>): Array<KubbFile.Source> {
   return uniqueBy(sources, (obj) => [obj.name, obj.isExportable, obj.isTypeOnly] as const)
 }
@@ -65,79 +60,100 @@ export function combineExports(exports: Array<KubbFile.Export>): Array<KubbFile.
 }
 
 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)
+  const exportedNameLookup = new Set<string>()
+  for (const item of exports) {
+    const { name } = item
+    if (!name) {
+      continue
+    }
+
+    if (Array.isArray(name)) {
+      for (const value of name) {
+        if (value) {
+          exportedNameLookup.add(value)
         }
-
-        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)))
       }
+      continue
+    }
 
-      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
-      }
+    exportedNameLookup.add(name)
+  }
 
-      // new item, append name
-      if (!prevByPath) {
-        return [
-          ...prev,
-          {
-            ...curr,
-            name,
-          },
-        ]
-      }
+  const usageCache = new Map<string, boolean>()
+  const hasImportInSource = (importName: string): boolean => {
+    if (!source) {
+      return true
+    }
 
-      // 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])]
+    const cached = usageCache.get(importName)
+    if (cached !== undefined) {
+      return cached
+    }
 
-        return prev
-      }
+    const isUsed = source.includes(importName) || exportedNameLookup.has(importName)
+    usageCache.set(importName, isUsed)
 
-      // no import was found in the source, ignore import
-      if (!Array.isArray(name) && name && !hasImportInSource(name)) {
-        return prev
-      }
+    return isUsed
+  }
 
-      return [...prev, curr]
-    },
-    [] as 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<Array<KubbFile.Import>>((prev, curr) => {
+    let name = Array.isArray(curr.name) ? [...new Set(curr.name)] : curr.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]
+  }, [])
 }
 
 /**
@@ -156,7 +172,7 @@ export function createFile<TMeta extends object = object>(file: KubbFile.File<TM
 
   return {
     ...file,
-    id: hashObject({ path: file.path }),
+    id: createHash('sha256').update(file.path).digest('hex'),
     name: trimExtName(file.baseName),
     extname,
     imports: imports,