@kubb/fabric-core 0.0.0-canary-20251021185909 → 0.0.0-canary-20251022151827

package/dist/typescriptParser-BBbbmG5W.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"typescriptParser-BBbbmG5W.cjs","names":["path","ts","output: string","path","importPropertyName: ts.Identifier | undefined","importName: ts.NamedImportBindings | undefined"],"sources":["../src/utils/trimExtName.ts","../src/parsers/createParser.ts","../src/utils/getRelativePath.ts","../src/parsers/typescriptParser.ts"],"sourcesContent":["export function trimExtName(text: string): string {\n  return text.replace(/\\.[^/.]+$/, '')\n}\n","import type { Parser, UserParser } from './types.ts'\n\nexport function createParser<TOptions = any[], TMeta extends object = any>(parser: UserParser<TOptions, TMeta>): Parser<TOptions, TMeta> {\n  return {\n    type: 'parser',\n    ...parser,\n  }\n}\n","import { normalize, relative } from 'node:path'\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 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 } from '../utils/getRelativePath.ts'\nimport { trimExtName } from '../utils/trimExtName.ts'\nimport path from 'node:path'\nimport { createParser } from './createParser.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 = createParser({\n  name: 'typescript',\n  extNames: ['.ts', '.js'],\n  install() {},\n  async parse(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/dist/typescriptParser-C-sBy1iR.d.cts

@@ -0,0 +1,50 @@
+import { o as Parser } from "./App-zyf9KG3p.cjs";
+import ts from "typescript";
+
+//#region src/parsers/typescriptParser.d.ts
+type PrintOptions = {
+  source?: string;
+  baseName?: string;
+  scriptKind?: ts.ScriptKind;
+};
+/**
+ * Convert AST TypeScript/TSX nodes to a string based on the TypeScript printer.
+ * Ensures consistent output across environments.
+ * Also works as a formatter when `source` is provided without `elements`.
+ */
+declare function print(elements?: Array<ts.Node>, {
+  source,
+  baseName,
+  scriptKind
+}?: PrintOptions): string;
+declare function createImport({
+  name,
+  path,
+  root,
+  isTypeOnly,
+  isNameSpace
+}: {
+  name: string | Array<string | {
+    propertyName: string;
+    name?: string;
+  }>;
+  path: string;
+  root?: string;
+  isTypeOnly?: boolean;
+  isNameSpace?: boolean;
+}): ts.ImportDeclaration;
+declare function createExport({
+  path,
+  asAlias,
+  isTypeOnly,
+  name
+}: {
+  path: string;
+  asAlias?: boolean;
+  isTypeOnly?: boolean;
+  name?: string | Array<ts.Identifier | string>;
+}): ts.ExportDeclaration;
+declare const typescriptParser: Parser<[], any>;
+//#endregion
+export { typescriptParser as i, createImport as n, print as r, createExport as t };
+//# sourceMappingURL=typescriptParser-C-sBy1iR.d.cts.map

package/dist/typescriptParser-CtMmz0UV.d.ts

@@ -0,0 +1,50 @@
+import { o as Parser } from "./App-DZuROf6f.js";
+import ts from "typescript";
+
+//#region src/parsers/typescriptParser.d.ts
+type PrintOptions = {
+  source?: string;
+  baseName?: string;
+  scriptKind?: ts.ScriptKind;
+};
+/**
+ * Convert AST TypeScript/TSX nodes to a string based on the TypeScript printer.
+ * Ensures consistent output across environments.
+ * Also works as a formatter when `source` is provided without `elements`.
+ */
+declare function print(elements?: Array<ts.Node>, {
+  source,
+  baseName,
+  scriptKind
+}?: PrintOptions): string;
+declare function createImport({
+  name,
+  path,
+  root,
+  isTypeOnly,
+  isNameSpace
+}: {
+  name: string | Array<string | {
+    propertyName: string;
+    name?: string;
+  }>;
+  path: string;
+  root?: string;
+  isTypeOnly?: boolean;
+  isNameSpace?: boolean;
+}): ts.ImportDeclaration;
+declare function createExport({
+  path,
+  asAlias,
+  isTypeOnly,
+  name
+}: {
+  path: string;
+  asAlias?: boolean;
+  isTypeOnly?: boolean;
+  name?: string | Array<ts.Identifier | string>;
+}): ts.ExportDeclaration;
+declare const typescriptParser: Parser<[], any>;
+//#endregion
+export { typescriptParser as i, createImport as n, print as r, createExport as t };
+//# sourceMappingURL=typescriptParser-CtMmz0UV.d.ts.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kubb/fabric-core",
-  "version": "0.0.0-canary-20251021185909",
+  "version": "0.0.0-canary-20251022151827",
   "description": "Core functionality for Kubb's plugin-based code generation system, providing the foundation for transforming OpenAPI specifications.",
   "keywords": [
     "typescript",
@@ -26,18 +26,18 @@
       "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"
+    "./parsers": {
+      "import": "./dist/parsers.js",
+      "require": "./dist/parsers.cjs"
     },
     "./parsers/typescript": {
       "import": "./dist/parsers/typescript.js",
       "require": "./dist/parsers/typescript.cjs"
     },
+    "./plugins": {
+      "import": "./dist/plugins.js",
+      "require": "./dist/plugins.cjs"
+    },
     "./types": {
       "import": "./dist/types.js",
       "require": "./dist/types.cjs"
@@ -49,14 +49,14 @@
   "types": "./dist/index.d.cts",
   "typesVersions": {
     "*": {
+      "parsers": [
+        "./dist/parsers.d.ts"
+      ],
       "parsers/typescript": [
         "./dist/parsers/typescript.d.ts"
       ],
-      "parsers/tsx": [
-        "./dist/parsers/tsx.d.ts"
-      ],
-      "parsers/default": [
-        "./dist/parsers/default.d.ts"
+      "plugins": [
+        "./dist/plugins.d.ts"
       ],
       "types": [
         "./dist/types.d.ts"

package/src/App.ts

@@ -0,0 +1,91 @@
+import type * as KubbFile from './KubbFile.ts'
+import type { Plugin } from './plugins/types.ts'
+import type { Parser } from './parsers/types.ts'
+import type { AsyncEventEmitter } from './utils/AsyncEventEmitter.ts'
+import type { FileManager } from './FileManager.ts'
+
+export type Component = any
+
+export type AppEvents = {
+  /**
+   * Called in the beginning of the app lifecycle.
+   */
+  start: [{ app: App }]
+  /**
+   * Called in the end of the app lifecycle.
+   */
+  end: [{ app: App }]
+  /**
+   * Called when being rendered
+   */
+  render: [{ app: App }]
+  /**
+   * Called once before processing any files.
+   */
+  'process:start': [{ files: KubbFile.ResolvedFile[] }]
+
+  /**
+   * Called for each file when processing begins.
+   */
+  'file:start': [{ file: KubbFile.ResolvedFile; index: number; total: number }]
+
+  /**
+   * Called for each file when processing finishes.
+   */
+  'file:end': [{ file: KubbFile.ResolvedFile; index: number; total: number }]
+
+  /**
+   * Called periodically (or after each file) to indicate progress.
+   * Useful for progress bars or logging.
+   */
+  'process:progress': [
+    {
+      processed: number
+      total: number
+      percentage: number
+      source: string
+      file: KubbFile.ResolvedFile
+    },
+  ]
+
+  /**
+   * Called once all files have been processed successfully.
+   */
+  'process:end': [{ files: KubbFile.ResolvedFile[] }]
+}
+
+export type AppContext<TOptions = unknown> = {
+  options?: TOptions
+  events: AsyncEventEmitter<AppEvents>
+  fileManager: FileManager
+  installedPlugins: Set<Plugin>
+  installedParsers: Set<Parser>
+}
+
+export type Install<TOptions = any[] | object | undefined> = TOptions extends any[]
+  ? (app: App, context: AppContext, ...options: TOptions) => void
+  : TOptions extends object
+    ? (app: App, context: AppContext, options?: TOptions) => void
+    : (app: App, context: AppContext) => void
+
+export type Override<TOptions = any[] | object | undefined, TAppExtension extends Record<string, any> = {}> = TOptions extends any[]
+  ? (app: App, context: AppContext, ...options: TOptions) => Partial<TAppExtension>
+  : TOptions extends object
+    ? (app: App, context: AppContext, options?: TOptions) => Partial<TAppExtension>
+    : (app: App, context: AppContext) => Partial<TAppExtension>
+
+export interface App {
+  _component: Component
+  render(): Promise<void>
+  renderToString(): Promise<string>
+  files: Array<KubbFile.ResolvedFile>
+  use<TOptions extends any[] | object = any, TMeta extends object = object, TAppExtension extends Record<string, any> = {}>(
+    pluginOrParser: Plugin<TOptions, TAppExtension> | Parser<TOptions, TMeta>,
+    ...options: TOptions extends any[] ? NoInfer<TOptions> : [NoInfer<TOptions>]
+  ): this & TAppExtension
+  use<TOptions extends any[] | object = any, TMeta extends object = object, TAppExtension extends Record<string, any> = {}>(
+    pluginOrParser: Plugin<TOptions, TAppExtension> | Parser<TOptions, TMeta>,
+  ): this & TAppExtension
+  addFile(...files: Array<KubbFile.File>): Promise<void>
+  waitUntilExit(): Promise<void>
+}

package/src/FileManager.ts

@@ -1,9 +1,11 @@
 import type * as KubbFile from './KubbFile.ts'
 import { Cache } from './utils/Cache.ts'
-import { trimExtName } from './fs.ts'
+import { trimExtName } from './utils/trimExtName.ts'
 import { orderBy } from 'natural-orderby'
 import { createFile } from './createFile.ts'
 import { FileProcessor, type ProcessFilesProps } from './FileProcessor.ts'
+import { AsyncEventEmitter } from './utils/AsyncEventEmitter.ts'
+import type { AppEvents } from './App.ts'
 
 function mergeFile<TMeta extends object = object>(a: KubbFile.File<TMeta>, b: KubbFile.File<TMeta>): KubbFile.File<TMeta> {
   return {
@@ -14,11 +16,16 @@ function mergeFile<TMeta extends object = object>(a: KubbFile.File<TMeta>, b: Ku
   }
 }
 
+type Options = {
+  events?: AsyncEventEmitter<AppEvents>
+}
+
 export class FileManager {
   #cache = new Cache<KubbFile.ResolvedFile>()
-  processor = new FileProcessor()
+  processor: FileProcessor
 
-  constructor() {
+  constructor({ events = new AsyncEventEmitter<AppEvents>() }: Options = {}) {
+    this.processor = new FileProcessor({ events })
     return this
   }
 

package/src/FileProcessor.ts

@@ -1,85 +1,88 @@
 import type * as KubbFile from './KubbFile.ts'
-import { EventEmitter } from './utils/EventEmitter.ts'
-import { write } from './fs.ts'
 import pLimit from 'p-limit'
+import path from 'node:path'
+
 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 }]
-}
+import { defaultParser } from './parsers/defaultParser.ts'
+import { AsyncEventEmitter } from './utils/AsyncEventEmitter.ts'
+import type { AppEvents } from './App.ts'
+import { typescriptParser } from './parsers/typescriptParser.ts'
+import { tsxParser } from './parsers/tsxParser.ts'
 
 export type ProcessFilesProps = {
+  parsers?: Set<Parser>
   extension?: Record<KubbFile.Extname, KubbFile.Extname | ''>
   dryRun?: boolean
 }
 
-type GetSourceOptions = {
+type GetParseOptions = {
+  parsers?: Set<Parser>
   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,
-  }
+type Options = {
+  events?: AsyncEventEmitter<AppEvents>
+}
+
+export class FileProcessor {
+  #limit = pLimit(100)
+  events: AsyncEventEmitter<AppEvents>
+
+  constructor({ events = new AsyncEventEmitter<AppEvents>() }: Options = {}) {
+    this.events = events
 
-  if (!extname) {
-    return defaultParser
+    return this
   }
 
-  const parser = parsers[extname]
+  get #defaultParser(): Set<Parser> {
+    console.warn(`[parser] using default parsers, please consider using the "use" method to add custom parsers.`)
 
-  if (!parser) {
-    console.warn(`[parser] No parser found for ${extname}, default parser will be used`)
+    return new Set<Parser>([typescriptParser, tsxParser, defaultParser])
   }
 
-  return parser || defaultParser
-}
+  async parse(file: KubbFile.ResolvedFile, { parsers = this.#defaultParser, extname }: GetParseOptions = {}): Promise<string> {
+    if (!extname) {
+      console.warn('[parser] No extname found, default parser will be used')
+      return defaultParser.parse(file, { extname })
+    }
 
-export class FileProcessor extends EventEmitter<FileProcessorEvents> {
-  #limit = pLimit(100)
+    const parser = [...parsers].find((item) => item.extNames?.includes(extname))
 
-  constructor(maxListener = 1000) {
-    super(maxListener)
-    return this
-  }
+    if (!parser) {
+      console.warn(`[parser] No parser found for ${extname}, default parser will be used`)
 
-  async parse(file: KubbFile.ResolvedFile, { extname }: GetSourceOptions = {}): Promise<string> {
-    const parser = await getParser(file.extname)
+      return defaultParser.parse(file, { extname })
+    }
 
-    return parser.print(file, { extname })
+    return parser.parse(file, { extname })
   }
 
-  async run(files: Array<KubbFile.ResolvedFile>, { dryRun, extension }: ProcessFilesProps = {}): Promise<KubbFile.ResolvedFile[]> {
-    this.emit('start', { files })
+  async run(files: Array<KubbFile.ResolvedFile>, { parsers, dryRun, extension }: ProcessFilesProps = {}): Promise<KubbFile.ResolvedFile[]> {
+    await this.events.emit('process:start', { files })
+
+    let processed = 0
+    const total = files.length
 
-    const promises = files.map((resolvedFile) =>
+    const promises = files.map((resolvedFile, index) =>
       this.#limit(async () => {
-        const extname = extension?.[resolvedFile.extname] || undefined
+        const extname = extension?.[resolvedFile.extname] || (path.extname(resolvedFile.path) as KubbFile.Extname)
 
-        this.emit('file:start', { file: resolvedFile })
+        await this.events.emit('file:start', { file: resolvedFile, index, total })
 
         if (!dryRun) {
-          const source = await this.parse(resolvedFile, { extname })
-          await write(resolvedFile.path, source, { sanity: false })
+          const source = await this.parse(resolvedFile, { extname, parsers })
+          await this.events.emit('process:progress', { file: resolvedFile, source, processed, percentage: (processed / total) * 100, total })
         }
 
-        this.emit('file:finish', { file: resolvedFile })
+        await this.events.emit('file:end', { file: resolvedFile, index, total })
+
+        processed++
       }),
     )
 
     await Promise.all(promises)
 
-    this.emit('finish', { files })
+    await this.events.emit('process:end', { files })
 
     return files
   }

package/src/createFile.ts

@@ -1,5 +1,5 @@
 import type * as KubbFile from './KubbFile.ts'
-import { trimExtName } from './fs.ts'
+import { trimExtName } from './utils/trimExtName.ts'
 import { createHash } from 'node:crypto'
 import path from 'node:path'
 import { isDeepEqual, uniqueBy } from 'remeda'

package/src/defineApp.ts

@@ -1,17 +1,9 @@
-import type * as KubbFile from './KubbFile.ts'
 import { FileManager } from './FileManager.ts'
-import { isPromise } from 'remeda'
-
-const isFunction = (val: unknown): val is Function => typeof val === 'function'
-
-type Component = any
-
-type PluginInstallFunction<Options = any[]> = Options extends unknown[] ? (app: App, ...options: Options) => any : (app: App, options: Options) => any
-
-export type ObjectPlugin<Options = any[]> = {
-  install: PluginInstallFunction<Options>
-}
-export type FunctionPlugin<Options = any[]> = PluginInstallFunction<Options> & Partial<ObjectPlugin<Options>>
+import { isFunction, isPromise } from 'remeda'
+import type { Plugin } from './plugins/types.ts'
+import type { Parser } from './parsers/types.ts'
+import { AsyncEventEmitter } from './utils/AsyncEventEmitter.ts'
+import type { App, AppContext, Component, AppEvents } from './App.ts'
 
 type AppRenderer = {
   render(): Promise<void> | void
@@ -19,57 +11,27 @@ type AppRenderer = {
   waitUntilExit(): Promise<void>
 }
 
-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, 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>
-
-type WriteOptions = {
-  extension?: Record<KubbFile.Extname, KubbFile.Extname | ''>
-  dryRun?: boolean
-}
-
-export interface App {
-  _component: Component
-  render(): Promise<void>
-  renderToString(): Promise<string>
-  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>
-  waitUntilExit(): Promise<void>
-}
-
 export type DefineApp<TContext extends AppContext> = (rootComponent?: Component, options?: TContext['options']) => App
 
 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 events = new AsyncEventEmitter<AppEvents>()
+    const installedPlugins = new Set<Plugin>()
+    const installedParsers = new Set<Parser>()
+    const fileManager = new FileManager({ events })
     const context = {
+      events,
       options,
       fileManager,
-      async addFile(...newFiles) {
-        await fileManager.add(...newFiles)
-      },
-      clear() {
-        context.fileManager.clear()
-      },
-      get files() {
-        return fileManager.files
-      },
+      installedPlugins,
+      installedParsers,
     } as TContext
 
     const { render, renderToString, waitUntilExit } = instance.call(context, rootComponent, context)
 
-    const app: App = {
+    const app = {
       _component: rootComponent,
       async render() {
         if (isPromise(render)) {
@@ -85,32 +47,45 @@ export function defineApp<THostElement, TContext extends AppContext>(instance: R
         return fileManager.files
       },
       waitUntilExit,
-      addFile: context.addFile,
-      async write(
-        options = {
-          extension: { '.ts': '.ts' },
-          dryRun: false,
-        },
-      ) {
-        await fileManager.write({
-          extension: options.extension,
-          dryRun: options.dryRun,
-        })
+      async addFile(...newFiles) {
+        await fileManager.add(...newFiles)
       },
-      use(plugin: Plugin, ...options: any[]) {
-        if (installedPlugins.has(plugin)) {
-          console.warn('Plugin has already been applied to target app.')
-        } else if (plugin && isFunction(plugin.install)) {
-          installedPlugins.add(plugin)
-          plugin.install(app, ...options)
-        } else if (isFunction(plugin)) {
-          installedPlugins.add(plugin)
-          plugin(app, ...options)
+      use(pluginOrParser, ...options) {
+        const args = Array.isArray(options) ? options : [options[0]]
+
+        if (pluginOrParser.type === 'plugin') {
+          if (installedPlugins.has(pluginOrParser)) {
+            console.warn('Plugin has already been applied to target app.')
+          } else {
+            installedPlugins.add(pluginOrParser)
+          }
+
+          if (pluginOrParser.override && isFunction(pluginOrParser.override)) {
+            const overrider = pluginOrParser.override
+
+            const extraApp = (overrider as any)(app, context, ...args)
+            Object.assign(app, extraApp)
+          }
+        }
+        if (pluginOrParser.type === 'parser') {
+          if (installedParsers.has(pluginOrParser)) {
+            console.warn('Parser has already been applied to target app.')
+          } else {
+            installedParsers.add(pluginOrParser)
+          }
+        }
+
+        if (pluginOrParser && isFunction(pluginOrParser.install)) {
+          const installer = pluginOrParser.install
+
+          ;(installer as any)(app, context, ...args)
         }
 
         return app
       },
-    }
+    } as App
+
+    events.emit('start', { app })
 
     return app
   }

package/src/index.ts

@@ -3,4 +3,4 @@ export { defineApp } from './defineApp.ts'
 export { FileManager } from './FileManager.ts'
 export { createFile } from './createFile.ts'
 export { FileProcessor } from './FileProcessor.ts'
-export { createFileParser } from './parsers/createFileParser.ts'
+export type { App } from './App.ts'

package/src/parsers/createParser.ts

@@ -0,0 +1,8 @@
+import type { Parser, UserParser } from './types.ts'
+
+export function createParser<TOptions = any[], TMeta extends object = any>(parser: UserParser<TOptions, TMeta>): Parser<TOptions, TMeta> {
+  return {
+    type: 'parser',
+    ...parser,
+  }
+}

package/src/parsers/defaultParser.ts

@@ -0,0 +1,10 @@
+import { createParser } from './createParser.ts'
+
+export const defaultParser = createParser({
+  name: 'default',
+  extNames: ['.json'],
+  install() {},
+  async parse(file) {
+    return file.sources.map((item) => item.value).join('\n\n')
+  },
+})

package/src/parsers/index.ts

@@ -0,0 +1,5 @@
+export { createParser } from './createParser.ts'
+
+export { defaultParser } from './defaultParser.ts'
+export { tsxParser } from './tsxParser.ts'
+export { typescriptParser } from './typescriptParser.ts'

package/src/parsers/tsxParser.ts

@@ -0,0 +1,11 @@
+import { typescriptParser } from './typescriptParser.ts'
+import { createParser } from './createParser.ts'
+
+export const tsxParser = createParser({
+  name: 'tsx',
+  extNames: ['.tsx', '.jsx'],
+  install() {},
+  async parse(file, options = { extname: '.tsx' }) {
+    return typescriptParser.parse(file, options)
+  },
+})