@kubb/react-fabric 0.1.8 → 0.2.1

package/README.md

@@ -21,32 +21,279 @@
 </div>
 <br />
 
-## Supporting Kubb
+Kubb Fabric is a language-agnostic toolkit for generating code and files using JSX and TypeScript.
+It offers a lightweight layer for file generation while orchestrating the overall process of creating and managing files.
 
-Kubb uses an MIT-licensed open source project with its ongoing development made possible entirely by the support of Sponsors. If you would like to become a sponsor, please consider:
+> [!WARNING]
+> Fabric is under active development. Until a stable 1.0 release, minor versions may occasionally include breaking changes. Please check release notes and PR titles for breaking changes.
 
-- [Become a Sponsor on GitHub](https://github.com/sponsors/stijnvanhulle)
 
-<p align="center">
-  <a href="https://github.com/sponsors/stijnvanhulle">
-    <img src="https://raw.githubusercontent.com/stijnvanhulle/sponsors/main/sponsors.svg" alt="My sponsors" />
-  </a>
-</p>
-
-
-<!-- Badges -->
-
-[npm-version-src]: https://img.shields.io/npm/v/@kubb/react-fabric?flat&colorA=18181B&colorB=f58517
-[npm-version-href]: https://npmjs.com/package/@kubb/react-fabric
-[npm-downloads-src]: https://img.shields.io/npm/dm/@kubb/react-fabric?flat&colorA=18181B&colorB=f58517
-[npm-downloads-href]: https://npmjs.com/package/@kubb/react-fabric
-[license-src]: https://img.shields.io/github/license/kubb-labs/kubb.svg?flat&colorA=18181B&colorB=f58517
-[license-href]: https://github.com/kubb-labs/kubb/blob/main/LICENSE
-[build-src]: https://img.shields.io/github/actions/workflow/status/kubb-labs/kubb/ci.yaml?style=flat&colorA=18181B&colorB=f58517
-[build-href]: https://www.npmjs.com/package/@kubb/react-fabric
-[minified-src]: https://img.shields.io/bundlephobia/min/@kubb/react-fabric?style=flat&colorA=18181B&colorB=f58517
-[minified-href]: https://www.npmjs.com/package/@kubb/react-fabric
-[coverage-src]: https://img.shields.io/codecov/c/github/kubb-labs/kubb?style=flat&colorA=18181B&colorB=f58517
-[coverage-href]: https://www.npmjs.com/package/@kubb/react-fabric
-[sponsors-src]: https://img.shields.io/github/sponsors/stijnvanhulle?style=flat&colorA=18181B&colorB=f58517
-[sponsors-href]: https://github.com/sponsors/stijnvanhulle/
+# Features
+
+- 🎨 Declarative file generation — Create files effortlessly using JSX or JavaScript syntax.
+- 📦 Cross-runtime support — Works seamlessly with Node.js and Bun.
+- 🧩 Built-in debugging utilities — Simplify development and inspect generation flows with ease.
+- ⚡ Fast and lightweight — Minimal overhead, maximum performance.
+
+## Write a TypeScript file
+
+Below is a minimal example showing how `createFabric` works together with plugins and parsers via `fabric.use`.
+
+```ts
+import { createFabric } from '@kubb/fabric-core'
+import { fsPlugin } from '@kubb/fabric-core/plugins'
+import { typescriptParser, createParser } from '@kubb/fabric-core/parsers'
+
+const fabric = createFabric()
+
+fabric.use(fsPlugin, {
+  dryRun: false,
+  onBeforeWrite: (path, data) => {
+    console.log('About to write:', path)
+  },
+  clean: { path: './generated' },
+})
+
+fabric.use(typescriptParser)
+
+await fabric.addFile({
+  baseName: 'index.ts',
+  path: './generated/index.ts',
+  sources: [
+    { value: 'export const x = 1', isExportable: true },
+  ],
+})
+
+await fabric.write()
+
+```
+
+# API Reference
+
+## Core
+### `createFabric(options?): Fabric`
+Returns a Fabric instance with:
+- `fabric.use(pluginOrParser, ...options) => Fabric` — register plugins and parsers.
+- `fabric.addFile(...files)` — queue in-memory files to generate.
+- `fabric.files` — getter with all queued files.
+- `fabric.context` — internal context holding events, options, FileManager, installed plugins/parsers.
+
+### `defineFabric(instance?): () => Fabric`
+Factory to create your own `createFabric` with an optional bootstrap `instance(fabric)` called on creation.
+
+### Events (emitted by the core during processing)
+- `start`
+- `end`
+- `render { fabric }`
+- `file:add { files }`
+- `write:start { files }`
+- `write:end { files }`
+- `file:start { file, index, total }`
+- `file:end { file, index, total }`
+- `process:start { files }`
+- `process:progress { file, source, processed, percentage, total }`
+- `process:end { files }`
+
+
+## Plugins
+#### `fsPlugin`
+Writes files to disk on `process:progress`, supports dry runs and cleaning an output folder before writing.
+
+```
+import { fsPlugin } from '@kubb/fabric-core/plugins'
+```
+
+| Option | Type                                                                 | Default | Description                                                           |
+|---|----------------------------------------------------------------------|---|-----------------------------------------------------------------------|
+| dryRun | `boolean`                                                            | `false` | If true, do not write files to disk.               |
+| onBeforeWrite | `(path: string, data: string \| undefined) => void \| Promise<void>` | — | Called right before each file write on `process:progress`.            |
+| clean | `{ path: string }`                                                   | — | If provided, removes the directory at `path` before writing any files. |
+
+Injected `fabric.write` options (via `fsPlugin`):
+
+| Option | Type                             | Default | Description |
+|---|----------------------------------|---|---|
+| extension | `Record<Extname, Extname \| ''>` | — | Maps input file extensions to output extensions. When set, the matching parser (by extNames) is used. |
+
+#### `barrelPlugin`
+Generates `index.ts` barrel files per folder at `process:end`. `writeEntry` creates a single entry barrel at `root`.
+
+```
+import { barrelPlugin } from '@kubb/fabric-core/plugins'
+```
+
+| Option | Type                                       | Default | Description |
+|---|--------------------------------------------|---|---|
+| root | `string`                                   | — | Root directory to generate barrel files for. |
+| mode | `'all' \| 'named' \| 'propagate' \| false` | — | Controls how exports are generated: all exports, only named exports, propagate (skip barrels), or disabled. |
+| dryRun | `boolean`                                  | `false` | If true, computes barrels but skips writing. |
+
+Injected `fabric.writeEntry` parameters (via `barrelPlugin`):
+
+| Param | Type                                       | Description |
+|---|--------------------------------------------|---|
+| root | `string`                                   | Root directory where the entry `index.ts` should be created. |
+| mode | `'all' \| 'named' \| 'propagate' \| false` | Controls which export style to use for the entry barrel. |
+
+#### `progressPlugin`
+Shows a CLI progress bar by listening to core events.
+
+```
+import { progressPlugin } from '@kubb/fabric-core/plugins'
+```
+
+| Option | Type | Default | Description                                                                             |
+|---|---|---|-----------------------------------------------------------------------------------------|
+| — | — | — | This plugin has no options, it displays a CLI progress bar by listening to core events. |
+
+
+#### `graphPlugin`
+Shows a graph of all files
+
+```
+import { graphPlugin } from '@kubb/fabric-core/plugins'
+```
+
+| Option | Type      | Default | Description                                   |
+|--------|-----------|---------|-----------------------------------------------|
+| root   | `string`  |         | Root directory where to start searching from. |
+| open   | `boolean` | false   | Open a webpage with the generated graph       |
+
+
+#### `reactPlugin`
+Enables rendering React components to the terminal or to a string. Useful for CLI UIs and templating.
+
+```
+import { reactPlugin } from '@kubb/react-fabric/plugins'
+```
+
+| Option | Type | Default | Description |
+|---|---|---|---|
+| stdout | `NodeJS.WriteStream` | — | Optional output stream used to print the rendered content while the app is running. If set, the output is written progressively. |
+| stdin | `NodeJS.ReadStream` | — | Optional input stream for interactive components. |
+| stderr | `NodeJS.WriteStream` | — | Optional error output stream. |
+| debug | `boolean` | — | When true, logs render/unmount information to the console to aid debugging. |
+
+Injected methods (via `reactPlugin`):
+
+| Method | Signature | Description                                                                                        |
+|---|---|----------------------------------------------------------------------------------------------------|
+| `render` | `(App: React.ElementType) => Promise<void> \| void` | Render a React component tree to the terminal and emit the core `start` event.                     |
+| `renderToString` | `(App: React.ElementType) => Promise<string> \| string` | Render a React component tree and return the final output as a string (without writing to stdout). |
+| `waitUntilExit` | `() => Promise<void>` | Wait until the rendered app exits, resolves when unmounted and emits the core `end` event.         |
+
+#### `createPlugin`
+
+Factory to declare a plugin that can be registered via `fabric.use`.
+
+| Field                      | Required | Description                                                                                                                  |
+|----------------------------|---|------------------------------------------------------------------------------------------------------------------------------|
+| `name`                     | Yes | String identifier of your plugin.                                                                                            |
+| `install(fabric, options)` | Yes | Called when the plugin is registered. You can subscribe to core events and perform side effects here.                        |
+| `inject?(fabric, options)` | No | Return synchronously the runtime methods/properties to merge into `fabric` (e.g. `write`, `render`). This must not be async. |
+
+Example:
+
+```ts
+import { createFabric } from '@kubb/fabric-core'
+import { createPlugin } from '@kubb/fabric-core/plugins'
+
+const helloPlugin = createPlugin<{ name?: string }, { sayHello: (msg?: string) => void }>({
+  name: 'helloPlugin',
+  install(fabric, options) {
+    fabric.context.events.on('start', () => {
+      console.log('Fabric started')
+    })
+  },
+  inject(fabric, options) {
+    return {
+      sayHello(msg = options?.name ?? 'world') {
+        console.log(`Hello ${msg}!`)
+      },
+    }
+  },
+})
+
+const fabric = createFabric()
+await fabric.use(helloPlugin, { name: 'Fabric' })
+fabric.sayHello() // -> Hello Fabric!
+```
+
+## Parsers
+#### `typescriptParser`
+
+Prints TS/JS imports/exports and sources, supports extname mapping for generated import/export paths.
+
+```
+import { typescriptParser } from '@kubb/fabric-core/parsers'
+```
+
+| Option | Type | Default | Description                                                                                 |
+|---|---|---|---------------------------------------------------------------------------------------------|
+| file | `KubbFile.File` | -| File that will be used to be parsed.                                                        |
+| extname | `string` | `'.ts'` | Extension to use when emitting import/export paths (e.g., rewrite `./file` to `./file.ts`). |
+
+#### `tsxParser`
+
+Delegates to `typescriptParser` with TSX printing settings.
+
+```
+import { tsxParser } from '@kubb/fabric-core/parsers'
+```
+
+| Option | Type | Default | Description |
+|---|---|---|---|
+| file | `KubbFile.File` | -| File that will be used to be parsed.                                                        |
+| extname | `string` | `'.tsx'` | Extension to use when emitting import/export paths for TSX/JSX files. |
+
+#### `defaultParser`
+
+Fallback parser used when no extension mapping is provided to `fabric.write`.
+
+```
+import { defaultParser } @kubb/fabric-core/parsers`
+```
+
+| Option | Type | Default | Description                                                              |
+|---|---|---|--------------------------------------------------------------------------|
+| file | `KubbFile.File` | -| File that will be used to be parsed.                                                        |
+
+#### `createParser`
+Factory to declare a parser that can be registered via `fabric.use` and selected by `extNames` during `fabirc.write`.
+
+| Field                      | Required | Description                                                                                                     |
+|----------------------------|---|-----------------------------------------------------------------------------------------------------------------|
+| `name`                     | Yes | String identifier of your parser.                                                                               |
+| `extNames`                 | Yes | List of file extensions this parser can handle (e.g. ['.ts']). Use `undefined` for the default parser fallback. |
+| `install(fabric, options)` | No | Optional setup when the parser is registered (subscribe to events, set state, etc.).                            |
+| `parse(file, { extname })` | Yes | Must return the final string that will be written for the given file.                                           |
+
+Example:
+
+```ts
+import { createFabric } from '@kubb/fabric-core'
+import { createParser } from '@kubb/fabric-core/parsers'
+
+const vueParser = createParser<{ banner?: string }>({
+  name: 'vueParser',
+  extNames: ['.vue'],
+  async install(fabric, options) {
+    // Optional setup
+  },
+  async parse(file, { extname }) {
+    const banner = file.options?.banner ?? ''
+    const sources = file.sources.map(s => s.value).join('\n')
+    return `${banner}\n${sources}`
+  },
+})
+
+const fabric = createFabric()
+fabric.use(vueParser)
+fabric.use(fsPlugin); // make it possible to write to the filesystem
+
+fabric.write({ extension: { '.vue': '.ts' } })
+```
+
+> [!NOTE]
+> - `fabric.use` accepts both plugins and parsers. The `fsPlugin` handles I/O and adds `fabric.write`. Parsers decide how files are converted to strings for specific extensions.
+> - When extension mapping is provided to `fabric.write`, Fabric picks a parser whose `extNames` include the file’s extension. Otherwise, the default parser is used.

package/dist/{App-D7ehObix.d.ts → Fabric-nxgJyzWH.d.cts}

@@ -1,7 +1,7 @@
-import { i as File, o as Path, r as Extname, s as ResolvedFile } from "./KubbFile-D4gyyfL-.js";
+import { i as File, o as Path, r as Extname, s as ResolvedFile } from "./KubbFile-DHCtBOpy.cjs";
 
 //#region ../fabric-core/src/plugins/types.d.ts
-type Plugin<TOptions = unknown, TAppExtension$1 extends Record<string, any> = {}> = {
+type Plugin<TOptions = unknown, TAppExtension extends Record<string, any> = {}> = {
   name: string;
   type: 'plugin';
   install: Install<TOptions>;
@@ -10,15 +10,15 @@ type Plugin<TOptions = unknown, TAppExtension$1 extends Record<string, any> = {}
    * Merged into the app instance after install.
    * This cannot be async
    */
-  inject?: Inject<TOptions, TAppExtension$1>;
+  inject?: Inject<TOptions, TAppExtension>;
 };
-type UserPlugin<TOptions = unknown, TAppExtension$1 extends Record<string, any> = {}> = Omit<Plugin<TOptions, TAppExtension$1>, 'type'>;
+type UserPlugin<TOptions = unknown, TAppExtension extends Record<string, any> = {}> = Omit<Plugin<TOptions, TAppExtension>, 'type'>;
 //#endregion
 //#region ../fabric-core/src/parsers/types.d.ts
 type PrintOptions = {
   extname?: Extname;
 };
-type Parser<TOptions = unknown, TMeta$1 extends object = any> = {
+type Parser<TOptions = unknown, TMeta extends object = any> = {
   name: string;
   type: 'parser';
   /**
@@ -29,9 +29,9 @@ type Parser<TOptions = unknown, TMeta$1 extends object = any> = {
   /**
    * Convert a file to string
    */
-  parse(file: ResolvedFile<TMeta$1>, options: PrintOptions): Promise<string>;
+  parse(file: ResolvedFile<TMeta>, options: PrintOptions): Promise<string>;
 };
-type UserParser<TOptions = unknown, TMeta$1 extends object = any> = Omit<Parser<TOptions, TMeta$1>, 'type'>;
+type UserParser<TOptions = unknown, TMeta extends object = any> = Omit<Parser<TOptions, TMeta>, 'type'>;
 //#endregion
 //#region ../fabric-core/src/utils/AsyncEventEmitter.d.ts
 declare class AsyncEventEmitter<TEvents extends Record<string, any>> {
@@ -52,18 +52,18 @@ type ProcessFilesProps = {
   /**
    * @default 'sequential'
    */
-  mode?: AppMode;
+  mode?: FabricMode;
 };
 type GetParseOptions = {
   parsers?: Set<Parser>;
   extension?: Record<Extname, Extname | ''>;
 };
 type Options$1 = {
-  events?: AsyncEventEmitter<AppEvents>;
+  events?: AsyncEventEmitter<FabricEvents>;
 };
 declare class FileProcessor {
   #private;
-  events: AsyncEventEmitter<AppEvents>;
+  events: AsyncEventEmitter<FabricEvents>;
   constructor({
     events
   }?: Options$1);
@@ -81,11 +81,11 @@ declare class FileProcessor {
 //#endregion
 //#region ../fabric-core/src/FileManager.d.ts
 type Options = {
-  events?: AsyncEventEmitter<AppEvents>;
+  events?: AsyncEventEmitter<FabricEvents>;
 };
 declare class FileManager {
   #private;
-  events: AsyncEventEmitter<AppEvents>;
+  events: AsyncEventEmitter<FabricEvents>;
   processor: FileProcessor;
   constructor({
     events
@@ -99,19 +99,19 @@ declare class FileManager {
   write(options: ProcessFilesProps): Promise<ResolvedFile[]>;
 }
 //#endregion
-//#region ../fabric-core/src/App.d.ts
+//#region ../fabric-core/src/Fabric.d.ts
 declare global {
   namespace Kubb {
-    interface App {}
+    interface Fabric {}
   }
 }
-type AppOptions = {
+type FabricOptions = {
   /**
    * @default 'sequential'
    */
-  mode?: AppMode;
+  mode?: FabricMode;
 };
-type AppEvents = {
+type FabricEvents = {
   /**
    * Called in the beginning of the app lifecycle.
    */
@@ -124,7 +124,7 @@ type AppEvents = {
    * Called when being rendered
    */
   render: [{
-    app: App;
+    fabric: Fabric;
   }];
   /**
    * Called once before processing any files.
@@ -178,23 +178,23 @@ type AppEvents = {
     files: ResolvedFile[];
   }];
 };
-type AppContext<TOptions extends AppOptions> = {
+type FabricContext<TOptions extends FabricOptions> = {
   options?: TOptions;
-  events: AsyncEventEmitter<AppEvents>;
+  events: AsyncEventEmitter<FabricEvents>;
   fileManager: FileManager;
   installedPlugins: Set<Plugin>;
   installedParsers: Set<Parser>;
 };
-type AppMode = 'sequential' | 'parallel';
+type FabricMode = 'sequential' | 'parallel';
 type AllOptional<T> = {} extends T ? true : false;
-type Install<TOptions = unknown> = TOptions extends any[] ? (app: App, ...options: TOptions) => void | Promise<void> : AllOptional<TOptions> extends true ? (app: App, options: TOptions | undefined) => void | Promise<void> : (app: App, options: TOptions) => void | Promise<void>;
-type Inject<TOptions = unknown, TAppExtension$1 extends Record<string, any> = {}> = TOptions extends any[] ? (app: App, ...options: TOptions) => Partial<TAppExtension$1> : AllOptional<TOptions> extends true ? (app: App, options: TOptions | undefined) => Partial<TAppExtension$1> : (app: App, options: TOptions) => Partial<TAppExtension$1>;
-interface App<TOptions extends AppOptions = AppOptions> extends Kubb.App {
-  context: AppContext<TOptions>;
+type Install<TOptions = unknown> = TOptions extends any[] ? (app: Fabric, ...options: TOptions) => void | Promise<void> : AllOptional<TOptions> extends true ? (app: Fabric, options: TOptions | undefined) => void | Promise<void> : (app: Fabric, options: TOptions) => void | Promise<void>;
+type Inject<TOptions = unknown, TAppExtension extends Record<string, any> = {}> = TOptions extends any[] ? (app: Fabric, ...options: TOptions) => Partial<TAppExtension> : AllOptional<TOptions> extends true ? (app: Fabric, options: TOptions | undefined) => Partial<TAppExtension> : (app: Fabric, options: TOptions) => Partial<TAppExtension>;
+interface Fabric<TOptions extends FabricOptions = FabricOptions> extends Kubb.Fabric {
+  context: FabricContext<TOptions>;
   files: Array<ResolvedFile>;
   use<TPluginOptions = unknown, TMeta extends object = object, TAppExtension extends Record<string, any> = {}>(pluginOrParser: Plugin<TPluginOptions, TAppExtension> | Parser<TPluginOptions, TMeta>, ...options: TPluginOptions extends any[] ? NoInfer<TPluginOptions> : AllOptional<TPluginOptions> extends true ? [NoInfer<TPluginOptions>?] : [NoInfer<TPluginOptions>]): (this & TAppExtension) | Promise<this & TAppExtension>;
   addFile(...files: Array<File>): Promise<void>;
 }
 //#endregion
-export { UserParser as a, Parser as i, AppOptions as n, Plugin as o, FileManager as r, UserPlugin as s, App as t };
-//# sourceMappingURL=App-D7ehObix.d.ts.map
+export { Parser as a, UserPlugin as c, FileManager as i, FabricMode as n, UserParser as o, FabricOptions as r, Plugin as s, Fabric as t };
+//# sourceMappingURL=Fabric-nxgJyzWH.d.cts.map

package/dist/{App-CbT7rbmH.d.cts → Fabric-tVWTpMR5.d.ts}

@@ -1,7 +1,7 @@
-import { i as File, o as Path, r as Extname, s as ResolvedFile } from "./KubbFile-FGXV713i.cjs";
+import { i as File, o as Path, r as Extname, s as ResolvedFile } from "./KubbFile-DFnA3mmn.js";
 
 //#region ../fabric-core/src/plugins/types.d.ts
-type Plugin<TOptions = unknown, TAppExtension$1 extends Record<string, any> = {}> = {
+type Plugin<TOptions = unknown, TAppExtension extends Record<string, any> = {}> = {
   name: string;
   type: 'plugin';
   install: Install<TOptions>;
@@ -10,15 +10,15 @@ type Plugin<TOptions = unknown, TAppExtension$1 extends Record<string, any> = {}
    * Merged into the app instance after install.
    * This cannot be async
    */
-  inject?: Inject<TOptions, TAppExtension$1>;
+  inject?: Inject<TOptions, TAppExtension>;
 };
-type UserPlugin<TOptions = unknown, TAppExtension$1 extends Record<string, any> = {}> = Omit<Plugin<TOptions, TAppExtension$1>, 'type'>;
+type UserPlugin<TOptions = unknown, TAppExtension extends Record<string, any> = {}> = Omit<Plugin<TOptions, TAppExtension>, 'type'>;
 //#endregion
 //#region ../fabric-core/src/parsers/types.d.ts
 type PrintOptions = {
   extname?: Extname;
 };
-type Parser<TOptions = unknown, TMeta$1 extends object = any> = {
+type Parser<TOptions = unknown, TMeta extends object = any> = {
   name: string;
   type: 'parser';
   /**
@@ -29,9 +29,9 @@ type Parser<TOptions = unknown, TMeta$1 extends object = any> = {
   /**
    * Convert a file to string
    */
-  parse(file: ResolvedFile<TMeta$1>, options: PrintOptions): Promise<string>;
+  parse(file: ResolvedFile<TMeta>, options: PrintOptions): Promise<string>;
 };
-type UserParser<TOptions = unknown, TMeta$1 extends object = any> = Omit<Parser<TOptions, TMeta$1>, 'type'>;
+type UserParser<TOptions = unknown, TMeta extends object = any> = Omit<Parser<TOptions, TMeta>, 'type'>;
 //#endregion
 //#region ../fabric-core/src/utils/AsyncEventEmitter.d.ts
 declare class AsyncEventEmitter<TEvents extends Record<string, any>> {
@@ -52,18 +52,18 @@ type ProcessFilesProps = {
   /**
    * @default 'sequential'
    */
-  mode?: AppMode;
+  mode?: FabricMode;
 };
 type GetParseOptions = {
   parsers?: Set<Parser>;
   extension?: Record<Extname, Extname | ''>;
 };
 type Options$1 = {
-  events?: AsyncEventEmitter<AppEvents>;
+  events?: AsyncEventEmitter<FabricEvents>;
 };
 declare class FileProcessor {
   #private;
-  events: AsyncEventEmitter<AppEvents>;
+  events: AsyncEventEmitter<FabricEvents>;
   constructor({
     events
   }?: Options$1);
@@ -81,11 +81,11 @@ declare class FileProcessor {
 //#endregion
 //#region ../fabric-core/src/FileManager.d.ts
 type Options = {
-  events?: AsyncEventEmitter<AppEvents>;
+  events?: AsyncEventEmitter<FabricEvents>;
 };
 declare class FileManager {
   #private;
-  events: AsyncEventEmitter<AppEvents>;
+  events: AsyncEventEmitter<FabricEvents>;
   processor: FileProcessor;
   constructor({
     events
@@ -99,19 +99,19 @@ declare class FileManager {
   write(options: ProcessFilesProps): Promise<ResolvedFile[]>;
 }
 //#endregion
-//#region ../fabric-core/src/App.d.ts
+//#region ../fabric-core/src/Fabric.d.ts
 declare global {
   namespace Kubb {
-    interface App {}
+    interface Fabric {}
   }
 }
-type AppOptions = {
+type FabricOptions = {
   /**
    * @default 'sequential'
    */
-  mode?: AppMode;
+  mode?: FabricMode;
 };
-type AppEvents = {
+type FabricEvents = {
   /**
    * Called in the beginning of the app lifecycle.
    */
@@ -124,7 +124,7 @@ type AppEvents = {
    * Called when being rendered
    */
   render: [{
-    app: App;
+    fabric: Fabric;
   }];
   /**
    * Called once before processing any files.
@@ -178,23 +178,23 @@ type AppEvents = {
     files: ResolvedFile[];
   }];
 };
-type AppContext<TOptions extends AppOptions> = {
+type FabricContext<TOptions extends FabricOptions> = {
   options?: TOptions;
-  events: AsyncEventEmitter<AppEvents>;
+  events: AsyncEventEmitter<FabricEvents>;
   fileManager: FileManager;
   installedPlugins: Set<Plugin>;
   installedParsers: Set<Parser>;
 };
-type AppMode = 'sequential' | 'parallel';
+type FabricMode = 'sequential' | 'parallel';
 type AllOptional<T> = {} extends T ? true : false;
-type Install<TOptions = unknown> = TOptions extends any[] ? (app: App, ...options: TOptions) => void | Promise<void> : AllOptional<TOptions> extends true ? (app: App, options: TOptions | undefined) => void | Promise<void> : (app: App, options: TOptions) => void | Promise<void>;
-type Inject<TOptions = unknown, TAppExtension$1 extends Record<string, any> = {}> = TOptions extends any[] ? (app: App, ...options: TOptions) => Partial<TAppExtension$1> : AllOptional<TOptions> extends true ? (app: App, options: TOptions | undefined) => Partial<TAppExtension$1> : (app: App, options: TOptions) => Partial<TAppExtension$1>;
-interface App<TOptions extends AppOptions = AppOptions> extends Kubb.App {
-  context: AppContext<TOptions>;
+type Install<TOptions = unknown> = TOptions extends any[] ? (app: Fabric, ...options: TOptions) => void | Promise<void> : AllOptional<TOptions> extends true ? (app: Fabric, options: TOptions | undefined) => void | Promise<void> : (app: Fabric, options: TOptions) => void | Promise<void>;
+type Inject<TOptions = unknown, TAppExtension extends Record<string, any> = {}> = TOptions extends any[] ? (app: Fabric, ...options: TOptions) => Partial<TAppExtension> : AllOptional<TOptions> extends true ? (app: Fabric, options: TOptions | undefined) => Partial<TAppExtension> : (app: Fabric, options: TOptions) => Partial<TAppExtension>;
+interface Fabric<TOptions extends FabricOptions = FabricOptions> extends Kubb.Fabric {
+  context: FabricContext<TOptions>;
   files: Array<ResolvedFile>;
   use<TPluginOptions = unknown, TMeta extends object = object, TAppExtension extends Record<string, any> = {}>(pluginOrParser: Plugin<TPluginOptions, TAppExtension> | Parser<TPluginOptions, TMeta>, ...options: TPluginOptions extends any[] ? NoInfer<TPluginOptions> : AllOptional<TPluginOptions> extends true ? [NoInfer<TPluginOptions>?] : [NoInfer<TPluginOptions>]): (this & TAppExtension) | Promise<this & TAppExtension>;
   addFile(...files: Array<File>): Promise<void>;
 }
 //#endregion
-export { UserParser as a, Parser as i, AppOptions as n, Plugin as o, FileManager as r, UserPlugin as s, App as t };
-//# sourceMappingURL=App-CbT7rbmH.d.cts.map
+export { Parser as a, UserPlugin as c, FileManager as i, FabricMode as n, UserParser as o, FabricOptions as r, Plugin as s, Fabric as t };
+//# sourceMappingURL=Fabric-tVWTpMR5.d.ts.map

package/dist/{KubbFile-D4gyyfL-.d.ts → KubbFile-DFnA3mmn.d.ts}

@@ -112,4 +112,4 @@ type ResolvedFile<TMeta extends object = object> = File<TMeta> & {
 };
 //#endregion
 export { Import as a, Source as c, File as i, Export as n, Path as o, Extname as r, ResolvedFile as s, BaseName as t };
-//# sourceMappingURL=KubbFile-D4gyyfL-.d.ts.map
+//# sourceMappingURL=KubbFile-DFnA3mmn.d.ts.map

package/dist/{KubbFile-FGXV713i.d.cts → KubbFile-DHCtBOpy.d.cts}

@@ -112,4 +112,4 @@ type ResolvedFile<TMeta extends object = object> = File<TMeta> & {
 };
 //#endregion
 export { Import as a, Source as c, File as i, Export as n, Path as o, Extname as r, ResolvedFile as s, BaseName as t };
-//# sourceMappingURL=KubbFile-FGXV713i.d.cts.map
+//# sourceMappingURL=KubbFile-DHCtBOpy.d.cts.map

package/dist/chunk-CVmoYqME.js

@@ -0,0 +1,27 @@
+//#region rolldown:runtime
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJS = (cb, mod) => function() {
+	return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+
+//#endregion
+export { __toESM as n, __commonJS as t };