@aussieljk/forkbook 0.0.0-stage → 0.0.1-2

package/dist/chunk-BGkgZp-H.d.ts

@@ -0,0 +1,214 @@
+//#region .dts-emit/code/core/src/theming/base.d.ts
+declare const easing: {
+  rubber: string;
+};
+declare const color: {
+  primary: string;
+  secondary: string;
+  tertiary: string;
+  ancillary: string;
+  orange: string;
+  gold: string;
+  green: string;
+  seafoam: string;
+  purple: string;
+  ultraviolet: string;
+  lightest: string;
+  lighter: string;
+  light: string;
+  mediumlight: string;
+  medium: string;
+  mediumdark: string;
+  dark: string;
+  darker: string;
+  darkest: string;
+  border: string;
+  positive: string;
+  warning: string;
+  negative: string;
+  critical: string;
+  defaultText: string;
+  inverseText: string;
+  positiveText: string;
+  warningText: string;
+  negativeText: string;
+};
+declare const background: {
+  app: string;
+  bar: string;
+  content: string;
+  preview: string;
+  gridCellSize: number;
+  hoverable: string;
+  positive: string;
+  warning: string;
+  negative: string;
+  critical: string;
+};
+declare const typography: {
+  fonts: {
+    base: string;
+    mono: string;
+  };
+  weight: {
+    regular: number;
+    bold: number;
+  };
+  size: {
+    s1: number;
+    s2: number;
+    s3: number;
+    m1: number;
+    m2: number;
+    m3: number;
+    l1: number;
+    l2: number;
+    l3: number;
+    code: number;
+  };
+};
+declare const tokens: {
+  light: {
+    fgColor: {
+      default: string;
+      muted: string;
+      accent: string;
+      inverse: string;
+      positive: string;
+      warning: string;
+      negative: string;
+      critical: string;
+      agentic: string;
+    };
+    bgColor: {
+      default: string;
+      muted: string;
+      positive: string;
+      warning: string;
+      negative: string;
+      critical: string;
+      agentic: string;
+    };
+    borderColor: {
+      default: string;
+      muted: string;
+      inverse: string;
+      positive: string;
+      warning: string;
+      negative: string;
+      critical: string;
+      agentic: string;
+    };
+  };
+  dark: {
+    fgColor: {
+      default: string;
+      muted: string;
+      accent: string;
+      inverse: string;
+      positive: string;
+      warning: string;
+      negative: string;
+      critical: string;
+      agentic: string;
+    };
+    bgColor: {
+      default: string;
+      muted: string;
+      positive: string;
+      warning: string;
+      negative: string;
+      critical: string;
+      agentic: string;
+    };
+    borderColor: {
+      default: string;
+      muted: string;
+      inverse: string;
+      positive: string;
+      warning: string;
+      negative: string;
+      critical: string;
+      agentic: string;
+    };
+  };
+};
+//#endregion
+//#region .dts-emit/code/core/src/theming/types.d.ts
+interface ThemeVars extends ThemeVarsBase, ThemeVarsColors {}
+interface ThemeVarsPartial extends ThemeVarsBase, Partial<ThemeVarsColors> {}
+interface ThemeVarsBase {
+  base: 'light' | 'dark';
+}
+interface ThemeVarsColors {
+  colorPrimary: string;
+  colorSecondary: string;
+  appBg: string;
+  appContentBg: string;
+  appHoverBg: string;
+  appPreviewBg: string;
+  appBorderColor: string;
+  appBorderRadius: number;
+  fontBase: string;
+  fontCode: string;
+  textColor: string;
+  textInverseColor: string;
+  textMutedColor: string;
+  barTextColor: string;
+  barHoverColor: string;
+  barSelectedColor: string;
+  barBg: string;
+  buttonBg: string;
+  buttonBorder: string;
+  booleanBg: string;
+  booleanSelectedBg: string;
+  inputBg: string;
+  inputBorder: string;
+  inputTextColor: string;
+  inputBorderRadius: number;
+  brandTitle?: string;
+  brandUrl?: string;
+  brandImage?: string;
+  brandTarget?: string;
+  gridCellSize?: number;
+}
+type Color = typeof color;
+type Background = typeof background;
+type Typography = typeof typography;
+type Easing = typeof easing;
+type TextSize = number | string;
+interface Brand {
+  title: string | undefined;
+  url: string | null | undefined;
+  image: string | null | undefined;
+  target: string | null | undefined;
+}
+interface StorybookTheme {
+  color: Color;
+  fgColor: typeof tokens.light.fgColor;
+  bgColor: typeof tokens.light.bgColor;
+  borderColor: typeof tokens.light.borderColor;
+  background: Background;
+  typography: Typography;
+  easing: Easing;
+  input: {
+    border: string;
+    background: string;
+    color: string;
+    borderRadius: number;
+  };
+  layoutMargin: number;
+  appBorderColor: string;
+  appBorderRadius: number;
+  barTextColor: string;
+  barHoverColor: string;
+  barSelectedColor: string;
+  barBg: string;
+  brand: Brand;
+  code: {
+    [key: string]: string | object;
+  };
+  [key: string]: any;
+}
+//#endregion
+export { StorybookTheme as a, ThemeVarsColors as c, background as d, color as f, typography as h, Easing as i, ThemeVarsPartial as l, tokens as m, Brand as n, TextSize as o, easing as p, Color as r, ThemeVars as s, Background as t, Typography as u };

