@aussieljk/forkbook 0.0.0-stage → 0.0.1-2

package/dist/channels/index.js

@@ -0,0 +1,352 @@
+import {
+  UniversalStore
+} from "../_browser-chunks/chunk-OQWFVDIN.js";
+import {
+  isJSON,
+  parse,
+  stringify
+} from "../_browser-chunks/chunk-WGVAAM43.js";
+import {
+  InvalidChannelPageError
+} from "../_browser-chunks/chunk-RNTIV5CE.js";
+import {
+  invariant
+} from "../_browser-chunks/chunk-IWQGIXJS.js";
+import {
+  Channel,
+  clearChannel,
+  ensureChannel,
+  getChannel,
+  installNoopChannel,
+  requireChannel,
+  setChannel
+} from "../_browser-chunks/chunk-OD6IBQCC.js";
+import "../_browser-chunks/chunk-RSPAQWVJ.js";
+import "../_browser-chunks/chunk-V5M7Q4HT.js";
+import "../_browser-chunks/chunk-IMSF75WX.js";
+
+// src/channels/postmessage/index.ts
+import { logger as logger2, pretty } from "@aussieljk/forkbook/internal/client-logger";
+import * as EVENTS from "@aussieljk/forkbook/internal/core-events";
+
+// src/shared/utils/local-hosts.ts
+var LOOPBACK_HOSTNAMES = ["localhost", "*.localhost", "127.0.0.1"], matchesHostname = (hostname, patterns) => patterns.some(
+  (pattern) => pattern.startsWith("*.") ? hostname.endsWith(pattern.slice(1)) : hostname === pattern
+);
+
+// src/channels/postmessage/getEventSourceUrl.ts
+import { logger } from "@aussieljk/forkbook/internal/client-logger";
+var pickFrameByRefId = (candidates, refId) => {
+  if (candidates.length === 1)
+    return candidates[0];
+  if (!(candidates.length === 0 || !refId))
+    return candidates.find(
+      (el) => (el.getAttribute("src") ?? "").includes(`refId=${encodeURIComponent(refId)}`)
+    );
+}, getEventSourceUrl = (event, refId) => {
+  let candidates = Array.from(
+    document.querySelectorAll("iframe[data-is-storybook]")
+  ).filter((element) => {
+    try {
+      return element.contentWindow?.location.origin === event.source.location.origin && element.contentWindow?.location.pathname === event.source.location.pathname;
+    } catch {
+    }
+    try {
+      return element.contentWindow === event.source;
+    } catch {
+    }
+    let src2 = element.getAttribute("src"), origin;
+    try {
+      if (!src2)
+        return !1;
+      ({ origin } = new URL(src2, document.location.toString()));
+    } catch {
+      return !1;
+    }
+    return origin === event.origin;
+  }), src = pickFrameByRefId(candidates, refId)?.getAttribute("src");
+  if (src) {
+    let { protocol, host, pathname } = new URL(src, document.location.toString());
+    return `${protocol}//${host}${pathname}`;
+  }
+  return candidates.length > 1 && logger.error("found multiple candidates for event source"), null;
+};
+
+// src/channels/postmessage/index.ts
+var { document: document2, location } = globalThis, KEY = "storybook-channel", CHANNEL_OPTIONS = globalThis.CHANNEL_OPTIONS || {}, defaultEventOptions = { maxDepth: 25 }, getReferrerOrigin = () => {
+  try {
+    let origin = document2?.referrer && new URL(document2.referrer).origin;
+    return origin && origin !== "null" ? origin : null;
+  } catch {
+    return null;
+  }
+}, isOnInitialBlankDocument = (frame) => {
+  try {
+    return frame.location.href === "about:blank";
+  } catch {
+    return !1;
+  }
+}, getOriginValidator = () => {
+  let own = location?.origin;
+  return globalThis.CONFIG_TYPE !== "DEVELOPMENT" || !own || own === "null" ? null : (origin) => {
+    if (origin === own)
+      return !0;
+    try {
+      return matchesHostname(new URL(origin).hostname, LOOPBACK_HOSTNAMES);
+    } catch {
+      return !1;
+    }
+  };
+}, PostMessageTransport = class {
+  constructor(config) {
+    this.config = config;
+    this.connected = !1;
+    this.rejectedOrigins = /* @__PURE__ */ new Set();
+    if (this.buffer = [], this.originValidator = getOriginValidator(), this.insecureIframeMessaging = globalThis.INSECURE_IFRAME_MESSAGING === !0, this.pinsTargetOrigin = globalThis.CONFIG_TYPE === "DEVELOPMENT" && !this.insecureIframeMessaging, typeof globalThis.addEventListener == "function" && globalThis.addEventListener("message", this.handleEvent.bind(this), !1), config.page !== "manager" && config.page !== "preview")
+      throw new InvalidChannelPageError({ page: config.page });
+  }
+  setHandler(handler) {
+    this.handler = (...args) => {
+      handler.apply(this, args), !this.connected && this.getLocalFrame().length && (this.flush(), this.connected = !0);
+    };
+  }
+  /**
+   * Sends `event` to the associated window. If the window does not yet exist the event will be
+   * stored in a buffer and sent when the window exists.
+   *
+   * @param event
+   */
+  send(event, options) {
+    let {
+      target,
+      // telejson options
+      allowRegExp,
+      allowSymbol,
+      allowDate,
+      allowError,
+      allowUndefined,
+      maxDepth,
+      space
+    } = options || {}, eventOptions = Object.fromEntries(
+      Object.entries({
+        allowRegExp,
+        allowSymbol,
+        allowDate,
+        allowError,
+        allowUndefined,
+        maxDepth,
+        space
+      }).filter(([k, v]) => typeof v < "u")
+    ), stringifyOptions = {
+      ...defaultEventOptions,
+      ...CHANNEL_OPTIONS,
+      ...eventOptions
+    }, frames = this.getFrames(target), query = new URLSearchParams(location?.search || ""), data = stringify(
+      {
+        key: KEY,
+        event,
+        refId: query.get("refId")
+      },
+      stringifyOptions
+    );
+    return frames.length ? (this.buffer.length && this.flush(), frames.forEach(({ contentWindow, targetOrigin }) => {
+      if (!(this.config.page === "manager" && isOnInitialBlankDocument(contentWindow)))
+        try {
+          contentWindow.postMessage(data, this.pinsTargetOrigin ? targetOrigin : "*");
+        } catch {
+          logger2.error("sending over postmessage fail");
+        }
+    }), Promise.resolve(null)) : new Promise((resolve, reject) => {
+      this.buffer.push({ event, resolve, reject });
+    });
+  }
+  flush() {
+    let { buffer } = this;
+    this.buffer = [], buffer.forEach((item) => {
+      this.send(item.event).then(item.resolve).catch(item.reject);
+    });
+  }
+  getFrames(target) {
+    if (this.config.page === "manager") {
+      let list = Array.from(
+        document2.querySelectorAll("iframe[data-is-storybook][data-is-loaded]")
+      ).flatMap((e) => {
+        try {
+          return e.contentWindow && e.dataset.isStorybook !== void 0 && e.id === target ? [
+            { contentWindow: e.contentWindow, targetOrigin: this.getIframeTargetOrigin(e) }
+          ] : [];
+        } catch {
+          return [];
+        }
+      });
+      return list?.length ? list : this.getCurrentFrames();
+    }
+    return globalThis.parent && globalThis.parent !== globalThis.self ? [{ contentWindow: globalThis.parent, targetOrigin: this.getManagerTargetOrigin() }] : [];
+  }
+  getCurrentFrames() {
+    return this.config.page === "manager" ? Array.from(
+      document2.querySelectorAll('[data-is-storybook="true"]')
+    ).flatMap(
+      (e) => e.contentWindow ? [{ contentWindow: e.contentWindow, targetOrigin: this.getIframeTargetOrigin(e) }] : []
+    ) : globalThis.parent ? [{ contentWindow: globalThis.parent, targetOrigin: this.getManagerTargetOrigin() }] : [];
+  }
+  getIframeTargetOrigin(element) {
+    let src = element.getAttribute("src");
+    if (src)
+      try {
+        let { origin } = new URL(src, document2.location.toString());
+        if (origin !== "null")
+          return origin;
+      } catch {
+      }
+    return location?.origin && location.origin !== "null" ? location.origin : "*";
+  }
+  // In composition the manager lives on a different origin than this preview; the referrer
+  // identifies which host embedded it.
+  getManagerTargetOrigin() {
+    let referrerOrigin = getReferrerOrigin();
+    return this.originValidator ? referrerOrigin !== null && this.originValidator(referrerOrigin) ? referrerOrigin : location.origin : referrerOrigin ?? "*";
+  }
+  getLocalFrame() {
+    return this.config.page === "manager" ? Array.from(
+      document2.querySelectorAll("#storybook-preview-iframe")
+    ).flatMap((e) => e.contentWindow ? [e.contentWindow] : []) : globalThis.parent ? [globalThis.parent] : [];
+  }
+  isAllowedSender(rawEvent) {
+    return this.insecureIframeMessaging ? !0 : this.config.page === "manager" ? this.isAllowedToContactManager(rawEvent) : this.config.page === "preview" ? this.isAllowedToContactPreview(rawEvent) : !1;
+  }
+  // A dev-mode preview only accepts messages from its own origin and from local hosts. A built
+  // preview, or one served from an opaque origin, has no validator and accepts any message.
+  isAllowedToContactPreview(rawEvent) {
+    return !this.originValidator || this.originValidator(rawEvent.origin) ? !0 : (this.warnOnceAboutRejectedSender(
+      rawEvent,
+      `Ignored Forkbook channel message from unexpected origin "${rawEvent.origin}". While it runs in dev mode, this preview only accepts messages from local hosts and its own origin. To accept messages from any origin, set "security.insecureIframeMessaging" to true in the main config of the Forkbook serving this preview.`
+    ), !1);
+  }
+  // A channel message reaches the manager only from a preview iframe it rendered itself: the local
+  // preview or a composed ref. `event.source` is set by the browser and cannot be forged, but it
+  // survives navigation, so in dev mode the message must also come from the origin the iframe was given.
+  isAllowedToContactManager(rawEvent) {
+    let senderFrame = rawEvent.source ? Array.from(document2.querySelectorAll("iframe")).find(
+      (frame) => frame.contentWindow === rawEvent.source
+    ) : void 0;
+    if (senderFrame?.hasAttribute("data-is-storybook")) {
+      if (!this.pinsTargetOrigin)
+        return !0;
+      let expectedOrigin = this.getIframeTargetOrigin(senderFrame);
+      return expectedOrigin === "*" || expectedOrigin === rawEvent.origin ? !0 : (this.warnOnceAboutRejectedSender(
+        rawEvent,
+        `Ignored Forkbook channel message from a registered preview iframe that is on origin "${rawEvent.origin}" instead of "${expectedOrigin}". While it runs in dev mode, the manager only accepts channel messages from the origin each preview iframe was given, so a page the iframe navigated to cannot send them. To accept messages from any origin, set "security.insecureIframeMessaging" to true.`
+      ), !1);
+    }
+    return senderFrame?.hasAttribute("data-is-storybook-thumbnail") || this.warnOnceAboutRejectedSender(
+      rawEvent,
+      `Ignored Forkbook channel message from a window that is not a registered preview iframe (origin "${rawEvent.origin}"). The manager only accepts channel messages from its own preview and composed Forkbook iframes, never from a page that embeds it. To accept messages from any window, set "security.insecureIframeMessaging" to true.`
+    ), !1;
+  }
+  warnOnceAboutRejectedSender(rawEvent, message) {
+    (typeof rawEvent.data == "string" ? rawEvent.data.includes(KEY) : rawEvent.data?.key === KEY) && !this.rejectedOrigins.has(rawEvent.origin) && (this.rejectedOrigins.add(rawEvent.origin), logger2.warn(message));
+  }
+  handleEvent(rawEvent) {
+    try {
+      if (!this.isAllowedSender(rawEvent))
+        return;
+      let { data } = rawEvent, { key, event, refId } = typeof data == "string" && isJSON(data) ? parse(data, CHANNEL_OPTIONS) : data;
+      if (key === KEY) {
+        let pageString = this.config.page === "manager" ? '<span style="color: #37D5D3; background: black"> manager </span>' : '<span style="color: #1EA7FD; background: black"> preview </span>', eventString = Object.values(EVENTS).includes(event.type) ? `<span style="color: #FF4785">${event.type}</span>` : `<span style="color: #FFAE00">${event.type}</span>`;
+        if (refId && (event.refId = refId), event.source = this.config.page === "preview" ? rawEvent.origin : getEventSourceUrl(rawEvent, refId), !event.source) {
+          pretty.error(
+            `${pageString} received ${eventString} but was unable to determine the source of the event`
+          );
+          return;
+        }
+        let message = `${pageString} received ${eventString} (${data.length})`;
+        pretty.debug(
+          location.origin !== event.source ? message : `${message} <span style="color: gray">(on ${location.origin} from ${event.source})</span>`,
+          ...event.args
+        ), invariant(this.handler, "ChannelHandler should be set"), this.config.page === "manager" && this.buffer.length && this.flush(), this.handler(event);
+      }
+    } catch (error) {
+      logger2.error(error);
+    }
+  }
+};
+
+// src/channels/websocket/index.ts
+import * as EVENTS2 from "@aussieljk/forkbook/internal/core-events";
+var HEARTBEAT_INTERVAL = 15e3, SERVER_CHANNEL_PATH = "/storybook-server-channel", CHANNEL_OPTIONS2 = globalThis.CHANNEL_OPTIONS || {}, WebsocketTransport = class {
+  constructor({ url, onError, page, createSocket }) {
+    this.buffer = [];
+    this.isReady = !1;
+    this.isClosed = !1;
+    this.socket = createSocket ? createSocket(url) : new WebSocket(url), this.socket.onopen = () => {
+      this.isReady = !0, this.flush();
+    }, this.socket.onmessage = ({ data }) => {
+      let event = typeof data == "string" && isJSON(data) ? parse(data) : data;
+      if (invariant(this.handler, "WebsocketTransport handler should be set"), event.type === "ping") {
+        this.send({ type: "pong" });
+        return;
+      }
+      this.handler(event);
+    }, this.socket.onerror = (e) => {
+      onError && onError(e);
+    }, this.socket.onclose = (ev) => {
+      invariant(this.handler, "WebsocketTransport handler should be set"), this.handler({
+        type: EVENTS2.CHANNEL_WS_DISCONNECT,
+        args: [{ reason: ev.reason, code: ev.code }],
+        from: page || "preview"
+      }), this.isClosed = !0;
+    };
+  }
+  setHandler(handler) {
+    this.handler = handler;
+  }
+  send(event) {
+    this.isClosed || (this.isReady ? this.sendNow(event) : this.sendLater(event));
+  }
+  sendLater(event) {
+    this.buffer.push(event);
+  }
+  sendNow(event) {
+    let data = stringify(event, {
+      maxDepth: 15,
+      ...CHANNEL_OPTIONS2
+    });
+    this.socket.send(data);
+  }
+  flush() {
+    let { buffer } = this;
+    this.buffer = [], buffer.forEach((event) => this.send(event));
+  }
+};
+
+// src/channels/index.ts
+var channels_default = Channel;
+function createBrowserChannel({ page, extraTransports = [] }) {
+  let transports = [new PostMessageTransport({ page }), ...extraTransports];
+  if (globalThis.CONFIG_TYPE === "DEVELOPMENT") {
+    let protocol = window.location.protocol === "http:" ? "ws" : "wss", { hostname, port } = window.location, { wsToken } = globalThis.CHANNEL_OPTIONS || {}, channelUrl = `${protocol}://${hostname}:${port}${SERVER_CHANNEL_PATH}?token=${wsToken}&page=${page}`;
+    transports.push(new WebsocketTransport({ url: channelUrl, onError: () => {
+    }, page }));
+  }
+  let channel = new Channel({ transports });
+  return UniversalStore.__prepare(
+    channel,
+    page === "manager" ? UniversalStore.Environment.MANAGER : UniversalStore.Environment.PREVIEW
+  ), channel;
+}
+export {
+  Channel,
+  HEARTBEAT_INTERVAL,
+  PostMessageTransport,
+  SERVER_CHANNEL_PATH,
+  WebsocketTransport,
+  clearChannel,
+  createBrowserChannel,
+  channels_default as default,
+  ensureChannel,
+  getChannel,
+  installNoopChannel,
+  requireChannel,
+  setChannel
+};

