@aussieljk/forkbook 0.0.0-stage → 0.0.1-2

package/dist/addon-docs/preset.js

@@ -0,0 +1,378 @@
+import CJS_COMPAT_NODE_URL_ro17f80mg6k from 'node:url';
+import CJS_COMPAT_NODE_PATH_ro17f80mg6k from 'node:path';
+import CJS_COMPAT_NODE_MODULE_ro17f80mg6k from "node:module";
+
+var __filename = CJS_COMPAT_NODE_URL_ro17f80mg6k.fileURLToPath(import.meta.url);
+var __dirname = CJS_COMPAT_NODE_PATH_ro17f80mg6k.dirname(__filename);
+var require = CJS_COMPAT_NODE_MODULE_ro17f80mg6k.createRequire(import.meta.url);
+
+// ------------------------------------------------------------
+// end of CJS compatibility banner, injected by Forkbook's esbuild configuration
+// ------------------------------------------------------------
+import {
+  resolvePackageDir
+} from "../_node-chunks/chunk-F3ZFKBHY.js";
+import "../_node-chunks/chunk-TNJIXE37.js";
+import "../_node-chunks/chunk-CXRU72ET.js";
+
+// src/addon-docs/preset.ts
+import { isAbsolute } from "node:path";
+import { fileURLToPath } from "node:url";
+
+// src/addon-docs/csf-plugin/transform-csf.ts
+import { readFile } from "node:fs/promises";
+import { enrichCsf, formatCsf, loadCsf } from "@aussieljk/forkbook/internal/csf-tools";
+import { logger } from "@aussieljk/forkbook/internal/node-logger";
+
+// src/addon-docs/csf-plugin/constants.ts
+var STORIES_REGEX = /(?<!node_modules.*)\.(story|stories)\.[tj]sx?$/;
+
+// src/addon-docs/csf-plugin/transform-csf.ts
+async function transformCsf(code, id, options) {
+  if (!STORIES_REGEX.test(id))
+    return;
+  let sourceCode = await readFile(id, "utf-8");
+  try {
+    let makeTitle = (userTitle) => userTitle || "default", csf = loadCsf(code, { makeTitle }).parse(), csfSource = code === sourceCode && !options.enrichCsf ? csf : loadCsf(sourceCode, { makeTitle }).parse();
+    return await enrichCsf(csf, csfSource, options), formatCsf(csf, { sourceMaps: !0, sourceFileName: id }, code);
+  } catch (err) {
+    let message = err instanceof Error ? err.message : String(err);
+    return message.startsWith("CSF:") || logger.warn(message), code;
+  }
+}
+
+// src/addon-docs/csf-plugin/index.ts
+function csfPlugin(options) {
+  return {
+    name: "plugin-csf",
+    // Stay in the `pre` bucket with framework compilers, but run after their default-order
+    // transforms so enrichment is not discarded when a plugin re-emits from its own source instead
+    // of transforming `code`.
+    enforce: "pre",
+    transform: {
+      order: "post",
+      async handler(code, id) {
+        return transformCsf(code, id, options);
+      }
+    }
+  };
+}
+
+// src/addon-docs/mdx-service/server.ts
+import {
+  getComponentIdFromEntry as getComponentIdFromEntry2,
+  groupBy as groupBy2,
+  registerService
+} from "@aussieljk/forkbook/internal/common";
+import { Tag as Tag2 } from "@aussieljk/forkbook/internal/core-server";
+
+// src/addon-docs/manifest.ts
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
+import { getComponentIdFromEntry, groupBy } from "@aussieljk/forkbook/internal/common";
+import {
+  Tag,
+  analyzeMdx,
+  mdxManifestRef
+} from "@aussieljk/forkbook/internal/core-server";
+import { logger as logger2 } from "@aussieljk/forkbook/internal/node-logger";
+
+// src/addon-docs/extract-docs-summary.ts
+function extractDocsSummary(content) {
+  let result = content;
+  result = result.replace(/^\s*import\s+(?:[\s\S]*?from\s+)?['"][^'"]+['"];?\s*$/gm, "");
+  let prevResult = "";
+  for (; prevResult !== result; )
+    prevResult = result, result = result.replace(/\{[^{}]*\}/g, "");
+  for (result = result.replace(/<[^>]+\/>/g, ""), prevResult = ""; prevResult !== result; )
+    prevResult = result, result = result.replace(/<(\w+)[^>]*>([\s\S]*?)<\/\1>/g, "$2");
+  if (result = result.replace(/<[^>]+>/g, ""), result = result.replace(/\s+/g, " ").trim(), !!result)
+    return result.length > 90 ? `${result.slice(0, 90)}...` : result;
+}
+
+// src/addon-docs/manifest.ts
+async function createDocsManifestEntry(entry) {
+  let absolutePath = path.join(process.cwd(), entry.importPath);
+  try {
+    let content = await fs.readFile(absolutePath, "utf-8"), { summary } = await analyzeMdx(content), derivedSummary = summary ?? extractDocsSummary(content);
+    return {
+      id: entry.id,
+      name: entry.name,
+      path: entry.importPath,
+      title: entry.title,
+      content,
+      ...derivedSummary !== void 0 && { summary: derivedSummary }
+    };
+  } catch (err) {
+    return {
+      id: entry.id,
+      name: entry.name,
+      path: entry.importPath,
+      title: entry.title,
+      error: {
+        name: err instanceof Error ? err.name : "Error",
+        message: err instanceof Error ? err.message : String(err)
+      }
+    };
+  }
+}
+function createDocsManifestRefEntry(entry, componentId) {
+  return {
+    id: entry.id,
+    name: entry.name,
+    mdx: { $ref: mdxManifestRef(componentId, entry.id) }
+  };
+}
+async function buildUnattachedDocs(entries, build) {
+  let docs2 = await Promise.all(
+    entries.map(async (entry) => [entry.id, await build(entry, entry.id)])
+  );
+  return Object.fromEntries(docs2);
+}
+async function applyAttachedDocs(entries, existingComponents, build) {
+  if (!existingComponents || entries.length === 0)
+    return existingComponents;
+  let docs2 = await Promise.all(
+    entries.map(async (entry) => {
+      let componentId = getComponentIdFromEntry(entry);
+      return { componentId, doc: await build(entry, componentId) };
+    })
+  ), components = { ...existingComponents.components };
+  for (let { componentId, doc } of docs2) {
+    let component = components[componentId] ?? { id: componentId, name: componentId };
+    components[componentId] = {
+      ...component,
+      docs: { ...component.docs, [doc.id]: doc }
+    };
+  }
+  return { ...existingComponents, components };
+}
+var manifests = async (existingManifests = {}, { manifestEntries, presets }) => {
+  let startPerformance = performance.now(), features = await presets?.apply?.("features"), useMdxService = features?.docgenServer === !0 && features?.componentsManifest === !0, docsEntries = manifestEntries.filter(
+    (entry) => entry.type === "docs"
+  );
+  if (docsEntries.length === 0)
+    return existingManifests;
+  let { attachedEntries = [], unattachedEntries = [] } = groupBy(docsEntries, (entry) => {
+    switch (!0) {
+      case entry.tags?.includes(Tag.UNATTACHED_MDX):
+        return "unattachedEntries";
+      case entry.tags?.includes(Tag.ATTACHED_MDX):
+        return "attachedEntries";
+      default:
+        return "ignored";
+    }
+  });
+  if (unattachedEntries.length === 0 && attachedEntries.length === 0)
+    return existingManifests;
+  let existingManifestsWithDocs = existingManifests, build = useMdxService ? createDocsManifestRefEntry : createDocsManifestEntry, [unattachedDocs, updatedComponents] = await Promise.all([
+    buildUnattachedDocs(unattachedEntries, build),
+    applyAttachedDocs(attachedEntries, existingManifestsWithDocs.components, build)
+  ]), processedCount = unattachedEntries.length + attachedEntries.length;
+  logger2.verbose(
+    `Docs manifest generation took ${performance.now() - startPerformance}ms for ${processedCount} entries (${unattachedEntries.length} unattached, ${attachedEntries.length} attached)`
+  );
+  let result = { ...existingManifestsWithDocs };
+  return Object.keys(unattachedDocs).length > 0 && (result.docs = {
+    v: useMdxService ? 1 : 0,
+    docs: unattachedDocs
+  }), updatedComponents && (result.components = updatedComponents), result;
+};
+
+// src/addon-docs/mdx-service/definition.ts
+import {
+  MDX_SERVICE_ID,
+  mdxQueryStaticPath
+} from "@aussieljk/forkbook/internal/core-server";
+import * as v from "valibot";
+import { defineService } from "@aussieljk/forkbook/open-service";
+var mdxInputSchema = v.object({ id: v.string() }), mdxErrorSchema = v.object({
+  name: v.string(),
+  message: v.string()
+}), mdxDocPayloadSchema = v.object({
+  id: v.string(),
+  name: v.string(),
+  path: v.string(),
+  title: v.string(),
+  content: v.optional(v.string()),
+  summary: v.optional(v.string()),
+  error: v.optional(mdxErrorSchema)
+}), mdxPayloadSchema = v.object({
+  id: v.string(),
+  name: v.string(),
+  docs: v.record(v.string(), mdxDocPayloadSchema)
+}), mdxOutputSchema = v.optional(mdxPayloadSchema), mdxServiceDef = defineService({
+  id: MDX_SERVICE_ID,
+  internal: !0,
+  // this service really only ensures that the MDX docs are available in manifests, so there is no need to expose it to the public API
+  initialState: { components: {} },
+  queries: {
+    mdxForComponent: {
+      input: mdxInputSchema,
+      output: mdxOutputSchema,
+      handler: (input, ctx) => ctx.self.state.components[input.id],
+      load: async (input, ctx) => {
+        await ctx.self.commands._extractMdxForComponent(input);
+      },
+      staticPath: (input) => mdxQueryStaticPath(input.id)
+    },
+    mdxForAllComponents: {
+      input: v.void(),
+      output: v.record(v.string(), mdxPayloadSchema),
+      handler: (_input, ctx) => ctx.self.state.components,
+      load: async (_input, ctx) => {
+        await ctx.self.commands._extractAllMdx(void 0);
+      }
+    }
+  },
+  commands: {
+    _extractMdxForComponent: {
+      internal: !0,
+      input: mdxInputSchema,
+      output: mdxOutputSchema
+    },
+    _extractAllMdx: {
+      internal: !0,
+      input: v.undefined(),
+      output: v.void()
+    }
+  }
+});
+
+// src/addon-docs/mdx-service/server.ts
+function groupMdxEntriesByComponent(index) {
+  return groupBy2(
+    Object.values(index.entries).filter(
+      (entry) => entry.type === "docs" && ((entry.tags?.includes(Tag2.ATTACHED_MDX) ?? !1) || (entry.tags?.includes(Tag2.UNATTACHED_MDX) ?? !1))
+    ),
+    (entry) => entry.tags?.includes(Tag2.ATTACHED_MDX) ? getComponentIdFromEntry2(entry) : entry.id
+  );
+}
+var defaultMdxProvider = async ({ componentId, entries }) => {
+  if (entries.length === 0)
+    return;
+  let docs2 = await Promise.all(entries.map(createDocsManifestEntry));
+  return {
+    id: componentId,
+    name: componentId,
+    docs: Object.fromEntries(docs2.map((doc) => [doc.id, doc]))
+  };
+};
+function registerMdxService({
+  getIndex,
+  provider = defaultMdxProvider
+}) {
+  return registerService(mdxServiceDef, {
+    queries: {
+      mdxForComponent: {
+        staticInputs: async () => {
+          let index = await getIndex(), grouped = groupMdxEntriesByComponent(index);
+          return Object.keys(grouped).map((id) => ({ id }));
+        }
+      }
+    },
+    commands: {
+      _extractMdxForComponent: {
+        handler: async (input, ctx) => {
+          let index = await getIndex(), entries = groupMdxEntriesByComponent(index)[input.id] ?? [];
+          if (entries.length === 0)
+            return;
+          let payload = await provider({
+            componentId: input.id,
+            entries
+          });
+          if (payload)
+            return ctx.self.setState((state) => {
+              state.components[input.id] = payload;
+            }), payload;
+        }
+      },
+      _extractAllMdx: {
+        handler: async (_input, ctx) => {
+          let index = await getIndex(), grouped = groupMdxEntriesByComponent(index), extracted = await Promise.all(
+            Object.entries(grouped).map(async ([id, entries]) => {
+              let payload = await provider({ componentId: id, entries });
+              return payload ? [id, payload] : void 0;
+            })
+          );
+          ctx.self.setState((state) => {
+            for (let result of extracted) {
+              if (!result)
+                continue;
+              let [id, payload] = result;
+              state.components[id] = payload;
+            }
+          });
+        }
+      }
+    }
+  });
+}
+
+// src/addon-docs/preset.ts
+var getResolvedReact = async (options) => {
+  let resolvedReact2 = await options.presets.apply("resolvedReact", {});
+  return {
+    react: resolvedReact2.react ?? resolvePackageDir("react"),
+    reactDom: resolvedReact2.reactDom ?? resolvePackageDir("react-dom"),
+    // Explicitly alias @mdx-js/react, so that symlinked MDX files can resolve it when it is not hoisted
+    mdx: resolvedReact2.mdx ?? fileURLToPath(import.meta.resolve("@mdx-js/react"))
+  };
+}, docs = (input = {}, options) => {
+  if (options?.build?.test?.disableAutoDocs)
+    return;
+  let result = {
+    ...input,
+    defaultName: "Docs"
+  }, docsMode = options.docs;
+  return docsMode && (result.docsMode = docsMode), result;
+}, viteFinal = async (config, options) => {
+  let { plugins = [] } = config, { csfPluginOptions = {} } = options, { mdxPlugin } = await import("../_node-chunks/mdx-plugin-MWISDWDQ.js"), enrichCsf2 = await options.presets.apply("experimental_enrichCsf"), { react, reactDom, mdx } = await getResolvedReact(options), packageDeduplicationPlugin = {
+    name: "storybook:package-deduplication",
+    enforce: "pre",
+    config: () => ({
+      resolve: {
+        alias: {
+          react,
+          // Vite doesn't respect export maps when resolving an absolute path, so we need to do that manually here
+          ...isAbsolute(reactDom) && { "react-dom/server": `${reactDom}/server.browser.js` },
+          "react-dom": reactDom,
+          "@mdx-js/react": mdx
+        }
+      }
+    })
+  };
+  return csfPluginOptions && plugins.unshift(
+    csfPlugin({
+      ...csfPluginOptions,
+      enrichCsf: enrichCsf2
+    })
+  ), plugins.unshift(packageDeduplicationPlugin), plugins.unshift(mdxPlugin(options)), {
+    ...config,
+    plugins
+  };
+}, docsX = docs, resolvedReact = async (existing) => ({
+  react: existing?.react ?? resolvePackageDir("react"),
+  reactDom: existing?.reactDom ?? resolvePackageDir("react-dom"),
+  mdx: existing?.mdx ?? fileURLToPath(import.meta.resolve("@mdx-js/react"))
+}), services = async (_value, options) => {
+  let features = await options.presets.apply("features");
+  features?.docgenServer && features?.componentsManifest && registerMdxService({
+    getIndex: () => options.presets.apply("storyIndexGenerator").then((generator) => generator.getIndex())
+  });
+}, optimizeViteDeps = [
+  "@aussieljk/forkbook/addon-docs",
+  "@aussieljk/forkbook/addon-docs/blocks",
+  "@aussieljk/forkbook/addon-docs > @mdx-js/react",
+  "react-dom/client",
+  "react/jsx-runtime",
+  "react"
+];
+export {
+  docsX as docs,
+  manifests as experimental_manifests,
+  optimizeViteDeps,
+  resolvedReact,
+  services,
+  viteFinal
+};

