@kubb/fabric-core 0.0.0 → 0.1.0

package/src/FileManager.ts

@@ -1,6 +1,6 @@
 import pLimit from 'p-limit'
 
-import type * as KubbFile from './types.ts'
+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'
@@ -14,91 +14,6 @@ type WriteFilesProps = {
   dryRun?: boolean
 }
 
-export class FileManager {
-  #cache = new Cache<KubbFile.ResolvedFile>()
-  #limit = pLimit(100)
-
-  constructor() {
-    return this
-  }
-
-  async add(...files: Array<KubbFile.File>) {
-    const resolvedFiles: Array<KubbFile.ResolvedFile> = []
-
-    const mergedFiles = new Map<string, KubbFile.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)
-      }
-    })
-
-    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.flush()
-
-      resolvedFiles.push(resolvedFile)
-    }
-
-    return resolvedFiles
-  }
-
-  flush() {
-    this.#cache.flush()
-  }
-
-  getByPath(path: KubbFile.Path): KubbFile.ResolvedFile | null {
-    return this.#cache.get(path)
-  }
-
-  deleteByPath(path: KubbFile.Path): void {
-    this.#cache.delete(path)
-  }
-
-  clear(): void {
-    this.#cache.clear()
-  }
-
-  getFiles(): Array<KubbFile.ResolvedFile> {
-    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))
-
-    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')
@@ -268,3 +183,88 @@ export function createFile<TMeta extends object = object>(file: KubbFile.File<TM
     meta: file.meta || ({} as TMeta),
   }
 }
+
+export class FileManager {
+  #cache = new Cache<KubbFile.ResolvedFile>()
+  #limit = pLimit(100)
+
+  constructor() {
+    return this
+  }
+
+  async add(...files: Array<KubbFile.File>) {
+    const resolvedFiles: Array<KubbFile.ResolvedFile> = []
+
+    const mergedFiles = new Map<string, KubbFile.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)
+      }
+    })
+
+    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.flush()
+
+      resolvedFiles.push(resolvedFile)
+    }
+
+    return resolvedFiles
+  }
+
+  flush() {
+    this.#cache.flush()
+  }
+
+  getByPath(path: KubbFile.Path): KubbFile.ResolvedFile | null {
+    return this.#cache.get(path)
+  }
+
+  deleteByPath(path: KubbFile.Path): void {
+    this.#cache.delete(path)
+  }
+
+  clear(): void {
+    this.#cache.clear()
+  }
+
+  getFiles(): Array<KubbFile.ResolvedFile> {
+    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))
+
+    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
+  }
+}

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/defineApp.ts

@@ -1,4 +1,4 @@
-import type * as KubbFile from './types.ts'
+import type * as KubbFile from './KubbFile.ts'
 import { FileManager } from './FileManager.ts'
 import { isPromise } from 'remeda'
 
@@ -19,46 +19,42 @@ type AppRenderer = {
   waitUntilExit(): Promise<void>
 }
 
