@kubb/react-fabric 0.13.3 → 0.15.0

package/dist/reactPlugin-OUKiWH1q.d.ts

@@ -1,463 +0,0 @@
-import { r as __name } from "./chunk-DbZtQ4qb.js";
-import { FabricReactElement, t as types_d_exports } from "./types.js";
-import { TreeNode } from "@kubb/fabric-core";
-
-//#region ../fabric-core/src/KubbFile.d.ts
-type ImportName = string | Array<string | {
-  propertyName: string;
-  name?: string;
-}>;
-type Import = {
-  /**
-   * Import name to be used
-   * @example ["useState"]
-   * @example "React"
-   */
-  name: ImportName;
-  /**
-   * Path for the import
-   * @example '@kubb/core'
-   */
-  path: string;
-  /**
-   * Add type-only import prefix.
-   * - `true` generates `import type { Type } from './path'`
-   * - `false` generates `import { Type } from './path'`
-   * @default false
-   */
-  isTypeOnly?: boolean;
-  /**
-   * Import entire module as namespace.
-   * - `true` generates `import * as Name from './path'`
-   * - `false` generates standard import
-   * @default false
-   */
-  isNameSpace?: boolean;
-  /**
-   * When root is set it will get the path with relative getRelativePath(root, path).
-   */
-  root?: string;
-};
-type Source = {
-  name?: string;
-  value?: string;
-  /**
-   * Make this source a type-only export.
-   * - `true` marks source as type export
-   * - `false` marks source as value export
-   * @default false
-   */
-  isTypeOnly?: boolean;
-  /**
-   * Include export keyword in source.
-   * - `true` generates exportable const or type
-   * - `false` generates internal declaration
-   * @default false
-   */
-  isExportable?: boolean;
-  /**
-   * Include in barrel file generation.
-   * - `true` adds to barrel exports
-   * - `false` excludes from barrel exports
-   * @default false
-   */
-  isIndexable?: boolean;
-};
-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-only export prefix.
-   * - `true` generates `export type { Type } from './path'`
-   * - `false` generates `export { Type } from './path'`
-   * @default false
-   */
-  isTypeOnly?: boolean;
-  /**
-   * Export as aliased namespace.
-   * - `true` generates `export * as aliasName from './path'`
-   * - `false` generates standard export
-   * @default false
-   */
-  asAlias?: boolean;
-};
-type Extname = '.ts' | '.js' | '.tsx' | '.json' | `.${string}`;
-/**
- * Name to be used to dynamically create the baseName(based on input.path)
- * Based on UNIX basename
- * @link https://nodejs.org/api/path.html#pathbasenamepath-suffix
- */
-type BaseName = `${string}.${string}`;
-/**
- * Path will be full qualified path to a specified file
- */
-type Path = string;
-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: 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;
-};
-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<Import>;
-  exports: Array<Export>;
-};
-//#endregion
-//#region ../fabric-core/src/parsers/types.d.ts
-type PrintOptions = {
-  extname?: Extname;
-};
-type Parser<TOptions = unknown, TMeta extends object = any> = {
-  name: string;
-  type: 'parser';
-  /**
-   * Undefined is being used for the defaultParser
-   */
-  extNames: Array<Extname> | undefined;
-  install: Install<TOptions>;
-  /**
-   * Convert a file to string
-   */
-  parse(file: ResolvedFile<TMeta>, options: PrintOptions): Promise<string> | string;
-};
-//#endregion
-//#region ../fabric-core/src/utils/AsyncEventEmitter.d.ts
-type Options$3 = {
-  mode?: FabricMode;
-  maxListener?: number;
-};
-declare class AsyncEventEmitter<TEvents extends Record<string, any>> {
-  #private;
-  constructor({
-    maxListener,
-    mode
-  }?: Options$3);
-  emit<TEventName extends keyof TEvents & string>(eventName: TEventName, ...eventArgs: TEvents[TEventName]): Promise<void>;
-  on<TEventName extends keyof TEvents & string>(eventName: TEventName, handler: (...eventArg: TEvents[TEventName]) => void): void;
-  onOnce<TEventName extends keyof TEvents & string>(eventName: TEventName, handler: (...eventArgs: TEvents[TEventName]) => void): void;
-  off<TEventName extends keyof TEvents & string>(eventName: TEventName, handler: (...eventArg: TEvents[TEventName]) => void): void;
-  removeAll(): void;
-}
-//#endregion
-//#region ../fabric-core/src/FileProcessor.d.ts
-type ProcessFilesProps = {
-  parsers?: Map<Extname, Parser>;
-  extension?: Record<Extname, Extname | ''>;
-  dryRun?: boolean;
-  /**
-   * @default 'sequential'
-   */
-  mode?: FabricMode;
-};
-type GetParseOptions = {
-  parsers?: Map<Extname, Parser>;
-  extension?: Record<Extname, Extname | ''>;
-};
-type Options$2 = {
-  events?: AsyncEventEmitter<FabricEvents>;
-};
-declare class FileProcessor {
-  #private;
-  events: AsyncEventEmitter<FabricEvents>;
-  constructor({
-    events
-  }?: Options$2);
-  parse(file: ResolvedFile, {
-    parsers,
-    extension
-  }?: GetParseOptions): Promise<string>;
-  run(files: Array<ResolvedFile>, {
-    parsers,
-    mode,
-    dryRun,
-    extension
-  }?: ProcessFilesProps): Promise<ResolvedFile[]>;
-}
-//#endregion
-//#region ../fabric-core/src/FileManager.d.ts
-type Options$1 = {
-  events?: AsyncEventEmitter<FabricEvents>;
-};
-declare class FileManager$1 {
-  #private;
-  events: AsyncEventEmitter<FabricEvents>;
-  processor: FileProcessor;
-  constructor({
-    events
-  }?: Options$1);
-  add(...files: Array<File>): Array<ResolvedFile>;
-  upsert(...files: Array<File>): Array<ResolvedFile>;
-  flush(): void;
-  getByPath(path: Path): ResolvedFile | null;
-  deleteByPath(path: Path): void;
-  clear(): void;
-  get files(): Array<ResolvedFile>;
-  write(options: ProcessFilesProps): Promise<ResolvedFile[]>;
-}
-//#endregion
-//#region ../fabric-core/src/Fabric.d.ts
-/**
- * Defines core runtime options for Fabric.
- */
-interface FabricOptions {
-  /**
-   * Determines how Fabric processes files.
-   * - `sequential`: files are processed one by one
-   * - `parallel`: files are processed concurrently
-   *
-   * @default 'sequential'
-   */
-  mode?: FabricMode;
-}
-/**
- * Available modes for file processing.
- * @default 'sequential'
- */
-type FabricMode = 'sequential' | 'parallel';
-/**
- * Event definitions emitted during the Fabric lifecycle.
- *
- * These events allow plugins and external code to hook into different stages
- * of the file generation process. All events are asynchronous and can be
- * listened to using `fabric.context.on()` or `fabric.context.onOnce()`.
- *
- * @example
- * ```ts
- * fabric.context.on('lifecycle:start', async () => {
- *   console.log('Fabric started!')
- * })
- * ```
- */
-interface FabricEvents {
-  /**
-   * Emitted when the Fabric application lifecycle begins.
-   * This is typically the first event fired when starting a Fabric run.
-   * Use this to perform initial setup or logging.
-   */
-  'lifecycle:start': [];
-  /**
-   * Emitted when the Fabric application lifecycle completes.
-   * This is typically the last event fired after all processing is done.
-   * Use this for cleanup tasks or final reporting.
-   */
-  'lifecycle:end': [];
-  /**
-   * Emitted when Fabric starts rendering (used with reactPlugin).
-   * Provides access to the Fabric instance for render-time operations.
-   */
-  'lifecycle:render': [fabric: Fabric];
-  /**
-   * Emitted once before file processing begins.
-   * Provides the complete list of files that will be processed.
-   * Use this to prepare for batch operations or display initial file counts.
-   */
-  'files:processing:start': [files: Array<ResolvedFile>];
-  /**
-   * Emitted when files are successfully added to the FileManager's internal cache.
-   * This happens after files pass through path and name resolution.
-   * Use this to track which files have been registered.
-   */
-  'files:added': [files: Array<ResolvedFile>];
-  /**
-   * Emitted during file path resolution, before a file is cached.
-   * Listeners can modify the file's path property to customize output location.
-   * This is called for each file being added via `addFile()` or `upsertFile()`.
-   */
-  'file:resolve:path': [file: File];
-  /**
-   * Emitted during file name resolution, before a file is cached.
-   * Listeners can modify the file's name-related properties to customize naming.
-   * This is called for each file being added via `addFile()` or `upsertFile()`.
-   */
-  'file:resolve:name': [file: File];
-  /**
-   * Emitted just before files are written to disk.
-   * Provides all files that will be written in this batch.
-   * Use this to perform pre-write operations like creating directories.
-   */
-  'files:writing:start': [files: Array<ResolvedFile>];
-  /**
-   * Emitted after all files have been successfully written to disk.
-   * Provides all files that were written in this batch.
-   * Use this for post-write operations like running formatters or reporting.
-   */
-  'files:writing:end': [files: Array<ResolvedFile>];
-  /**
-   * Emitted when an individual file starts being processed.
-   * This happens for each file in the queue, before parsing.
-   * Use this for per-file setup or detailed logging.
-   */
-  'file:processing:start': [file: ResolvedFile, index: number, total: number];
-  /**
-   * Emitted when an individual file completes processing.
-   * This happens after the file has been parsed and handled.
-   * Use this for per-file cleanup or progress tracking.
-   */
-  'file:processing:end': [file: ResolvedFile, index: number, total: number];
-  /**
-   * Emitted after each file is processed, providing progress metrics.
-   * This is the primary event for implementing progress bars or tracking.
-   * Plugins like fsPlugin use this to write files to disk.
-   *
-   * @property processed - Number of files processed so far
-   * @property total - Total number of files to process
-   * @property percentage - Completion percentage (0-100)
-   * @property source - Optional parsed source code of the file
-   * @property file - The file that was just processed
-   */
-  'file:processing:update': [{
-    processed: number;
-    total: number;
-    percentage: number;
-    source?: string;
-    file: ResolvedFile;
-  }];
-  /**
-   * Emitted once all files have been successfully processed.
-   * This marks the completion of the processing phase.
-   * Use this to perform batch operations on all processed files.
-   */
-  'files:processing:end': [files: Array<ResolvedFile>];
-}
-/**
- * Shared context passed to all plugins, parsers, and Fabric internals.
- */
-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$1;
-  /** List of files currently in memory. */
-  files: ResolvedFile[];
-  /** Add new files to the file manager. */
-  addFile(...files: File[]): Promise<void>;
-  /** Track installed plugins and parsers to prevent duplicates. */
-  installedPlugins: Set<Plugin>;
-  installedParsers: Map<Extname, Parser>;
-}
-/**
- * Base configuration object for Fabric.
- */
-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;
-/**
- * Defines the signature of a plugin or parser's `install` function.
- */
-type Install<TOptions = unknown> = TOptions extends any[] ? (context: FabricContext, ...options: TOptions) => void | Promise<void> : AllOptional<TOptions> extends true ? (context: FabricContext, options?: TOptions) => void | Promise<void> : (context: FabricContext, options: TOptions) => void | Promise<void>;
-/**
- * Defines the signature of a plugin or parser's `inject` function.
- * Returns an object that extends the Fabric instance.
- */
-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) => 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.
- */
-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: 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>?] : [NoInfer<TPluginOptions>]): (this & TExtension) | Promise<this & TExtension>;
-  /**
-   * Add one or more files to the Fabric file manager.
-   */
-  addFile(...files: File[]): Promise<void>;
-  /**
-   * Add one or more files to the Fabric file manager and merge the source, imports, exports
-   */
-  upsertFile(...files: File[]): Promise<void>;
-  /**
-   * Unmount the Fabric instance and remove all registered event listeners.
-   * Plugins may extend this to perform additional cleanup (e.g. process signal listeners).
-   */
-  unmount(error?: Error | number | null): void;
-}
-//#endregion
-//#region ../fabric-core/src/plugins/types.d.ts
-type Plugin<TOptions = unknown, TAppExtension extends Record<string, any> = {}> = {
-  name: string;
-  type: 'plugin';
-  install: Install<TOptions>;
-  /**
-   * Runtime app overrides or extensions.
-   * Merged into the app instance after install.
-   * This cannot be async
-   */
-  inject?: Inject<TOptions, TAppExtension>;
-};
-//#endregion
-//#region src/plugins/reactPlugin.d.ts
-type Options = {
-  stdout?: NodeJS.WriteStream;
-  stdin?: NodeJS.ReadStream;
-  stderr?: NodeJS.WriteStream;
-  treeNode?: TreeNode<types_d_exports.ComponentNode>;
-  /**
-   * Set this to true to always see the result of the render in the console(line per render)
-   */
-  debug?: boolean;
-};
-type ExtendOptions = {
-  render(App: FabricReactElement): Promise<void>;
-  renderToString(App: FabricReactElement): Promise<string>;
-  waitUntilExit(): Promise<void>;
-  unmount(error?: Error | number | null): void;
-};
-declare global {
-  namespace Kubb {
-    interface Fabric {
-      render(App: FabricReactElement): Promise<void>;
-      renderToString(App: FabricReactElement): Promise<string>;
-      waitUntilExit(): Promise<void>;
-    }
-  }
-}
-declare const reactPlugin: Plugin<Options, ExtendOptions>;
-//#endregion
-export { reactPlugin as n, Options as t };
-//# sourceMappingURL=reactPlugin-OUKiWH1q.d.ts.map

