@jfrader/storybook-docs 0.0.0-stage → 0.4.3

package/dist/vite-plugin.js

@@ -0,0 +1,697 @@
+// src/vite-plugin.ts
+import { readFileSync as readFileSync3, realpathSync } from "node:fs";
+import path7 from "node:path";
+
+// src/build/catalog.ts
+import { existsSync } from "node:fs";
+import path2 from "node:path";
+
+// src/scan.ts
+import { readdirSync, readFileSync } from "node:fs";
+import path from "node:path";
+function matchGlob(pattern, candidate) {
+  const patternParts = pattern.split("/");
+  const candidateParts = candidate.split("/");
+  const segmentRegExp = (segment) => new RegExp(`^${segment.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*/g, "[^/]*")}$`);
+  const walk = (patternIndex, candidateIndex) => {
+    if (patternIndex === patternParts.length) return candidateIndex === candidateParts.length;
+    const patternPart = patternParts[patternIndex];
+    if (patternPart === "**") {
+      for (let skip = candidateIndex; skip <= candidateParts.length; skip += 1) {
+        if (walk(patternIndex + 1, skip)) return true;
+      }
+      return false;
+    }
+    if (candidateIndex >= candidateParts.length) return false;
+    if (segmentRegExp(patternPart ?? "").test(candidateParts[candidateIndex] ?? "")) {
+      return walk(patternIndex + 1, candidateIndex + 1);
+    }
+    return false;
+  };
+  return walk(0, 0);
+}
+function collectMatches(rootDir, pattern) {
+  const matches = [];
+  const visit = (directory) => {
+    for (const entry of readdirSync(directory, { withFileTypes: true })) {
+      const full = path.join(directory, entry.name);
+      if (entry.isDirectory()) {
+        visit(full);
+        continue;
+      }
+      const relative = path.relative(rootDir, full).split(path.sep).join("/");
+      if (matchGlob(pattern, relative)) matches.push(full);
+    }
+  };
+  visit(rootDir);
+  return matches.sort();
+}
+function extractTitle(source) {
+  const metaStart = source.search(/\bconst\s+meta\b/);
+  if (metaStart >= 0) {
+    const rest = source.slice(metaStart);
+    const end = rest.search(/export\s+default\s+meta|satisfies\s+Meta|\)\s*;\s*$/m);
+    const scope = end >= 0 ? rest.slice(0, end) : rest.slice(0, 6e3);
+    const scoped = scope.match(/title:\s*'([^']+)'/) ?? scope.match(/title:\s*"([^"]+)"/);
+    if (scoped?.[1]) return scoped[1];
+  }
+  const anywhere = source.match(/title:\s*'([^']+)'/) ?? source.match(/title:\s*"([^"]+)"/);
+  return anywhere?.[1] ?? null;
+}
+function readStoryFile(file) {
+  const source = readFileSync(file, "utf8");
+  const title = extractTitle(source);
+  if (!title) return null;
+  const stories = [...source.matchAll(/^export const ([A-Za-z0-9_]+)/gm)].map((match) => match[1] ?? "");
+  return { title, stories, hasComponent: /component:\s*\w+/.test(source) };
+}
+var toKebab = (value) => value.replace(/([a-z0-9])([A-Z])/g, "$1-$2").replace(/[^a-zA-Z0-9]+/g, "-").replace(/^-|-$/g, "").toLowerCase();
+function storyIdentity(file, title) {
+  const [group = "Components", ...leaf] = title.split("/");
+  const filename = path.basename(file).replace(/\.stories\.[^.]+$/, "");
+  return { group, name: leaf.join("/") || filename, slug: toKebab(filename) };
+}
+
+// src/build/module-ids.ts
+var VIRTUAL_PREFIX = "virtual:storybook-docs/";
+var FILE_PREFIX = "storybook-docs-file:";
+
+// src/build/catalog.ts
+var DEFAULT_GROUP_ORDER = [
+  "Getting started",
+  "Foundations",
+  "Actions",
+  "Forms",
+  "Inputs",
+  "Data display",
+  "Feedback",
+  "Navigation",
+  "Surfaces",
+  "Pickers",
+  "Layout",
+  "Content",
+  "Components"
+];
+function resolveStoryRoot(from, root) {
+  if (from.startsWith(".") || path2.isAbsolute(from)) {
+    const resolved = path2.resolve(root, from);
+    if (!existsSync(resolved)) {
+      throw new Error(`storybook-docs: story root "${from}" does not exist (looked in ${resolved})`);
+    }
+    return resolved;
+  }
+  let dir = root;
+  for (; ; ) {
+    const candidate = path2.join(dir, "node_modules", from);
+    if (existsSync(candidate)) return candidate;
+    const parent = path2.dirname(dir);
+    if (parent === dir) {
+      throw new Error(`storybook-docs: package "${from}" is not installed from ${root}`);
+    }
+    dir = parent;
+  }
+}
+function scanStories(config, root) {
+  const stories = [];
+  for (const file of collectMatches(resolveStoryRoot(config.from, root), config.pattern)) {
+    const facts = readStoryFile(file);
+    if (facts) stories.push({ file, facts });
+  }
+  return stories;
+}
+function buildCatalog(stories, groupsConfig) {
+  const rename = groupsConfig?.rename ?? {};
+  const order = groupsConfig?.order ?? DEFAULT_GROUP_ORDER;
+  const entries = [];
+  const files = /* @__PURE__ */ new Map();
+  for (const { file, facts } of stories) {
+    const { group: authoredGroup, name, slug } = storyIdentity(file, facts.title);
+    if (files.has(slug)) {
+      throw new Error(`storybook-docs: duplicate story slug "${slug}" in "${files.get(slug)}" and "${file}"`);
+    }
+    files.set(slug, file);
+    entries.push({
+      slug,
+      name,
+      group: rename[authoredGroup] ?? authoredGroup,
+      storybookTitle: facts.title,
+      stories: facts.stories,
+      hasComponent: facts.hasComponent,
+      load: () => import(
+        /* @vite-ignore */
+        `${FILE_PREFIX}${file}`
+      )
+    });
+  }
+  entries.sort((a, b) => {
+    const indexA = order.indexOf(a.group);
+    const indexB = order.indexOf(b.group);
+    if (indexA !== indexB) return (indexA === -1 ? 99 : indexA) - (indexB === -1 ? 99 : indexB);
+    return a.name.localeCompare(b.name);
+  });
+  const groups = [...new Set(entries.map((entry) => entry.group))].sort((a, b) => {
+    const indexA = order.indexOf(a);
+    const indexB = order.indexOf(b);
+    return (indexA === -1 ? 99 : indexA) - (indexB === -1 ? 99 : indexB);
+  });
+  return {
+    entries,
+    groups,
+    files,
+    stats: {
+      components: entries.length,
+      stories: entries.reduce((total, entry) => total + entry.stories.length, 0),
+      groups: groups.length
+    }
+  };
+}
+function catalogCode(catalog) {
+  const resolveStoryFile = (entry) => {
+    const found = catalog.files.get(entry.slug);
+    if (!found) throw new Error(`storybook-docs: no file resolved for "${entry.slug}"`);
+    return found;
+  };
+  return `
+export const catalog = [
+${catalog.entries.map(
+    (entry) => `  { slug: ${JSON.stringify(entry.slug)}, name: ${JSON.stringify(entry.name)}, group: ${JSON.stringify(entry.group)}, storybookTitle: ${JSON.stringify(entry.storybookTitle)}, hasComponent: ${entry.hasComponent}, stories: ${JSON.stringify(entry.stories)}, load: () => import(${JSON.stringify(`${FILE_PREFIX}${resolveStoryFile(entry)}`)}) },`
+  ).join("\n")}
+];
+export const groups = ${JSON.stringify(catalog.groups)};
+export const stats = ${JSON.stringify(catalog.stats)};
+`;
+}
+
+// src/config.ts
+var THEME_ROLES = [
+  "bg",
+  "surface",
+  "surfaceRaised",
+  "surfaceHover",
+  "border",
+  "borderSubtle",
+  "text",
+  "textMuted",
+  "textSubtle",
+  "accent",
+  "accentText",
+  "accentSoft",
+  "accentContrast",
+  "danger",
+  "dangerText",
+  "success",
+  "focusRing"
+];
+
+// src/build/site.ts
+function siteCode(config) {
+  const hasTokens = Boolean(config.tokens?.varsModule);
+  const pages = {
+    overview: config.pages?.overview ?? true,
+    api: config.pages?.api ?? true,
+    color: (config.pages?.color ?? true) && hasTokens,
+    typography: (config.pages?.typography ?? true) && hasTokens,
+    spacing: (config.pages?.spacing ?? true) && hasTokens,
+    effects: (config.pages?.effects ?? true) && hasTokens
+  };
+  const theme = {
+    attribute: config.theme?.attribute ?? "data-theme",
+    values: config.theme?.values ?? ["dark", "light"],
+    vars: config.theme?.vars ?? {}
+  };
+  const themeCss = Object.entries(theme.vars).filter(([role]) => THEME_ROLES.includes(role)).map(([role, reference]) => `  --sd-${role.replace(/[A-Z]/g, (c) => `-${c.toLowerCase()}`)}: ${reference};`).join("\n");
+  return `
+export const site = ${JSON.stringify(config.site)};
+export const theme = ${JSON.stringify(theme)};
+export const pages = ${JSON.stringify(pages)};
+export const hasTokens = ${JSON.stringify(hasTokens)};
+export const themeCss = ${JSON.stringify(themeCss ? `:root {
+${themeCss}
+}` : "")};
+`;
+}
+
+// src/build/tokens.ts
+function tokensCode(tokens) {
+  if (!tokens?.varsModule) return `export const vars = {};`;
+  const named = tokens.varsExport ?? "vars";
+  return `export { ${named} as vars } from ${JSON.stringify(tokens.varsModule)};`;
+}
+
+// src/build/global-styles.ts
+function globalStylesCode(engineStyles, css = []) {
+  const imports = [
+    `import ${JSON.stringify(`${FILE_PREFIX}${engineStyles}`)};`,
+    ...css.map((specifier) => `import ${JSON.stringify(specifier)};`)
+  ];
+  return imports.join("\n");
+}
+
+// src/build/props.ts
+import { readdirSync as readdirSync2 } from "node:fs";
+import path3 from "node:path";
+import { withCompilerOptions } from "react-docgen-typescript";
+import ts from "typescript";
+function compareProps(a, b) {
+  return Number(Boolean(a.inheritedFrom)) - Number(Boolean(b.inheritedFrom)) || Number(b.required) - Number(a.required) || a.name.localeCompare(b.name);
+}
+var isExternal = (fileName) => /(^|\/)node_modules\/(@types|typescript)(\/|$)/.test(fileName);
+var DOCGEN_COMPILER_OPTIONS = {
+  jsx: ts.JsxEmit.React,
+  module: ts.ModuleKind.CommonJS,
+  target: ts.ScriptTarget.Latest,
+  esModuleInterop: true
+};
+var TYPE_PROPS_COMPILER_OPTIONS = {
+  jsx: ts.JsxEmit.ReactJSX,
+  target: ts.ScriptTarget.ES2022,
+  module: ts.ModuleKind.ESNext,
+  moduleResolution: ts.ModuleResolutionKind.Bundler,
+  skipLibCheck: true,
+  strict: true
+};
+var docgen = withCompilerOptions(DOCGEN_COMPILER_OPTIONS, {
+  savePropValueAsString: true,
+  shouldExtractLiteralValuesFromEnum: true,
+  shouldRemoveUndefinedFromOptional: true,
+  skipChildrenPropWithoutDoc: false,
+  // Keep the component's own props (and its local types); drop inherited DOM/React props and
+  // the utility-type plumbing that TypeScript's own libs and DefinitelyTyped add. The check is
+  // by *package*, not by "contains node_modules" — when a design system is consumed from
+  // node_modules, that path test would drop every prop.
+  propFilter: (prop) => !isExternal(prop.parent?.fileName ?? "")
+});
+function toPropDoc(prop) {
+  const value = prop;
+  const declared = value.defaultValue;
+  const raw = declared !== null && typeof declared === "object" ? declared.value : declared;
+  const text = declared === null || raw === void 0 || raw === "undefined" ? null : typeof raw === "object" ? JSON.stringify(raw) ?? null : String(raw);
+  return {
+    name: value.name,
+    type: value.type?.name === "enum" && Array.isArray(value.type.value) ? value.type.value.map((option) => option.value).join(" | ") : value.type?.name ?? "unknown",
+    typeUnavailable: !value.type?.name,
+    required: Boolean(value.required),
+    defaultValue: text !== null && (value.type?.name === "string" || value.type?.value?.some((option) => option.value === JSON.stringify(text))) ? JSON.stringify(text) : text,
+    description: value.description ?? ""
+  };
+}
+function createPropsCollector() {
+  let isBuild = false;
+  const programCaches = /* @__PURE__ */ new Map();
+  const createPropsProgram = (sources, compilerOptions) => {
+    if (!isBuild) return ts.createProgram(sources, compilerOptions);
+    let cache = programCaches.get(compilerOptions);
+    if (!cache) {
+      const host = ts.createCompilerHost(compilerOptions);
+      const getSourceFile = host.getSourceFile;
+      const sourceFiles = /* @__PURE__ */ new Map();
+      host.getSourceFile = (fileName, languageVersion, onError, shouldCreateNewSourceFile) => {
+        const key = host.getCanonicalFileName(fileName);
+        const cached = sourceFiles.get(key);
+        if (cached && !shouldCreateNewSourceFile) return cached;
+        const source = getSourceFile(fileName, languageVersion, onError, shouldCreateNewSourceFile);
+        if (source) sourceFiles.set(key, source);
+        return source;
+      };
+      cache = { host };
+      programCaches.set(compilerOptions, cache);
+    }
+    cache.program = ts.createProgram(sources, compilerOptions, cache.host, cache.program);
+    return cache.program;
+  };
+  const collect = (storyFile, entryName, slug) => {
+    if (storyFile) {
+      const directory = path3.dirname(storyFile);
+      const sources = readdirSync2(directory).filter((file) => /\.tsx?$/.test(file) && !file.endsWith(".stories.tsx")).map((file) => path3.join(directory, file));
+      if (sources.length > 0) {
+        try {
+          const parsed = docgen.parseWithProgramProvider(sources, () => createPropsProgram(sources, DOCGEN_COMPILER_OPTIONS)).map((result) => ({
+            name: result.displayName,
+            props: Object.values(result.props ?? {}).map(toPropDoc).sort(compareProps)
+          })).filter((component) => component.props.length > 0);
+          const matchesOwnName = (name) => entryName.length > 0 && name.toLowerCase().startsWith(entryName.toLowerCase());
+          const relevant = parsed.some((component) => matchesOwnName(component.name)) ? parsed.filter((component) => matchesOwnName(component.name)) : parsed;
+          const typed = collectTypeProps(sources, entryName);
+          return mergePropsTables(typed.length > 0 ? [...relevant.filter((table) => typed.some((item) => item.name === table.name)), ...typed] : relevant);
+        } catch (cause) {
+          console.warn(`storybook-docs: could not read props for "${slug}" (${String(cause)})`);
+        }
+      }
+    }
+    return [];
+  };
+  const collectTypeProps = (sources, entryName) => {
+    const program = createPropsProgram(sources, TYPE_PROPS_COMPILER_OPTIONS);
+    const checker = program.getTypeChecker();
+    const tables = [];
+    const unresolved = /* @__PURE__ */ Symbol("unresolved");
+    const literalValue = (node, seen = /* @__PURE__ */ new Set()) => {
+      if (seen.has(node)) return unresolved;
+      const visited = new Set(seen).add(node);
+      if (ts.isStringLiteral(node) || ts.isNoSubstitutionTemplateLiteral(node)) return node.text;
+      if (ts.isNumericLiteral(node)) return Number(node.text);
+      if (node.kind === ts.SyntaxKind.TrueKeyword) return true;
+      if (node.kind === ts.SyntaxKind.FalseKeyword) return false;
+      if (node.kind === ts.SyntaxKind.NullKeyword) return null;
+      if (ts.isParenthesizedExpression(node) || ts.isAsExpression(node) || ts.isSatisfiesExpression(node)) return literalValue(node.expression, visited);
+      if (ts.isIdentifier(node)) {
+        const symbol = checker.getSymbolAtLocation(node);
+        const target = symbol && (symbol.flags & ts.SymbolFlags.Alias ? checker.getAliasedSymbol(symbol) : symbol);
+        const declaration = target?.valueDeclaration;
+        if (declaration && ts.isVariableDeclaration(declaration) && declaration.initializer && ts.isVariableDeclarationList(declaration.parent) && declaration.parent.flags & ts.NodeFlags.Const) {
+          return literalValue(declaration.initializer, visited);
+        }
+      }
+      if (ts.isPrefixUnaryExpression(node) && ts.isNumericLiteral(node.operand)) {
+        if (node.operator === ts.SyntaxKind.MinusToken) return -Number(node.operand.text);
+        if (node.operator === ts.SyntaxKind.PlusToken) return Number(node.operand.text);
+      }
+      if (ts.isArrayLiteralExpression(node)) {
+        const values = node.elements.map((element) => literalValue(element, visited));
+        return values.includes(unresolved) ? unresolved : values;
+      }
+      if (ts.isObjectLiteralExpression(node)) {
+        const entries = [];
+        for (const property of node.properties) {
+          if (!ts.isPropertyAssignment(property) || ts.isComputedPropertyName(property.name)) return unresolved;
+          const value = literalValue(property.initializer, visited);
+          if (value === unresolved) return unresolved;
+          entries.push([property.name.text, value]);
+        }
+        return Object.fromEntries(entries);
+      }
+      return unresolved;
+    };
+    const describeProps = (type, location, depth = 0) => checker.getPropertiesOfType(type).filter((symbol) => symbol.getName() !== "key").map((symbol) => {
+      const declaration = symbol.valueDeclaration ?? symbol.declarations?.[0];
+      const propType = checker.getTypeOfSymbolAtLocation(symbol, declaration ?? location);
+      const optional = (symbol.flags & ts.SymbolFlags.Optional) !== 0;
+      const typeFlags = ts.TypeFormatFlags.NoTruncation | ts.TypeFormatFlags.UseAliasDefinedOutsideCurrentScope;
+      const literalUnion = propType.isUnion() && propType.types.every((part) => Boolean(part.flags & (ts.TypeFlags.Literal | ts.TypeFlags.Null | ts.TypeFlags.Undefined)));
+      const printedType = checker.typeToString(propType, void 0, typeFlags);
+      const displayType = literalUnion && propType.isUnion() ? propType.types.filter((part) => !optional || !(part.flags & ts.TypeFlags.Undefined)).map((part) => checker.typeToString(part, void 0, typeFlags)).join(" | ").replace(/false \| true/g, "boolean") : optional ? printedType.replace(/ \| undefined$/, "") : printedType;
+      const parent = declaration?.parent;
+      const inheritedFrom = declaration && (isExternal(declaration.getSourceFile().fileName) || !sources.includes(declaration.getSourceFile().fileName)) ? parent && (ts.isInterfaceDeclaration(parent) || ts.isTypeAliasDeclaration(parent)) ? parent.name.text : path3.basename(declaration.getSourceFile().fileName) : void 0;
+      const memberType = checker.getNonNullableType(propType);
+      const hasLocalMembers = !checker.isArrayType(memberType) && !checker.isTupleType(memberType) && !memberType.getCallSignatures().length && checker.getPropertiesOfType(memberType).some((member) => member.declarations?.some((node) => !isExternal(node.getSourceFile().fileName)));
+      return {
+        name: symbol.getName(),
+        type: displayType || "unknown",
+        typeUnavailable: false,
+        required: !optional,
+        defaultValue: null,
+        description: ts.displayPartsToString(symbol.getDocumentationComment(checker)).trim(),
+        inheritedFrom,
+        tags: symbol.getJsDocTags(checker).filter((tag) => ["deprecated", "since", "example"].includes(tag.name)).map((tag) => ({ name: tag.name, text: ts.displayPartsToString(tag.text) })),
+        members: depth === 0 && (symbol.getName() === "slotProps" || !inheritedFrom && hasLocalMembers) ? describeProps(memberType, location, depth + 1) : void 0
+      };
+    }).sort(compareProps);
+    const visitComponent = (type, label, location, depth = 0) => {
+      const signature = type.getCallSignatures()[0];
+      if (signature) {
+        const parameter = signature.getParameters()[0];
+        if (parameter) {
+          const declaration = signature.getDeclaration();
+          const propsType = checker.getTypeOfSymbolAtLocation(parameter, declaration ?? location);
+          const props = describeProps(propsType, declaration ?? location);
+          const binding = declaration?.parameters[0]?.name;
+          const readDefaults = (elements) => {
+            for (const element of elements) {
+              const prop = props.find((item) => item.name === (element.propertyName ?? element.name).getText());
+              if (prop && element.initializer && element.initializer.getText() !== "undefined") {
+                const value = literalValue(element.initializer);
+                prop.defaultValue = value === unresolved ? element.initializer.getText() : JSON.stringify(value) ?? null;
+              }
+            }
+          };
+          if (binding && ts.isObjectBindingPattern(binding)) readDefaults(binding.elements);
+          const parameterNames = binding && ts.isIdentifier(binding) ? [binding.text] : binding && ts.isObjectBindingPattern(binding) ? binding.elements.filter((element) => element.dotDotDotToken && ts.isIdentifier(element.name)).map((element) => element.name.getText()) : [];
+          const readBodyDefaults = (node) => {
+            if (ts.isFunctionLike(node) && node !== declaration) return;
+            if (ts.isVariableDeclaration(node) && ts.isObjectBindingPattern(node.name) && node.initializer) {
+              const input = ts.isCallExpression(node.initializer) ? node.initializer.arguments : [node.initializer];
+              if (input.some((argument) => ts.isIdentifier(argument) && parameterNames.includes(argument.text))) {
+                const inputType = checker.getTypeAtLocation(node.initializer);
+                const elements = node.name.elements.filter((element) => {
+                  const name = (element.propertyName ?? element.name).getText();
+                  const original = propsType.getProperty(name);
+                  const projected = inputType.getProperty(name);
+                  return original?.declarations?.some((item) => projected?.declarations?.includes(item));
+                });
+                readDefaults(elements);
+              }
+            }
+            ts.forEachChild(node, readBodyDefaults);
+          };
+          if (declaration) {
+            ts.forEachChild(declaration, readBodyDefaults);
+          }
+          tables.push({ name: label, props });
+        }
+      }
+      if (depth >= 2) return;
+      for (const member of checker.getPropertiesOfType(type)) {
+        const memberType = checker.getTypeOfSymbolAtLocation(member, member.valueDeclaration ?? location);
+        if (memberType.getCallSignatures().length > 0 && !["bind", "call", "apply"].includes(member.getName())) {
+          visitComponent(memberType, `${label}.${member.getName()}`, location, depth + 1);
+        }
+      }
+    };
+    for (const file of sources) {
+      const source = program.getSourceFile(file);
+      const module = source && checker.getSymbolAtLocation(source);
+      if (!source || !module) continue;
+      for (const symbol of checker.getExportsOfModule(module)) {
+        if (symbol.getName() !== entryName && symbol.getName() !== "default") continue;
+        const target = symbol.flags & ts.SymbolFlags.Alias ? checker.getAliasedSymbol(symbol) : symbol;
+        visitComponent(checker.getTypeOfSymbolAtLocation(target, target.valueDeclaration ?? source), entryName, source);
+      }
+    }
+    return tables;
+  };
+  return {
+    collect,
+    setBuildMode(value) {
+      isBuild = value;
+    },
+    clearPrograms() {
+      programCaches.clear();
+    }
+  };
+}
+function mergePropsTables(tables) {
+  const byName = /* @__PURE__ */ new Map();
+  for (const table of tables) {
+    const existing = byName.get(table.name);
+    if (!existing) byName.set(table.name, table);
+    else {
+      const props = new Map(existing.props.filter((prop) => prop.name !== "key").map((prop) => [prop.name, prop]));
+      for (const prop of table.props) {
+        const previous = props.get(prop.name);
+        props.set(prop.name, { ...previous, ...prop, defaultValue: prop.defaultValue ?? previous?.defaultValue ?? null });
+      }
+      byName.set(table.name, { ...existing, ...table, props: [...props.values()].sort(compareProps) });
+    }
+  }
+  return [...byName.values()].sort((a, b) => a.name.split(".").length - b.name.split(".").length || a.name.localeCompare(b.name));
+}
+function propsCode(components) {
+  return `export const components = ${JSON.stringify(components)};`;
+}
+function propsIndexCode(slugs) {
+  return `
+export function loadProps(slug) {
+  switch (slug) {
+${[...slugs].map((slug) => `    case ${JSON.stringify(slug)}: return import(${JSON.stringify(`${VIRTUAL_PREFIX}props/${slug}`)});`).join("\n")}
+    default: return Promise.resolve({ components: [] });
+  }
+}
+`;
+}
+
+// src/build/guidance.ts
+import { existsSync as existsSync2, readdirSync as readdirSync3 } from "node:fs";
+import path4 from "node:path";
+function indexGuidance(guidance, root) {
+  const files = /* @__PURE__ */ new Map();
+  for (const dir of [guidance?.dir ?? []].flat()) {
+    const directory = path4.resolve(root, dir);
+    if (!existsSync2(directory)) continue;
+    for (const file of readdirSync3(directory)) {
+      if (!file.endsWith(".md")) continue;
+      files.set(file.slice(0, -".md".length), path4.join(directory, file));
+    }
+  }
+  return files;
+}
+function guidanceIndexCode(slugs) {
+  return `
+export function loadGuidance(slug) {
+  switch (slug) {
+${[...slugs].map((slug) => `    case ${JSON.stringify(slug)}: return import(${JSON.stringify(`${VIRTUAL_PREFIX}guidance/${slug}`)});`).join("\n")}
+    default: return Promise.resolve({ markdown: '' });
+  }
+}
+`;
+}
+function guidanceCode(markdown) {
+  return `export const markdown = ${JSON.stringify(markdown)};`;
+}
+
+// src/build/releases.ts
+import { existsSync as existsSync3, readFileSync as readFileSync2 } from "node:fs";
+import path5 from "node:path";
+function readReleases(config, root) {
+  const readIfPresent = (candidate) => {
+    if (!candidate) return null;
+    const resolved = path5.resolve(root, candidate);
+    return existsSync3(resolved) ? readFileSync2(resolved, "utf8") : null;
+  };
+  let version = config.site.version ?? null;
+  if (!version && config.releases?.versionFrom) {
+    const manifest = readIfPresent(config.releases.versionFrom);
+    if (manifest) {
+      try {
+        version = JSON.parse(manifest).version ?? null;
+      } catch {
+        version = null;
+      }
+    }
+  }
+  const changelog = readIfPresent(config.releases?.changelog);
+  return { version, changelog };
+}
+function releasesCode(releases) {
+  return `export const releases = ${JSON.stringify(releases)};`;
+}
+
+// src/build/code.ts
+import { existsSync as existsSync4 } from "node:fs";
+import path6 from "node:path";
+function resolveCodeModule(module, root) {
+  if (!module) return void 0;
+  const resolved = path6.resolve(root, module);
+  if (!existsSync4(resolved)) {
+    throw new Error(`storybook-docs: code.module "${module}" does not exist (looked in ${resolved})`);
+  }
+  return resolved;
+}
+function codeModuleCode(resolved) {
+  if (!resolved) return "export const provided = false;\nexport const Code = undefined;\n";
+  return `import { lazy } from 'react';
+export const Code = lazy(() => import(${JSON.stringify(resolved)}));
+export const provided = true;
+`;
+}
+
+// src/build/storybook-test.ts
+var STORYBOOK_TEST_STUB = `
+const chainable = (impl) => {
+  const callable = (...args) => (typeof impl === 'function' ? impl(...args) : undefined);
+  const chain = () => callable;
+  for (const name of [
+    'mockName', 'mockImplementation', 'mockImplementationOnce', 'mockResolvedValue',
+    'mockResolvedValueOnce', 'mockRejectedValue', 'mockReturnValue', 'mockReturnThis',
+    'mockReset', 'mockClear', 'mockRestore',
+  ]) callable[name] = chain;
+  callable.mock = { calls: [], results: [] };
+  return callable;
+};
+export const fn = (impl) => chainable(impl);
+export const spyOn = () => chainable();
+export const mocked = (value) => value;
+export const expect = () => new Proxy({}, { get: () => () => undefined });
+export const within = () => new Proxy({}, { get: () => () => ({}) });
+export const waitFor = (callback) => Promise.resolve(typeof callback === 'function' ? callback() : undefined);
+export const userEvent = new Proxy({}, { get: () => () => Promise.resolve() });
+export const fireEvent = () => true;
+export const cleanup = () => {};
+`;
+
+// src/vite-plugin.ts
+function storybookDocs(options) {
+  const { config } = options;
+  let projectRoot = options.root ?? process.cwd();
+  let catalog = buildCatalog(scanStories(config.stories, projectRoot), config.groups);
+  catalog.files.clear();
+  const engineStyles = path7.join(import.meta.dirname, "styles.css");
+  const propsCache = /* @__PURE__ */ new Map();
+  const propsCollector = createPropsCollector();
+  let guidanceFiles = /* @__PURE__ */ new Map();
+  const loadProps = (slug) => {
+    let components = propsCache.get(slug);
+    if (!components) {
+      const name = catalog.entries.find((entry) => entry.slug === slug)?.name ?? "";
+      components = propsCollector.collect(catalog.files.get(slug), name, slug);
+      propsCache.set(slug, components);
+    }
+    return propsCode(components);
+  };
+  const modules = {
+    catalog: () => `${catalogCode(catalog)}
+export const storySource = ${JSON.stringify(config.stories.from)};`,
+    site: () => siteCode(config),
+    tokens: () => tokensCode(config.tokens),
+    "global-styles": () => globalStylesCode(engineStyles, config.tokens?.css),
+    "stub-storybook-test": () => STORYBOOK_TEST_STUB,
+    props: () => propsIndexCode(catalog.entries.map((entry) => entry.slug)),
+    guidance: () => guidanceIndexCode(guidanceFiles.keys()),
+    releases: () => releasesCode(readReleases(config, projectRoot)),
+    code: () => codeModuleCode(resolveCodeModule(config.code?.module, projectRoot))
+  };
+  return {
+    name: "storybook-docs",
+    enforce: "pre",
+    config() {
+      const entries = [];
+      try {
+        const storyRoot = resolveStoryRoot(config.stories.from, process.cwd());
+        entries.push(path7.join(storyRoot, config.stories.pattern).split(path7.sep).join("/"));
+      } catch {
+      }
+      return {
+        resolve: { dedupe: ["react", "react-dom"] },
+        optimizeDeps: { entries: ["index.html", ...entries] }
+      };
+    },
+    configResolved(resolved) {
+      propsCollector.setBuildMode(resolved.command === "build");
+      projectRoot = options.root ?? resolved.root;
+      catalog = buildCatalog(scanStories(config.stories, projectRoot), config.groups);
+      guidanceFiles = indexGuidance(config.guidance, projectRoot);
+      this.info?.(
+        `storybook-docs: ${catalog.stats.components} components, ${catalog.stats.stories} stories, ${catalog.stats.groups} groups from ${config.stories.from}`
+      );
+    },
+    buildStart() {
+      propsCache.clear();
+      propsCollector.clearPrograms();
+    },
+    closeBundle() {
+      propsCollector.clearPrograms();
+    },
+    resolveId(id) {
+      if (id.startsWith(VIRTUAL_PREFIX)) return `\0${id}`;
+      if (id.startsWith(FILE_PREFIX)) return realpathSync(id.slice(FILE_PREFIX.length));
+      if (id === "storybook/test") return `\0${VIRTUAL_PREFIX}stub-storybook-test`;
+      return null;
+    },
+    load(id) {
+      if (!id.startsWith(`\0${VIRTUAL_PREFIX}`)) return null;
+      const name = id.slice(`\0${VIRTUAL_PREFIX}`.length);
+      const module = Object.hasOwn(modules, name) ? modules[name] : void 0;
+      if (module) return module();
+      if (name.startsWith("props/")) return loadProps(name.slice("props/".length));
+      if (name.startsWith("guidance/")) {
+        const file = guidanceFiles.get(name.slice("guidance/".length));
+        return guidanceCode(file ? readFileSync3(file, "utf8") : "");
+      }
+      return null;
+    }
+  };
+}
+var vite_plugin_default = storybookDocs;
+export {
+  vite_plugin_default as default,
+  storybookDocs
+};