-export type AppContext = {
+export type AppContext<TOptions = unknown> = {
+  options?: TOptions
   fileManager: FileManager
   addFile(...files: Array<KubbFile.File>): Promise<void>
   files: Array<KubbFile.ResolvedFile>
   clear: () => void
 }
 
-type RootRenderFunction<THostElement = unknown> = (this: AppContext, container: THostElement, context: AppContext) => AppRenderer
+type RootRenderFunction<THostElement, TContext extends AppContext> = (this: TContext, container: THostElement, context: TContext) => AppRenderer
 
 type Plugin<Options = any[], P extends unknown[] = Options extends unknown[] ? Options : [Options]> = FunctionPlugin<P> | ObjectPlugin<P>
 
-export interface App<_THostElement = unknown> {
+type WriteOptions = {
+  extension?: Record<KubbFile.Extname, KubbFile.Extname | ''>
+  dryRun?: boolean
+}
+
+export interface App {
   _component: Component
   render(): Promise<void>
   renderToString(): Promise<string>
   getFiles(): Promise<Array<KubbFile.ResolvedFile>>
   use<Options>(plugin: Plugin<Options>, options: NoInfer<Options>): this
-  write(): Promise<void>
+  write(options?: WriteOptions): Promise<void>
   addFile(...files: Array<KubbFile.File>): Promise<void>
   waitUntilExit(): Promise<void>
 }
 
-type DefineOptions = {
-  extension?: Record<KubbFile.Extname, KubbFile.Extname | ''>
-  dryRun?: boolean
-}
+export type DefineApp<TContext extends AppContext> = (rootComponent?: Component, options?: TContext['options']) => App
 
-export type DefineApp<THostElement> = (rootComponent?: Component, options?: DefineOptions) => App<THostElement>
-
-export function defineApp<THostElement>(instance: RootRenderFunction<THostElement>): DefineApp<THostElement> {
-  function createApp(
-    rootComponent: Component,
-    options: DefineOptions = {
-      extension: { '.ts': '.ts' },
-      dryRun: false,
-    },
-  ) {
+export function defineApp<THostElement, TContext extends AppContext>(instance: RootRenderFunction<THostElement, TContext>): DefineApp<TContext> {
+  function createApp(rootComponent: Component, options?: TContext['options']): App {
     const installedPlugins = new WeakSet()
     const fileManager = new FileManager()
-    const context: AppContext = {
+    const context = {
+      options,
       fileManager,
       async addFile(...newFiles) {
         await fileManager.add(...newFiles)
@@ -69,11 +65,11 @@ export function defineApp<THostElement>(instance: RootRenderFunction<THostElemen
       get files() {
         return fileManager.getFiles()
       },
-    }
+    } as TContext
 
     const { render, renderToString, waitUntilExit } = instance.call(context, rootComponent, context)
 
-    const app: App<THostElement> = {
+    const app: App = {
       _component: rootComponent,
       async render() {
         if (isPromise(render)) {
@@ -90,7 +86,12 @@ export function defineApp<THostElement>(instance: RootRenderFunction<THostElemen
       },
       waitUntilExit,
       addFile: context.addFile,
-      async write() {
+      async write(
+        options = {
+          extension: { '.ts': '.ts' },
+          dryRun: false,
+        },
+      ) {
         await fileManager.processFiles({
           extension: options.extension,
           dryRun: options.dryRun,

package/src/index.ts

@@ -1,4 +1,4 @@
 export { createApp } from './createApp.ts'
-export type { DefineApp, AppContext } from './defineApp.ts'
 export { defineApp } from './defineApp.ts'
-export * as KubbFile from './types.ts'
+export { FileManager } from './FileManager.ts'
+export { parseFile } from './parsers/parser.ts'

package/src/parsers/parser.ts

@@ -1,4 +1,4 @@
-import type * as KubbFile from '../types.ts'
+import type * as KubbFile from '../KubbFile.ts'
 import { typeScriptParser } from './typescript.ts'
 import { tsxParser } from './tsx.ts'
 

package/src/types.ts

@@ -1,132 +1,2 @@
-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>
-}
+export * as KubbFile from './KubbFile.ts'
+export type { DefineApp, AppContext, App } from './defineApp.ts'

package/dist/parser-Bck6QDwN.d.cts

@@ -1,15 +0,0 @@
-import { i as ResolvedFile, t as Extname } from "./types-lS0JaZqX.cjs";
-
-//#region src/parsers/parser.d.ts
-type ParserModule<TMeta extends object = object> = {
-  /**
-   * Convert a file to string
-   */
-  print: (file: ResolvedFile<TMeta>, options: PrintOptions) => Promise<string>;
-};
-type PrintOptions = {
-  extname?: Extname;
-};
-//#endregion
-export { ParserModule as t };
-//# sourceMappingURL=parser-Bck6QDwN.d.cts.map

package/dist/parser-CRl-iUw1.d.ts

@@ -1,15 +0,0 @@
-import { i as ResolvedFile, t as Extname } from "./types-BY5X8xoR.js";
-
-//#region src/parsers/parser.d.ts
-type ParserModule<TMeta extends object = object> = {
-  /**
-   * Convert a file to string
-   */
-  print: (file: ResolvedFile<TMeta>, options: PrintOptions) => Promise<string>;
-};
-type PrintOptions = {
-  extname?: Extname;
-};
-//#endregion
-export { ParserModule as t };
-//# sourceMappingURL=parser-CRl-iUw1.d.ts.map