@aussieljk/forkbook 0.0.0-stage → 0.0.1-1

package/dist/_browser-chunks/chunk-LV5PIKV4.js

@@ -0,0 +1,93 @@
+import {
+  EVENT_ID
+} from "./chunk-V2G23FV7.js";
+
+// src/actions/runtime/configureActions.ts
+var config = {
+  depth: 10,
+  clearOnStoryChange: !0,
+  limit: 50
+}, configureActions = (options = {}) => {
+  Object.assign(config, options);
+};
+
+// src/actions/runtime/action.ts
+import { ImplicitActionsDuringRendering } from "@aussieljk/forkbook/internal/preview-errors";
+import { global } from "@storybook/global";
+import { addons } from "@aussieljk/forkbook/preview-api";
+var findProto = (obj, callback) => {
+  let proto = Object.getPrototypeOf(obj);
+  return !proto || callback(proto) ? proto : findProto(proto, callback);
+}, isReactSyntheticEvent = (e) => !!(typeof e == "object" && e && findProto(e, (proto) => /^Synthetic(?:Base)?Event$/.test(proto.constructor.name)) && typeof e.persist == "function"), serializeArg = (a) => {
+  if (isReactSyntheticEvent(a)) {
+    let e = Object.create(
+      a.constructor.prototype,
+      Object.getOwnPropertyDescriptors(a)
+    );
+    e.persist();
+    let viewDescriptor = Object.getOwnPropertyDescriptor(e, "view"), view = viewDescriptor?.value;
+    return typeof view == "object" && view?.constructor.name === "Window" && Object.defineProperty(e, "view", {
+      ...viewDescriptor,
+      value: Object.create(view.constructor.prototype)
+    }), e;
+  }
+  return a;
+};
+function action(name, options = {}) {
+  let actionOptions = {
+    ...config,
+    ...options
+  }, handler = function(...args) {
+    if (options.implicit) {
+      let storyRenderer = ("__STORYBOOK_PREVIEW__" in global ? global.__STORYBOOK_PREVIEW__ : void 0)?.storyRenders.find(
+        (render) => render.phase === "playing" || render.phase === "rendering"
+      );
+      if (storyRenderer) {
+        let deprecated = !globalThis?.FEATURES?.disallowImplicitActionsInRenderV8, error = new ImplicitActionsDuringRendering({
+          phase: storyRenderer.phase,
+          name,
+          deprecated
+        });
+        if (deprecated)
+          console.warn(error);
+        else
+          throw error;
+      }
+    }
+    let channel = addons.getChannel(), id = Date.now().toString(36) + Math.random().toString(36).substring(2), minDepth = 5, serializedArgs = args.map(serializeArg), normalizedArgs = args.length > 1 ? serializedArgs : serializedArgs[0], actionDisplayToEmit = {
+      id,
+      count: 0,
+      data: { name, args: normalizedArgs },
+      options: {
+        ...actionOptions,
+        maxDepth: minDepth + (actionOptions.depth || 3)
+      }
+    };
+    channel.emit(EVENT_ID, actionDisplayToEmit);
+  };
+  return handler.isAction = !0, handler.implicit = options.implicit, handler;
+}
+
+// src/actions/runtime/actions.ts
+var actions = (...args) => {
+  let options = config, names = args;
+  names.length === 1 && Array.isArray(names[0]) && ([names] = names), names.length !== 1 && typeof names[names.length - 1] != "string" && (options = {
+    ...config,
+    ...names.pop()
+  });
+  let namesObject = names[0];
+  (names.length !== 1 || typeof namesObject == "string") && (namesObject = {}, names.forEach((name) => {
+    namesObject[name] = name;
+  }));
+  let actionsObject = {};
+  return Object.keys(namesObject).forEach((name) => {
+    actionsObject[name] = action(namesObject[name], options);
+  }), actionsObject;
+};
+
+export {
+  config,
+  configureActions,
+  action,
+  actions
+};

package/dist/_browser-chunks/chunk-MDOL7KML.js

