@kubb/fabric-core 0.9.5 → 0.10.0

package/dist/index.d.ts

@@ -1,7 +1,403 @@
-import { a as FabricOptions, c as FileManager, h as ResolvedFile, l as FileProcessor, n as FabricConfig, p as File, t as Fabric } from "./Fabric-CDFwTDyP.js";
+import { a as FabricOptions, b as Source, c as FileManager, f as BaseName, g as Import, h as File$1, l as FileProcessor, n as FabricConfig, p as Export, t as Fabric, v as Path, y as ResolvedFile } from "./Fabric-BwLKB57c.js";
+import { t as JSDoc$1 } from "./types-B1GXvvBG.js";
 
+//#region src/context.d.ts
+/**
+ * Context type that carries type information about its value
+ * This is a branded symbol type that enables type-safe context usage
+ */
+type Context<T> = symbol & {
+  readonly __type: T;
+};
+/**
+ * Provides a value to descendant components (Vue 3 style)
+ *
+ * @example
+ * ```ts
+ * const ThemeKey = Symbol('theme')
+ * provide(ThemeKey, { color: 'blue' })
+ * ```
+ */
+declare function provide<T>(key: symbol | Context<T>, value: T): void;
+/**
+ * Injects a value provided by an ancestor component (Vue 3 style)
+ *
+ * @example
+ * ```ts
+ * const theme = inject(ThemeKey, { color: 'default' })
+ * ```
+ */
+declare function inject<T>(key: symbol | Context<T>, defaultValue?: T): T;
+/**
+ * Unprovides a value (for cleanup)
+ * @internal
+ */
+declare function unprovide<T>(key: symbol | Context<T>): void;
+/**
+ * Creates a context key with a default value (React-style compatibility)
+ *
+ * @example
+ * ```ts
+ * const ThemeContext = createContext({ color: 'blue' })
+ * // ThemeContext is now typed as Context<{ color: string }>
+ * const theme = useContext(ThemeContext) // theme is { color: string }
+ * ```
+ */
+declare function createContext<T>(defaultValue: T): Context<T>;
+//#endregion
+//#region src/components/App.d.ts
+type AppContextProps$1<TMeta = unknown> = {
+  /**
+   * Exit (unmount)
+   */
+  readonly exit: (error?: Error) => void;
+  readonly meta: TMeta;
+};
+type Props$3<TMeta = unknown> = {
+  readonly meta: TMeta;
+  readonly children?: string;
+};
+/**
+ * Minimal fsx app container — provides an AppContext carrying `meta` and an
+ * `exit` hook. In fsx mode this just returns children content.
+ */
+declare function App<TMeta = unknown>({
+  children,
+  meta
+}: Props$3<TMeta>): string;
+declare namespace App {
+  var Context: Context<AppContextProps$1<unknown> | undefined>;
+  var displayName: string;
+}
+//#endregion
+//#region src/components/Const.d.ts
+type JSDoc = {
+  comments: Array<string>;
+};
+type Props$2 = {
+  /**
+   * Name of the const
+   */
+  name: string;
+  /**
+   * Does this type need to be exported.
+   */
+  export?: boolean;
+  /**
+   * Type to make the const being typed
+   */
+  type?: string;
+  /**
+   * Options for JSdocs.
+   */
+  JSDoc?: JSDoc;
+  /**
+   * Use of `const` assertions
+   */
+  asConst?: boolean;
+  children?: string;
+};
+declare function Const({
+  name,
+  export: canExport,
+  type,
+  JSDoc,
+  asConst,
+  children
+}: Props$2): string;
+declare namespace Const {
+  var displayName: string;
+}
+//#endregion
+//#region src/components/File.d.ts
+type FileProps<TMeta extends object = object> = {
+  /**
+   * 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
+   */
+  baseName: BaseName;
+  /**
+   * Path will be full qualified path to a specified file.
+   */
+  path: Path;
+  meta?: TMeta;
+  banner?: string;
+  footer?: string;
+  children?: string;
+};
+/**
+ * File component for fsx - registers files via context
+ *
+ * When executed this will create or reuse a FileCollector from context and
+ * register the file (baseName/path) so it can be emitted later. Returns the
+ * children string content for fsx renderers.
+ */
+declare function File<TMeta extends object = object>({
+  children,
+  ...rest
+}: FileProps<TMeta>): string;
+declare namespace File {
+  var Source: typeof FileSource;
+  var Import: typeof FileImport;
+  var Export: typeof FileExport;
+}
+/**
+ * FileSource - for adding source code to a file
+ *
+ * Returns the provided children string so the fsx renderer can collect it.
+ */
+declare function FileSource(props: Omit<Source, 'value'> & {
+  children?: string;
+}): string;
+/**
+ * FileExport - for adding exports to a file
+ *
+ * No-op function used by renderers to record exports.
+ */
+declare function FileExport(_props: Export): string;
+/**
+ * FileImport - for adding imports to a file
+ *
+ * No-op function used by renderers to record imports.
+ */
+declare function FileImport(_props: Import): string;
+//#endregion
+//#region src/components/Function.d.ts
+type Props$1 = {
+  /**
+   * Name of the function.
+   */
+  name: string;
+  /**
+   * Add default when export is being used
+   */
+  default?: boolean;
+  /**
+   * Parameters/options/props that need to be used.
+   */
+  params?: string;
+  /**
+   * Does this function need to be exported.
+   */
+  export?: boolean;
+  /**
+   * Does the function has async/promise behaviour.
+   * This will also add `Promise<returnType>` as the returnType.
+   */
+  async?: boolean;
+  /**
+   * Generics that needs to be added for TypeScript.
+   */
+  generics?: string | string[];
+  /**
+   * ReturnType(see async for adding Promise type).
+   */
+  returnType?: string;
+  /**
+   * Options for JSdocs.
+   */
+  JSDoc?: JSDoc$1;
+  children?: string;
+};
+/**
+ * Builds a function declaration string for the fsx renderer. Supports optional
+ * export/default/async flags, generics, params and JSDoc rendering.
+ */
+declare function Function({
+  name,
+  default: isDefault,
+  export: canExport,
+  async,
+  generics,
+  params,
+  returnType,
+  JSDoc: JSDoc$1,
+  children
+}: Props$1): string;
+declare namespace Function {
+  var displayName: string;
+  var Arrow: typeof ArrowFunction;
+}
+type ArrowFunctionProps = Props$1 & {
+  /**
+   * Create Arrow function in one line
+   */
+  singleLine?: boolean;
+};
+/**
+ * ArrowFunction
+ *
+ * Builds an arrow function declaration string for the fsx renderer. Supports
+ * the same options as `Function`. Use `singleLine` to produce a one-line
+ * arrow expression.
+ */
+declare function ArrowFunction({
+  name,
+  default: isDefault,
+  export: canExport,
+  async,
+  generics,
+  params,
+  returnType,
+  JSDoc: JSDoc$1,
+  singleLine,
+  children
+}: ArrowFunctionProps): string;
+declare namespace ArrowFunction {
+  var displayName: string;
+}
+//#endregion
+//#region src/components/Root.d.ts
+type RootProps = {
+  /**
+   * Exit (unmount) hook
+   */
+  readonly onExit: (error?: Error) => void;
+  /**
+   * Error hook
+   */
+  readonly onError: (error: Error) => void;
+  readonly children?: string;
+};
+/**
+ * Top-level root for fsx renderers. Returns children content and ensures
+ * `onError` is called for runtime exceptions. Provides a RootContext with
+ * an `exit` hook for downstream consumers.
+ */
+declare function Root({
+  onError,
+  children
+}: Omit<RootProps, 'onExit'>): string;
+declare namespace Root {
+  var displayName: string;
+}
+//#endregion
+//#region src/components/Type.d.ts
+type Props = {
+  /**
+   * Name of the type, this needs to start with a capital letter.
+   */
+  name: string;
+  /**
+   * Does this type need to be exported.
+   */
+  export?: boolean;
+  /**
+   * Options for JSdocs.
+   */
+  JSDoc?: JSDoc$1;
+  children?: string;
+};
+/**
+ * Renders a TypeScript type alias string for use with the fsx renderer.
+ * Optionally emits JSDoc comments when `JSDoc.comments` is provided.
+ */
+declare function Type({
+  name,
+  export: canExport,
+  JSDoc: JSDoc$1,
+  children
+}: Props): string;
+declare namespace Type {
+  var displayName: string;
+}
+//#endregion
+//#region src/contexts/AppContext.d.ts
+type AppContextProps<TMeta = unknown> = {
+  /**
+   * Exit (unmount)
+   */
+  readonly exit: (error?: Error) => void;
+  readonly meta: TMeta;
+};
+/**
+ * Provides app-level metadata and lifecycle hooks (like `exit`) to
+ * components and composables within a Fabric runtime.
+ */
+declare const AppContext: Context<AppContextProps<unknown> | undefined>;
+//#endregion
+//#region src/composables/useApp.d.ts
+/**
+ * `useApp` will return the current App with meta and exit function.
+ *
+ * Throws an error when there is no AppContext available.
+ */
+declare function useApp<TMeta = unknown>(): AppContextProps<TMeta>;
+//#endregion
+//#region src/composables/useContext.d.ts
+/**
+ * React-style alias for inject
+ *
+ * @example
+ * ```ts
+ * const theme = useContext(ThemeContext) // type is inferred from ThemeContext
+ * ```
+ */
+declare function useContext<T>(key: Context<T>): T;
+declare function useContext<T, TValue = T>(key: Context<T>, defaultValue: TValue): NonNullable<T> | TValue;
+//#endregion
+//#region src/utils/FileCollector.d.ts
+/**
+ * FileCollector is used to collect files from components via context
+ * instead of walking the DOM tree.
+ */
+declare class FileCollector {
+  #private;
+  /**
+   * Add a file to the collector
+   */
+  add(file: File$1): void;
+  /**
+   * Get all collected files
+   */
+  get files(): Array<File$1>;
+  /**
+   * Clear all collected files
+   */
+  clear(): void;
+}
+//#endregion
+//#region src/composables/useFile.d.ts
+/**
+ * `useFile` will return the current FileCollector for registering files.
+ *
+ * Throws when no FileCollector is present in context — ensure a Fabric that
+ * provides a FileCollector is mounted before calling this hook.
+ */
+declare function useFile(): FileCollector;
+//#endregion
+//#region src/composables/useLifecycle.d.ts
+/**
+ * `useLifecycle` will return some helpers to exit/restart the generation.
+ *
+ * This hook reads the RootContext and exposes lifecycle helpers (like `exit`)
+ * for consumers to programmatically stop generation or perform teardown.
+ */
+declare function useLifecycle(): {
+  exit: ((error?: Error) => void) | (() => void);
+};
+//#endregion
+//#region src/contexts/FileCollectorContext.d.ts
+/**
+ * Context for collecting files - provided by createFsxFabric
+ */
+declare const FileCollectorContext: Context<FileCollector | null>;
+//#endregion
+//#region src/contexts/RootContext.d.ts
+type RootContextProps = {
+  /**
+   * Exit (unmount) the whole app.
+   */
+  readonly exit: (error?: Error) => void;
+};
+/**
+ * Provides a top-level lifecycle hook (`exit`) for terminating the Fabric
+ * runtime. This context is available at the root of a Fabric app.
+ */
+declare const RootContext: Context<RootContextProps>;
+//#endregion
 //#region src/createFabric.d.ts
-
 /**
  * Creates a new Fabric instance
  *
@@ -15,7 +411,17 @@ declare function createFabric<T extends FabricOptions>(config?: FabricConfig<T>)
 /**
  * Helper to create a file with name and id set
  */
-declare function createFile<TMeta extends object = object>(file: File<TMeta>): ResolvedFile<TMeta>;
+declare function createFile<TMeta extends object = object>(file: File$1<TMeta>): ResolvedFile<TMeta>;
+//#endregion
+//#region src/utils/createJSDoc.d.ts
+/**
+ * Create JSDoc comment block from comments array
+ */
+declare function createJSDoc({
+  comments
+}: {
+  comments: string[];
+}): string;
 //#endregion
-export { type Fabric, FileManager, FileProcessor, createFabric, createFile };
+export { App, AppContext, Const, type Context, type Fabric, File, FileCollector, FileCollectorContext, FileManager, FileProcessor, Function, Root, RootContext, Type, createContext, createFabric, createFile, createJSDoc, inject, provide, unprovide, useApp, useContext, useFile, useLifecycle };
 //# sourceMappingURL=index.d.ts.map