@aussieljk/forkbook 0.0.0-stage → 0.0.1-2

package/dist/react/index.js

@@ -0,0 +1,26 @@
+import {
+  INTERNAL_DEFAULT_PROJECT_ANNOTATIONS,
+  composeStories,
+  composeStory,
+  setProjectAnnotations
+} from "../_browser-chunks/chunk-MDOL7KML.js";
+import {
+  __definePreview
+} from "../_browser-chunks/chunk-MFMDGWP6.js";
+import "../_browser-chunks/chunk-5WMXI5GW.js";
+import "../_browser-chunks/chunk-GNZY6LOW.js";
+import "../_browser-chunks/chunk-CFWWCCZV.js";
+import "../_browser-chunks/chunk-WHQRNHXD.js";
+import "../_browser-chunks/chunk-IMSF75WX.js";
+
+// src/react/globals.ts
+import { global } from "@storybook/global";
+var { window: globalWindow } = global;
+globalWindow && (globalWindow.FORKBOOK_ENV = "react");
+export {
+  INTERNAL_DEFAULT_PROJECT_ANNOTATIONS,
+  __definePreview,
+  composeStories,
+  composeStory,
+  setProjectAnnotations
+};

package/dist/react/preset.js

@@ -0,0 +1,301 @@
+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 {
+  ComponentMetaManager,
+  buildReactComponentDocgenFromResolved,
+  buildStoryDocsFromResolved,
+  extractArgTypesFromComponentMeta,
+  getCodeSnippet,
+  invalidateCache,
+  resolveStoryFileComponents
+} from "../_node-chunks/chunk-KISMCCP5.js";
+import "../_node-chunks/chunk-3T4ZSNPH.js";
+import "../_node-chunks/chunk-WCULS5TP.js";
+import "../_node-chunks/chunk-2DSIDINN.js";
+import "../_node-chunks/chunk-JDXXX6LB.js";
+import {
+  resolvePackageDir
+} from "../_node-chunks/chunk-F3ZFKBHY.js";
+import "../_node-chunks/chunk-TNJIXE37.js";
+import "../_node-chunks/chunk-CXRU72ET.js";
+
+// src/react/preset.ts
+import path3, { join as join2 } from "node:path";
+import { fileURLToPath as fileURLToPath2 } from "node:url";
+import { getProjectRoot } from "@aussieljk/forkbook/internal/common";
+
+// src/react/componentManifest/componentMetaManagerSingleton.ts
+import { logger } from "@aussieljk/forkbook/internal/node-logger";
+var componentMetaManager;
+function getSharedComponentMetaManager() {
+  if (componentMetaManager === void 0)
+    try {
+      componentMetaManager = new ComponentMetaManager();
+    } catch (error) {
+      logger.debug(`[reactComponentMeta] Cannot start tsgo: ${error}`), componentMetaManager = null;
+    }
+  return componentMetaManager ?? void 0;
+}
+
+// src/react/componentManifest/generator.ts
+import {
+  getStoryImportPathFromEntry,
+  selectComponentEntriesByComponentId
+} from "@aussieljk/forkbook/internal/common";
+import path from "pathe";
+var manifests = async (existingManifests = {}, options) => {
+  let { manifestEntries, presets } = options;
+  if ((await presets?.apply("features", {}))?.docgenServer)
+    return {
+      ...existingManifests,
+      components: {
+        v: 0,
+        components: {},
+        meta: { docgen: "react-component-meta", durationMs: 0 }
+      }
+    };
+  invalidateCache();
+  let startTime = performance.now(), manager = getSharedComponentMetaManager(), entriesByUniqueComponent = [
+    ...selectComponentEntriesByComponentId(manifestEntries).values()
+  ], resolvedEntries = await Promise.all(
+    entriesByUniqueComponent.map(async (entry) => {
+      let storyFilePath = getStoryImportPathFromEntry(entry);
+      if (!storyFilePath)
+        throw new Error(`No story file path for index entry ${entry.id}`);
+      let storyPath = path.join(process.cwd(), storyFilePath), resolved = await resolveStoryFileComponents({
+        storyPath,
+        title: entry.title
+      });
+      return { entry, storyFilePath, ...resolved };
+    })
+  );
+  manager && manager.batchExtract(
+    resolvedEntries.flatMap(({ storyPath, component, subcomponents }) => [
+      ...component ? [{ storyPath, component }] : [],
+      ...subcomponents.filter(
+        (subcomponent) => subcomponent.component !== void 0
+      ).map((subcomponent) => ({
+        storyPath,
+        component: subcomponent.component
+      }))
+    ])
+  );
+  let manifestEntryIds = new Set(manifestEntries.map((entry) => entry.id)), components = resolvedEntries.map(
+    ({
+      storyPath,
+      component,
+      entry,
+      storyFilePath,
+      storyFile,
+      csf,
+      componentName,
+      allComponents,
+      subcomponents
+    }) => buildReactComponentDocgenFromResolved({
+      entry,
+      storyPath,
+      storyFilePath,
+      storyFile,
+      csf,
+      componentName,
+      component,
+      allComponents,
+      subcomponents,
+      filterStoryIds: manifestEntryIds
+    })
+  ).filter((component) => component !== void 0), durationMs = Math.round(performance.now() - startTime);
+  return {
+    ...existingManifests,
+    components: {
+      v: 0,
+      components: Object.fromEntries(components.map((component) => [component.id, component])),
+      meta: {
+        docgen: "react-component-meta",
+        durationMs
+      }
+    }
+  };
+};
+
+// src/react/enrichCsf.ts
+import { recast, types as t } from "@aussieljk/forkbook/internal/babel";
+import { formatCode } from "@aussieljk/forkbook/internal/common";
+import { join } from "pathe";
+var enrichCsf = async (input, options) => {
+  let features2 = await options.presets.apply("features");
+  if (!(!features2.experimentalCodeExamples || features2.docgenServer))
+    return async (csf, csfSource) => {
+      let statements = Object.keys(csf._stories).map(async (key) => {
+        if (!csfSource._meta?.component)
+          return;
+        let node, snippet;
+        try {
+          node = getCodeSnippet(csfSource, key, csfSource._meta?.component).node;
+        } catch (e) {
+          if (!(e instanceof Error))
+            return;
+          snippet = e.message;
+        }
+        try {
+          !snippet && node && (snippet = await formatCode(join(process.cwd(), "component.tsx"), recast.print(node).code));
+        } catch (e) {
+          if (!(e instanceof Error))
+            return;
+          snippet = e.message;
+        }
+        if (!snippet)
+          return;
+        let originalParameters = t.memberExpression(
+          csf._metaIsFactory ? t.memberExpression(t.identifier(key), t.identifier("input")) : t.identifier(key),
+          t.identifier("parameters")
+        ), docsParameter = t.optionalMemberExpression(
+          originalParameters,
+          t.identifier("docs"),
+          !1,
+          !0
+        );
+        return t.expressionStatement(
+          t.assignmentExpression(
+            "=",
+            originalParameters,
+            t.objectExpression([
+              t.spreadElement(originalParameters),
+              t.objectProperty(
+                t.identifier("docs"),
+                t.objectExpression([
+                  t.spreadElement(docsParameter),
+                  t.objectProperty(
+                    t.identifier("source"),
+                    t.objectExpression([
+                      t.objectProperty(t.identifier("code"), t.stringLiteral(snippet)),
+                      t.spreadElement(
+                        t.optionalMemberExpression(docsParameter, t.identifier("source"), !1, !0)
+                      )
+                    ])
+                  )
+                ])
+              )
+            ])
+          )
+        );
+      });
+      for (let statement of await Promise.all(statements))
+        statement && csf._ast.program.body.push(statement);
+    };
+};
+
+// src/react/docgen/preset.ts
+import { fileURLToPath } from "node:url";
+var experimental_docgenProvider = async (existing = []) => [
+  ...existing,
+  {
+    moduleSpecifier: fileURLToPath(
+      import.meta.resolve("@aussieljk/forkbook/react/internal/docgen-worker")
+    )
+  }
+];
+
+// src/react/docgen/story-docs-preset.ts
+import {
+  STORY_FILE_TEST_REGEXP,
+  getStoryImportPathFromEntry as getStoryImportPathFromEntry3
+} from "@aussieljk/forkbook/internal/common";
+
+// src/react/docgen/build-story-docs.ts
+import { getStoryImportPathFromEntry as getStoryImportPathFromEntry2 } from "@aussieljk/forkbook/internal/common";
+import path2 from "pathe";
+async function buildStoryDocsPayload(input, context) {
+  let storyFilePath = getStoryImportPathFromEntry2(input.entry);
+  if (!storyFilePath)
+    return;
+  let storyPath = (context.resolvePath ?? ((importPath) => path2.join(process.cwd(), importPath)))(storyFilePath), resolved;
+  try {
+    resolved = await resolveStoryFileComponents({
+      storyPath,
+      title: input.entry.title
+    });
+  } catch {
+    return;
+  }
+  let { csf, componentName, component, allComponents } = resolved;
+  return buildStoryDocsFromResolved({
+    entry: input.entry,
+    storyPath,
+    storyFilePath,
+    csf,
+    componentName,
+    component,
+    allComponents
+  });
+}
+
+// src/react/docgen/story-docs-preset.ts
+var experimental_storyDocsProvider = async (nextStoryDocs) => async (input) => {
+  let storyImportPath = getStoryImportPathFromEntry3(input.entry);
+  if (!storyImportPath || !STORY_FILE_TEST_REGEXP.test(storyImportPath))
+    return nextStoryDocs(input);
+  let ours = await buildStoryDocsPayload(input, {});
+  return ours ? { ...await nextStoryDocs(input), ...ours } : nextStoryDocs(input);
+};
+
+// src/react/preset.ts
+var isDocgenProviderEnabled = () => !0, features = async (existing) => ({
+  ...existing,
+  componentsManifest: !0
+}), previewAnnotations = async (input = [], options) => {
+  let [docsConfig, features2] = await Promise.all([
+    options.presets.apply("docs", {}, options),
+    options.presets.apply("features", {}, options)
+  ]), docsEnabled = Object.keys(docsConfig).length > 0, experimentalRSC = features2?.experimentalRSC;
+  return [].concat(input).concat([
+    fileURLToPath2(import.meta.resolve("@aussieljk/forkbook/react/entry-preview")),
+    fileURLToPath2(import.meta.resolve("@aussieljk/forkbook/react/entry-preview-argtypes"))
+  ]).concat(
+    docsEnabled ? [fileURLToPath2(import.meta.resolve("@aussieljk/forkbook/react/entry-preview-docs"))] : []
+  ).concat(
+    experimentalRSC ? [fileURLToPath2(import.meta.resolve("@aussieljk/forkbook/react/entry-preview-rsc"))] : []
+  );
+}, resolvedReact = async (existing) => {
+  try {
+    return {
+      ...existing,
+      react: resolvePackageDir("react"),
+      reactDom: resolvePackageDir("react-dom")
+    };
+  } catch {
+    return existing;
+  }
+};
+async function internal_getArgTypesData(_input, options) {
+  let { componentFilePath, componentExportName } = options ?? {};
+  if (!componentFilePath)
+    return null;
+  let filePath = path3.isAbsolute(componentFilePath) ? componentFilePath : join2(getProjectRoot(), componentFilePath), doc = getSharedComponentMetaManager()?.extractFromFile(filePath, componentExportName);
+  return extractArgTypesFromComponentMeta(doc) ?? null;
+}
+var optimizeViteDeps = [
+  "react-dom/client",
+  "react-dom/test-utils",
+  "react/jsx-runtime"
+];
+export {
+  experimental_docgenProvider,
+  enrichCsf as experimental_enrichCsf,
+  manifests as experimental_manifests,
+  experimental_storyDocsProvider,
+  features,
+  internal_getArgTypesData,
+  isDocgenProviderEnabled,
+  optimizeViteDeps,
+  previewAnnotations,
+  resolvedReact
+};

