@aussieljk/forkbook 0.0.0-stage → 0.0.1-2

package/dist/chunk-C6PAgHLT.d.ts

@@ -0,0 +1,12 @@
+//#region ../../node_modules/telejson/dist/index.d.ts
+interface Options {
+  allowRegExp: boolean;
+  allowSymbol: boolean;
+  allowDate: boolean;
+  allowUndefined: boolean;
+  allowError: boolean;
+  maxDepth: number;
+  space: number | undefined;
+}
+//#endregion
+export { Options as t };

package/dist/chunk-CMeX4WRe.d.ts

@@ -0,0 +1,179 @@
+import { t as Simplify } from "./chunk-FjDVzZTj.js";
+import { AddonTypes, InferTypes, Meta, MetaInput, MetaTypes, Preview, PreviewAddonEntry, Story, StoryArgs, TypedMetaArgKeys } from "@aussieljk/forkbook/internal/csf";
+import { ComponentType, JSX } from "react";
+import { Args as Args$1, ArgsStoryFn, Canvas, DecoratorFunction as DecoratorFunction$1, ProjectAnnotations as ProjectAnnotations$1, StoryAnnotations, WebRenderer } from "@aussieljk/forkbook/internal/types";
+import { RootOptions } from "react-dom/client";
+
+//#region .dts-emit/code/core/src/react/types.d.ts
+interface ReactRenderer extends WebRenderer {
+  component: ComponentType<this['T']>;
+  storyResult: StoryFnReactReturnType;
+  mount: (ui?: JSX.Element) => Promise<Canvas>;
+}
+interface ReactParameters {
+  /** React renderer configuration */
+  react?: {
+    /**
+     * Whether to enable React Server Components
+     *
+     * @see https://storybook.js.org/docs/get-started/frameworks/nextjs#react-server-components-rsc
+     */
+    rsc?: boolean; /** Options passed to React root creation */
+    rootOptions?: RootOptions;
+  };
+}
+interface ReactTypes extends ReactRenderer {
+  parameters: ReactParameters;
+}
+type StoryFnReactReturnType = JSX.Element;
+//#endregion
+//#region .dts-emit/code/core/src/react/preview.d.ts
+/**
+ * Creates a React-specific preview configuration with CSF factories support.
+ *
+ * This function wraps the base `definePreview` and adds React-specific annotations for rendering
+ * and documentation. It returns a `ReactPreview` that provides type-safe `meta()` and `story()`
+ * factory methods.
+ *
+ * @example
+ *
+ * ```ts
+ * // .forkbook/preview.ts
+ * import { definePreview } from '@aussieljk/forkbook/react';
+ *
+ * export const preview = definePreview({
+ *   addons: [],
+ *   parameters: { layout: 'centered' },
+ * });
+ * ```
+ */
+declare function __definePreview<Addons extends PreviewAddonEntry[]>(input: {
+  addons: Addons;
+} & ProjectAnnotations$1<ReactTypes & InferTypes<Addons>>): ReactPreview<ReactTypes & InferTypes<Addons>>;
+/**
+ * React-specific Preview interface that provides type-safe CSF factory methods.
+ *
+ * Use `preview.meta()` to create a meta configuration for a component, and then `meta.story()` to
+ * create individual stories. The type system will infer args from the component props, decorators,
+ * and any addon types.
+ *
+ * @example
+ *
+ * ```ts
+ * const meta = preview.meta({ component: Button });
+ * export const Primary = meta.story({ args: { label: 'Click me' } });
+ * ```
+ */
+interface ReactPreview<T extends AddonTypes> extends Omit<Preview<ReactTypes & T>, 'meta' | 'type'> {
+  /**
+   * Narrows the type of the preview to include additional type information. This is useful when you
+   * need to add args that aren't inferred from the component.
+   *
+   * @example
+   *
+   * ```ts
+   * const meta = preview.type<{ args: { theme: 'light' | 'dark' } }>().meta({
+   *   component: Button,
+   * });
+   * ```
+   */
+  type<R>(): ReactPreview<T & R>;
+  meta<TArgs extends Args$1, Decorators extends DecoratorFunction$1<ReactTypes & T, any>, TMetaArgKeys extends PropertyKey = never>(meta: {
+    render?: ArgsStoryFn<ReactTypes & T, TArgs & T['args']>;
+    component?: ComponentType<TArgs>;
+  } & MetaInput<ReactTypes & T, TArgs, Decorators, TMetaArgKeys>): ReactMeta<MetaTypes<ReactTypes & T, TArgs, Decorators, TMetaArgKeys>, TMetaArgKeys>;
+}
+/**
+ * React-specific Meta interface returned by `preview.meta()`.
+ *
+ * Provides the `story()` method to create individual stories with proper type inference. Args
+ * provided in meta become optional in stories, while missing required args must be provided at the
+ * story level.
+ */
+interface ReactMeta<T extends ReactTypes, TMetaArgKeys extends PropertyKey = never> extends Meta<T, TMetaArgKeys> {
+  /**
+   * Creates a story with a custom render function that takes no args.
+   *
+   * This overload allows you to define a story using just a render function or an object with a
+   * render function that doesn't depend on args. Since the render function doesn't use args, no
+   * args need to be provided regardless of what's required by the component.
+   *
+   * @example
+   *
+   * ```ts
+   * // Using just a render function
+   * export const CustomRender = meta.story(() => <div>Custom content</div>);
+   *
+   * // Using an object with render
+   * export const WithRender = meta.story({
+   *   render: () => <MyComponent prop="static" />,
+   * });
+   * ```
+   */
+  story<TInput extends (() => ReactTypes['storyResult']) | (StoryAnnotations<T, T['args']> & {
+    render: () => ReactTypes['storyResult'];
+  })>(story: TInput): ReactStory<T, TInput extends (() => ReactTypes['storyResult']) ? {
+    render: TInput;
+  } : TInput>;
+  /**
+   * Creates a story with custom configuration including args, decorators, or other annotations.
+   *
+   * This is the primary overload for defining stories. Args that were already provided in meta
+   * become optional, while any remaining required args must be specified here.
+   *
+   * @example
+   *
+   * ```ts
+   * // Provide required args not in meta
+   * export const Primary = meta.story({
+   *   args: { label: 'Click me', disabled: false },
+   * });
+   *
+   * // Override meta args and add story-specific configuration
+   * export const Disabled = meta.story({
+   *   args: { disabled: true },
+   *   decorators: [withCustomWrapper],
+   * });
+   * ```
+   */
+  story<TInput extends Simplify<StoryAnnotations<T, T['args'], StoryArgs<T['args'], TMetaArgKeys>>>>(story: TInput): ReactStory<T, TInput>;
+  /**
+   * Creates a story with no additional configuration.
+   *
+   * This overload is only available when all required args have been provided in meta. The
+   * conditional type `Partial<T['args']> extends StoryArgs<...>` checks if the remaining required
+   * args (after accounting for args provided in meta) are all optional. If so, the function accepts
+   * zero arguments `[]`. Otherwise, it requires `[never]` which makes this overload unmatchable,
+   * forcing the user to provide args.
+   *
+   * @example
+   *
+   * ```ts
+   * // When meta provides all required args, story() can be called with no arguments
+   * const meta = preview.meta({ component: Button, args: { label: 'Hi', disabled: false } });
+   * export const Default = meta.story(); // Valid - all args provided in meta
+   * ```
+   */
+  story(..._args: Partial<T['args']> extends StoryArgs<T['args'], TMetaArgKeys> ? [] : [never]): ReactStory<T, {}>;
+  /**
+   * Add types to the stories created from the returned meta, such as an arg that only one story
+   * has: `meta.type<{ args: { icon: string } }>().story({ args: { icon: 'star' } })`.
+   */
+  type<S>(): ReactMeta<T & S, TypedMetaArgKeys<TMetaArgKeys, S>>;
+}
+/**
+ * React-specific Story interface returned by `meta.story()`.
+ *
+ * Represents a single story with its configuration and provides access to the composed story for
+ * testing via `story.run()`.
+ *
+ * Also includes a `Component` property for portable story compatibility.
+ */
+interface ReactStory<T extends ReactTypes, TInput extends {
+  play?: (...args: never[]) => void;
+  render?: (...args: never[]) => T['storyResult'];
+}> extends Story<T, TInput> {
+  Component: ComponentType<Partial<T['args']>>;
+}
+//#endregion
+export { ReactRenderer as a, __definePreview as i, ReactPreview as n, ReactTypes as o, ReactStory as r, ReactMeta as t };