package/dist/chunk-BTVrWliM.d.ts

@@ -0,0 +1,115 @@
+import { n as UnionToIntersection, t as OmitIndexSignature } from "./chunk-DaVb55-_.js";
+import { t as SetOptional } from "./chunk-pcFXCimE.js";
+import { t as Simplify } from "./chunk-FjDVzZTj.js";
+import { C as Globals$2, s as Args$2, w as InputType } from "./chunk-Dw1z1Pki.js";
+import { AddonTypes, StoryContext } from "@aussieljk/forkbook/internal/csf";
+import { Args as Args$1, ComponentAnnotations, ComposedStoryFn, DecoratorFunction as DecoratorFunction$1, NormalizedProjectAnnotations, ProjectAnnotations as ProjectAnnotations$1, Renderer as Renderer$1, StoryAnnotations, TestFunction } from "@aussieljk/forkbook/internal/types";
+
+//#region .dts-emit/code/core/src/csf/includeConditionalArg.d.ts
+/**
+ * Helper function to include/exclude an arg based on the value of other other args aka "conditional
+ * args"
+ */
+declare const includeConditionalArg: (argType: InputType, args: Args$2, globals: Globals$2) => any;
+//#endregion
+//#region .dts-emit/code/core/src/csf/csf-factories.d.ts
+interface Preview$1<TRenderer extends Renderer$1 = Renderer$1> {
+  readonly _tag: 'Preview';
+  input: ProjectAnnotations$1<TRenderer> & {
+    addons?: PreviewAddonEntry$1[];
+  };
+  composed: NormalizedProjectAnnotations<TRenderer>;
+  meta<TArgs = Args$1, TMetaArgKeys extends PropertyKey = never>(input: Omit<ComponentAnnotations<TRenderer & {
+    args: TArgs;
+  }, TArgs & TRenderer['args']>, 'args'> & {
+    args?: MetaArgs<TArgs & TRenderer['args'], TMetaArgKeys>;
+  }): Meta$1<RequireMetaArgs<TRenderer & {
+    args: TArgs;
+  }, TMetaArgKeys>, TMetaArgKeys>;
+  type<T>(): Preview$1<TRenderer & T>;
+}
+/**
+ * A typed addon created with `definePreviewAddon`, or a legacy preview annotations module namespace
+ * (`import * as addon from 'some-addon/preview'`). Legacy namespaces add no types to the preview.
+ */
+type PreviewAddonEntry$1 = PreviewAddon<never> | Record<string, unknown>;
+type InferTypes$1<T extends PreviewAddonEntry$1[]> = Extract<T[number], PreviewAddon<never>>[] extends PreviewAddon<infer C>[] ? C & {
+  csf4: true;
+} : never;
+declare function definePreview<TRenderer extends Renderer$1, Addons extends PreviewAddonEntry$1[]>(input: ProjectAnnotations$1<TRenderer> & {
+  addons?: Addons;
+}): Preview$1<TRenderer & InferTypes$1<Addons>>;
+interface PreviewAddon<in TExtraContext extends AddonTypes = AddonTypes> extends ProjectAnnotations$1<Renderer$1> {}
+declare function definePreviewAddon<TExtraContext extends AddonTypes = AddonTypes>(preview: ProjectAnnotations$1<Renderer$1>): PreviewAddon<TExtraContext>;
+declare function isPreview(input: unknown): input is Preview$1<Renderer$1>;
+type MetaArgs<TArgs, TKeys extends PropertyKey> = string extends TKeys ? Partial<NoInfer<TArgs>> : { [K in TKeys]?: K extends keyof NoInfer<TArgs> ? NoInfer<TArgs>[K] : never } & Partial<Record<Exclude<keyof NoInfer<TArgs>, TKeys>, unknown>>;
+type MetaArgKeys<TArgs, TKeys extends PropertyKey> = string extends TKeys ? never : TKeys & keyof TArgs;
+type WithMetaArgs<TArgs, TKeys extends PropertyKey> = TArgs & Required<Pick<TArgs, MetaArgKeys<TArgs, TKeys>>>;
+type RequireMetaArgs<TRenderer extends Renderer$1, TKeys extends PropertyKey> = TRenderer & {
+  args: WithMetaArgs<TRenderer['args'], TKeys>;
+};
+type DecoratorsArgs<TRenderer extends Renderer$1, Decorators> = UnionToIntersection<Decorators extends DecoratorFunction$1<TRenderer, infer TArgs> ? TArgs : unknown>;
+type InferMetaTypes<TRenderer extends Renderer$1, TArgs, Decorators> = TRenderer & {
+  args: Simplify<TArgs & OmitIndexSignature<DecoratorsArgs<TRenderer, Decorators>>>;
+};
+/**
+ * The input of a renderer's `preview.meta()`, apart from `component` and `render`. `args` are
+ * typed by the keys provided, and the meta's own hooks see those args as present.
+ */
+type MetaInput$1<TRenderer extends Renderer$1, TArgs, Decorators, TKeys extends PropertyKey> = {
+  args?: MetaArgs<InferMetaTypes<TRenderer, TArgs, Decorators>['args'], TKeys>;
+  decorators?: Decorators | Decorators[];
+} & Omit<ComponentAnnotations<TRenderer, NoInfer<WithMetaArgs<TArgs & TRenderer['args'], TKeys>>>, 'args' | 'component' | 'decorators' | 'render'>;
+/**
+ * The renderer types of the meta returned by `preview.meta()`: `TArgs` plus the args read by
+ * `Decorators`, with the args set in meta present.
+ */
+type MetaTypes$1<TRenderer extends Renderer$1, TArgs, Decorators, TKeys extends PropertyKey> = RequireMetaArgs<InferMetaTypes<TRenderer, TArgs, Decorators>, TKeys>;
+/** The args a story must still provide: the ones `preview.meta()` didn't set. */
+type StoryArgs$1<TArgs, TKeys extends PropertyKey> = SetOptional<TArgs, MetaArgKeys<TArgs, TKeys>>;
+/**
+ * The meta's arg keys after `meta.type<T>()`. An arg that `T` redeclares is required again, because
+ * the meta's value was not checked against its new type.
+ */
+type TypedMetaArgKeys$1<TKeys extends PropertyKey, T> = Exclude<TKeys, T extends {
+  args: infer TArgs;
+} ? keyof TArgs : never>;
+/**
+ * Adds the args of a typed `render` to those of the meta's `component`. A `render` typed as `any` or
+ * `Args` adds none, and it can't change the types of the component's args.
+ */
+type WithRenderArgs<TComponentArgs, TRenderArgs> = TComponentArgs & (string extends keyof TRenderArgs ? unknown : Omit<TRenderArgs, keyof TComponentArgs>);
+interface Meta$1<TRenderer extends Renderer$1, TMetaArgKeys extends PropertyKey = never> {
+  readonly _tag: 'Meta';
+  input: Omit<ComponentAnnotations<TRenderer, TRenderer['args']>, 'args'> & {
+    args: [MetaArgKeys<TRenderer['args'], TMetaArgKeys>] extends [never] ? Partial<TRenderer['args']> | undefined : WithMetaArgs<Partial<TRenderer['args']>, TMetaArgKeys>;
+  };
+  preview: Preview$1<TRenderer>;
+  story(input?: () => TRenderer['storyResult']): Story$1<TRenderer, {
+    render: () => TRenderer['storyResult'];
+  }>;
+  story<TInput extends StoryAnnotations<TRenderer, TRenderer['args'], StoryArgs$1<TRenderer['args'], TMetaArgKeys>>>(input?: TInput): Story$1<TRenderer, TInput>;
+  type<T>(): Meta$1<TRenderer & T, TypedMetaArgKeys$1<TMetaArgKeys, T>>;
+}
+declare function isMeta(input: unknown): input is Meta$1<Renderer$1>;
+interface Story$1<TRenderer extends Renderer$1, TInput extends {
+  play?: (...args: never[]) => void;
+  render?: (...args: never[]) => TRenderer['storyResult'];
+} = StoryAnnotations<TRenderer, TRenderer['args']>> {
+  readonly _tag: 'Story';
+  input: TInput;
+  composed: Pick<ComposedStoryFn<TRenderer>, 'argTypes' | 'parameters' | 'id' | 'tags' | 'globals'> & {
+    args: TRenderer['args'];
+    name: string;
+  };
+  meta: Meta$1<TRenderer>;
+  play: TInput['play'];
+  run: (context?: Partial<StoryContext<TRenderer, Partial<TRenderer['args']>>>, testName?: string) => Promise<void>;
+  extend<TInput extends StoryAnnotations<TRenderer, TRenderer['args']>>(input: TInput): Story$1<TRenderer, TInput>;
+  test(name: string, fn: TestFunction<TRenderer>): void;
+  test(name: string, annotations: StoryAnnotations<TRenderer, TRenderer['args']>, fn: TestFunction<TRenderer>): void;
+}
+declare function isStory<TRenderer extends Renderer$1>(input: unknown): input is Story$1<TRenderer>;
+declare function getStoryChildren<TRenderer extends Renderer$1>(story: Story$1<TRenderer>): Story$1<TRenderer>[];
+//#endregion
+export { isStory as _, Preview$1 as a, Story$1 as c, WithRenderArgs as d, definePreview as f, isPreview as g, isMeta as h, MetaTypes$1 as i, StoryArgs$1 as l, getStoryChildren as m, Meta$1 as n, PreviewAddon as o, definePreviewAddon as p, MetaInput$1 as r, PreviewAddonEntry$1 as s, InferTypes$1 as t, TypedMetaArgKeys$1 as u, includeConditionalArg as v };