package/dist/react/preview.d.ts

@@ -0,0 +1,2 @@
+import { i as __definePreview, n as ReactPreview, r as ReactStory, t as ReactMeta } from "../chunk-CMeX4WRe.js";
+export { ReactMeta, ReactPreview, ReactStory, __definePreview };

package/dist/react/preview.js

@@ -0,0 +1,11 @@
+import {
+  __definePreview
+} from "../_browser-chunks/chunk-MFMDGWP6.js";
+import "../_browser-chunks/chunk-5WMXI5GW.js";
+import "../_browser-chunks/chunk-GNZY6LOW.js";
+import "../_browser-chunks/chunk-CFWWCCZV.js";
+import "../_browser-chunks/chunk-WHQRNHXD.js";
+import "../_browser-chunks/chunk-IMSF75WX.js";
+export {
+  __definePreview
+};

package/dist/react-native/bin/get-stories.js

@@ -0,0 +1,34 @@
+#!/usr/bin/env node
+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 {
+  generate
+} from "../../_node-chunks/chunk-RXNJDRGO.js";
+import "../../_node-chunks/chunk-CXRU72ET.js";
+
+// src/react-native/bin/get-stories.ts
+import { program } from "commander";
+program.description("Generator for the storybook.requires file used in react native storybook").option(
+  "-c, --config-path <path>",
+  "The path to your config folder relative to your project-dir",
+  "./.rnstorybook"
+).option("-j, --use-js", "Use a js file for storybook.requires").option("-D, --no-doc-tools", "Do not include doc tools in the storybook.requires file").option(
+  "-w, --host <host>",
+  "Host for websockets, the value 'auto' will tell storybook to use your local ip address"
+).option("-p, --port <port>", "Port for websockets", (value) => {
+  let port = parseInt(value, 10);
+  if (isNaN(port))
+    throw new Error(`Invalid port number: "${value}"`);
+  return port;
+});
+program.parse();
+await generate(program.opts());

