@aussieljk/forkbook 0.0.0-stage → 0.0.1-2

package/dist/chunk-DEVFdzxR.d.ts

@@ -0,0 +1,253 @@
+import { o as ToolsetGetService, r as InvokedToolsetOutcome, t as AnyToolsetDefinition } from "./chunk-BCoJQE-f.js";
+import { bc as ToolsetMethodId, pt as StorybookError } from "./chunk-C2p5r3Vt.js";
+import * as v from "valibot";
+
+//#region .dts-emit/code/core/src/cli/tools/instances/types.d.ts
+/**
+ * A single Forkbook runtime record written under the registry dir (default
+ * `~/.forkbook/instances`). One file per running `forkbook dev` instance.
+ * Spec: storybookjs/storybook#34826.
+ */
+declare const StorybookInstanceRecordSchema: v.ObjectSchema<{
+  readonly schemaVersion: v.LiteralSchema<1, undefined>;
+  readonly instanceId: v.StringSchema<undefined>;
+  readonly pid: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, 1, undefined>, v.IntegerAction<number, undefined>]>;
+  readonly cwd: v.StringSchema<undefined>;
+  /**
+   * Resolved config directory of the running Forkbook, used as a second matching key so
+   * monorepo instances are found from a different cwd (storybookjs/storybook#35359). Optional:
+   * records written by Storybooks older than 10.5 lack it.
+   */
+  readonly configDir: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+  readonly url: v.StringSchema<undefined>;
+  readonly port: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, 1, undefined>, v.MaxValueAction<number, 65535, undefined>, v.IntegerAction<number, undefined>]>;
+  /**
+   * Token authenticating clients against the instance's WebSocket channel. Optional: records
+   * written by older Storybooks lack it.
+   */
+  readonly token: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+  readonly agent: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+  readonly storybookVersion: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+  /**
+   * Realpathed root of the `storybook` package the dev server actually runs, recorded by the
+   * server from its own module location. The caller attaches in-process when this equals its own
+   * root, and spawns its child host from this root otherwise. Optional: records written by older
+   * Storybooks lack it, which makes attach refuse.
+   */
+  readonly storybookPath: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+  readonly startedAt: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+  readonly updatedAt: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+  readonly mcp: v.ObjectSchema<{
+    readonly status: v.PicklistSchema<["not-installed", "starting", "ready", "error"], undefined>;
+    readonly endpoint: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+  }, undefined>;
+}, undefined>;
+type StorybookInstanceRecord = v.InferOutput<typeof StorybookInstanceRecordSchema>;
+//#endregion
+//#region .dts-emit/code/core/src/cli/tools/sdk/local-runtime.d.ts
+type ToolsRuntime = {
+  configDir: string;
+  toolsets: AnyToolsetDefinition[];
+  getService: ToolsetGetService;
+  close(): Promise<void>;
+};
+//#endregion
+//#region .dts-emit/code/core/src/cli/tools/sdk/errors.d.ts
+/** Why attaching to a running Forkbook was not possible. */
+type AttachUnavailableReason = 'no-instance' | 'port-mismatch' | 'old-server' | 'connection-failed';
+/**
+ * The requested capability needs a running Forkbook and the SDK could not attach to one.
+ *
+ * `remediation` is the whole message: it is written for the agent or developer that triggered the
+ * call and names the next step, which is what `agentFacing` declares. `instances` carries every
+ * live record the SDK knows about so a caller can point at another project or resolve a
+ * `port-mismatch` failure itself. Channel tokens are omitted so logging the error cannot leak
+ * them.
+ */
+declare class AttachUnavailableError extends StorybookError {
+  data: {
+    reason: AttachUnavailableReason;
+    instances: StorybookInstanceRecord[];
+    remediation: string;
+  };
+  constructor(data: {
+    reason: AttachUnavailableReason;
+    instances: StorybookInstanceRecord[];
+    remediation: string;
+  });
+}
+/**
+ * The instance record cannot prove which `storybook` installation the running Forkbook is, or
+ * the installations differ and spawning a child host from the recorded one is not allowed
+ * (`autoSpawn: false`, or this process is already a child host). `reason` is the whole message
+ * and names the recovery.
+ */
+declare class EnvironmentMismatchError extends StorybookError {
+  data: {
+    reason: string;
+  };
+  constructor(data: {
+    reason: string;
+  });
+}
+/** The child host that would run the target project's tools could not be resolved or started. */
+declare class SpawnFailedError extends StorybookError {
+  data: {
+    reason: string;
+    cause?: unknown;
+  };
+  constructor(data: {
+    reason: string;
+    cause?: unknown;
+  });
+}
+/** Why a tools runtime fault was raised. */
+type ToolsRuntimeErrorReason = 'mode-unavailable' | 'config-load-failed' | 'closed' | 'unknown-toolset' | 'unknown-method' | 'invalid-input' | 'connection-lost' | 'command-unhandled';
+/**
+ * A tools runtime fault: the SDK could not run what was asked of it.
+ *
+ * Distinct from a tool that ran and reported bad news, which is an outcome with `ok: false` and
+ * never an exception.
+ */
+declare class ToolsRuntimeError extends StorybookError {
+  data: {
+    reason: ToolsRuntimeErrorReason;
+    message: string;
+    cause?: unknown; /** Schema issues when `reason` is `invalid-input`. */
+    issues?: ReadonlyArray<{
+      message: string;
+      path?: ReadonlyArray<PropertyKey | {
+        key?: unknown;
+      }>;
+    }>;
+  };
+  constructor(data: {
+    reason: ToolsRuntimeErrorReason;
+    message: string;
+    cause?: unknown; /** Schema issues when `reason` is `invalid-input`. */
+    issues?: ReadonlyArray<{
+      message: string;
+      path?: ReadonlyArray<PropertyKey | {
+        key?: unknown;
+      }>;
+    }>;
+  });
+}
+declare function isAttachGateError(error: unknown): error is AttachUnavailableError | EnvironmentMismatchError | SpawnFailedError;
+/** Why attached mode was not used, either as a hard failure or as an `auto` fallback. */
+type ToolsAttachGateReason = AttachUnavailableReason | 'environment-mismatch' | 'spawn-failed';
+declare function attachGateReasonFromError(error: AttachUnavailableError | EnvironmentMismatchError | SpawnFailedError): ToolsAttachGateReason;
+declare function attachGateReasonFromError(error: unknown): ToolsAttachGateReason | undefined;
+//#endregion
+//#region .dts-emit/code/core/src/cli/tools/sdk/json-schema.d.ts
+/** A JSON Schema document, as produced from a toolset method's input or output schema. */
+type ToolsetJsonSchema = Record<string, unknown>;
+//#endregion
+//#region .dts-emit/code/core/src/cli/tools/sdk/types.d.ts
+/**
+ * How the SDK hosts the target project's tools.
+ *
+ * `attached` talks to a running Forkbook dev server. `local` loads the target configuration
+ * without one: in this process when `cwd` already matches, otherwise in a child host started from
+ * that directory. `auto` prefers attached and falls back to local.
+ */
+type ToolsMode = 'auto' | 'attached' | 'local';
+type ToolsHostKind = 'in-process' | 'child';
+/** Identifies the surface calling the SDK, for the attach handshake and for telemetry. */
+type ToolsClientInfo = {
+  name: string;
+  version: string; /** Defaults to `sdk`; first-party surfaces stamp their own, as the `forkbook tools` CLI does. */
+  kind?: 'sdk' | 'cli';
+};
+type CreateToolsOptions = {
+  /** Project directory of the target Forkbook; defaults to `process.cwd()`. */cwd?: string; /** Directory to load the Forkbook configuration from; relative paths resolve from `cwd`. */
+  configDir?: string; /** Port of a running Forkbook; a known port targets that instance without cwd or config dir. */
+  port?: number; /** Defaults to `auto`. */
+  mode?: ToolsMode; /** Whether the SDK may start a child host in the target project's own environment. */
+  autoSpawn?: boolean;
+  clientInfo?: ToolsClientInfo;
+};
+/** A running instance that also matched the target project but was not attached to. */
+type ToolsSiblingInstance = {
+  url: string;
+  port: number;
+  pid: number;
+  cwd: string;
+  configDir?: string;
+};
+/** What the resolved host knows about the Forkbook it serves. */
+type ToolsStorybookInfo = {
+  version: string;
+  configDir: string; /** Base URL of the running Forkbook, including any deployment subpath. */
+  url?: string; /** Process id of the running Forkbook. */
+  pid?: number; /** Port of the running Forkbook, as recorded by `forkbook dev`. */
+  port?: number; /** Directory the running Forkbook was started from. */
+  cwd?: string;
+  /**
+   * Set when attach chose among several matching instances: the competing instances, best first,
+   * so callers can warn and name `port` as the way to target another one.
+   */
+  siblings?: ToolsSiblingInstance[];
+};
+/** One callable tool, described for an agent that has only this catalog to go on. */
+type ToolsetCatalogMethod = {
+  /** Dotted `toolsetId.methodName`, as passed to {@link Tools.call}. */ref: ToolsetMethodId;
+  title: string;
+  description: string;
+  requiresDevServer: boolean; /** `undefined` when the method's schema has no JSON Schema representation. */
+  input: ToolsetJsonSchema | undefined;
+  output?: ToolsetJsonSchema;
+};
+type ToolsetCatalogEntry = {
+  id: string;
+  description: string;
+  methods: ToolsetCatalogMethod[];
+};
+/** Every tool the target Forkbook configuration registers. */
+type ToolsetCatalog = {
+  configDir: string;
+  toolsets: ToolsetCatalogEntry[];
+};
+type ToolsDescribeOptions = {
+  /** Restrict the catalog to one toolset id. */toolset?: string;
+};
+type ToolsCallOptions = {
+  signal?: AbortSignal; /** Overrides the host's Forkbook origin for this call. */
+  origin?: string;
+};
+type ToolsBase = {
+  clientInfo: Required<ToolsClientInfo>;
+  storybook: ToolsStorybookInfo; /** The `mode` passed to `createTools`; `auto` when omitted. */
+  requestedMode: ToolsMode; /** `in-process` unless this host is a project-local child. */
+  host: ToolsHostKind; /** Set when `auto` mode could not attach for an unexpected reason and loaded locally instead. */
+  fallbackNotice?: string; /** Why `auto` loaded locally instead of attaching. */
+  fallbackReason?: ToolsAttachGateReason; /** Toolset registry and service accessor for an in-process host. Empty when this host is a child. */
+  runtime: ToolsRuntime;
+  describe(options?: ToolsDescribeOptions): Promise<ToolsetCatalog>;
+  /**
+   * Run one tool by its dotted `toolsetId.methodName` reference.
+   *
+   * A tool that ran and reported bad news resolves to an outcome with `ok: false`; only a fault
+   * that stopped the tool from running rejects.
+   *
+   * @throws {ToolsRuntimeError} When the reference is unknown, the input fails the method's
+   *   schema, or the host can no longer serve calls.
+   * @throws {AttachUnavailableError} When the method needs a running Forkbook the host has not
+   *   attached to.
+   */
+  call(ref: string, input?: Record<string, unknown>, options?: ToolsCallOptions): Promise<InvokedToolsetOutcome>;
+  close(): Promise<void>;
+};
+/**
+ * A host that loaded the target configuration without a running Forkbook.
+ */
+type LocalTools = ToolsBase & {
+  mode: 'local';
+};
+/** A host that joined a running Forkbook over its channel. */
+type AttachedTools = ToolsBase & {
+  mode: 'attached';
+};
+type Tools = LocalTools | AttachedTools;
+//#endregion
+export { attachGateReasonFromError as C, StorybookInstanceRecord as E, ToolsRuntimeErrorReason as S, ToolsRuntime as T, AttachUnavailableReason as _, ToolsCallOptions as a, ToolsAttachGateReason as b, ToolsHostKind as c, ToolsStorybookInfo as d, ToolsetCatalog as f, AttachUnavailableError as g, ToolsetJsonSchema as h, Tools as i, ToolsMode as l, ToolsetCatalogMethod as m, CreateToolsOptions as n, ToolsClientInfo as o, ToolsetCatalogEntry as p, LocalTools as r, ToolsDescribeOptions as s, AttachedTools as t, ToolsSiblingInstance as u, EnvironmentMismatchError as v, isAttachGateError as w, ToolsRuntimeError as x, SpawnFailedError as y };