package/dist/chunk-Ct9xd6IM.d.ts

@@ -0,0 +1,65 @@
+import React, { Context, FC, PropsWithChildren, ReactElement } from "react";
+import { Channel } from "@aussieljk/forkbook/internal/channels";
+import { DocsContextProps as DocsContextProps$1, Renderer } from "@aussieljk/forkbook/internal/types";
+import { ThemeVars } from "@aussieljk/forkbook/theming";
+
+//#region .dts-emit/code/core/src/addon-docs/blocks/components/TableOfContents.d.ts
+interface TocbotOptions {
+  tocSelector: string;
+  contentSelector: string;
+  headingSelector: string;
+  ignoreSelector?: string;
+  headingsOffset?: number;
+  scrollSmoothOffset?: number;
+  orderedList?: boolean;
+  onClick?: (e: MouseEvent) => void;
+  scrollEndCallback?: () => void;
+  [key: string]: unknown;
+}
+interface TocParameters {
+  /** CSS selector for the container to search for headings. */
+  contentsSelector?: string;
+  /**
+   * When true, hide the TOC. We still show the empty container (as opposed to showing nothing at
+   * all) because it affects the page layout and we want to preserve the layout across pages.
+   */
+  disable?: boolean;
+  /** CSS selector to match headings to list in the TOC. */
+  headingSelector?: string;
+  /** Headings that match the ignoreSelector will be skipped. */
+  ignoreSelector?: string;
+  /** Custom title ReactElement or string to display above the TOC. */
+  title?: ReactElement | string | null;
+  /**
+   * TocBot options, not guaranteed to be available in future versions.
+   *
+   * @see tocbot docs {@link https://tscanlin.github.io/tocbot/#usage}
+   */
+  unsafeTocbotOptions?: Omit<TocbotOptions, 'onClick' | 'scrollEndCallback'>;
+}
+type TableOfContentsProps = React.PropsWithChildren<TocParameters & {
+  className?: string;
+  channel: Channel;
+}>;
+declare const TableOfContents: ({
+  title,
+  disable,
+  headingSelector,
+  contentsSelector,
+  ignoreSelector,
+  unsafeTocbotOptions,
+  channel,
+  className
+}: TableOfContentsProps) => React.JSX.Element;
+//#endregion
+//#region .dts-emit/code/core/src/addon-docs/blocks/blocks/DocsContext.d.ts
+declare const DocsContext: Context<DocsContextProps$1<Renderer>>;
+//#endregion
+//#region .dts-emit/code/core/src/addon-docs/blocks/blocks/DocsContainer.d.ts
+interface DocsContainerProps<TFramework extends Renderer = Renderer> {
+  context: DocsContextProps$1<TFramework>;
+  theme?: ThemeVars;
+}
+declare const DocsContainer: FC<PropsWithChildren<DocsContainerProps>>;
+//#endregion
+export { TableOfContents as a, DocsContextProps$1 as i, DocsContainerProps as n, TocParameters as o, DocsContext as r, DocsContainer as t };

package/dist/chunk-CwQKNaYL.d.ts

@@ -0,0 +1,15 @@
+import { A as Queries, K as ServiceRegistrationOptions, S as Commands, V as ServiceDefinition, W as ServiceInstance, q as ServiceRegistryApi } from "./chunk-BCoJQE-f.js";
+import { co as TypedGetService, so as ServerCoreServices } from "./chunk-C2p5r3Vt.js";
+
+//#region .dts-emit/code/core/src/shared/open-service/server.d.ts
+declare const getService: TypedGetService<ServerCoreServices>;
+/**
+ * Registers a service on the dev server and returns its runtime surface.
+ *
+ * The server is a relay hub: when a channel is installed (the `services` preset does this on a real
+ * websocket transport) it bridges every connected manager tab. Without a channel — static builds and
+ * the index builder — the runtime stays local-only.
+ */
+declare function registerService<TState, TQueries extends Queries<TState>, TCommands extends Commands<TState>>(definition: ServiceDefinition<TState, TQueries, TCommands>, registration?: ServiceRegistrationOptions<TState, TQueries, TCommands>): ServiceInstance<TState, TQueries, TCommands> & ServiceRegistryApi;
+//#endregion
+export { registerService as n, getService as t };