package/dist/addon-docs/preview.d.ts

@@ -0,0 +1,4 @@
+//#region .dts-emit/code/core/src/addon-docs/preview.d.ts
+declare const parameters: any;
+//#endregion
+export { parameters };

package/dist/addon-docs/preview.js

@@ -0,0 +1,7 @@
+import {
+  parameters
+} from "../_browser-chunks/chunk-RBCHTR7C.js";
+import "../_browser-chunks/chunk-IMSF75WX.js";
+export {
+  parameters
+};

package/dist/addon-links/index.d.ts

@@ -0,0 +1,22 @@
+import { Addon_MakeDecoratorResult, ComponentTitle, StoryId, StoryKind, StoryName } from "@aussieljk/forkbook/internal/types";
+
+//#region .dts-emit/code/core/src/addon-links/utils.d.ts
+interface ParamsId {
+  storyId: StoryId;
+}
+interface ParamsCombo {
+  kind?: StoryKind;
+  title?: ComponentTitle;
+  story?: StoryName;
+  name?: StoryName;
+}
+declare const navigate: (params: ParamsId | ParamsCombo) => void;
+declare const hrefTo: (title: ComponentTitle | undefined, name: StoryName) => Promise<string>;
+declare const hrefToSync: (title: ComponentTitle | undefined, name: StoryName) => string;
+declare const linkTo: (idOrTitle: string | ((...args: any[]) => string), nameInput?: string | ((...args: any[]) => string)) => (...args: any[]) => void;
+declare const withLinks: Addon_MakeDecoratorResult;
+//#endregion
+//#region .dts-emit/code/core/src/addon-links/index.d.ts
+declare function _default(): import("@aussieljk/forkbook/internal/csf").PreviewAddon<import("@aussieljk/forkbook/internal/csf").AddonTypes>;
+//#endregion
+export { _default as default, hrefTo, hrefToSync, linkTo, navigate, withLinks };