package/dist/chunk-B2t1tGRh.d.ts

@@ -0,0 +1,284 @@
+import { n as Options$1, t as ResultPromise } from "./chunk-BfBzpgct.js";
+import { PackageJson as PackageJson$1 } from "@aussieljk/forkbook/internal/types";
+
+//#region .dts-emit/code/core/src/common/utils/command.d.ts
+type ExecuteCommandOptions = Omit<Options$1, 'cancelSignal'> & {
+  command: string;
+  args?: string[];
+  cwd?: string;
+  ignoreError?: boolean;
+  env?: Record<string, string>;
+  signal?: AbortSignal;
+};
+declare function executeCommand(options: ExecuteCommandOptions): ResultPromise;
+declare function executeCommandSync(options: ExecuteCommandOptions): string;
+declare function executeNodeCommand({
+  scriptPath,
+  args,
+  options
+}: {
+  scriptPath: string;
+  args?: string[];
+  options?: Options$1;
+}): ResultPromise;
+//#endregion
+//#region .dts-emit/code/core/src/common/js-package-manager/PackageJson.d.ts
+type PackageJsonWithDepsAndDevDeps = PackageJson$1 & Required<Pick<PackageJson$1, 'dependencies' | 'devDependencies'>>;
+type PackageJsonWithMaybeDeps = Partial<Pick<PackageJson$1, 'dependencies' | 'devDependencies' | 'peerDependencies' | 'files'>>;
+//#endregion
+//#region .dts-emit/code/core/src/common/js-package-manager/types.d.ts
+type PackageMetadata = {
+  version: string;
+  location?: string;
+  reasons?: string[];
+};
+type InstallationMetadata = {
+  dependencies: Record<string, PackageMetadata[]>;
+  duplicatedDependencies: Record<string, string[]>;
+  infoCommand: string;
+  dedupeCommand: string;
+};
+//#endregion
+//#region .dts-emit/code/core/src/common/js-package-manager/JsPackageManager.d.ts
+declare enum PackageManagerName {
+  NPM = "npm",
+  YARN1 = "yarn1",
+  YARN2 = "yarn2",
+  PNPM = "pnpm",
+  BUN = "bun"
+}
+declare const indentSymbol: unique symbol;
+type PackageJsonWithIndent = PackageJsonWithDepsAndDevDeps & {
+  [indentSymbol]?: any;
+};
+/**
+ * Prints a package manager's name in a way that's easier to compute by humans and agents.
+ * @param packageManager The package manager's internal name (e.g. "yarn1")
+ * @return A human-friendly name for the package manager (e.g. "Yarn Classic (v1)")
+ */
+declare function getPrettyPackageManagerName(packageManager: string | undefined): string;
+/**
+ * Extract package name and version from input
+ *
+ * @param pkg A string like `@aussieljk/forkbook/internal/cli-commands`, `react` or `react@^16`
+ * @returns A tuple of 2 elements: [packageName, packageVersion]
+ */
+declare function getPackageDetails(pkg: string): [string, string?];
+interface JsPackageManagerOptions {
+  cwd?: string;
+  configDir?: string;
+  storiesPaths?: string[];
+}
+type PackageJsonInfo = {
+  packageJsonPath: string;
+  operationDir: string;
+  packageJson: PackageJsonWithDepsAndDevDeps;
+};
+declare abstract class JsPackageManager {
+  #private;
+  abstract readonly type: PackageManagerName;
+  /** The path to the primary package.json file (contains the `@aussieljk/forkbook` dependency). */
+  readonly primaryPackageJson: PackageJsonInfo;
+  /** The paths to all package.json files in the project root. */
+  packageJsonPaths: string[];
+  /**
+   * The path to the Forkbook instance directory. This is used to find the primary package.json
+   * file in a repository.
+   */
+  readonly instanceDir: string;
+  /** The current working directory. */
+  protected readonly cwd: string;
+  /** Cache for latest version results to avoid repeated network calls. */
+  static readonly latestVersionCache: Map<string, string | null>;
+  /** Cache for installed version results to avoid repeated file system calls. */
+  static readonly installedVersionCache: Map<string, string | null>;
+  /** Cache for package.json files to avoid repeated file system calls. */
+  static readonly packageJsonCache: Map<string, PackageJsonWithIndent>;
+  constructor(options?: JsPackageManagerOptions);
+  /** Returns the name of the command to invoke this package manager. */
+  abstract getCommandName(): string;
+  /** Installs package dependencies. */
+  abstract getInstallCommand(deps: string[], dev?: boolean): string;
+  /** Runs arbitrary package scripts (as a string for display). */
+  abstract getRunCommand(command: string): string;
+  /** Returns the command to run the binary of a local package */
+  abstract getPackageCommand(args: string[]): string;
+  /** Returns the command to run the binary of a remote package, as `runPackageCommand` does with `useRemotePkg` */
+  abstract getRemoteRunCommand(args: string[]): string;
+  /** Get the package.json file for a given module. */
+  abstract getModulePackageJSON(packageName: string, cwd?: string): Promise<PackageJson$1 | null>;
+  isStorybookInMonorepo(): boolean;
+  installDependencies(options?: {
+    force?: boolean;
+  }): Promise<void>;
+  precheckStorybookPackageInstall(options: {
+    storybookVersion: string;
+    nonInteractive: boolean;
+  }): Promise<void>;
+  dedupeDependencies(options?: {
+    force?: boolean;
+  }): Promise<void>;
+  /** Read the `package.json` file available in the provided directory */
+  static getPackageJson(packageJsonPath: string): PackageJsonWithIndent;
+  writePackageJson(packageJson: PackageJson$1, directory?: string): void;
+  getAllDependencies(): Record<string, string>;
+  isDependencyInstalled(dependency: string): boolean;
+  /**
+   * Resolve the effective version/range of a declared dependency: the installed version if present,
+   * otherwise the declared semver range. Returns null when the package is not declared or only a
+   * non-semver specifier is declared. PNPMProxy additionally resolves pnpm `catalog:` references.
+   */
+  getDeclaredVersionSpecifier(packageName: string): Promise<string | null>;
+  /**
+   * Pin `packages` to `version`, mirroring how `anchorPackage` is declared. The base implementation
+   * pins each directly (`pkg@version`). PNPMProxy overrides this to honor pnpm catalogs: when
+   * `anchorPackage` is declared through a catalog, the packages are registered in that catalog and
+   * referenced as `catalog:` instead. Returns the install specifiers to write to package.json.
+   */
+  applyVersionToRelatedPackages(packages: string[], version: string, _anchorPackage: string): string[];
+  /**
+   * Add dependencies to a project using `yarn add` or `npm install`.
+   *
+   * @example
+   *
+   * ```ts
+   * addDependencies(options, [
+   *   `@aussieljk/forkbook/react@${storybookVersion}`,
+   *   `@aussieljk/forkbook/addon-links@${linksVersion}`,
+   * ]);
+   * ```
+   *
+   * @param {Object} options Contains `skipInstall`, `packageJson` and `installAsDevDependencies`
+   *   which we use to determine how we install packages.
+   * @param {Array} dependencies Contains a list of packages to add.
+   */
+  addDependencies(options: {
+    skipInstall: true;
+    type: 'dependencies' | 'devDependencies' | 'peerDependencies';
+    writeOutputToFile?: boolean;
+    packageJsonInfo?: PackageJsonInfo;
+  } | {
+    skipInstall?: false;
+    type: 'dependencies' | 'devDependencies';
+    writeOutputToFile?: boolean;
+    packageJsonInfo?: PackageJsonInfo;
+  }, dependencies: string[]): Promise<void | ResultPromise>;
+  /**
+   * Removing dependencies from the package.json file, which is found first starting from the
+   * instance root. The method does not run a package manager install like `npm install`.
+   *
+   * @example
+   *
+   * ```ts
+   * removeDependencies([`@aussieljk/forkbook/react`]);
+   * ```
+   *
+   * @param dependencies Contains a list of packages to remove.
+   */
+  removeDependencies(dependencies: string[]): Promise<void>;
+  /**
+   * Return an array of strings matching following format: `<storybook_package_name>@<package_latest_version>`
+   *
+   * For packages in the storybook monorepo, when the latest version is equal to the version of the
+   * current CLI the version is not added to the string.
+   *
+   * When a package is in the monorepo, and the version is not equal to the CLI version, the version
+   * is taken from the versions.ts file and added to the string.
+   *
+   * When a package is not in the monorepo, we don't change the package version and return the package name as is.
+   * The package manager will resolve the latest version of the package upon installing it.
+   *
+   * @param packages
+   */
+  getVersionedPackages(packages: string[], options?: {
+    storybookVersionSpecifier?: string;
+  }): Promise<string[]>;
+  /**
+   * Return an array of string standing for the latest version of the input packages. To be able to
+   * identify which version goes with which package the order of the input array is keep.
+   *
+   * @param packageNames
+   */
+  getVersions(...packageNames: string[]): Promise<string[]>;
+  /**
+   * Return the latest version of the input package available on npmjs registry. If constraint are
+   * provided it return the latest version matching the constraints.
+   *
+   * For `@storybook/*` packages the latest version is retrieved from `cli/src/versions.json` file
+   * directly
+   *
+   * @param packageName The name of the package
+   * @param constraint A valid semver constraint, example: '1.x || >=2.5.0 || 5.0.0 - 7.2.3'
+   */
+  getVersion(packageName: string, constraint?: string): Promise<string>;
+  /**
+   * Get the latest version of the package available on npmjs.com. If constraint is set then it
+   * returns a version satisfying it, otherwise the latest version available is returned.
+   *
+   * @param packageName Name of the package
+   * @param constraint Version range to use to constraint the returned version
+   */
+  latestVersion(packageName: string, constraint?: string): Promise<string | null>;
+  /**
+   * Clear the latest version cache. Useful for testing or when you want to refresh version
+   * information.
+   *
+   * @param packageName Optional package name to clear only specific entries. If not provided,
+   *   clears all cache.
+   */
+  static clearLatestVersionCache(packageName?: string): void;
+  /**
+   * Clear the installed version cache for a specific package or all packages.
+   *
+   * @param packageName Optional package name to clear from cache. If not provided, clears all.
+   */
+  clearInstalledVersionCache(packageName?: string): void;
+  /**
+   * Clear both the latest version cache and installed version cache. This should be called after
+   * any operation that modifies dependencies.
+   */
+  clearAllVersionCaches(): void;
+  addStorybookCommandInScripts(options?: {
+    port: number;
+    preCommand?: string;
+  }): void;
+  addScripts(scripts: Record<string, string>): void;
+  addPackageResolutions(versions: Record<string, string>): void;
+  protected abstract runInstall(options?: {
+    force?: boolean;
+  }): ResultPromise;
+  protected abstract runAddDeps(dependencies: string[], installAsDevDependencies: boolean, writeOutputToFile?: boolean): ResultPromise;
+  protected abstract getResolutions(packageJson: PackageJson$1, versions: Record<string, string>): Record<string, any>;
+  /**
+   * Get the latest or all versions of the input package available on npmjs.com
+   *
+   * @param packageName Name of the package
+   * @param fetchAllVersions Should return
+   */
+  protected abstract runGetVersions<T extends boolean>(packageName: string, fetchAllVersions: T): Promise<T extends true ? string[] : string>;
+  abstract getRegistryURL(): Promise<string | undefined>;
+  abstract runInternalCommand(command: string, args: string[], cwd?: string, stdio?: 'inherit' | 'pipe' | 'ignore'): ResultPromise;
+  abstract runPackageCommand(options: Omit<ExecuteCommandOptions, 'command'> & {
+    args: string[];
+    useRemotePkg?: boolean;
+  }): ResultPromise;
+  abstract findInstallations(pattern?: string[]): Promise<InstallationMetadata | undefined>;
+  abstract findInstallations(pattern?: string[], options?: {
+    depth: number;
+  }): Promise<InstallationMetadata | undefined>;
+  /** Returns the installed version of a specified package */
+  getInstalledVersion(packageName: string): Promise<string | null>;
+  isPackageInstalled(packageName: string): Promise<boolean>;
+  /**
+   * Searches for a dependency/devDependency in all package.json files and returns the version of
+   * the dependency.
+   */
+  getDependencyVersion(dependency: string): string | null;
+  static hasStorybookDependency(packageJsonPath: string): boolean;
+  static hasAnyStorybookDependency(packageJsonPath: string): boolean;
+  /** List all package.json files starting from the given directory and stopping at the project root. */
+  static listAllPackageJsonPaths(instanceDir: string, storiesPaths?: string[]): string[];
+  static getPackageJsonInfo(packageJsonPath: string): PackageJsonInfo;
+}
+//#endregion
+export { getPrettyPackageManagerName as a, PackageJson$1 as c, ExecuteCommandOptions as d, executeCommand as f, getPackageDetails as i, PackageJsonWithDepsAndDevDeps as l, executeNodeCommand as m, PackageJsonInfo as n, InstallationMetadata as o, executeCommandSync as p, PackageManagerName as r, PackageMetadata as s, JsPackageManager as t, PackageJsonWithMaybeDeps as u };