@@ -0,0 +1,56 @@
+import {
+  entry_preview_argtypes_exports
+} from "./chunk-GNZY6LOW.js";
+import {
+  entry_preview_exports,
+  renderToCanvas
+} from "./chunk-CFWWCCZV.js";
+
+// src/react/portable-stories.tsx
+import {
+  composeConfigs,
+  composeStories as originalComposeStories,
+  composeStory as originalComposeStory,
+  setProjectAnnotations as originalSetProjectAnnotations,
+  setDefaultProjectAnnotations
+} from "@aussieljk/forkbook/preview-api";
+import { jsx } from "react/jsx-runtime";
+function setProjectAnnotations(projectAnnotations) {
+  return setDefaultProjectAnnotations(INTERNAL_DEFAULT_PROJECT_ANNOTATIONS), originalSetProjectAnnotations(
+    projectAnnotations
+  );
+}
+var INTERNAL_DEFAULT_PROJECT_ANNOTATIONS = composeConfigs([
+  entry_preview_exports,
+  entry_preview_argtypes_exports,
+  {
+    /** @deprecated */
+    renderToCanvas: async (renderContext, canvasElement) => {
+      if (renderContext.storyContext.testingLibraryRender == null)
+        return renderToCanvas(renderContext, canvasElement);
+      let {
+        storyContext: { context, unboundStoryFn: Story, testingLibraryRender: render }
+      } = renderContext, { unmount } = render(jsx(Story, { ...context }), { container: context.canvasElement });
+      return unmount;
+    }
+  }
+]);
+function composeStory(story, componentAnnotations, projectAnnotations, exportsName) {
+  return originalComposeStory(
+    story,
+    componentAnnotations,
+    projectAnnotations,
+    globalThis.globalProjectAnnotations ?? INTERNAL_DEFAULT_PROJECT_ANNOTATIONS,
+    exportsName
+  );
+}
+function composeStories(csfExports, projectAnnotations) {
+  return originalComposeStories(csfExports, projectAnnotations, composeStory);
+}
+
+export {
+  setProjectAnnotations,
+  INTERNAL_DEFAULT_PROJECT_ANNOTATIONS,
+  composeStory,
+  composeStories
+};

package/dist/_browser-chunks/chunk-MFMDGWP6.js

@@ -0,0 +1,34 @@
+import {
+  entry_preview_docs_exports
+} from "./chunk-5WMXI5GW.js";
+import {
+  entry_preview_argtypes_exports
+} from "./chunk-GNZY6LOW.js";
+import {
+  entry_preview_exports
+} from "./chunk-CFWWCCZV.js";
+
+// src/react/preview.tsx
+import { definePreview as definePreviewBase } from "@aussieljk/forkbook/internal/csf";
+function __definePreview(input) {
+  let preview = definePreviewBase({
+    ...input,
+    addons: [
+      entry_preview_exports,
+      entry_preview_argtypes_exports,
+      entry_preview_docs_exports,
+      ...input.addons ?? []
+    ]
+  }), defineMeta = preview.meta.bind(preview);
+  return preview.meta = (_input) => {
+    let meta = defineMeta(_input), defineStory = meta.story.bind(meta);
+    return meta.story = (__input) => {
+      let story = defineStory(__input);
+      return story.Component = story.__compose(), story;
+    }, meta;
+  }, preview;
+}
+
+export {
+  __definePreview
+};

package/dist/_browser-chunks/chunk-MLBOOZL4.js