package/dist/addon-links/index.js

@@ -0,0 +1,20 @@
+import {
+  addon_links_default
+} from "../_browser-chunks/chunk-2SCZVUKW.js";
+import {
+  hrefTo,
+  hrefToSync,
+  linkTo,
+  navigate,
+  withLinks
+} from "../_browser-chunks/chunk-52CW7FF7.js";
+import "../_browser-chunks/chunk-ENKK74N4.js";
+import "../_browser-chunks/chunk-IMSF75WX.js";
+export {
+  addon_links_default as default,
+  hrefTo,
+  hrefToSync,
+  linkTo,
+  navigate,
+  withLinks
+};

package/dist/addon-links/manager.js

@@ -0,0 +1,14 @@
+import {
+  ADDON_ID,
+  constants_default
+} from "../_browser-chunks/chunk-ENKK74N4.js";
+import "../_browser-chunks/chunk-IMSF75WX.js";
+
+// src/addon-links/manager.ts
+import { addons } from "@aussieljk/forkbook/manager-api";
+addons.register(ADDON_ID, (api) => {
+  api.on(constants_default.REQUEST, ({ kind, name }) => {
+    let id = api.storyId(kind, name);
+    api.emit(constants_default.RECEIVE, id);
+  });
+});

package/dist/addon-links/preview.d.ts

