storybook 10.1.0-alpha.1 → 10.1.0-alpha.11

package/dist/_node-chunks/p-limit-F5ZKJ6WZ.js

@@ -0,0 +1,116 @@
+import CJS_COMPAT_NODE_URL_843v2rliy1 from 'node:url';
+import CJS_COMPAT_NODE_PATH_843v2rliy1 from 'node:path';
+import CJS_COMPAT_NODE_MODULE_843v2rliy1 from "node:module";
+
+var __filename = CJS_COMPAT_NODE_URL_843v2rliy1.fileURLToPath(import.meta.url);
+var __dirname = CJS_COMPAT_NODE_PATH_843v2rliy1.dirname(__filename);
+var require = CJS_COMPAT_NODE_MODULE_843v2rliy1.createRequire(import.meta.url);
+
+// ------------------------------------------------------------
+// end of CJS compatibility banner, injected by Storybook's esbuild configuration
+// ------------------------------------------------------------
+import "./chunk-XGVLB4UJ.js";
+
+// ../node_modules/yocto-queue/index.js
+var Node = class {
+  value;
+  next;
+  constructor(value) {
+    this.value = value;
+  }
+}, Queue = class {
+  #head;
+  #tail;
+  #size;
+  constructor() {
+    this.clear();
+  }
+  enqueue(value) {
+    let node = new Node(value);
+    this.#head ? (this.#tail.next = node, this.#tail = node) : (this.#head = node, this.#tail = node), this.#size++;
+  }
+  dequeue() {
+    let current = this.#head;
+    if (current)
+      return this.#head = this.#head.next, this.#size--, this.#head || (this.#tail = void 0), current.value;
+  }
+  peek() {
+    if (this.#head)
+      return this.#head.value;
+  }
+  clear() {
+    this.#head = void 0, this.#tail = void 0, this.#size = 0;
+  }
+  get size() {
+    return this.#size;
+  }
+  *[Symbol.iterator]() {
+    let current = this.#head;
+    for (; current; )
+      yield current.value, current = current.next;
+  }
+  *drain() {
+    for (; this.#head; )
+      yield this.dequeue();
+  }
+};
+
+// ../node_modules/p-limit/index.js
+function pLimit(concurrency) {
+  validateConcurrency(concurrency);
+  let queue = new Queue(), activeCount = 0, resumeNext = () => {
+    activeCount < concurrency && queue.size > 0 && (queue.dequeue()(), activeCount++);
+  }, next = () => {
+    activeCount--, resumeNext();
+  }, run = async (function_, resolve, arguments_) => {
+    let result = (async () => function_(...arguments_))();
+    resolve(result);
+    try {
+      await result;
+    } catch {
+    }
+    next();
+  }, enqueue = (function_, resolve, arguments_) => {
+    new Promise((internalResolve) => {
+      queue.enqueue(internalResolve);
+    }).then(
+      run.bind(void 0, function_, resolve, arguments_)
+    ), (async () => (await Promise.resolve(), activeCount < concurrency && resumeNext()))();
+  }, generator = (function_, ...arguments_) => new Promise((resolve) => {
+    enqueue(function_, resolve, arguments_);
+  });
+  return Object.defineProperties(generator, {
+    activeCount: {
+      get: () => activeCount
+    },
+    pendingCount: {
+      get: () => queue.size
+    },
+    clearQueue: {
+      value() {
+        queue.clear();
+      }
+    },
+    concurrency: {
+      get: () => concurrency,
+      set(newConcurrency) {
+        validateConcurrency(newConcurrency), concurrency = newConcurrency, queueMicrotask(() => {
+          for (; activeCount < concurrency && queue.size > 0; )
+            resumeNext();
+        });
+      }
+    }
+  }), generator;
+}
+function limitFunction(function_, option) {
+  let { concurrency } = option, limit = pLimit(concurrency);
+  return (...arguments_) => limit(() => function_(...arguments_));
+}
+function validateConcurrency(concurrency) {
+  if (!((Number.isInteger(concurrency) || concurrency === Number.POSITIVE_INFINITY) && concurrency > 0))
+    throw new TypeError("Expected `concurrency` to be a number from 1 and up");
+}
+export {
+  pLimit as default,
+  limitFunction
+};

package/dist/_node-chunks/plugin-7YY7JXCH.js

@@ -0,0 +1,123 @@
+import CJS_COMPAT_NODE_URL_843v2rliy1 from 'node:url';
+import CJS_COMPAT_NODE_PATH_843v2rliy1 from 'node:path';
+import CJS_COMPAT_NODE_MODULE_843v2rliy1 from "node:module";
+
+var __filename = CJS_COMPAT_NODE_URL_843v2rliy1.fileURLToPath(import.meta.url);
+var __dirname = CJS_COMPAT_NODE_PATH_843v2rliy1.dirname(__filename);
+var require = CJS_COMPAT_NODE_MODULE_843v2rliy1.createRequire(import.meta.url);
+
+// ------------------------------------------------------------
+// end of CJS compatibility banner, injected by Storybook's esbuild configuration
+// ------------------------------------------------------------
+import {
+  getAutomockCode
+} from "./chunk-UGDPX5LE.js";
+import {
+  babelParser,
+  extractMockCalls,
+  getRealPath,
+  rewriteSbMockImportCalls
+} from "./chunk-ZZPBSYA5.js";
+import {
+  normalize
+} from "./chunk-BBOP3XCK.js";
+import "./chunk-XGVLB4UJ.js";
+
+// src/core-server/presets/vitePlugins/vite-mock/plugin.ts
+import { readFileSync } from "node:fs";
+import { logger } from "storybook/internal/node-logger";
+
+// src/core-server/presets/vitePlugins/vite-mock/utils.ts
+function getCleanId(id) {
+  return id.replace(/^.*\/deps\//, "").replace(/\.js.*$/, "").replace(/_/g, "/");
+}
+function invalidateAllRelatedModules(server, absPath, pkgName) {
+  for (let mod of server.moduleGraph.idToModuleMap.values())
+    (mod.id === absPath || mod.id && getCleanId(mod.id) === pkgName) && server.moduleGraph.invalidateModule(mod);
+}
+
+// src/core-server/presets/vitePlugins/vite-mock/plugin.ts
+function viteMockPlugin(options) {
+  let viteConfig, mockCalls = [], normalizedPreviewConfigPath = normalize(options.previewConfigPath);
+  return [
+    {
+      name: "storybook:mock-loader",
+      configResolved(config) {
+        viteConfig = config;
+      },
+      buildStart() {
+        mockCalls = extractMockCalls(options, babelParser, viteConfig.root);
+      },
+      configureServer(server) {
+        async function invalidateAffectedFiles(file) {
+          if (file === options.previewConfigPath || file.includes("__mocks__")) {
+            let oldMockCalls = mockCalls;
+            mockCalls = extractMockCalls(options, babelParser, viteConfig.root);
+            let previewMod = server.moduleGraph.getModuleById(options.previewConfigPath);
+            previewMod && server.moduleGraph.invalidateModule(previewMod);
+            for (let call of mockCalls)
+              invalidateAllRelatedModules(server, call.absolutePath, call.path);
+            let newAbsPaths = new Set(mockCalls.map((c) => c.absolutePath));
+            for (let oldCall of oldMockCalls)
+              newAbsPaths.has(oldCall.absolutePath) || invalidateAllRelatedModules(server, oldCall.absolutePath, oldCall.path);
+            return server.ws.send({ type: "full-reload" }), [];
+          }
+        }
+        server.watcher.on("change", invalidateAffectedFiles), server.watcher.on("add", invalidateAffectedFiles), server.watcher.on("unlink", invalidateAffectedFiles);
+      },
+      load: {
+        order: "pre",
+        handler(id) {
+          let preserveSymlinks = viteConfig.resolve.preserveSymlinks, idNorm = getRealPath(id, preserveSymlinks), cleanId = getCleanId(idNorm);
+          for (let call of mockCalls)
+            if (!(getRealPath(call.absolutePath, preserveSymlinks) !== idNorm && call.path !== cleanId) && call.redirectPath)
+              return this.addWatchFile(call.redirectPath), readFileSync(call.redirectPath, "utf-8");
+          return null;
+        }
+      },
+      transform: {
+        order: "pre",
+        handler(code, id) {
+          for (let call of mockCalls) {
+            let preserveSymlinks = viteConfig.resolve.preserveSymlinks, idNorm = getRealPath(id, preserveSymlinks), callNorm = getRealPath(call.absolutePath, preserveSymlinks);
+            if (viteConfig.command !== "serve") {
+              if (callNorm !== idNorm)
+                continue;
+            } else {
+              let cleanId = getCleanId(idNorm);
+              if (call.path !== cleanId && callNorm !== idNorm)
+                continue;
+            }
+            try {
+              if (!call.redirectPath) {
+                let automockedCode = getAutomockCode(code, call.spy, babelParser);
+                return {
+                  code: automockedCode.toString(),
+                  map: automockedCode.generateMap()
+                };
+              }
+            } catch (e) {
+              return logger.error(`Error automocking ${id}: ${e}`), null;
+            }
+          }
+          return null;
+        }
+      }
+    },
+    {
+      name: "storybook:mock-loader-preview",
+      transform(code, id) {
+        if (id === normalizedPreviewConfigPath)
+          try {
+            return rewriteSbMockImportCalls(code);
+          } catch (e) {
+            return logger.debug(`Could not transform sb.mock(import(...)) calls in ${id}: ${e}`), null;
+          }
+        return null;
+      }
+    }
+  ];
+}
+export {
+  viteMockPlugin
+};

package/dist/_node-chunks/{plugin-HJLCLGNT.js → plugin-SZP3CW6W.js}

@@ -1,25 +1,24 @@
-import CJS_COMPAT_NODE_URL_in4hyfgp7kn from 'node:url';
-import CJS_COMPAT_NODE_PATH_in4hyfgp7kn from 'node:path';
-import CJS_COMPAT_NODE_MODULE_in4hyfgp7kn from "node:module";
+import CJS_COMPAT_NODE_URL_843v2rliy1 from 'node:url';
+import CJS_COMPAT_NODE_PATH_843v2rliy1 from 'node:path';
+import CJS_COMPAT_NODE_MODULE_843v2rliy1 from "node:module";
 
-var __filename = CJS_COMPAT_NODE_URL_in4hyfgp7kn.fileURLToPath(import.meta.url);
-var __dirname = CJS_COMPAT_NODE_PATH_in4hyfgp7kn.dirname(__filename);
-var require = CJS_COMPAT_NODE_MODULE_in4hyfgp7kn.createRequire(import.meta.url);
+var __filename = CJS_COMPAT_NODE_URL_843v2rliy1.fileURLToPath(import.meta.url);
+var __dirname = CJS_COMPAT_NODE_PATH_843v2rliy1.dirname(__filename);
+var require = CJS_COMPAT_NODE_MODULE_843v2rliy1.createRequire(import.meta.url);
 
 // ------------------------------------------------------------
 // end of CJS compatibility banner, injected by Storybook's esbuild configuration
 // ------------------------------------------------------------
 import {
   resolvePackageDir
-} from "./chunk-6OAXYS5T.js";
-import "./chunk-BYVQZ2HU.js";
+} from "./chunk-SPQXMU2Q.js";
+import "./chunk-BBOP3XCK.js";
 import {
   require_dist
-} from "./chunk-TUFWZUTO.js";
+} from "./chunk-PHOZWZZO.js";
 import {
-  __name,
   __toESM
-} from "./chunk-XCEBYOA4.js";
+} from "./chunk-XGVLB4UJ.js";
 
 // src/core-server/presets/vitePlugins/vite-inject-mocker/plugin.ts
 import { readFileSync } from "node:fs";