@@ -0,0 +1,67 @@
+// src/component-testing/constants.ts
+var ADDON_ID = "@aussieljk/forkbook/interactions", PANEL_ID = `${ADDON_ID}/panel`, PARAM_KEY = "interactions", DOCUMENTATION_LINK = "writing-tests/integrations/vitest-addon", DOCUMENTATION_DISCREPANCY_LINK = `${DOCUMENTATION_LINK}#what-happens-when-there-are-different-test-results-in-multiple-environments`, DOCUMENTATION_PLAY_FUNCTION_LINK = "writing-stories/play-function#writing-stories-with-the-play-function", INTERNAL_RENDER_CALL_ID = "internal_render_call";
+
+// src/addon-vitest/constants.ts
+var ADDON_ID3 = "@aussieljk/forkbook/test", TEST_PROVIDER_ID = `${ADDON_ID3}/test-provider`, FORKBOOK_ADDON_TEST_CHANNEL = `${ADDON_ID3}/channel`;
+var DOCUMENTATION_LINK2 = "writing-tests/integrations/vitest-addon", DOCUMENTATION_FATAL_ERROR_LINK = `${DOCUMENTATION_LINK2}#what-happens-if-vitest-itself-has-an-error`;
+var storeOptions = {
+  id: ADDON_ID3,
+  initialState: {
+    config: {
+      coverage: !1,
+      a11y: !1
+    },
+    watching: !1,
+    cancelling: !1,
+    fatalError: void 0,
+    currentRun: {
+      triggeredBy: void 0,
+      config: {
+        coverage: !1,
+        a11y: !1
+      },
+      componentTestStatuses: [],
+      a11yStatuses: [],
+      a11yReports: {},
+      reports: {},
+      componentTestCount: {
+        success: 0,
+        error: 0
+      },
+      a11yCount: {
+        success: 0,
+        warning: 0,
+        error: 0
+      },
+      storyIds: void 0,
+      totalTestCount: void 0,
+      startedAt: void 0,
+      finishedAt: void 0,
+      unhandledErrors: [],
+      coverageSummary: void 0
+    }
+  }
+}, FULL_RUN_TRIGGERS = ["global", "run-all"], STORE_CHANNEL_EVENT_NAME = `UNIVERSAL_STORE:${storeOptions.id}`;
+var STORY_INDEX_CHANNEL_EVENT_NAME = `${ADDON_ID3}/story-index`, STATUS_TYPE_ID_COMPONENT_TEST = "@aussieljk/forkbook/component-test", STATUS_TYPE_ID_A11Y = "@aussieljk/forkbook/a11y", FORKBOOK_TEST_PROVIDE_KEY = "@aussieljk/forkbook/test-provided", FORKBOOK_CORE_GHOST_STORIES_PROVIDE_KEY = "@aussieljk/forkbook/core-ghost-stories", FORKBOOK_CORE_RENDER_ANALYSIS_PROVIDE_KEY = "@aussieljk/forkbook/core-render-analysis", FORKBOOK_TEST_INITIAL_GLOBALS_PROVIDE_KEY = "@aussieljk/forkbook/test-initial-globals", FORKBOOK_TEST_FEATURES_PROVIDE_KEY = "@aussieljk/forkbook/test-features", TRIGGER_TEST_RUN_REQUEST = `${ADDON_ID3}/trigger-test-run-request`, TRIGGER_TEST_RUN_RESPONSE = `${ADDON_ID3}/trigger-test-run-response`;
+
+export {
+  ADDON_ID,
+  PANEL_ID,
+  PARAM_KEY,
+  DOCUMENTATION_DISCREPANCY_LINK,
+  DOCUMENTATION_PLAY_FUNCTION_LINK,
+  INTERNAL_RENDER_CALL_ID,
+  ADDON_ID3 as ADDON_ID2,
+  TEST_PROVIDER_ID,
+  FORKBOOK_ADDON_TEST_CHANNEL,
+  DOCUMENTATION_FATAL_ERROR_LINK,
+  storeOptions,
+  FULL_RUN_TRIGGERS,
+  STATUS_TYPE_ID_COMPONENT_TEST,
+  STATUS_TYPE_ID_A11Y,
+  FORKBOOK_TEST_PROVIDE_KEY,
+  FORKBOOK_CORE_GHOST_STORIES_PROVIDE_KEY,
+  FORKBOOK_CORE_RENDER_ANALYSIS_PROVIDE_KEY,
+  FORKBOOK_TEST_INITIAL_GLOBALS_PROVIDE_KEY,
+  FORKBOOK_TEST_FEATURES_PROVIDE_KEY
+};

package/dist/_browser-chunks/chunk-NQUD4B7H.js