@@ -0,0 +1,6 @@
+import { Ai as Addon_MakeDecoratorResult } from "../chunk-C2p5r3Vt.js";
+
+//#region .dts-emit/code/core/src/addon-links/preview.d.ts
+declare const decorators: Addon_MakeDecoratorResult[];
+//#endregion
+export { decorators };

package/dist/addon-links/preview.js

@@ -0,0 +1,9 @@
+import {
+  decorators
+} from "../_browser-chunks/chunk-2SCZVUKW.js";
+import "../_browser-chunks/chunk-52CW7FF7.js";
+import "../_browser-chunks/chunk-ENKK74N4.js";
+import "../_browser-chunks/chunk-IMSF75WX.js";
+export {
+  decorators
+};

package/dist/addon-links/react/index.d.ts

@@ -0,0 +1,25 @@
+import React, { PureComponent, ReactNode } from "react";
+import { ComponentTitle, StoryKind, StoryName } from "@aussieljk/forkbook/internal/types";
+
+//#region .dts-emit/code/core/src/addon-links/react/components/link.d.ts
+interface Props {
+  kind?: StoryKind;
+  title?: ComponentTitle;
+  story?: StoryName;
+  name?: StoryName;
+  children: ReactNode;
+}
+interface State {
+  href: string;
+}
+declare class LinkTo extends PureComponent<Props, State> {
+  static defaultProps: Props;
+  state: State;
+  componentDidMount(): void;
+  componentDidUpdate(prevProps: Props): void;
+  updateHref: () => Promise<void>;
+  handleClick: () => void;
+  render(): React.JSX.Element;
+}
+//#endregion
+export { LinkTo as default };