package/dist/chunk-BXLImeLy.d.ts

@@ -0,0 +1,197 @@
+//#region .dts-emit/code/core/src/channels/types.d.ts
+interface Config {
+  page: 'manager' | 'preview';
+}
+type ChannelHandler = (event: ChannelEvent) => void;
+interface ChannelTransport {
+  send(event: ChannelEvent, options?: any): void;
+  setHandler(handler: ChannelHandler): void;
+}
+interface ChannelEvent {
+  type: string;
+  from: string;
+  args: any[];
+}
+interface Listener {
+  (...args: any[]): void;
+}
+/**
+ * Structural interface for Channel, used in type declarations to avoid nominal incompatibility
+ * between source and dist Channel class declarations.
+ */
+interface ChannelLike {
+  readonly isAsync: boolean;
+  readonly hasTransport: boolean;
+  addListener(eventName: string, listener: Listener): void;
+  emit(eventName: string, ...args: any): void;
+  last(eventName: string): any;
+  eventNames(): string[];
+  listenerCount(eventName: string): number;
+  listeners(eventName: string): Listener[] | undefined;
+  once(eventName: string, listener: Listener): void;
+  removeAllListeners(eventName?: string): void;
+  removeListener(eventName: string, listener: Listener): void;
+  on(eventName: string, listener: Listener): void;
+  off(eventName: string, listener: Listener): void;
+  receive?(event: ChannelEvent): void;
+}
+interface ChannelArgsSingle {
+  transport?: ChannelTransport;
+  async?: boolean;
+}
+interface ChannelArgsMulti {
+  transports: ChannelTransport[];
+  async?: boolean;
+}
+//#endregion
+//#region .dts-emit/code/core/src/channels/main.d.ts
+declare class Channel implements ChannelLike {
+  readonly isAsync: boolean;
+  private sender;
+  private events;
+  private data;
+  private readonly transports;
+  constructor(input: ChannelArgsMulti);
+  constructor(input: ChannelArgsSingle);
+  get hasTransport(): boolean;
+  addListener(eventName: string, listener: Listener): void;
+  emit(eventName: string, ...args: any): void;
+  last(eventName: string): any;
+  eventNames(): string[];
+  listenerCount(eventName: string): number;
+  listeners(eventName: string): Listener[] | undefined;
+  once(eventName: string, listener: Listener): void;
+  removeAllListeners(eventName?: string): void;
+  removeListener(eventName: string, listener: Listener): void;
+  on(eventName: string, listener: Listener): void;
+  off(eventName: string, listener: Listener): void;
+  /**
+   * Deliver an event to local listeners without sending it to this channel's transports.
+   */
+  receive(event: ChannelEvent): void;
+  private handleEvent;
+  private onceListener;
+}
+//#endregion
+//#region .dts-emit/code/core/src/channels/channel-slot.d.ts
+/**
+ * Returns the installed addons channel, or `null` before one exists.
+ *
+ * The global slot wins over the module cache so duplicate copies of this module (e.g. dev-server
+ * preset code and `.forkbook` service registration loading different bundles) still observe
+ * `setChannel` from whichever copy installed the live websocket channel.
+ */
+declare function getChannel(): ChannelLike | null;
+/**
+ * Returns the installed addons channel.
+ *
+ * Callers assume each runtime has installed a channel at its entry boundary (builder iframe setup,
+ * manager boot, server `services` preset, or Node module bootstrap). Prefer this over nullable
+ * `getChannel()` when the channel must exist.
+ */
+declare function requireChannel(): ChannelLike;
+/** Installs (or replaces) the shared addons channel. Pass `null` to clear. */
+declare function setChannel(next: ChannelLike | null): void;
+/** Clears the shared channel slot. Alias for `setChannel(null)`. */
+declare function clearChannel(): void;
+/** Installs a noop in-process channel — used by server presets and unit tests. */
+declare function installNoopChannel(): void;
+/**
+ * Installs a noop channel when none is present yet.
+ *
+ * Prefer explicit `setChannel` / `installNoopChannel` at runtime entry points. This helper remains for
+ * tests and tooling that need an in-process channel without a mock transport.
+ */
+declare function ensureChannel(): void;
+//#endregion
+//#region .dts-emit/code/core/src/channels/postmessage/index.d.ts
+declare class PostMessageTransport implements ChannelTransport {
+  private readonly config;
+  private buffer;
+  private handler?;
+  private connected;
+  private readonly originValidator;
+  private readonly insecureIframeMessaging;
+  private readonly pinsTargetOrigin;
+  private readonly rejectedOrigins;
+  constructor(config: Config);
+  setHandler(handler: ChannelHandler): void;
+  /**
+   * Sends `event` to the associated window. If the window does not yet exist the event will be
+   * stored in a buffer and sent when the window exists.
+   *
+   * @param event
+   */
+  send(event: ChannelEvent, options?: any): Promise<any>;
+  private flush;
+  private getFrames;
+  private getCurrentFrames;
+  private getIframeTargetOrigin;
+  private getManagerTargetOrigin;
+  private getLocalFrame;
+  private isAllowedSender;
+  private isAllowedToContactPreview;
+  private isAllowedToContactManager;
+  private warnOnceAboutRejectedSender;
+  private handleEvent;
+}
+//#endregion
+//#region .dts-emit/code/core/src/channels/websocket/index.d.ts
+type OnError = (message: Event) => void;
+/**
+ * The slice of the WebSocket API this transport drives, so a Node runtime can supply a `ws` socket
+ * where the DOM `WebSocket` global is unusable.
+ */
+interface ChannelWebSocket {
+  send(data: string): void;
+  close(code?: number, reason?: string): void;
+  onopen: ((event: any) => void) | null;
+  onmessage: ((event: any) => void) | null;
+  onerror: ((event: any) => void) | null;
+  onclose: ((event: any) => void) | null;
+}
+interface WebsocketTransportArgs extends Partial<Config> {
+  url: string;
+  onError: OnError;
+  createSocket?: (url: string) => ChannelWebSocket;
+}
+declare const HEARTBEAT_INTERVAL = 15000;
+declare const SERVER_CHANNEL_PATH = "/storybook-server-channel";
+declare class WebsocketTransport implements ChannelTransport {
+  private buffer;
+  private handler?;
+  private socket;
+  private isReady;
+  private isClosed;
+  constructor({
+    url,
+    onError,
+    page,
+    createSocket
+  }: WebsocketTransportArgs);
+  setHandler(handler: ChannelHandler): void;
+  send(event: any): void;
+  private sendLater;
+  private sendNow;
+  private flush;
+}
+//#endregion
+//#region .dts-emit/code/core/src/channels/index.d.ts
+type Options = Config & {
+  extraTransports?: ChannelTransport[];
+};
+/**
+ * Creates a new browser channel instance.
+ *
+ * @param {Options} options - The options object.
+ * @param {Page} options.page - Page identifier.
+ * @param {ChannelTransport[]} [options.extraTransports=[]] - An optional array of extra channel
+ *   transports. Default is `[]`
+ * @returns {Channel} - The new channel instance.
+ */
+declare function createBrowserChannel({
+  page,
+  extraTransports
+}: Options): Channel;
+//#endregion
+export { ChannelTransport as _, WebsocketTransport as a, ensureChannel as c, requireChannel as d, setChannel as f, ChannelLike as g, ChannelHandler as h, SERVER_CHANNEL_PATH as i, getChannel as l, ChannelEvent as m, ChannelWebSocket as n, PostMessageTransport as o, Channel as p, HEARTBEAT_INTERVAL as r, clearChannel as s, createBrowserChannel as t, installNoopChannel as u, Listener as v };