@aussieljk/forkbook 0.0.0-stage → 0.0.1-2

package/dist/_browser-chunks/react-dom-client-4OHE3QDV.js

@@ -0,0 +1,9 @@
+import {
+  renderElement,
+  unmountElement
+} from "./chunk-46Z7NGAS.js";
+import "./chunk-IMSF75WX.js";
+export {
+  renderElement,
+  unmountElement
+};

package/dist/_node-chunks/attached-runtime-I2G4WLJI.js

@@ -0,0 +1,282 @@
+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 {
+  readRegistry,
+  selectInstances
+} from "./chunk-LO56I6E2.js";
+import {
+  resolveStorybookConfigDir
+} from "./chunk-FK7KGTV7.js";
+import {
+  formatConnectionFailed,
+  formatInstallationMismatch,
+  formatNoInstance,
+  formatOldServer,
+  formatPortMismatch,
+  formatUnknownInstallation
+} from "./chunk-LXBD4UL4.js";
+import {
+  AttachUnavailableError,
+  EnvironmentMismatchError,
+  ToolsRuntimeError,
+  projectPathsEqual
+} from "./chunk-3SDUYDXH.js";
+import {
+  SERVER_CHANNEL_PATH,
+  WebsocketTransport
+} from "./chunk-42UWAGPW.js";
+import "./chunk-TWI4GVH7.js";
+import {
+  detectAgent
+} from "./chunk-DHJFTB4K.js";
+import "./chunk-JZOO7GGC.js";
+import {
+  UniversalStore
+} from "./chunk-OISX4AGQ.js";
+import {
+  getRegisteredToolsets
+} from "./chunk-3Y6AAY5H.js";
+import "./chunk-ICPBH3E7.js";
+import "./chunk-EWOX7HPJ.js";
+import {
+  Channel,
+  getChannel,
+  setChannel,
+  setDelegatedMode
+} from "./chunk-4FEANXWU.js";
+import "./chunk-TEQGGSP7.js";
+import "./chunk-OWNFOGTA.js";
+import "./chunk-HMP2G23X.js";
+import "./chunk-3W7F2B7P.js";
+import "./chunk-OUW6R7C3.js";
+import "./chunk-RRN2V55B.js";
+import "./chunk-34EO2PUT.js";
+import {
+  StorybookDevServerDisconnectedError
+} from "./chunk-U5W53R2J.js";
+import "./chunk-2BUPBPFB.js";
+import "./chunk-CXRU72ET.js";
+
+// src/cli/tools/sdk/attached-runtime.ts
+import { resolve } from "node:path";
+import {
+  defaultConfigDir,
+  findStorybookPackageRoot,
+  versions
+} from "@aussieljk/forkbook/internal/common";
+
+// src/cli/tools/sdk/node-channel.ts
+import { CHANNEL_WS_DISCONNECT } from "@aussieljk/forkbook/internal/core-events";
+import { WebSocket } from "ws";
+var LOOPBACK_HOSTNAMES = /* @__PURE__ */ new Set(["localhost", "127.0.0.1", "::1", "[::1]"]), installedNodeChannels = [], displacedSlot;
+function installNodeChannel(channel) {
+  installedNodeChannels.length === 0 && (displacedSlot = {
+    channel: getChannel(),
+    environment: UniversalStore.preparedEnvironment
+  }), installedNodeChannels.push(channel), setChannel(channel), UniversalStore.__prepare(channel, UniversalStore.Environment.UNKNOWN);
+}
+function uninstallNodeChannel(channel) {
+  let index = installedNodeChannels.indexOf(channel);
+  if (index >= 0 && installedNodeChannels.splice(index, 1), getChannel() !== channel) {
+    installedNodeChannels.length === 0 && (displacedSlot = void 0);
+    return;
+  }
+  let remaining = installedNodeChannels.at(-1);
+  if (remaining) {
+    setChannel(remaining), UniversalStore.__prepare(remaining, UniversalStore.Environment.UNKNOWN);
+    return;
+  }
+  let previous = displacedSlot;
+  displacedSlot = void 0, setChannel(previous?.channel ?? null), previous?.channel && previous.environment ? UniversalStore.__prepare(previous.channel, previous.environment) : UniversalStore.__reset();
+}
+function createNodeChannel({ url, token }) {
+  let socketUrl = new URL(url);
+  socketUrl.protocol = socketUrl.protocol === "https:" ? "wss:" : "ws:", socketUrl.pathname = SERVER_CHANNEL_PATH, socketUrl.search = new URLSearchParams({ token }).toString();
+  let rejectUnauthorized = !LOOPBACK_HOSTNAMES.has(socketUrl.hostname), socket = new WebSocket(socketUrl.href, { rejectUnauthorized }), connected = waitUntilOpen(socket);
+  connected.catch(() => {
+  });
+  let transport = new WebsocketTransport({
+    url: socketUrl.href,
+    onError: () => {
+    },
+    createSocket: () => socket
+  }), channel = new Channel({ transports: [transport] });
+  installNodeChannel(channel);
+  let disconnected = new Promise((_, reject) => {
+    channel.once(CHANNEL_WS_DISCONNECT, ({ code, reason }) => {
+      reject(new StorybookDevServerDisconnectedError({ code, reason }));
+    });
+  });
+  return disconnected.catch(() => {
+  }), {
+    channel,
+    connected,
+    disconnected,
+    close: () => {
+      socket.close(), uninstallNodeChannel(channel);
+    }
+  };
+}
+function waitUntilOpen(socket) {
+  return new Promise((resolve2, reject) => {
+    if (socket.readyState === WebSocket.OPEN) {
+      resolve2();
+      return;
+    }
+    let fail = (reason) => reject(new StorybookDevServerDisconnectedError({ reason }));
+    if (socket.readyState === WebSocket.CLOSED || socket.readyState === WebSocket.CLOSING) {
+      fail("WebSocket closed before the Forkbook channel opened");
+      return;
+    }
+    let settle = (action) => {
+      socket.off("open", onOpen), socket.off("error", onError), socket.off("close", onClose), action();
+    }, onOpen = () => settle(resolve2), onError = (error) => settle(() => fail(error.message)), onClose = () => settle(() => fail("WebSocket closed before the Forkbook channel opened"));
+    socket.once("open", onOpen), socket.once("error", onError), socket.once("close", onClose);
+  });
+}
+
+// src/cli/tools/sdk/installation.ts
+import { realpathSync } from "node:fs";
+import { normalize } from "pathe";
+function checkInstallation(record, callerPath) {
+  if (!callerPath || !record.storybookPath)
+    return { ok: !1, reason: "unknown-installation" };
+  let instancePath;
+  try {
+    instancePath = normalize(realpathSync(record.storybookPath));
+  } catch {
+    return { ok: !1, reason: "unknown-installation" };
+  }
+  return projectPathsEqual(instancePath, callerPath) ? { ok: !0 } : { ok: !1, reason: "different-installation", callerPath, instancePath };
+}
+
+// src/cli/tools/sdk/attached-runtime.ts
+async function bootstrapAttachedRuntime(options = {}, deps = {}) {
+  let discoveryCwd = resolve(options.cwd ?? process.cwd()), resolvedConfigDir = resolveStorybookConfigDir({
+    cwd: discoveryCwd,
+    configDir: options.configDir
+  }), records = await (deps.readRegistry ?? readRegistry)(), selection = selectInstances(records, {
+    cwd: discoveryCwd,
+    configDir: resolvedConfigDir,
+    configDirExplicit: options.configDir != null,
+    port: options.port,
+    agent: (deps.detectAgentName ?? (() => detectAgent()?.name))()
+  });
+  if (selection.kind === "no-instance")
+    throw new AttachUnavailableError({
+      reason: "no-instance",
+      instances: records,
+      remediation: formatNoInstance(records)
+    });
+  if (selection.kind === "port-mismatch")
+    throw new AttachUnavailableError({
+      reason: "port-mismatch",
+      instances: selection.candidates,
+      remediation: formatPortMismatch(selection.port, selection.candidates)
+    });
+  let [record, ...siblings] = selection.matches, callerVersion = deps.version ?? versions["@aussieljk/forkbook"];
+  if (!record.token)
+    throw new AttachUnavailableError({
+      reason: "old-server",
+      instances: [record],
+      remediation: formatOldServer(callerVersion)
+    });
+  let callerStorybookPath = (deps.storybookPath ?? findStorybookPackageRoot)(), installation = checkInstallation(record, callerStorybookPath);
+  if (!installation.ok) {
+    let autoSpawn = options.autoSpawn ?? !1, isChildHost = deps.isChildHost ?? process.env.FORKBOOK_TOOLS_CHILD_HOST === "true";
+    if (installation.reason === "different-installation" && autoSpawn && !isChildHost)
+      return { kind: "spawn", record, storybookPath: installation.instancePath, siblings };
+    throw new EnvironmentMismatchError({
+      reason: installation.reason === "different-installation" ? formatInstallationMismatch({
+        callerPath: installation.callerPath,
+        callerVersion,
+        instancePath: installation.instancePath,
+        instanceVersion: record.storybookVersion,
+        configDir: record.configDir
+      }) : formatUnknownInstallation()
+    });
+  }
+  let connection;
+  try {
+    connection = await (deps.createNodeChannel ?? createNodeChannel)({
+      url: record.url,
+      token: record.token
+    }), await waitForHandshake(connection);
+  } catch {
+    throw connection?.close(), new AttachUnavailableError({
+      reason: "connection-failed",
+      instances: [record],
+      remediation: formatConnectionFailed(record)
+    });
+  }
+  let enableDelegatedMode = deps.setDelegatedMode ?? setDelegatedMode;
+  enableDelegatedMode(!0);
+  let configDir = record.configDir ?? resolve(record.cwd, defaultConfigDir(record.cwd)), { loadStorybook, getService } = await resolveLoaders(deps);
+  try {
+    await loadStorybook({ configDir, channel: connection.channel });
+  } catch (error) {
+    throw enableDelegatedMode(!1), connection.close(), new ToolsRuntimeError({
+      reason: "config-load-failed",
+      message: `Could not load the Forkbook configuration for this project: ${error instanceof Error ? error.message : String(error)}`,
+      cause: error
+    });
+  }
+  return {
+    kind: "in-process",
+    runtime: {
+      configDir,
+      toolsets: (deps.getRegisteredToolsets ?? getRegisteredToolsets)(),
+      getService,
+      close: async () => {
+      }
+    },
+    record,
+    siblings,
+    connection
+  };
+}
+async function resolveLoaders(deps) {
+  if (deps.loadStorybook && deps.getService)
+    return { loadStorybook: deps.loadStorybook, getService: deps.getService };
+  let core = await import("@aussieljk/forkbook/internal/core-server");
+  return {
+    loadStorybook: deps.loadStorybook ?? ((options) => core.experimental_loadStorybook({
+      configDir: options.configDir,
+      channel: options.channel
+    })),
+    getService: deps.getService ?? ((id, options) => core.getService(id, options))
+  };
+}
+var ATTACH_HANDSHAKE_TIMEOUT_MS = 1e4;
+async function waitForHandshake(connection) {
+  let timer;
+  try {
+    await Promise.race([
+      connection.connected,
+      new Promise((_, reject) => {
+        timer = setTimeout(
+          () => reject(
+            new StorybookDevServerDisconnectedError({
+              reason: "Timed out waiting for the Forkbook channel to open"
+            })
+          ),
+          ATTACH_HANDSHAKE_TIMEOUT_MS
+        );
+      })
+    ]);
+  } finally {
+    clearTimeout(timer);
+  }
+}
+export {
+  bootstrapAttachedRuntime
+};