package/dist/addon-links/react/index.js

@@ -0,0 +1,52 @@
+import {
+  hrefTo,
+  navigate
+} from "../../_browser-chunks/chunk-52CW7FF7.js";
+import "../../_browser-chunks/chunk-ENKK74N4.js";
+import "../../_browser-chunks/chunk-IMSF75WX.js";
+
+// src/addon-links/react/components/link.tsx
+import { PureComponent } from "react";
+import { jsx } from "react/jsx-runtime";
+var LEFT_BUTTON = 0, isPlainLeftClick = (e) => e.button === LEFT_BUTTON && !e.altKey && !e.ctrlKey && !e.metaKey && !e.shiftKey, cancelled = (e, cb = (_e) => {
+}) => {
+  isPlainLeftClick(e) && (e.preventDefault(), cb(e));
+}, LinkTo = class extends PureComponent {
+  constructor() {
+    super(...arguments);
+    this.state = {
+      href: "/"
+    };
+    this.updateHref = async () => {
+      let { kind, title = kind, story, name = story } = this.props;
+      if (title && name) {
+        let href = await hrefTo(title, name);
+        this.setState({ href });
+      }
+    };
+    this.handleClick = () => {
+      let { kind, title = kind, story, name = story } = this.props;
+      title && name && navigate({ title, name });
+    };
+  }
+  componentDidMount() {
+    this.updateHref();
+  }
+  componentDidUpdate(prevProps) {
+    let { kind, title, story, name } = this.props;
+    (prevProps.kind !== kind || prevProps.story !== story || prevProps.title !== title || prevProps.name !== name) && this.updateHref();
+  }
+  render() {
+    let { kind, title = kind, story, name = story, children, ...rest } = this.props, { href } = this.state;
+    return jsx("a", { href, onClick: (e) => cancelled(e, this.handleClick), ...rest, children });
+  }
+};
+LinkTo.defaultProps = {
+  children: void 0
+};
+
+// src/addon-links/react/index.ts
+var react_default = LinkTo;
+export {
+  react_default as default
+};