package/dist/chunk-DaVb55-_.d.ts

@@ -0,0 +1,124 @@
+//#region ../../node_modules/type-fest/source/union-to-intersection.d.ts
+/**
+Convert a union type to an intersection type.
+
+Inspired by [this Stack Overflow answer](https://stackoverflow.com/a/50375286/2172153).
+
+@example
+```
+import type {UnionToIntersection} from 'type-fest';
+
+type Union = {the(): void} | {great(arg: string): void} | {escape: boolean};
+
+type Intersection = UnionToIntersection<Union>;
+//=> {the(): void} & {great(arg: string): void} & {escape: boolean}
+```
+
+@category Type
+*/
+type UnionToIntersection<Union> = (// `extends unknown` is always going to be the case and is used to convert the
+// `Union` into a [distributive conditional
+// type](https://www.typescriptlang.org/docs/handbook/release-notes/typescript-2-8.html#distributive-conditional-types).
+Union extends unknown // The union type is used as the only argument to a function since the union
+// of function arguments is an intersection.
+? (distributedUnion: Union) => void // This won't happen.
+: never // Infer the `Intersection` type since TypeScript represents the positional
+// arguments of unions of functions as an intersection of the union.
+) extends ((mergedIntersection: infer Intersection) => void) // The `& Union` is to ensure result of `UnionToIntersection<A | B>` is always assignable to `A | B`
+? Intersection & Union : never;
+//#endregion
+//#region ../../node_modules/type-fest/source/omit-index-signature.d.ts
+/**
+Omit any index signatures from the given object type, leaving only explicitly defined properties.
+
+This is the counterpart of `PickIndexSignature`.
+
+Use-cases:
+- Remove overly permissive signatures from third-party types.
+
+This type was taken from this [StackOverflow answer](https://stackoverflow.com/a/68261113/420747).
+
+It relies on the fact that an empty object (`{}`) is assignable to an object with just an index signature, like `Record<string, unknown>`, but not to an object with explicitly defined keys, like `Record<'foo' | 'bar', unknown>`.
+
+(The actual value type, `unknown`, is irrelevant and could be any type. Only the key type matters.)
+
+```
+const indexed: Record<string, unknown> = {}; // Allowed
+
+// @ts-expect-error
+const keyed: Record<'foo', unknown> = {}; // Error
+// TS2739: Type '{}' is missing the following properties from type 'Record<"foo" | "bar", unknown>': foo, bar
+```
+
+Instead of causing a type error like the above, you can also use a [conditional type](https://www.typescriptlang.org/docs/handbook/2/conditional-types.html) to test whether a type is assignable to another:
+
+```
+type Indexed = {} extends Record<string, unknown>
+	? '✅ `{}` is assignable to `Record<string, unknown>`'
+	: '❌ `{}` is NOT assignable to `Record<string, unknown>`';
+
+type IndexedResult = Indexed;
+//=> '✅ `{}` is assignable to `Record<string, unknown>`'
+
+type Keyed = {} extends Record<'foo' | 'bar', unknown>
+	? '✅ `{}` is assignable to `Record<\'foo\' | \'bar\', unknown>`'
+	: '❌ `{}` is NOT assignable to `Record<\'foo\' | \'bar\', unknown>`';
+
+type KeyedResult = Keyed;
+//=> '❌ `{}` is NOT assignable to `Record<\'foo\' | \'bar\', unknown>`'
+```
+
+Using a [mapped type](https://www.typescriptlang.org/docs/handbook/2/mapped-types.html#further-exploration), you can then check for each `KeyType` of `ObjectType`...
+
+```
+type OmitIndexSignature<ObjectType> = {
+	[KeyType in keyof ObjectType // Map each key of `ObjectType`...
+	]: ObjectType[KeyType]; // ...to its original value, i.e. `OmitIndexSignature<Foo> == Foo`.
+};
+```
+
+...whether an empty object (`{}`) would be assignable to an object with that `KeyType` (`Record<KeyType, unknown>`)...
+
+```
+type OmitIndexSignature<ObjectType> = {
+	[KeyType in keyof ObjectType
+	// Is `{}` assignable to `Record<KeyType, unknown>`?
+	as {} extends Record<KeyType, unknown>
+		? never // ✅ `{}` is assignable to `Record<KeyType, unknown>`
+		: KeyType // ❌ `{}` is NOT assignable to `Record<KeyType, unknown>`
+	]: ObjectType[KeyType];
+};
+```
+
+If `{}` is assignable, it means that `KeyType` is an index signature and we want to remove it. If it is not assignable, `KeyType` is a "real" key and we want to keep it.
+
+@example
+```
+import type {OmitIndexSignature} from 'type-fest';
+
+type Example = {
+	// These index signatures will be removed.
+	[x: string]: any;
+	[x: number]: any;
+	[x: symbol]: any;
+	[x: `head-${string}`]: string;
+	[x: `${string}-tail`]: string;
+	[x: `head-${string}-tail`]: string;
+	[x: `${bigint}`]: string;
+	[x: `embedded-${number}`]: string;
+
+	// These explicitly defined keys will remain.
+	foo: 'bar';
+	qux?: 'baz';
+};
+
+type ExampleWithoutIndexSignatures = OmitIndexSignature<Example>;
+//=> {foo: 'bar'; qux?: 'baz'}
+```
+
+@see {@link PickIndexSignature}
+@category Object
+*/
+type OmitIndexSignature<ObjectType> = { [KeyType in keyof ObjectType as {} extends Record<KeyType, unknown> ? never : KeyType]: ObjectType[KeyType] };
+//#endregion
+export { UnionToIntersection as n, OmitIndexSignature as t };

