@storybook-astro/framework 1.2.0 → 1.3.0-canary.1

package/dist/chunk-PBISP7PA.js

@@ -1,1137 +0,0 @@
-import {
-  installPassthroughImageService,
-  resolveSanitizationOptions,
-  resolveStoryModuleMock,
-  sanitizeRenderPayload,
-  selectStoryRules,
-  serializeSanitizationOptions,
-  withStoryModuleMocks,
-  withStoryRuleCleanups
-} from "./chunk-OUEDTRBO.js";
-import {
-  createVirtualModulePlugin,
-  resolveRulesConfigFilePath,
-  ssrLoadModuleWithFsFallback,
-  viteAstroContainerRenderersPlugin,
-  vitePluginAstroFontsFallback,
-  vitePluginAstroIntegrationOptsFallback,
-  vitePluginAstroRoutesFallback,
-  vitePluginAstroVueFallback,
-  vitePluginStorybookAstroMiddleware
-} from "./chunk-POHTFYST.js";
-import {
-  vitePluginAstroComponentMarker
-} from "./chunk-E4LB75JN.js";
-import {
-  importAstroConfig
-} from "./chunk-DNGQBPT7.js";
-
-// src/viteStorybookRendererFallbackPlugin.ts
-function viteStorybookRendererFallbackPlugin(integrations) {
-  const safeIntegrations = integrations ?? [];
-  return createVirtualModulePlugin({
-    pluginName: "storybook-renderer-fallback",
-    virtualModuleId: "virtual:storybook-renderer-fallback",
-    load() {
-      return safeIntegrations.filter((integration) => integration.storybookEntryPreview).map(
-        (integration) => `export * as ${integration.name} from '${integration.storybookEntryPreview}';`
-      ).join("\n");
-    }
-  });
-}
-
-// src/viteStorybookAstroRendererPlugin.ts
-var packageName = "@storybook-astro/framework";
-function viteStorybookAstroRendererPlugin(options) {
-  const pluginName = "storybook-astro:renderer-module";
-  const virtualModuleId = "virtual:storybook-astro-renderer";
-  const isProduction = options.mode === "production";
-  const isStaticMode = options.renderMode === "static";
-  return createVirtualModulePlugin({
-    pluginName,
-    virtualModuleId,
-    load() {
-      if (!isProduction) {
-        return `export * from '${packageName}/renderer/renderer-dev.ts';`;
-      }
-      if (isStaticMode) {
-        return `export * from '${packageName}/renderer/renderer-static.ts';`;
-      }
-      return [
-        `import { createServerRenderer } from '${packageName}/renderer/renderer-server.ts';`,
-        `const renderer = createServerRenderer(${JSON.stringify(
-          {
-            serverUrl: options.server?.serverUrl,
-            authToken: options.server?.authToken,
-            authHeader: options.server?.authHeader
-          },
-          null,
-          2
-        )});`,
-        "export const render = renderer.render;",
-        "export const init = renderer.init;",
-        "export const applyStyles = renderer.applyStyles;"
-      ].join("\n");
-    }
-  });
-}
-
-// src/vitePluginAstroBuildPrerender.ts
-import { createRequire } from "module";
-import { mkdir, readFile, readdir, writeFile } from "fs/promises";
-import { resolve } from "path";
-import { createServer, mergeConfig } from "vite";
-var PRERENDERED_STORIES_FILE = "astro-prerendered-stories.json";
-function vitePluginAstroBuildPrerender(options) {
-  const integrations = options.integrations ?? [];
-  const resolveFrom = options.resolveFrom ?? process.cwd();
-  const storyRulesConfigFilePath = resolveRulesConfigFilePath(options.storyRules, resolveFrom);
-  const trackedSpecifiers = collectTrackedSpecifiers(integrations);
-  const staticEntrypointRefs = /* @__PURE__ */ new Map();
-  const componentEntrypointRefs = /* @__PURE__ */ new Map();
-  let outDir = resolve(resolveFrom, "storybook-static");
-  return {
-    name: "storybook-astro:build-prerender",
-    apply: "build",
-    enforce: "post",
-    configResolved(config) {
-      outDir = resolve(resolveFrom, config.build.outDir ?? "storybook-static");
-    },
-    resolveId(id) {
-      if (id.startsWith("virtual:astro-static-module/")) {
-        return `\0${id}`;
-      }
-      if (id.startsWith("virtual:astro-component-module/")) {
-        return `\0${id}`;
-      }
-    },
-    load(id) {
-      if (id.startsWith("\0virtual:astro-static-module/")) {
-        const encodedSpecifier = id.replace("\0virtual:astro-static-module/", "");
-        const specifier = decodeURIComponent(encodedSpecifier);
-        if (isClientEntrypoint(specifier)) {
-          return [`export { default } from '${specifier}';`, `export * from '${specifier}';`].join("\n");
-        }
-        return [`import '${specifier}';`, "export default undefined;"].join("\n");
-      }
-      if (id.startsWith("\0virtual:astro-component-module/")) {
-        const withoutPrefix = id.replace("\0virtual:astro-component-module/", "");
-        const encodedSpecifier = withoutPrefix.replace(/\?.*$/, "");
-        const specifier = decodeURIComponent(encodedSpecifier);
-        return [`export { default } from '${specifier}';`, `export * from '${specifier}';`].join("\n");
-      }
-    },
-    async buildStart() {
-      integrations.forEach((integration) => {
-        const entrypoint = integration.renderer.client?.entrypoint;
-        if (entrypoint) {
-          this.addWatchFile(entrypoint);
-        }
-      });
-      trackedSpecifiers.forEach((specifier) => {
-        const fileReferenceId = this.emitFile({
-          type: "chunk",
-          id: toStaticVirtualId(specifier)
-        });
-        staticEntrypointRefs.set(specifier, fileReferenceId);
-      });
-      const componentRootPaths = [
-        resolve(resolveFrom, "src/components"),
-        ...options.renderMode === "static" && options.componentRoots ? options.componentRoots.map((root) => resolve(resolveFrom, root)) : []
-      ];
-      const specifierArrays = await Promise.all(
-        componentRootPaths.map((root) => collectHydratableSourceModules(root))
-      );
-      const specifiers = specifierArrays.flat();
-      specifiers.forEach((specifier) => {
-        const chunkId = /\.(svelte|vue)$/.test(specifier) ? specifier : toComponentVirtualId(specifier);
-        const fileReferenceId = this.emitFile({ type: "chunk", id: chunkId });
-        componentEntrypointRefs.set(specifier, fileReferenceId);
-      });
-    },
-    async writeBundle(_outputOptions, bundle) {
-      const staticModuleMap = buildStaticModuleMap(
-        this,
-        staticEntrypointRefs,
-        componentEntrypointRefs
-      );
-      const stories = await collectAstroStories(outDir);
-      if (stories.length === 0) {
-        await writePrerenderedStoriesFile(outDir, {});
-        return;
-      }
-      const prerenderedStories = await prerenderStories({
-        stories,
-        integrations,
-        sanitization: options.sanitization,
-        storyRulesConfigFilePath,
-        staticModuleMap,
-        trackedSpecifiers,
-        resolveFrom,
-        bundle
-      });
-      await writePrerenderedStoriesFile(outDir, prerenderedStories);
-    }
-  };
-}
-async function writePrerenderedStoriesFile(outDir, payload) {
-  await mkdir(outDir, { recursive: true });
-  await writeFile(resolve(outDir, PRERENDERED_STORIES_FILE), JSON.stringify(payload), "utf-8");
-}
-async function prerenderStories(options) {
-  const sanitizationOptions = resolveSanitizationOptions(options.sanitization ?? void 0);
-  const resolveClientModule = createClientModuleResolver(
-    options.integrations,
-    options.staticModuleMap
-  );
-  const viteServer = await createStorySsrServer(
-    options.integrations,
-    options.trackedSpecifiers,
-    options.resolveFrom
-  );
-  const rulesConfigModule = await loadRulesConfigModule(viteServer, options.storyRulesConfigFilePath);
-  const assetPathMap = buildAssetPathMap(options.bundle);
-  installPassthroughImageService();
-  try {
-    const containerModule = await viteServer.ssrLoadModule("astro/container");
-    const AstroContainerRuntime = containerModule.experimental_AstroContainer;
-    const container = await AstroContainerRuntime.create({
-      resolve: async (specifier) => {
-        const mockedModule = resolveStoryModuleMock(specifier);
-        if (mockedModule) {
-          return mockedModule;
-        }
-        const resolution = resolveClientModule(specifier);
-        if (resolution) {
-          return resolution;
-        }
-        return specifier;
-      }
-    });
-    await addContainerRenderers(container, options.integrations, resolveClientModule, viteServer);
-    const output = {};
-    for (const story of options.stories) {
-      const selectedRules = await selectStoryRules({
-        configModule: rulesConfigModule,
-        configFilePath: options.storyRulesConfigFilePath,
-        story: {
-          id: story.id,
-          title: story.title,
-          name: story.name
-        }
-      });
-      if (selectedRules.moduleMocks.size > 0) {
-        viteServer.moduleGraph.invalidateAll();
-      }
-      const html = await withStoryRuleCleanups(selectedRules.cleanups, async () => {
-        return withStoryModuleMocks(selectedRules.moduleMocks, async () => {
-          const modulePath = resolveImportPath(story.importPath, options.resolveFrom);
-          const storyModule = await viteServer.ssrLoadModule(modulePath);
-          const meta = isRecord(storyModule.default) ? storyModule.default : {};
-          const storyExport = isRecord(storyModule[story.exportName]) ? storyModule[story.exportName] : {};
-          if (typeof meta.component !== "function") {
-            throw new Error(
-              `Unable to prerender story "${story.id}". Missing default export component in ${story.importPath}.`
-            );
-          }
-          if (storyExport.component && storyExport.component !== meta.component) {
-            return void 0;
-          }
-          const mergedArgs = mergeStoryArgs(toRecord(meta.args), toRecord(storyExport.args));
-          const { args, slots } = separateSlots(mergedArgs);
-          const processedArgs = await processImageMetadata(args);
-          const sanitizedPayload = sanitizeRenderPayload(
-            {
-              args: processedArgs,
-              slots
-            },
-            sanitizationOptions
-          );
-          return container.renderToString(
-            patchCreateAstroCompat(meta.component),
-            {
-              props: sanitizedPayload.args,
-              slots: sanitizedPayload.slots
-            }
-          );
-        });
-      });
-      if (html !== void 0) {
-        output[story.id] = rewriteAssetPaths(html, assetPathMap);
-      }
-    }
-    return output;
-  } finally {
-    await viteServer.close();
-  }
-}
-async function createStorySsrServer(integrations, trackedSpecifiers, resolveFrom) {
-  const { getViteConfig, passthroughImageService } = await importAstroConfig(resolveFrom);
-  const astroConfig = await getViteConfig(
-    { root: resolveFrom },
-    {
-      configFile: false,
-      integrations: await Promise.all(
-        integrations.map((integration) => integration.loadIntegration(resolveFrom))
-      ),
-      // Use the passthrough image service so nested components that use <Image>
-      // from astro:assets render as plain <img> tags without triggering image
-      // optimization (which fails in the Storybook SSR context).
-      image: { service: passthroughImageService() }
-    }
-  )({
-    mode: "production",
-    command: "serve"
-  });
-  const config = mergeConfig(astroConfig, {
-    appType: "custom",
-    server: {
-      middlewareMode: true
-    },
-    ssr: {
-      // Force Astro runtime modules to be loaded through Vite's SSR transform
-      // pipeline rather than being externalized via Node.js native import().
-      // Without this, the AstroContainer (loaded via ssrLoadModule) and the
-      // component rendering pipeline may resolve internal classes like
-      // SlotString/HTMLString from separate module instances, causing
-      // instanceof checks to fail and slot HTML to be escaped.
-      noExternal: /^astro(\/.+)?$/
-    },
-    plugins: [
-      createProjectAstroResolutionPlugin(resolveFrom),
-      vitePluginAstroFontsFallback(),
-      vitePluginAstroIntegrationOptsFallback(),
-      vitePluginAstroVueFallback(),
-      vitePluginAstroRoutesFallback(),
-      {
-        name: "storybook-astro:static-prerender-ssr-stubs",
-        resolveId(id) {
-          if (trackedSpecifiers.has(id)) {
-            return `\0storybook-astro-static-prerender-stub:${encodeURIComponent(id)}`;
-          }
-        },
-        load(id) {
-          if (id.startsWith("\0storybook-astro-static-prerender-stub:")) {
-            return "export default undefined;";
-          }
-        }
-      }
-    ]
-  });
-  return createServer(config);
-}
-async function loadRulesConfigModule(viteServer, configFilePath) {
-  if (!configFilePath) {
-    return void 0;
-  }
-  try {
-    return await ssrLoadModuleWithFsFallback(viteServer, configFilePath, {
-      fixStacktrace: true
-    });
-  } catch (error) {
-    const reason = error instanceof Error ? error.message : String(error);
-    throw new Error(
-      `Unable to load framework.options.storyRules config module at ${configFilePath}: ${reason}`
-    );
-  }
-}
-async function addContainerRenderers(container, integrations, resolveClientModule, viteServer) {
-  for (const integration of integrations) {
-    const serverRenderer = integration.renderer.server;
-    if (serverRenderer) {
-      const serverRendererModule = await viteServer.ssrLoadModule(serverRenderer.entrypoint);
-      const renderer = serverRendererModule.default ?? serverRendererModule;
-      if (integration.name === "solid" && isRecord(renderer)) {
-        container.addServerRenderer({
-          name: serverRenderer.name,
-          renderer: {
-            ...renderer,
-            name: serverRenderer.name
-          }
-        });
-      } else {
-        container.addServerRenderer({
-          name: serverRenderer.name,
-          renderer
-        });
-      }
-    }
-    const clientRenderer = integration.renderer.client;
-    if (clientRenderer) {
-      const resolvedEntrypoint = resolveClientModule(clientRenderer.entrypoint) ?? clientRenderer.entrypoint;
-      container.addClientRenderer({
-        name: clientRenderer.name,
-        entrypoint: resolvedEntrypoint
-      });
-    }
-  }
-}
-function createClientModuleResolver(integrations, staticModuleMap) {
-  return function resolveClientModule(specifier) {
-    if (Object.hasOwn(staticModuleMap, specifier)) {
-      return staticModuleMap[specifier];
-    }
-    const normalizedSpecifier = specifier.replace(/\\/g, "/").replace(/\?.*$/, "");
-    if (Object.hasOwn(staticModuleMap, normalizedSpecifier)) {
-      return staticModuleMap[normalizedSpecifier];
-    }
-    for (const integration of integrations) {
-      const resolution = integration.resolveClient(specifier);
-      if (resolution) {
-        return resolution;
-      }
-    }
-  };
-}
-async function collectAstroStories(outDir) {
-  const indexFile = resolve(outDir, "index.json");
-  const indexRaw = await readFile(indexFile, "utf-8");
-  const indexJson = JSON.parse(indexRaw);
-  return Object.values(indexJson.entries ?? {}).filter((entry) => entry.type === "story" && entry.componentPath?.endsWith(".astro")).map((entry) => {
-    if (!entry.id || !entry.importPath || !entry.exportName) {
-      throw new Error(`Encountered an invalid Storybook index entry in ${indexFile}.`);
-    }
-    return {
-      id: entry.id,
-      importPath: entry.importPath,
-      exportName: entry.exportName,
-      title: entry.title,
-      name: entry.name
-    };
-  });
-}
-function mergeStoryArgs(metaArgs, storyArgs) {
-  return {
-    ...metaArgs ?? {},
-    ...storyArgs ?? {}
-  };
-}
-function separateSlots(inputArgs) {
-  const args = { ...inputArgs };
-  const slotsCandidate = args.slots;
-  delete args.slots;
-  if (!isRecord(slotsCandidate)) {
-    return {
-      args,
-      slots: {}
-    };
-  }
-  return {
-    args,
-    slots: slotsCandidate
-  };
-}
-function resolveImportPath(importPath, resolveFrom) {
-  if (importPath.startsWith("./")) {
-    return resolve(resolveFrom, importPath.slice(2));
-  }
-  return resolve(resolveFrom, importPath);
-}
-function isRecord(value) {
-  return typeof value === "object" && value !== null;
-}
-function toRecord(value) {
-  if (!isRecord(value)) {
-    return void 0;
-  }
-  return value;
-}
-function collectTrackedSpecifiers(integrations) {
-  const specifiers = /* @__PURE__ */ new Set(["astro:scripts/page.js", "astro:scripts/before-hydration.js"]);
-  integrations.forEach((integration) => {
-    const entrypoint = integration.renderer.client?.entrypoint;
-    if (entrypoint) {
-      specifiers.add(entrypoint);
-    }
-  });
-  return specifiers;
-}
-function buildStaticModuleMap(pluginContext, staticEntrypointRefs, componentEntrypointRefs) {
-  const map = {};
-  staticEntrypointRefs.forEach((fileReferenceId, specifier) => {
-    const fileName = pluginContext.getFileName(fileReferenceId);
-    if (fileName) {
-      map[specifier] = toPublicPath(fileName);
-    }
-  });
-  componentEntrypointRefs.forEach((fileReferenceId, specifier) => {
-    const fileName = pluginContext.getFileName(fileReferenceId);
-    if (fileName) {
-      map[specifier] = toPublicPath(fileName);
-    }
-  });
-  return map;
-}
-function toStaticVirtualId(specifier) {
-  return `virtual:astro-static-module/${encodeURIComponent(specifier)}`;
-}
-function toComponentVirtualId(specifier) {
-  return `virtual:astro-component-module/${encodeURIComponent(specifier)}?component-wrapper`;
-}
-function isClientEntrypoint(specifier) {
-  return specifier.startsWith("@astrojs/") && specifier.endsWith("/client.js");
-}
-function toPublicPath(fileName) {
-  return `./${fileName}`;
-}
-function buildAssetPathMap(bundle) {
-  const exactMap = /* @__PURE__ */ new Map();
-  const stemMap = /* @__PURE__ */ new Map();
-  for (const chunk of Object.values(bundle)) {
-    if (chunk.type !== "asset") {
-      continue;
-    }
-    const asset = chunk;
-    if (asset.originalFileNames && asset.originalFileNames.length > 0) {
-      for (const originalPath of asset.originalFileNames) {
-        exactMap.set(originalPath, `/${asset.fileName}`);
-      }
-    }
-    const baseName = asset.fileName.split("/").pop() ?? "";
-    const stemMatch = baseName.match(/^(.+)-[A-Za-z0-9]{6,12}\.(png|jpe?g|gif|webp|svg|avif|ico)$/);
-    if (stemMatch) {
-      stemMap.set(`${stemMatch[1]}.${stemMatch[2]}`, `/${asset.fileName}`);
-    }
-  }
-  return { exactMap, stemMap };
-}
-function rewriteAssetPaths(html, assetPathMap) {
-  const { exactMap, stemMap } = assetPathMap;
-  if (exactMap.size === 0 && stemMap.size === 0) {
-    return html;
-  }
-  return html.replace(/\/@fs\/[^"']+/g, (match) => {
-    const pathOnly = match.replace(/\?.*$/, "");
-    const fsPath = pathOnly.slice("/@fs".length);
-    const absolutePath = fsPath.startsWith("//") ? fsPath.slice(1) : fsPath;
-    const exact = exactMap.get(absolutePath);
-    if (exact) {
-      return exact;
-    }
-    const baseName = absolutePath.split("/").pop() ?? "";
-    const stemHit = stemMap.get(baseName);
-    if (stemHit) {
-      return stemHit;
-    }
-    return match;
-  });
-}
-async function collectHydratableSourceModules(srcRoot) {
-  const modules = [];
-  async function walk(directory) {
-    let entries;
-    try {
-      entries = await readdir(directory, { withFileTypes: true });
-    } catch {
-      return;
-    }
-    await Promise.all(
-      entries.map(async (entry) => {
-        const absolutePath = resolve(directory, entry.name);
-        if (entry.isDirectory()) {
-          await walk(absolutePath);
-          return;
-        }
-        if (!entry.isFile()) {
-          return;
-        }
-        const normalizedPath = absolutePath.replace(/\\/g, "/");
-        if (!isHydratableSourceFile(normalizedPath)) {
-          return;
-        }
-        if (isNonHydratableSourceFile(normalizedPath)) {
-          return;
-        }
-        modules.push(normalizedPath);
-      })
-    );
-  }
-  await walk(srcRoot);
-  return modules;
-}
-function isHydratableSourceFile(input) {
-  return /\.(jsx|tsx|vue|svelte)$/.test(input);
-}
-function isNonHydratableSourceFile(input) {
-  return /\.stories\.[jt]sx?$|\.stories\.vue$|\.stories\.svelte$|\.(spec|test)\.[jt]sx?$/.test(
-    input
-  );
-}
-function patchCreateAstroCompat(component) {
-  if (typeof component !== "function") {
-    throw new Error("Expected Astro component factory to be a function.");
-  }
-  const originalComponent = component;
-  const wrapped = ((result, props, slots) => {
-    if (result && typeof result.createAstro === "function") {
-      const originalCreateAstro = result.createAstro;
-      const runtimeExpectsAstroGlobal = originalCreateAstro.length >= 3;
-      result.createAstro = (...args) => {
-        if (args.length === 3 && !runtimeExpectsAstroGlobal) {
-          return originalCreateAstro(args[1], args[2]);
-        }
-        return originalCreateAstro(...args);
-      };
-    }
-    return originalComponent(result, props, slots);
-  });
-  wrapped.isAstroComponentFactory = originalComponent.isAstroComponentFactory;
-  wrapped.moduleId = originalComponent.moduleId;
-  wrapped.propagation = originalComponent.propagation;
-  return wrapped;
-}
-async function processImageMetadata(args) {
-  const processed = {};
-  for (const [key, value] of Object.entries(args)) {
-    if (isImageMetadata(value)) {
-      processed[key] = value;
-      continue;
-    }
-    if (Array.isArray(value)) {
-      processed[key] = await Promise.all(
-        value.map(async (item) => {
-          if (isImageMetadata(item)) {
-            return item;
-          }
-          if (isRecord(item)) {
-            return processImageMetadata(item);
-          }
-          return item;
-        })
-      );
-      continue;
-    }
-    if (isRecord(value)) {
-      processed[key] = await processImageMetadata(value);
-      continue;
-    }
-    processed[key] = value;
-  }
-  return processed;
-}
-function isImageMetadata(value) {
-  return isRecord(value) && typeof value.src === "string" && ("width" in value || "height" in value || "format" in value);
-}
-function createProjectAstroResolutionPlugin(resolveFrom) {
-  const require2 = createRequire(import.meta.url);
-  return {
-    name: "storybook-astro:resolve-project-astro-prerender",
-    enforce: "pre",
-    resolveId(id) {
-      if (id !== "astro" && !id.startsWith("astro/")) {
-        return null;
-      }
-      try {
-        return require2.resolve(id, {
-          paths: [resolveFrom]
-        });
-      } catch {
-        return null;
-      }
-    }
-  };
-}
-
-// src/vitePluginAstroBuildServer.ts
-import { readdir as readdir2 } from "fs/promises";
-import { dirname, resolve as resolve2 } from "path";
-import { fileURLToPath } from "url";
-import { build } from "vite";
-
-// src/vitePluginAstro.ts
-import { mergeConfig as mergeConfig2 } from "vite";
-var ASTRO_PLUGINS_THAT_ARE_SUPPOSEDLY_NOT_NEEDED_IN_STORYBOOK = [
-  "@astro/plugin-actions",
-  "@astrojs/vite-plugin-astro-ssr-manifest",
-  "astro-content-virtual-mod-plugin",
-  "astro:actions",
-  "astro:build:normal",
-  "astro:container",
-  "astro:content-asset-propagation",
-  "astro:content-imports",
-  "astro:content-listen",
-  "astro:dev-toolbar",
-  "astro:head-metadata",
-  "astro:html",
-  "astro:i18n",
-  "astro:integration-container",
-  "astro:jsx",
-  "astro:markdown",
-  "astro:postprocess",
-  "astro:prefetch",
-  "astro:scanner",
-  "astro:scripts:page-ssr",
-  "astro:server",
-  "astro:vite-plugin-env",
-  "astro:vite-plugin-file-url"
-];
-async function mergeWithAstroConfig(config, integrations = [], resolveFrom = process.cwd(), mode = "development", command = "serve") {
-  const { getViteConfig } = await importAstroConfig(resolveFrom);
-  const safeIntegrations = integrations ?? [];
-  const astroConfig = await getViteConfig(
-    {},
-    {
-      configFile: false,
-      integrations: await Promise.all(
-        safeIntegrations.map((integration) => integration.loadIntegration(resolveFrom))
-      )
-    }
-  )({
-    mode,
-    command
-  });
-  const filteredPlugins = astroConfig.plugins.flat().filter(
-    (plugin) => plugin && "name" in plugin && !ASTRO_PLUGINS_THAT_ARE_SUPPOSEDLY_NOT_NEEDED_IN_STORYBOOK.includes(plugin.name)
-  );
-  return mergeConfig2(config, {
-    ...astroConfig,
-    plugins: filteredPlugins
-  });
-}
-
-// src/vite/astroFilesVirtualModulePlugin.ts
-function astroFilesVirtualModulePlugin(astroComponents) {
-  return createVirtualModulePlugin({
-    pluginName: "storybook-astro:virtual-astro-files",
-    virtualModuleId: "virtual:astro-files",
-    load() {
-      const imports = astroComponents.reduce((records, file, index) => {
-        const moduleId = `_astroFile${index}`;
-        return [
-          ...records,
-          {
-            id: moduleId,
-            file,
-            importStatement: `import ${moduleId} from '${file}';`
-          }
-        ];
-      }, []);
-      return [
-        imports.map(({ importStatement }) => importStatement).join("\n"),
-        "export default {",
-        imports.map(({ file, id }) => `'${file}': ${id}`).join(",\n"),
-        "};"
-      ].join("\n");
-    }
-  });
-}
-
-// src/vite/storybookAstroRulesConfigVirtualModulePlugin.ts
-var STORYBOOK_ASTRO_STORY_RULES_CONFIG_VIRTUAL_MODULE_ID = "virtual:storybook-astro-story-rules-config";
-function storybookAstroStoryRulesConfigVirtualModulePlugin(options, resolveFrom = process.cwd()) {
-  return createVirtualModulePlugin({
-    pluginName: "storybook-astro:virtual-story-rules-config",
-    virtualModuleId: STORYBOOK_ASTRO_STORY_RULES_CONFIG_VIRTUAL_MODULE_ID,
-    load() {
-      const configFilePath = resolveRulesConfigFilePath(options, resolveFrom);
-      if (!configFilePath) {
-        return [
-          "const storybookAstroStoryRulesConfig = { rules: [] };",
-          "export default storybookAstroStoryRulesConfig;",
-          "export const storybookAstroStoryRulesConfigFilePath = undefined;"
-        ].join("\n");
-      }
-      const importPath = JSON.stringify(configFilePath.replace(/\\/g, "/"));
-      const configPath = JSON.stringify(configFilePath.replace(/\\/g, "/"));
-      return [
-        `import * as storybookAstroStoryRulesConfigModule from ${importPath};`,
-        "export default storybookAstroStoryRulesConfigModule;",
-        `export const storybookAstroStoryRulesConfigFilePath = ${configPath};`
-      ].join("\n");
-    }
-  });
-}
-
-// src/vite/storybookAstroSanitizationConfigVirtualModulePlugin.ts
-var STORYBOOK_ASTRO_SANITIZATION_CONFIG_VIRTUAL_MODULE_ID = "virtual:storybook-astro-sanitization-config";
-function storybookAstroSanitizationConfigVirtualModulePlugin(options) {
-  return createVirtualModulePlugin({
-    pluginName: "storybook-astro:virtual-sanitization-config",
-    virtualModuleId: STORYBOOK_ASTRO_SANITIZATION_CONFIG_VIRTUAL_MODULE_ID,
-    load() {
-      const serializedConfig = serializeSanitizationOptions(options);
-      return `export default ${serializedConfig};`;
-    }
-  });
-}
-
-// src/vite/storybookAstroServerAuthConfigVirtualModulePlugin.ts
-var STORYBOOK_ASTRO_SERVER_AUTH_CONFIG_VIRTUAL_MODULE_ID = "virtual:storybook-astro-server-auth-config";
-function storybookAstroServerAuthConfigVirtualModulePlugin(options) {
-  const authToken = normalizeOptionalString(options?.authToken);
-  const authHeader = normalizeAuthHeader(options?.authHeader);
-  return createVirtualModulePlugin({
-    pluginName: "storybook-astro:virtual-server-auth-config",
-    virtualModuleId: STORYBOOK_ASTRO_SERVER_AUTH_CONFIG_VIRTUAL_MODULE_ID,
-    load() {
-      return [
-        `export const storybookAstroServerAuthToken = ${authToken ? JSON.stringify(authToken) : "undefined"};`,
-        `export const storybookAstroServerAuthHeader = ${JSON.stringify(authHeader)};`
-      ].join("\n");
-    }
-  });
-}
-function normalizeOptionalString(value) {
-  if (!value) {
-    return void 0;
-  }
-  const normalizedValue = value.trim();
-  return normalizedValue || void 0;
-}
-function normalizeAuthHeader(value) {
-  const normalizedValue = normalizeOptionalString(value);
-  return (normalizedValue ?? "authorization").toLowerCase();
-}
-
-// src/vitePluginAstroBuildServer.ts
-var moduleRoot = resolve2(dirname(fileURLToPath(import.meta.url)), ".");
-var packageRoot = resolve2(moduleRoot, "..");
-function vitePluginAstroBuildServer(options) {
-  const integrations = options.integrations ?? [];
-  const resolveFrom = options.resolveFrom ?? process.cwd();
-  const storiesMap = /* @__PURE__ */ new Map();
-  const trackedSpecifiers = collectTrackedSpecifiers2(integrations);
-  const staticEntrypointRefs = /* @__PURE__ */ new Map();
-  const componentEntrypointRefs = /* @__PURE__ */ new Map();
-  let storybookStaticOutDir = resolve2(resolveFrom, "storybook-static");
-  return {
-    name: "storybook-astro:build-server",
-    apply: "build",
-    enforce: "post",
-    configResolved(config) {
-      storybookStaticOutDir = resolve2(resolveFrom, config.build.outDir ?? "storybook-static");
-    },
-    resolveId(id, importer) {
-      if (id.endsWith(".astro") && importer) {
-        const absoluteAstroPath = resolve2(dirname(importer), id);
-        if (!storiesMap.has(absoluteAstroPath)) {
-          storiesMap.set(absoluteAstroPath, /* @__PURE__ */ new Set());
-        }
-        storiesMap.get(absoluteAstroPath)?.add(importer);
-      }
-      if (id.startsWith("virtual:astro-static-module/")) {
-        return `\0${id}`;
-      }
-      if (id.startsWith("virtual:astro-component-module/")) {
-        return `\0${id}`;
-      }
-    },
-    load(id) {
-      if (id.startsWith("\0virtual:astro-static-module/")) {
-        const encodedSpecifier = id.replace("\0virtual:astro-static-module/", "");
-        const specifier = decodeURIComponent(encodedSpecifier);
-        if (isClientEntrypoint2(specifier)) {
-          return [`export { default } from '${specifier}';`, `export * from '${specifier}';`].join("\n");
-        }
-        return [`import '${specifier}';`, "export default undefined;"].join("\n");
-      }
-      if (id.startsWith("\0virtual:astro-component-module/")) {
-        const encodedSpecifier = id.replace("\0virtual:astro-component-module/", "");
-        const specifier = decodeURIComponent(encodedSpecifier);
-        return [`export { default } from '${specifier}';`, `export * from '${specifier}';`].join("\n");
-      }
-    },
-    async buildStart() {
-      integrations.forEach((integration) => {
-        const entrypoint = integration.renderer.client?.entrypoint;
-        if (entrypoint) {
-          this.addWatchFile(entrypoint);
-        }
-      });
-      trackedSpecifiers.forEach((specifier) => {
-        const fileReferenceId = this.emitFile({
-          type: "chunk",
-          id: toStaticVirtualId2(specifier)
-        });
-        staticEntrypointRefs.set(specifier, fileReferenceId);
-      });
-      const srcRoot = resolve2(resolveFrom, "src/components");
-      const specifiers = await collectHydratableSourceModules2(srcRoot);
-      specifiers.forEach((specifier) => {
-        const fileReferenceId = this.emitFile({
-          type: "chunk",
-          id: toComponentVirtualId2(specifier)
-        });
-        componentEntrypointRefs.set(specifier, fileReferenceId);
-      });
-    },
-    async writeBundle() {
-      const astroComponents = Array.from(storiesMap.keys());
-      const staticModuleMap = buildStaticModuleMap2(
-        this,
-        staticEntrypointRefs,
-        componentEntrypointRefs
-      );
-      const serverOutDir = resolve2(dirname(storybookStaticOutDir), "storybook-server");
-      await buildAstroServer({
-        astroComponents,
-        integrations,
-        sanitization: options.sanitization,
-        storyRules: options.storyRules,
-        server: options.server,
-        outDir: serverOutDir,
-        staticModuleMap,
-        resolveFrom
-      });
-    }
-  };
-}
-async function buildAstroServer(options) {
-  const buildConfig = {
-    root: resolve2(packageRoot, "src/server"),
-    ssr: {
-      noExternal: /(@astrojs\/.+|react|react-dom)/
-    },
-    build: {
-      ssr: true,
-      outDir: options.outDir,
-      emptyOutDir: true,
-      sourcemap: true,
-      manifest: false,
-      rollupOptions: {
-        input: resolve2(packageRoot, "src/server/index.ts"),
-        treeshake: true
-      }
-    },
-    plugins: [
-      astroFilesVirtualModulePlugin(options.astroComponents),
-      storybookAstroSanitizationConfigVirtualModulePlugin(options.sanitization),
-      storybookAstroStoryRulesConfigVirtualModulePlugin(options.storyRules, options.resolveFrom),
-      storybookAstroServerAuthConfigVirtualModulePlugin(options.server),
-      viteAstroContainerRenderersPlugin(options.integrations, {
-        mode: "production",
-        staticModuleMap: options.staticModuleMap
-      })
-    ]
-  };
-  const finalConfig = await mergeWithAstroConfig(
-    buildConfig,
-    options.integrations,
-    options.resolveFrom,
-    "production",
-    "build"
-  );
-  await build(finalConfig);
-}
-function collectTrackedSpecifiers2(integrations) {
-  const specifiers = /* @__PURE__ */ new Set(["astro:scripts/page.js", "astro:scripts/before-hydration.js"]);
-  integrations.forEach((integration) => {
-    const entrypoint = integration.renderer.client?.entrypoint;
-    if (entrypoint) {
-      specifiers.add(entrypoint);
-    }
-  });
-  return specifiers;
-}
-function buildStaticModuleMap2(pluginContext, staticEntrypointRefs, componentEntrypointRefs) {
-  const map = {};
-  staticEntrypointRefs.forEach((fileReferenceId, specifier) => {
-    const fileName = pluginContext.getFileName(fileReferenceId);
-    if (fileName) {
-      map[specifier] = toPublicPath2(fileName);
-    }
-  });
-  componentEntrypointRefs.forEach((fileReferenceId, specifier) => {
-    const fileName = pluginContext.getFileName(fileReferenceId);
-    if (fileName) {
-      map[specifier] = toPublicPath2(fileName);
-    }
-  });
-  return map;
-}
-function toStaticVirtualId2(specifier) {
-  return `virtual:astro-static-module/${encodeURIComponent(specifier)}`;
-}
-function toComponentVirtualId2(specifier) {
-  return `virtual:astro-component-module/${encodeURIComponent(specifier)}`;
-}
-function isClientEntrypoint2(specifier) {
-  return specifier.startsWith("@astrojs/") && specifier.endsWith("/client.js");
-}
-function toPublicPath2(fileName) {
-  return `./${fileName}`;
-}
-async function collectHydratableSourceModules2(srcRoot) {
-  const modules = [];
-  async function walk(directory) {
-    let entries;
-    try {
-      entries = await readdir2(directory, { withFileTypes: true });
-    } catch {
-      return;
-    }
-    await Promise.all(
-      entries.map(async (entry) => {
-        const absolutePath = resolve2(directory, entry.name);
-        if (entry.isDirectory()) {
-          await walk(absolutePath);
-          return;
-        }
-        if (!entry.isFile()) {
-          return;
-        }
-        const normalizedPath = absolutePath.replace(/\\/g, "/");
-        if (!isHydratableSourceFile2(normalizedPath)) {
-          return;
-        }
-        if (isNonHydratableSourceFile2(normalizedPath)) {
-          return;
-        }
-        modules.push(normalizedPath);
-      })
-    );
-  }
-  await walk(srcRoot);
-  return modules;
-}
-function isHydratableSourceFile2(input) {
-  return /\.(jsx|tsx|vue|svelte|js|ts)$/.test(input);
-}
-function isNonHydratableSourceFile2(input) {
-  return /\.stories\.[jt]sx?$|\.stories\.vue$|\.stories\.svelte$|\.(spec|test)\.[jt]sx?$/.test(
-    input
-  );
-}
-
-// src/vitePluginAstroToolbarFallback.ts
-var TOOLBAR_INTERNAL_STUB = `
-export const loadDevToolbarApps = async () => [];
-`;
-function vitePluginAstroToolbarFallback() {
-  const VIRTUAL_ID = "astro:toolbar:internal";
-  const RESOLVED_ID = "\0" + VIRTUAL_ID;
-  return {
-    name: "storybook-astro-toolbar-fallback",
-    enforce: "pre",
-    resolveId(id) {
-      if (id === VIRTUAL_ID) {
-        return RESOLVED_ID;
-      }
-    },
-    load(id) {
-      if (id === RESOLVED_ID) {
-        return { code: TOOLBAR_INTERNAL_STUB };
-      }
-    }
-  };
-}
-
-// src/preset.ts
-var core = {
-  builder: "@storybook/builder-vite",
-  // Use import.meta.resolve so Storybook receives an absolute file:// URL
-  // to the renderer preset rather than a bare package specifier.  When
-  // package managers like pnpm use strict node_modules isolation, bare
-  // specifiers are resolved from the *project root*, where the renderer
-  // (a dep of this framework, not the user's project) is not hoisted.
-  // The absolute URL is resolved from *this* file's location where the
-  // renderer is always accessible as a direct dependency.
-  renderer: import.meta.resolve("@storybook-astro/renderer")
-};
-var viteFinal = async (config, { configType, presets }) => {
-  const options = await presets.apply("frameworkOptions");
-  if (!config.plugins) {
-    config.plugins = [];
-  }
-  const integrations = options.integrations ?? [];
-  const resolveFrom = options.resolveFrom ?? process.cwd();
-  const renderMode = options.renderMode ?? "server";
-  const mode = configType === "DEVELOPMENT" ? "development" : "production";
-  const command = configType === "DEVELOPMENT" ? "serve" : "build";
-  resolveSanitizationOptions(options.sanitization);
-  config.envPrefix = mergeEnvPrefixes(config.envPrefix, "STORYBOOK_");
-  const { vitePlugin: storybookAstroMiddlewarePlugin, viteConfig } = await vitePluginStorybookAstroMiddleware(options);
-  config.plugins.push(
-    viteStorybookRendererFallbackPlugin(integrations),
-    viteStorybookAstroRendererPlugin({
-      mode,
-      renderMode,
-      server: options.server
-    }),
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    vitePluginAstroComponentMarker(),
-    vitePluginAstroIntegrationOptsFallback(),
-    vitePluginAstroToolbarFallback(),
-    vitePluginAstroVueFallback()
-  );
-  if (configType === "DEVELOPMENT") {
-    config.plugins.push(storybookAstroMiddlewarePlugin, ...viteConfig.plugins);
-  } else if (renderMode === "static") {
-    config.plugins.push(vitePluginAstroBuildPrerender(options));
-  } else {
-    config.plugins.push(vitePluginAstroBuildServer(options));
-  }
-  if (configType !== "DEVELOPMENT") {
-    config.build = {
-      ...config.build ?? {},
-      manifest: true
-    };
-    config.build.rollupOptions = {
-      ...config.build.rollupOptions ?? {},
-      preserveEntrySignatures: "strict"
-    };
-  }
-  if (!config.resolve) {
-    config.resolve = {};
-  }
-  if (!config.resolve.alias) {
-    config.resolve.alias = {};
-  }
-  const aliases = config.resolve.alias;
-  if (!aliases["react"]) {
-    aliases["react"] = "react";
-  }
-  if (!aliases["react-dom"]) {
-    aliases["react-dom"] = "react-dom";
-  }
-  const finalConfig = await mergeWithAstroConfig(config, integrations, resolveFrom, mode, command);
-  if (!finalConfig.optimizeDeps) {
-    finalConfig.optimizeDeps = {};
-  }
-  if (!finalConfig.optimizeDeps.exclude) {
-    finalConfig.optimizeDeps.exclude = [];
-  }
-  for (const pkg of ["@astrojs/vue", "@astrojs/react", "@astrojs/preact"]) {
-    if (!finalConfig.optimizeDeps.exclude.includes(pkg)) {
-      finalConfig.optimizeDeps.exclude.push(pkg);
-    }
-  }
-  if (!finalConfig.optimizeDeps.exclude.includes("@storybook-astro/renderer")) {
-    finalConfig.optimizeDeps.exclude.push("@storybook-astro/renderer");
-  }
-  const integrationVirtualModules = [
-    "virtual:@astrojs/vue/app",
-    "virtual:astro:vue-app",
-    "astro:react:opts",
-    "astro:preact:opts",
-    "astro:toolbar:internal"
-  ];
-  if (!finalConfig.optimizeDeps.esbuildOptions) {
-    finalConfig.optimizeDeps.esbuildOptions = {};
-  }
-  if (!finalConfig.optimizeDeps.esbuildOptions.external) {
-    finalConfig.optimizeDeps.esbuildOptions.external = [];
-  }
-  for (const mod of integrationVirtualModules) {
-    if (!finalConfig.optimizeDeps.esbuildOptions.external.includes(mod)) {
-      finalConfig.optimizeDeps.esbuildOptions.external.push(mod);
-    }
-  }
-  const optimizeDepsMut = finalConfig.optimizeDeps;
-  const rolldownOpts = optimizeDepsMut.rolldownOptions ?? {};
-  rolldownOpts.external = Array.from(
-    /* @__PURE__ */ new Set([...rolldownOpts.external ?? [], ...integrationVirtualModules])
-  );
-  optimizeDepsMut.rolldownOptions = rolldownOpts;
-  return finalConfig;
-};
-function mergeEnvPrefixes(existing, additionalPrefix) {
-  const prefixes = Array.isArray(existing) ? existing : existing ? [existing] : [];
-  return Array.from(/* @__PURE__ */ new Set([...prefixes, additionalPrefix]));
-}
-
-export {
-  core,
-  viteFinal
-};
-//# sourceMappingURL=chunk-PBISP7PA.js.map