@@ -30,37 +29,30 @@ import { fileURLToPath } from "node:url";
 function exactRegex(str, flags) {
   return new RegExp(`^${escapeRegex(str)}$`, flags);
 }
-__name(exactRegex, "exactRegex");
 var escapeRegexRE = /[-/\\^$*+?.()|[\]{}]/g;
 function escapeRegex(str) {
   return str.replace(escapeRegexRE, "\\$&");
 }
-__name(escapeRegex, "escapeRegex");
 
 // src/core-server/presets/vitePlugins/vite-inject-mocker/plugin.ts
 var import_ts_dedent = __toESM(require_dist(), 1);
-var entryPath = "/vite-inject-mocker-entry.js";
-var entryCode = import_ts_dedent.dedent`
+var entryPath = "/vite-inject-mocker-entry.js", entryCode = import_ts_dedent.dedent`
     <script type="module" src=".${entryPath}"></script>
-  `;
-var server;
-var viteInjectMockerRuntime = /* @__PURE__ */ __name((options) => {
+  `, server, viteInjectMockerRuntime = (options) => {
   let viteConfig;
   return {
     name: "vite:storybook-inject-mocker-runtime",
     buildStart() {
-      if (viteConfig.command === "build") {
-        this.emitFile({
-          type: "chunk",
-          id: join(
-            resolvePackageDir("storybook"),
-            "assets",
-            "server",
-            "mocker-runtime.template.js"
-          ),
-          fileName: entryPath.slice(1)
-        });
-      }
+      viteConfig.command === "build" && this.emitFile({
+        type: "chunk",
+        id: join(
+          resolvePackageDir("storybook"),
+          "assets",
+          "server",
+          "mocker-runtime.template.js"
+        ),
+        fileName: entryPath.slice(1)
+      });
     },
     config() {
       return {
@@ -82,48 +74,36 @@ var viteInjectMockerRuntime = /* @__PURE__ */ __name((options) => {
       viteConfig = config;
     },
     configureServer(server_) {
-      server = server_;
-      if (options.previewConfigPath) {
-        server.watcher.on("change", (file) => {
-          if (file === options.previewConfigPath) {
-            server.ws.send({
-              type: "custom",
-              event: "invalidate-mocker"
-            });
-          }
+      server = server_, options.previewConfigPath && server.watcher.on("change", (file) => {
+        file === options.previewConfigPath && server.ws.send({
+          type: "custom",
+          event: "invalidate-mocker"
         });
-      }
+      });
     },
     resolveId: {
       filter: {
         id: [exactRegex(entryPath)]
       },
       handler(id) {
-        if (exactRegex(id).test(entryPath)) {
-          return id;
-        }
-        return null;
+        return exactRegex(id).test(entryPath) ? id : null;
       }
     },
     async load(id) {
-      if (exactRegex(id).test(entryPath)) {
-        return readFileSync(
-          join(resolvePackageDir("storybook"), "assets", "server", "mocker-runtime.template.js"),
-          "utf-8"
-        );
-      }
-      return null;
+      return exactRegex(id).test(entryPath) ? readFileSync(
+        join(resolvePackageDir("storybook"), "assets", "server", "mocker-runtime.template.js"),
+        "utf-8"
+      ) : null;
     },
     transformIndexHtml(html) {
-      const headTag = html.match(/<head[^>]*>/);
+      let headTag = html.match(/<head[^>]*>/);
       if (headTag) {
-        const headTagIndex = html.indexOf(headTag[0]);
-        const newHtml = html.slice(0, headTagIndex + headTag[0].length) + entryCode + html.slice(headTagIndex + headTag[0].length);
-        return newHtml;
+        let headTagIndex = html.indexOf(headTag[0]);
+        return html.slice(0, headTagIndex + headTag[0].length) + entryCode + html.slice(headTagIndex + headTag[0].length);
       }
     }
   };
-}, "viteInjectMockerRuntime");
+};
 export {
   viteInjectMockerRuntime
 };