package/dist/chunk-DgRNfmj_.d.ts

@@ -0,0 +1,40 @@
+import { RunOptions, Selector, SelectorList, Spec } from "axe-core";
+
+//#region .dts-emit/code/core/src/addon-a11y/params.d.ts
+type SelectorWithoutNode = Omit<Selector, 'Node'> | Omit<SelectorList, 'NodeList'>;
+type ContextObjectWithoutNode = {
+  include: SelectorWithoutNode;
+  exclude?: SelectorWithoutNode;
+} | {
+  exclude: SelectorWithoutNode;
+  include?: SelectorWithoutNode;
+};
+type ContextSpecWithoutNode = SelectorWithoutNode | ContextObjectWithoutNode;
+type A11yTest = 'off' | 'todo' | 'error';
+interface A11yParameters {
+  /**
+   * Context parameter for axe-core's run function, except without support for passing Nodes and
+   * NodeLists directly.
+   *
+   * @see https://github.com/dequelabs/axe-core/blob/develop/doc/context.md
+   */
+  context?: ContextSpecWithoutNode;
+  /**
+   * Options for running axe-core.
+   *
+   * @see https://github.com/dequelabs/axe-core/blob/develop/doc/API.md#options-parameter
+   */
+  options?: RunOptions;
+  /**
+   * Configuration object for axe-core.
+   *
+   * @see https://github.com/dequelabs/axe-core/blob/develop/doc/API.md#api-name-axeconfigure
+   */
+  config?: Spec;
+  /** Whether to disable accessibility tests. */
+  disable?: boolean;
+  /** Defines how accessibility violations should be handled: 'off', 'todo', or 'error'. */
+  test?: A11yTest;
+}
+//#endregion
+export { SelectorWithoutNode as i, ContextObjectWithoutNode as n, ContextSpecWithoutNode as r, A11yParameters as t };