@@ -0,0 +1,91 @@
+// src/measure/constants.ts
+var ADDON_ID = "@aussieljk/forkbook/measure-addon", TOOL_ID = `${ADDON_ID}/tool`, PARAM_KEY = "measureEnabled", EVENTS = {
+  RESULT: `${ADDON_ID}/result`,
+  REQUEST: `${ADDON_ID}/request`,
+  CLEAR: `${ADDON_ID}/clear`
+};
+
+// src/outline/constants.ts
+var ADDON_ID2 = "@aussieljk/forkbook/outline", PARAM_KEY2 = "outline";
+
+// src/shared/open-service/services/docgen/definition.ts
+import * as v from "valibot";
+import { defineService } from "@aussieljk/forkbook/open-service";
+
+// src/shared/open-service/services/docgen/paths.ts
+function docgenQueryStaticPath(id) {
+  return `${id}.json`;
+}
+
+// src/shared/open-service/services/docgen/definition.ts
+var docgenInputSchema = v.object({ id: v.string() }), argTypesSchema = v.custom(
+  (value) => typeof value == "object" && value !== null && !Array.isArray(value)
+), docgenErrorSchema = v.object({
+  name: v.string(),
+  message: v.string()
+}), docgenJsDocTagsSchema = v.record(v.string(), v.array(v.string())), docgenComponentFields = {
+  name: v.string(),
+  path: v.string(),
+  description: v.optional(v.string()),
+  summary: v.optional(v.string()),
+  jsDocTags: docgenJsDocTagsSchema,
+  argTypes: v.optional(argTypesSchema),
+  error: v.optional(docgenErrorSchema)
+}, docgenSubcomponentFields = {
+  ...docgenComponentFields,
+  import: v.optional(v.string())
+}, docgenSubcomponentSchema = v.looseObject(docgenSubcomponentFields), docgenPayloadSchema = v.looseObject({
+  id: v.string(),
+  ...docgenComponentFields,
+  subcomponents: v.optional(v.record(v.string(), docgenSubcomponentSchema))
+}), docgenOutputSchema = v.optional(docgenPayloadSchema), docgenServiceDef = defineService({
+  id: "core/docgen",
+  internal: !0,
+  description: "Component documentation (name, description, props, JSDoc tags) keyed by component id.",
+  initialState: { components: {} },
+  queries: {
+    docgen: {
+      description: "Returns the docgen payload for one component id, or undefined when not loaded.",
+      input: docgenInputSchema,
+      output: docgenOutputSchema,
+      handler: (input, ctx) => ctx.self.state.components[input.id],
+      load: async (input, ctx) => {
+        await ctx.self.commands.extractDocgen(input);
+      },
+      staticPath: (input) => docgenQueryStaticPath(input.id)
+    },
+    docgenForAllComponents: {
+      description: "Returns docgen payloads for every component in the story index.",
+      input: v.void(),
+      output: v.record(v.string(), docgenPayloadSchema),
+      handler: (_input, ctx) => ctx.self.state.components,
+      load: async (_input, ctx) => {
+        await ctx.self.commands.extractAllDocgen(void 0);
+      }
+    }
+  },
+  commands: {
+    extractDocgen: {
+      description: "Resolves the story entry for a component id, runs the registered provider chain, writes the result into state, and returns it (or undefined when no provider produced docgen).",
+      input: docgenInputSchema,
+      output: docgenOutputSchema
+      // Handler is supplied at registration time so it can close over the story index and the
+      // composed experimental_docgenProvider chain.
+    },
+    extractAllDocgen: {
+      description: "Extracts docgen for every component id in the story index by invoking `extractDocgen` for each.",
+      input: v.undefined(),
+      output: v.void()
+      // Handler is supplied at registration time so it can close over the story index.
+    }
+  }
+});
+
+export {
+  ADDON_ID,
+  TOOL_ID,
+  PARAM_KEY,
+  ADDON_ID2,
+  PARAM_KEY2,
+  docgenServiceDef
+};

package/dist/_browser-chunks/chunk-NULBREPZ.js