package/dist/react-native/index.d.ts

@@ -0,0 +1,160 @@
+import { StoryContext } from "@aussieljk/forkbook/internal/csf";
+import { Channel } from "@aussieljk/forkbook/internal/channels";
+import { Addon_StorySortParameterV7, ModuleExports, NormalizedProjectAnnotations, NormalizedStoriesSpecifier, PreparedStory, StoryIndex, StorybookConfig as StorybookConfig$1 } from "@aussieljk/forkbook/internal/types";
+import { ArgTypes, Args, Decorator, Loader, Meta, Parameters, Preview, ReactRenderer, StoryFn, StoryObj } from "@aussieljk/forkbook/react";
+import { Theme, Theme as Theme$1, darkTheme, theme } from "@aussieljk/forkbook/internal/react-native-theming";
+import { SBUI } from "@aussieljk/forkbook/internal/react-native-ui-common";
+import { PreviewWithSelection, SelectionStore } from "@aussieljk/forkbook/internal/preview-api";
+
+//#region .dts-emit/code/core/src/react-native/View.d.ts
+interface Storage {
+  getItem: (key: string) => Promise<string | null> | string | null;
+  setItem: (key: string, value: string) => Promise<void> | void;
+}
+type StoryKind$1 = string;
+type StoryName$1 = string;
+type InitialSelection = `${StoryKind$1}--${StoryName$1}` | {
+  /**
+   * Kind is the default export name or the storiesOf("name") name
+   */
+  kind: StoryKind$1;
+  /**
+   * Name is the named export or the .add("name") name
+   */
+  name: StoryName$1;
+};
+type DeepPartial<T> = T extends object ? { [P in keyof T]?: DeepPartial<T[P]> } : T;
+type ThemePartial = DeepPartial<Theme$1>;
+type Params = {
+  onDeviceUI?: boolean;
+  /**
+   * Set as false to disable the wrapper around the story view.
+   * NOTE We may remove this in the future for a better solution.
+   * default: true
+   */
+  hasStoryWrapper?: boolean;
+  /**
+   * Enable websockets for the storybook server to remotely control the storybook
+   * default: automatically enabled when a websocket config is injected via storybook.requires (i.e. when STORYBOOK_WS_HOST is set), otherwise false
+   */
+  enableWebsockets?: boolean;
+  query?: string; /** The host for the websocket server. default: localhost */
+  host?: string; /** The port for the websocket server. default: 7007 */
+  port?: number;
+  secured?: boolean; /** The initial story */
+  initialSelection?: InitialSelection; /** Whether to persist story selection. default: true */
+  shouldPersistSelection?: boolean;
+  theme: ThemePartial; /** Used for persisting story selection. required. */
+  storage?: Storage; /** The custom UI component to use instead of the default UI */
+  CustomUIComponent?: SBUI;
+};
+declare class View {
+  _storyIndex: StoryIndex;
+  _setStory: (story: StoryContext<ReactRenderer>) => void;
+  _forceRerender: () => void;
+  _ready: boolean;
+  _preview: PreviewWithSelection<ReactRenderer>;
+  _asyncStorageStoryId: string | null;
+  _webUrl?: string;
+  _storage: Storage;
+  _channel: Channel;
+  _options: any;
+  _idToPrepared: Record<string, PreparedStory<ReactRenderer>>;
+  constructor(preview: PreviewWithSelection<ReactRenderer>, channel: Channel, options: any);
+  _storyIdExists: (storyId: string) => boolean;
+  _selectInitialStory: ({
+    selectionSpecifier,
+    storyIdFromUrl
+  }: {
+    selectionSpecifier: NonNullable<SelectionStore['selectionSpecifier']>;
+    storyIdFromUrl?: string | null;
+  }) => Promise<void>;
+  _getInitialStory: ({
+    initialSelection,
+    shouldPersistSelection
+  }?: Partial<Params>) => Promise<NonNullable<SelectionStore['selectionSpecifier']>>;
+  _getHost: (params?: Partial<Params>) => string;
+  __getPort: (params?: Partial<Params>) => number;
+  _isSecureConnection: (params?: Partial<Params>) => boolean;
+  _getServerChannel: (params?: Partial<Params>) => Channel;
+  createPreparedStoryMapping: () => Promise<void>;
+  getStorybookUI: (params?: Partial<Params>) => () => import("react").JSX.Element;
+}
+//#endregion
+//#region .dts-emit/code/core/src/react-native/prepareStories.d.ts
+/** Configuration options that are needed at startup, only serialisable values are possible */
+interface ReactNativeOptions {
+  /**
+   * Note that this is for future and play functions are not yet fully supported on native.
+   */
+  playFn?: boolean;
+}
+declare function prepareStories({
+  storyEntries,
+  options,
+  storySort
+}: {
+  storyEntries: (NormalizedStoriesSpecifier & {
+    req: any;
+  })[];
+  options?: ReactNativeOptions;
+  storySort?: Addon_StorySortParameterV7;
+}): {
+  index: {
+    v: number;
+    entries: Record<string, import("@aussieljk/forkbook/internal/types").IndexEntry>;
+  };
+  importMap: Record<string, any>;
+};
+//#endregion
+//#region .dts-emit/code/core/src/react-native/Start.d.ts
+type StoryEntry = NormalizedStoriesSpecifier & {
+  req: {
+    keys(): string[];
+    (id: string): unknown;
+  };
+};
+declare const getProjectAnnotations: (view: View, annotations: ModuleExports[]) => () => Promise<NormalizedProjectAnnotations<ReactRenderer>>;
+declare function start({
+  annotations,
+  storyEntries,
+  options
+}: {
+  storyEntries: StoryEntry[];
+  annotations: ModuleExports[];
+  options?: ReactNativeOptions;
+}): View;
+declare function updateView(viewInstance: View, annotations: ModuleExports[], normalizedStories: StoryEntry[], options?: ReactNativeOptions): void;
+//#endregion
+//#region .dts-emit/code/core/src/react-native/constants.d.ts
+declare const RN_STORYBOOK_STORAGE_KEY = "lastOpenedStory";
+declare const RN_STORYBOOK_EVENTS: {
+  RN_GET_INDEX: string;
+  RN_GET_INDEX_RESPONSE: string;
+};
+declare const STORYBOOK_STORY_ID_PARAM = "STORYBOOK_STORY_ID";
+//#endregion
+//#region .dts-emit/code/core/src/react-native/config.d.ts
+type Features = {
+  /** Enable the built-in on-device backgrounds addon panel. */ondeviceBackgrounds?: boolean;
+};
+type Addon = string | {
+  name: string;
+  options?: Record<string, any>;
+};
+interface StorybookConfig {
+  stories: StorybookConfig$1['stories'];
+  /** @deprecated Use `deviceAddons`. This field will be removed in a future version. */
+  addons?: Addon[];
+  /**
+   * Addons loaded only at runtime on the device and merged into
+   * `storybook.requires`. Not evaluated as presets by Storybook Core, which
+   * avoids failures during server-side operations like `extract`.
+   */
+  deviceAddons?: Addon[];
+  reactNative?: ReactNativeOptions;
+  features?: Features;
+  framework?: '@aussieljk/forkbook/react-native' | '@storybook/react-native';
+}
+//#endregion
+export { type Addon, type ArgTypes, type Args, type Decorator, type Features, type InitialSelection, type Loader, type Meta, type Parameters, type Params, type Preview, RN_STORYBOOK_EVENTS, RN_STORYBOOK_STORAGE_KEY, STORYBOOK_STORY_ID_PARAM, type Storage, type StoryFn, type StoryObj, type StorybookConfig, type Theme, type ThemePartial, type View, darkTheme, getProjectAnnotations, prepareStories, start, theme, updateView };