package/src/composables/useApp.ts

@@ -1 +0,0 @@
-export { useApp } from '@kubb/fabric-core'

package/src/utils/getFunctionParams.ts

@@ -1,242 +0,0 @@
-import { sortBy } from 'remeda'
-
-export type Param = {
-  /**
-   * `object` will return the pathParams as an object.
-   *
-   * `inline` will return the pathParams as comma separated params.
-   * @default `'inline'`
-   * @private
-   */
-  mode?: 'object' | 'inline' | 'inlineSpread'
-  type?: 'string' | 'number' | (string & {})
-  optional?: boolean
-  /**
-   * @example test = "default"
-   */
-  default?: string
-  /**
-   * Used for no TypeScript(with mode object)
-   * @example test: "default"
-   */
-  value?: string
-  children?: Params
-}
-
-type ParamItem =
-  | (Pick<Param, 'mode' | 'type' | 'value'> & {
-      optional?: true
-      default?: never
-      children?: Params
-    })
-  | (Pick<Param, 'mode' | 'type' | 'value'> & {
-      optional?: false
-      default?: string
-      children?: Params
-    })
-
-export type Params = Record<string, Param | undefined>
-
-type Options = {
-  type: 'constructor' | 'call' | 'object' | 'objectValue'
-  transformName?: (name: string) => string
-  transformType?: (type: string) => string
-}
-
-function order(items: Array<[key: string, item?: ParamItem]>) {
-  return sortBy(items.filter(Boolean) as Array<[key: string, item?: ParamItem]>, ([_key, item]) => {
-    if (item?.children) {
-      return 0 // Treat items with children as required (they'll get = {} if all children are optional)
-    }
-    // Priority order: required (0) → optional (1) → default-only (2)
-    if (item?.optional) {
-      return 1 // Optional parameters (with or without default)
-    }
-    if (item?.default) {
-      // Parameters with default only (not marked as optional)
-      // Note: While the ParamItem type suggests optional and default are mutually exclusive,
-      // this handles the case where a parameter has a default value but isn't explicitly marked as optional
-      return 2
-    }
-    return 0 // Required parameters
-  })
-}
-
-function parseChild(key: string, item: ParamItem, options: Options): string | null {
-  // @ts-expect-error
-  const entries = order(Object.entries(item.children))
-
-  const types: string[] = []
-  const names: string[] = []
-
-  const optional = entries.every(([_key, item]) => item?.optional || !!item?.default)
-
-  entries.forEach(([key, entryItem]) => {
-    if (entryItem) {
-      const name = parseItem(key, { ...entryItem, type: undefined }, options)
-      if (entryItem.children) {
-        const subTypes = Object.entries(entryItem.children)
-          .map(([key]) => {
-            return key
-          })
-          .join(', ')
-
-        if (subTypes) {
-          names.push(`${name}: { ${subTypes} }`)
-        } else {
-          names.push(name)
-        }
-      } else {
-        if (options.type === 'call' && options.transformName) {
-          names.push(`${key}: ${name}`)
-        } else {
-          names.push(name)
-        }
-      }
-
-      if (entries.some(([_key, item]) => item?.type)) {
-        types.push(parseItem(key, { ...entryItem, default: undefined }, options))
-      }
-    }
-  })
-
-  const name = item.mode === 'inline' ? key : names.length ? `{ ${names.join(', ')} }` : undefined
-  const type = item.type ? item.type : types.length ? `{ ${types.join('; ')} }` : undefined
-
-  if (!name) {
-    return null
-  }
-
-  return parseItem(
-    name,
-    {
-      type,
-      default: item.default,
-      optional: !item.default ? optional : undefined,
-    } as ParamItem,
-    options,
-  )
-}
-
-function parseItem(name: string, item: ParamItem, options: Options): string {
-  const acc: string[] = []
-  const transformedName = options.transformName ? options.transformName(name) : name
-  const transformedType = options.transformType && item.type ? options.transformType(item.type) : item.type
-
-  if (options.type === 'object') {
-    return transformedName
-  }
-
-  if (options.type === 'objectValue') {
-    return item.value ? `${transformedName}: ${item.value}` : transformedName
-  }
-
-  //LEGACY
-  if (item.type && options.type === 'constructor') {
-    if (item.optional) {
-      // Check if this is a destructured parameter (object mode)
-      const isDestructured = transformedName.startsWith('{')
-      if (isDestructured) {
-        // For destructured parameters, use ": type = {}" syntax to make it optional
-        acc.push(`${transformedName}: ${transformedType} = {}`)
-      } else {
-        // For inline parameters, use "?: type" syntax
-        acc.push(`${transformedName}?: ${transformedType}`)
-      }
-    } else {
-      acc.push(`${transformedName}: ${transformedType}${item.default ? ` = ${item.default}` : ''}`)
-    }
-  } else if (item.default && options.type === 'constructor') {
-    acc.push(`${transformedName} = ${item.default}`)
-  } else if (item.value) {
-    acc.push(`${transformedName} : ${item.value}`)
-  } else if (item.mode === 'inlineSpread') {
-    acc.push(`... ${transformedName}`)
-  } else {
-    acc.push(transformedName)
-  }
-
-  return acc[0] as string
-}
-
-export function getFunctionParams(params: Params, options: Options): string {
-  const entries = order(Object.entries(params as Record<string, ParamItem | undefined>))
-
-  return entries
-    .reduce((acc, [key, item]) => {
-      if (!item) {
-        return acc
-      }
-
-      if (item.children) {
-        if (Object.keys(item.children).length === 0) {
-          return acc
-        }
-
-        if (item.mode === 'inlineSpread') {
-          return [...acc, getFunctionParams(item.children, options)]
-        }
-
-        const parsedItem = parseChild(key, item, options)
-        if (!parsedItem) {
-          return acc
-        }
-
-        return [...acc, parsedItem]
-      }
-
-      const parsedItem = parseItem(key, item, options)
-
-      return [...acc, parsedItem]
-    }, [] as string[])
-    .join(', ')
-}
-
-export function createFunctionParams(params: Params): Params {
-  return params
-}
-// TODO  use of zod
-//TODO use of string as `$name: $type` to create templates for functions instead of call/constructor
-export class FunctionParams {
-  #params: Params
-
-  static factory(params: Params) {
-    return new FunctionParams(params)
-  }
-  constructor(params: Params) {
-    this.#params = params
-  }
-
-  get params(): Params {
-    return this.#params
-  }
-
-  get flatParams(): Params {
-    const flatter = (acc: Params, [key, item]: [key: string, item?: Param]): Params => {
-      if (item?.children) {
-        return Object.entries(item.children).reduce(flatter, acc)
-      }
-      if (item) {
-        acc[key] = item
-      }
-
-      return acc
-    }
-    return Object.entries(this.#params).reduce(flatter, {} as Params)
-  }
-
-  toCall({ transformName, transformType }: Pick<Options, 'transformName' | 'transformType'> = {}): string {
-    return getFunctionParams(this.#params, { type: 'call', transformName, transformType })
-  }
-
-  toObject(): string {
-    return getFunctionParams(this.#params, { type: 'object' })
-  }
-  toObjectValue(): string {
-    return getFunctionParams(this.#params, { type: 'objectValue' })
-  }
-
-  toConstructor(): string {
-    return getFunctionParams(this.#params, { type: 'constructor' })
-  }
-}