@@ -0,0 +1,43 @@
+// src/csf/toStartCaseStr.ts
+function toStartCaseStr(str) {
+  return str.replace(/_/g, " ").replace(/-/g, " ").replace(/\./g, " ").replace(/([^\n])([A-Z])([a-z])/g, (str2, $1, $2, $3) => `${$1} ${$2}${$3}`).replace(/([a-z])([A-Z])/g, (str2, $1, $2) => `${$1} ${$2}`).replace(/([a-z])([0-9])/gi, (str2, $1, $2) => `${$1} ${$2}`).replace(/([0-9])([a-z])/gi, (str2, $1, $2) => `${$1} ${$2}`).replace(/(\s|^)(\w)/g, (str2, $1, $2) => `${$1}${$2.toUpperCase()}`).replace(/ +/g, " ").trim();
+}
+
+// src/csf/export-story.ts
+function matches(storyKey, arrayOrRegex) {
+  return Array.isArray(arrayOrRegex) ? arrayOrRegex.includes(storyKey) : storyKey.match(arrayOrRegex);
+}
+var storyNameFromExport = (key) => toStartCaseStr(key);
+function isExportStory(key, { includeStories, excludeStories }) {
+  return (
+    // Babel's CommonJS interop adds __esModule; it is not a CSF story export.
+    key !== "__esModule" && (!includeStories || matches(key, includeStories)) && (!excludeStories || !matches(key, excludeStories))
+  );
+}
+
+// src/csf/csf-utils.ts
+var sanitize = (string) => string.toLowerCase().replace(/[ ’–—―′¿'`~!@#$%^&*()_|+\-=?;:'",.<>\{\}\[\]\\\/]/gi, "-").replace(/-+/g, "-").replace(/^-+/, "").replace(/-+$/, ""), sanitizeSafe = (string, part) => {
+  let sanitized = sanitize(string);
+  if (sanitized === "")
+    throw new Error(`Invalid ${part} '${string}', must include alphanumeric characters`);
+  return sanitized;
+}, toId = (kind, name) => `${sanitizeSafe(kind, "kind")}${name ? `--${sanitizeSafe(name, "name")}` : ""}`, toTestId = (parentId, testName) => `${parentId}:${sanitizeSafe(testName, "test")}`, parseKind = (kind, { rootSeparator, groupSeparator }) => {
+  let [root, remainder] = kind.split(rootSeparator, 2), groups = (remainder || kind).split(groupSeparator).filter((i) => !!i);
+  return {
+    root: remainder ? root : null,
+    groups
+  };
+}, combineTags = (...tags) => {
+  let result = tags.reduce((acc, tag) => (tag.startsWith("!") ? acc.delete(tag.slice(1)) : acc.add(tag), acc), /* @__PURE__ */ new Set());
+  return Array.from(result);
+};
+
+export {
+  storyNameFromExport,
+  isExportStory,
+  sanitize,
+  toId,
+  toTestId,
+  parseKind,
+  combineTags
+};

package/dist/_browser-chunks/chunk-NZMVUW5T.js

@@ -0,0 +1,7 @@
+// ../../node_modules/es-toolkit/dist/function/noop.mjs
+function noop() {
+}
+
+export {
+  noop
+};

package/dist/_browser-chunks/chunk-OD6IBQCC.js

@@ -0,0 +1,117 @@
+// src/channels/main.ts
+var isMulti = (args) => args.transports !== void 0, generateRandomId = () => Math.random().toString(16).slice(2), Channel = class {
+  constructor(input = {}) {
+    this.sender = generateRandomId();
+    this.events = {};
+    this.data = {};
+    this.transports = [];
+    this.isAsync = input.async || !1, isMulti(input) ? (this.transports = input.transports || [], this.transports.forEach((t) => {
+      t.setHandler((event) => this.handleEvent(event));
+    })) : this.transports = input.transport ? [input.transport] : [], this.transports.forEach((t) => {
+      t.setHandler((event) => this.handleEvent(event));
+    });
+  }
+  get hasTransport() {
+    return this.transports.length > 0;
+  }
+  addListener(eventName, listener) {
+    this.events[eventName] = this.events[eventName] || [], this.events[eventName].push(listener);
+  }
+  emit(eventName, ...args) {
+    let event = { type: eventName, args, from: this.sender }, options = {};
+    args.length >= 1 && args[0] && args[0].options && (options = args[0].options);
+    let handler = () => {
+      this.transports.forEach((t) => {
+        t.send(event, options);
+      }), this.handleEvent(event);
+    };
+    this.isAsync ? setImmediate(handler) : handler();
+  }
+  last(eventName) {
+    return this.data[eventName];
+  }
+  eventNames() {
+    return Object.keys(this.events);
+  }
+  listenerCount(eventName) {
+    let listeners = this.listeners(eventName);
+    return listeners ? listeners.length : 0;
+  }
+  listeners(eventName) {
+    return this.events[eventName] || void 0;
+  }
+  once(eventName, listener) {
+    let onceListener = this.onceListener(eventName, listener);
+    this.addListener(eventName, onceListener);
+  }
+  removeAllListeners(eventName) {
+    eventName ? this.events[eventName] && delete this.events[eventName] : this.events = {};
+  }
+  removeListener(eventName, listener) {
+    let listeners = this.listeners(eventName);
+    listeners && (this.events[eventName] = listeners.filter((l) => l !== listener));
+  }
+  on(eventName, listener) {
+    this.addListener(eventName, listener);
+  }
+  off(eventName, listener) {
+    this.removeListener(eventName, listener);
+  }
+  /**
+   * Deliver an event to local listeners without sending it to this channel's transports.
+   */
+  receive(event) {
+    this.handleEvent(event);
+  }
+  handleEvent(event) {
+    let listeners = this.listeners(event.type);
+    listeners && listeners.length && listeners.forEach((fn) => {
+      fn.apply(event, event.args);
+    }), this.data[event.type] = event.args;
+  }
+  onceListener(eventName, listener) {
+    let onceListener = (...args) => (this.removeListener(eventName, onceListener), listener(...args));
+    return onceListener;
+  }
+};
+
+// src/channels/channel-slot.ts
+var channel;
+function syncGlobalSlot(next) {
+  globalThis.__STORYBOOK_ADDONS_CHANNEL__ = next;
+}
+function getChannel() {
+  let fromGlobal = globalThis.__STORYBOOK_ADDONS_CHANNEL__;
+  return fromGlobal && (channel = fromGlobal), channel ?? null;
+}
+function requireChannel() {
+  let installed = getChannel();
+  if (!installed)
+    throw new Error(
+      "Forkbook addons channel is not installed in this runtime. Install it via setChannel() or addons.setChannel() at the runtime entry point before registering services or emitting events."
+    );
+  return installed;
+}
+function setChannel(next) {
+  channel = next ?? void 0, syncGlobalSlot(channel);
+}
+function clearChannel() {
+  setChannel(null);
+}
+function installNoopChannel() {
+  setChannel(new Channel({}));
+}
+function ensureChannel() {
+  getChannel() || installNoopChannel();
+}
+typeof window > "u" && ensureChannel();
+
+export {
+  Channel,
+  getChannel,
+  requireChannel,
+  setChannel,
+  clearChannel,
+  installNoopChannel,
+  ensureChannel
+};

package/dist/_browser-chunks/chunk-ODVJ3XZJ.js

@@ -0,0 +1,157 @@
+import {
+  mapValues,
+  pickBy
+} from "./chunk-2JDQ35OA.js";
+import {
+  isPlainObject
+} from "./chunk-JWSKPMPC.js";
+
+// src/preview-api/modules/store/parameters.ts
+var combineParameters = (...parameterSets) => {
+  let mergeKeys = {}, definedParametersSets = parameterSets.filter(Boolean), combined = definedParametersSets.reduce((acc, parameters) => (Object.entries(parameters).forEach(([key, value]) => {
+    let existing = acc[key];
+    Array.isArray(value) || typeof existing > "u" ? acc[key] = value : isPlainObject(value) && isPlainObject(existing) ? mergeKeys[key] = !0 : typeof value < "u" && (acc[key] = value);
+  }), acc), {});
+  return Object.keys(mergeKeys).forEach((key) => {
+    let mergeValues = definedParametersSets.filter(Boolean).map((p) => p[key]).filter((value) => typeof value < "u");
+    mergeValues.every((value) => isPlainObject(value)) ? combined[key] = combineParameters(...mergeValues) : combined[key] = mergeValues[mergeValues.length - 1];
+  }), combined;
+};
+
+// src/preview-api/modules/store/filterArgTypes.ts
+var matches = (name, descriptor) => Array.isArray(descriptor) ? descriptor.includes(name) : name.match(descriptor), filterArgTypes = (argTypes, include, exclude) => !include && !exclude ? argTypes : argTypes && pickBy(argTypes, (argType, key) => {
+  let name = argType.name || key.toString();
+  return !!(!include || matches(name, include)) && (!exclude || !matches(name, exclude));
+});
+
+// src/preview-api/modules/store/inferControls.ts
+import { logger } from "@aussieljk/forkbook/internal/client-logger";
+var inferControl = (argType, name, matchers) => {
+  let { type, options } = argType;
+  if (type) {
+    if (matchers.color && matchers.color.test(name)) {
+      let controlType = type.name;
+      if (controlType === "string")
+        return { control: { type: "color" } };
+      controlType !== "enum" && logger.warn(
+        `Addon controls: Control of type color only supports string, received "${controlType}" instead`
+      );
+    }
+    if (matchers.date && matchers.date.test(name))
+      return { control: { type: "date" } };
+    switch (type.name) {
+      case "array":
+        return { control: { type: "object" } };
+      case "boolean":
+        return { control: { type: "boolean" } };
+      case "string":
+        return { control: { type: "text" } };
+      case "number":
+        return { control: { type: "number" } };
+      case "enum": {
+        let { value } = type;
+        return { control: { type: value?.length <= 5 ? "radio" : "select" }, options: value };
+      }
+      case "function":
+      case "symbol":
+        return null;
+      default:
+        return { control: { type: options ? "select" : "object" } };
+    }
+  }
+}, inferControls = (context) => {
+  let {
+    argTypes,
+    parameters: { __isArgsStory, controls: { include = null, exclude = null, matchers = {} } = {} }
+  } = context;
+  if (!__isArgsStory)
+    return argTypes;
+  let filteredArgTypes = filterArgTypes(argTypes, include, exclude), withControls = mapValues(filteredArgTypes, (argType, name) => argType?.type && inferControl(argType, name.toString(), matchers));
+  return combineParameters(withControls, filteredArgTypes);
+};
+inferControls.secondPass = !0;
+
+// src/preview-api/modules/store/inferArgTypes.ts
+import { logger as logger2 } from "@aussieljk/forkbook/internal/client-logger";
+import { dedent } from "ts-dedent";
+var inferType = (value, name, visited, cache) => {
+  let type = typeof value;
+  switch (type) {
+    case "boolean":
+    case "string":
+    case "number":
+    case "function":
+    case "symbol":
+      return { name: type };
+    default:
+      break;
+  }
+  if (value) {
+    if (cache.has(value))
+      return cache.get(value);
+    if (visited.has(value))
+      return logger2.warn(dedent`
+        We've detected a cycle in arg '${name}'. Args should be JSON-serializable.
+
+        Consider using the mapping feature or fully custom args:
+        - Mapping: https://storybook.js.org/docs/writing-stories/args#mapping-to-complex-arg-values
+        - Custom args: https://storybook.js.org/docs/essentials/controls#fully-custom-args
+      `), { name: "other", value: "cyclic object" };
+    visited.add(value);
+    let result;
+    return Array.isArray(value) ? result = { name: "array", value: value.length > 0 ? inferType(value[0], name, visited, cache) : { name: "other", value: "unknown" } } : result = { name: "object", value: mapValues(value, (field) => inferType(field, name, visited, cache)) }, visited.delete(value), cache.set(value, result), result;
+  }
+  return { name: "object", value: {} };
+}, inferArgTypes = (context) => {
+  let { id, argTypes: userArgTypes = {}, initialArgs = {} } = context, cache = /* @__PURE__ */ new Map(), argTypes = Object.fromEntries(
+    Object.entries(initialArgs).filter(([key]) => !userArgTypes[key]?.type).map(([key, arg]) => [
+      key,
+      {
+        name: key,
+        type: inferType(arg, `${id}.${key}`, /* @__PURE__ */ new Set(), cache)
+      }
+    ])
+  ), userArgTypesNames = mapValues(userArgTypes, (argType, key) => ({
+    name: key
+  }));
+  return combineParameters(argTypes, userArgTypesNames, userArgTypes);
+};
+inferArgTypes.secondPass = !0;
+
+// src/docs-tools/argTypes/docgenServiceArgTypes.ts
+function mergeServiceArgTypes({
+  payload,
+  storyId,
+  parameters,
+  initialArgs,
+  customArgTypes
+}) {
+  let merged = combineParameters(payload?.argTypes ?? {}, customArgTypes ?? {}), withInferredTypes = inferArgTypes({
+    id: storyId,
+    argTypes: merged,
+    initialArgs: initialArgs ?? {}
+  });
+  return inferControls({
+    argTypes: withInferredTypes,
+    // The manager can render this before the preview reports `storyPrepared`, so `parameters` may be
+    // undefined; `inferControls` reads `parameters.__isArgsStory` and would throw. An empty object
+    // makes it a no-op until prepared parameters arrive and trigger a re-render.
+    parameters: parameters ?? {}
+  });
+}
+function getServiceSubcomponentArgTypes(payload) {
+  return Object.fromEntries(
+    Object.entries(payload.subcomponents ?? {}).flatMap(
+      ([name, subcomponent]) => subcomponent.argTypes ? [[name, subcomponent.argTypes]] : []
+    )
+  );
+}
+
+export {
+  combineParameters,
+  inferArgTypes,
+  filterArgTypes,
+  inferControls,
+  mergeServiceArgTypes,
+  getServiceSubcomponentArgTypes
+};