astro 1.1.7 → 1.2.1

package/dist/core/config.js

@@ -1,3 +1,4 @@
+import fs from "fs";
 import load, { ProloadError, resolve } from "@proload/core";
 import loadTypeScript from "@proload/plugin-tsm";
 import * as colors from "kleur/colors";
@@ -224,6 +225,9 @@ function resolveFlags(flags) {
     drafts: typeof flags.drafts === "boolean" ? flags.drafts : void 0
   };
 }
+function resolveRoot(cwd) {
+  return cwd ? path.resolve(cwd) : process.cwd();
+}
 function mergeCLIFlags(astroConfig, flags, cmd) {
   astroConfig.server = astroConfig.server || {};
   astroConfig.markdown = astroConfig.markdown || {};
@@ -239,38 +243,35 @@ function mergeCLIFlags(astroConfig, flags, cmd) {
   }
   return astroConfig;
 }
-async function resolveConfigURL(configOptions) {
-  const root = configOptions.cwd ? path.resolve(configOptions.cwd) : process.cwd();
+async function resolveConfigPath(configOptions) {
+  const root = resolveRoot(configOptions.cwd);
   const flags = resolveFlags(configOptions.flags || {});
   let userConfigPath;
   if (flags == null ? void 0 : flags.config) {
     userConfigPath = /^\.*\//.test(flags.config) ? flags.config : `./${flags.config}`;
     userConfigPath = fileURLToPath(new URL(userConfigPath, `file://${root}/`));
   }
-  const configPath = await resolve("astro", {
-    mustExist: false,
-    cwd: root,
-    filePath: userConfigPath
-  });
-  if (configPath) {
-    return pathToFileURL(configPath);
+  try {
+    const configPath = await resolve("astro", {
+      mustExist: !!userConfigPath,
+      cwd: root,
+      filePath: userConfigPath
+    });
+    return configPath;
+  } catch (e) {
+    if (e instanceof ProloadError && flags.config) {
+      throw new Error(`Unable to resolve --config "${flags.config}"! Does the file exist?`);
+    }
+    throw e;
   }
 }
 async function openConfig(configOptions) {
-  const root = configOptions.cwd ? path.resolve(configOptions.cwd) : process.cwd();
+  const root = resolveRoot(configOptions.cwd);
   const flags = resolveFlags(configOptions.flags || {});
   let userConfig = {};
-  let userConfigPath;
-  if (flags == null ? void 0 : flags.config) {
-    userConfigPath = /^\.*\//.test(flags.config) ? flags.config : `./${flags.config}`;
-    userConfigPath = fileURLToPath(
-      new URL(userConfigPath, appendForwardSlash(pathToFileURL(root).toString()))
-    );
-  }
-  const config = await tryLoadConfig(configOptions, flags, userConfigPath, root);
+  const config = await tryLoadConfig(configOptions, flags, root);
   if (config) {
     userConfig = config.value;
-    userConfigPath = config.filePath;
   }
   const astroConfig = await resolveConfig(
     userConfig,
@@ -282,56 +283,74 @@ async function openConfig(configOptions) {
   return {
     astroConfig,
     userConfig,
-    userConfigPath,
     flags,
     root
   };
 }
-async function tryLoadConfig(configOptions, flags, userConfigPath, root) {
+async function tryLoadConfig(configOptions, flags, root) {
+  let finallyCleanup = async () => {
+  };
   try {
+    let configPath = await resolveConfigPath({
+      cwd: configOptions.cwd,
+      flags: configOptions.flags
+    });
+    if (!configPath)
+      return void 0;
+    if (configOptions.isConfigReload) {
+      const tempConfigPath = path.join(
+        root,
+        `.temp.${Date.now()}.config${path.extname(configPath)}`
+      );
+      await fs.promises.writeFile(tempConfigPath, await fs.promises.readFile(configPath));
+      finallyCleanup = async () => {
+        try {
+          await fs.promises.unlink(tempConfigPath);
+        } catch {
+        }
+      };
+      configPath = tempConfigPath;
+    }
     const config = await load("astro", {
-      mustExist: !!userConfigPath,
+      mustExist: !!configPath,
       cwd: root,
-      filePath: userConfigPath
+      filePath: configPath
     });
     return config;
   } catch (e) {
     if (e instanceof ProloadError && flags.config) {
       throw new Error(`Unable to resolve --config "${flags.config}"! Does the file exist?`);
     }
-    const configURL = await resolveConfigURL(configOptions);
-    if (!configURL) {
+    const configPath = await resolveConfigPath(configOptions);
+    if (!configPath) {
       throw e;
     }
     const viteServer = await vite.createServer({
       server: { middlewareMode: true, hmr: false },
+      optimizeDeps: { entries: [] },
+      clearScreen: false,
       appType: "custom"
     });
     try {
-      const mod = await viteServer.ssrLoadModule(fileURLToPath(configURL));
+      const mod = await viteServer.ssrLoadModule(configPath);
       if (mod == null ? void 0 : mod.default) {
         return {
           value: mod.default,
-          filePath: fileURLToPath(configURL)
+          filePath: configPath
         };
       }
     } finally {
       await viteServer.close();
     }
+  } finally {
+    await finallyCleanup();
   }
 }
 async function loadConfig(configOptions) {
-  const root = configOptions.cwd ? path.resolve(configOptions.cwd) : process.cwd();
+  const root = resolveRoot(configOptions.cwd);
   const flags = resolveFlags(configOptions.flags || {});
   let userConfig = {};
-  let userConfigPath;
-  if (flags == null ? void 0 : flags.config) {
-    userConfigPath = /^\.*\//.test(flags.config) ? flags.config : `./${flags.config}`;
-    userConfigPath = fileURLToPath(
-      new URL(userConfigPath, appendForwardSlash(pathToFileURL(root).toString()))
-    );
-  }
-  const config = await tryLoadConfig(configOptions, flags, userConfigPath, root);
+  const config = await tryLoadConfig(configOptions, flags, root);
   if (config) {
     userConfig = config.value;
   }
@@ -380,6 +399,8 @@ export {
   mergeConfig,
   openConfig,
   resolveConfig,
-  resolveConfigURL,
+  resolveConfigPath,
+  resolveFlags,
+  resolveRoot,
   validateConfig
 };

package/dist/core/dev/index.d.ts

@@ -7,6 +7,7 @@ import { LogOptions } from '../logger/core.js';
 export interface DevOptions {
     logging: LogOptions;
     telemetry: AstroTelemetry;
+    isRestart?: boolean;
 }
 export interface DevServer {
     address: AddressInfo;

package/dist/core/dev/index.js

@@ -18,6 +18,7 @@ async function dev(config, options) {
   await options.telemetry.record([]);
   config = await runHookConfigSetup({ config, command: "dev", logging: options.logging });
   const { host, port } = config.server;
+  const { isRestart = false } = options;
   const rendererClientEntries = config._ctx.renderers.map((r) => r.clientEntrypoint).filter(Boolean);
   const viteConfig = await createVite(
     {
@@ -43,10 +44,11 @@ async function dev(config, options) {
       config,
       devServerAddressInfo,
       site,
-      https: !!((_a = viteConfig.server) == null ? void 0 : _a.https)
+      https: !!((_a = viteConfig.server) == null ? void 0 : _a.https),
+      isRestart
     })
   );
-  const currentVersion = "1.1.7";
+  const currentVersion = "1.2.1";
   if (currentVersion.includes("-")) {
     warn(options.logging, null, msg.prerelease({ currentVersion }));
   }

package/dist/core/endpoint/dev/index.d.ts

@@ -1,7 +1,9 @@
+/// <reference types="node" />
 import type { SSROptions } from '../../render/dev';
 export declare function call(ssrOpts: SSROptions): Promise<{
     type: "simple";
     body: string;
+    encoding?: BufferEncoding | undefined;
 } | {
     type: "response";
     response: Response;

package/dist/core/endpoint/index.d.ts

@@ -1,9 +1,11 @@
+/// <reference types="node" />
 import type { EndpointHandler } from '../../@types/astro';
 import type { RenderOptions } from '../render/core';
 export declare type EndpointOptions = Pick<RenderOptions, 'logging' | 'origin' | 'request' | 'route' | 'routeCache' | 'pathname' | 'route' | 'site' | 'ssr' | 'status'>;
 declare type EndpointCallResult = {
     type: 'simple';
     body: string;
+    encoding?: BufferEncoding;
 } | {
     type: 'response';
     response: Response;

package/dist/core/endpoint/index.js

@@ -17,7 +17,8 @@ async function call(mod, opts) {
   }
   return {
     type: "simple",
-    body: response.body
+    body: response.body,
+    encoding: response.encoding
   };
 }
 export {

package/dist/core/messages.d.ts

@@ -17,12 +17,13 @@ export declare function hmr({ file, style }: {
     style?: boolean;
 }): string;
 /** Display dev server host and startup time */
-export declare function devStart({ startupTime, devServerAddressInfo, config, https, site, }: {
+export declare function devStart({ startupTime, devServerAddressInfo, config, https, site, isRestart, }: {
     startupTime: number;
     devServerAddressInfo: AddressInfo;
     config: AstroConfig;
     https: boolean;
     site: URL | undefined;
+    isRestart?: boolean;
 }): string;
 export declare function telemetryNotice(): string;
 export declare function telemetryEnabled(): string;

package/dist/core/messages.js

@@ -44,9 +44,10 @@ function devStart({
   devServerAddressInfo,
   config,
   https,
-  site
+  site,
+  isRestart = false
 }) {
-  const version = "1.1.7";
+  const version = "1.2.1";
   const rootPath = site ? site.pathname : "/";
   const localPrefix = `${dim("\u2503")} Local    `;
   const networkPrefix = `${dim("\u2503")} Network  `;
@@ -77,7 +78,7 @@ function devStart({
   }
   const messages = [
     `${emoji("\u{1F680} ", "")}${bgGreen(black(` astro `))} ${green(`v${version}`)} ${dim(
-      `started in ${Math.round(startupTime)}ms`
+      `${isRestart ? "re" : ""}started in ${Math.round(startupTime)}ms`
     )}`,
     "",
     local,
@@ -225,7 +226,7 @@ function printHelp({
     message.push(
       linebreak(),
       `  ${bgGreen(black(` ${commandName} `))} ${green(
-        `v${"1.1.7"}`
+        `v${"1.2.1"}`
       )} ${headline}`
     );
   }

package/dist/core/util.d.ts

@@ -1,3 +1,4 @@
+/// <reference types="node" />
 import type { ErrorPayload, ViteDevServer } from 'vite';
 import type { AstroConfig, RouteType } from '../@types/astro';
 export declare const ASTRO_VERSION: string;
@@ -46,3 +47,15 @@ export declare function getLocalAddress(serverAddress: string, host: string | bo
  * through a script tag or a dynamic import as-is.
  */
 export declare function resolveIdToUrl(viteServer: ViteDevServer, id: string): Promise<string>;
+export declare const AggregateError: AggregateErrorConstructor | {
+    new (errors: Iterable<any>, message?: string | undefined): {
+        errors: Array<any>;
+        name: string;
+        message: string;
+        stack?: string | undefined;
+        cause?: Error | undefined;
+    };
+    captureStackTrace(targetObject: object, constructorOpt?: Function | undefined): void;
+    prepareStackTrace?: ((err: Error, stackTraces: NodeJS.CallSite[]) => any) | undefined;
+    stackTraceLimit: number;
+};

package/dist/core/util.js

@@ -5,7 +5,7 @@ import resolve from "resolve";
 import slash from "slash";
 import { fileURLToPath, pathToFileURL } from "url";
 import { prependForwardSlash, removeTrailingForwardSlash } from "./path.js";
-const ASTRO_VERSION = "1.1.7";
+const ASTRO_VERSION = "1.2.1";
 function isObject(value) {
   return typeof value === "object" && value != null;
 }
@@ -87,7 +87,7 @@ function resolveDependency(dep, projectRoot) {
   return pathToFileURL(resolved).toString();
 }
 function viteID(filePath) {
-  return slash(fileURLToPath(filePath));
+  return slash(fileURLToPath(filePath) + filePath.search);
 }
 const VALID_ID_PREFIX = `/@id/`;
 function unwrapId(id) {
@@ -170,8 +170,16 @@ async function resolveIdToUrl(viteServer, id) {
   }
   return VALID_ID_PREFIX + result.id;
 }
+const AggregateError = typeof globalThis.AggregateError !== "undefined" ? globalThis.AggregateError : class extends Error {
+  constructor(errors, message) {
+    super(message);
+    this.errors = [];
+    this.errors = Array.from(errors);
+  }
+};
 export {
   ASTRO_VERSION,
+  AggregateError,
   VALID_ID_PREFIX,
   arraify,
   codeFrame,

package/dist/runtime/server/astro-global.js

@@ -1,4 +1,4 @@
-const ASTRO_VERSION = "1.1.7";
+const ASTRO_VERSION = "1.2.1";
 function createDeprecatedFetchContentFn() {
   return () => {
     throw new Error("Deprecated: Astro.fetchContent() has been replaced with Astro.glob().");

package/dist/runtime/server/render/page.js

@@ -56,7 +56,7 @@ async function renderPage(result, componentFactory, props, children, streaming)
                     controller.enqueue(encoder.encode("<!DOCTYPE html>\n"));
                   }
                 }
-                controller.enqueue(encoder.encode(html));
+                controller.enqueue(encoder.encode(String(html)));
                 i++;
               }
               controller.close();

package/dist/runtime/server/serialize.js

@@ -8,23 +8,35 @@ const PROP_TYPE = {
   BigInt: 6,
   URL: 7
 };
-function serializeArray(value, metadata) {
-  return value.map((v) => convertToSerializedForm(v, metadata));
+function serializeArray(value, metadata = {}, parents = /* @__PURE__ */ new WeakSet()) {
+  if (parents.has(value)) {
+    throw new Error(`Cyclic reference detected while serializing props for <${metadata.displayName} client:${metadata.hydrate}>!
+
+Cyclic references cannot be safely serialized for client-side usage. Please remove the cyclic reference.`);
+  }
+  parents.add(value);
+  const serialized = value.map((v) => {
+    return convertToSerializedForm(v, metadata, parents);
+  });
+  parents.delete(value);
+  return serialized;
 }
-function serializeObject(value, metadata) {
-  if (cyclicRefs.has(value)) {
+function serializeObject(value, metadata = {}, parents = /* @__PURE__ */ new WeakSet()) {
+  if (parents.has(value)) {
     throw new Error(`Cyclic reference detected while serializing props for <${metadata.displayName} client:${metadata.hydrate}>!
 
 Cyclic references cannot be safely serialized for client-side usage. Please remove the cyclic reference.`);
   }
-  cyclicRefs.add(value);
-  return Object.fromEntries(
+  parents.add(value);
+  const serialized = Object.fromEntries(
     Object.entries(value).map(([k, v]) => {
-      return [k, convertToSerializedForm(v, metadata)];
+      return [k, convertToSerializedForm(v, metadata, parents)];
     })
   );
+  parents.delete(value);
+  return serialized;
 }
-function convertToSerializedForm(value, metadata) {
+function convertToSerializedForm(value, metadata = {}, parents = /* @__PURE__ */ new WeakSet()) {
   const tag = Object.prototype.toString.call(value);
   switch (tag) {
     case "[object Date]": {
@@ -36,13 +48,13 @@ function convertToSerializedForm(value, metadata) {
     case "[object Map]": {
       return [
         PROP_TYPE.Map,
-        JSON.stringify(serializeArray(Array.from(value), metadata))
+        JSON.stringify(serializeArray(Array.from(value), metadata, parents))
       ];
     }
     case "[object Set]": {
       return [
         PROP_TYPE.Set,
-        JSON.stringify(serializeArray(Array.from(value), metadata))
+        JSON.stringify(serializeArray(Array.from(value), metadata, parents))
       ];
     }
     case "[object BigInt]": {
@@ -52,21 +64,19 @@ function convertToSerializedForm(value, metadata) {
       return [PROP_TYPE.URL, value.toString()];
     }
     case "[object Array]": {
-      return [PROP_TYPE.JSON, JSON.stringify(serializeArray(value, metadata))];
+      return [PROP_TYPE.JSON, JSON.stringify(serializeArray(value, metadata, parents))];
     }
     default: {
       if (value !== null && typeof value === "object") {
-        return [PROP_TYPE.Value, serializeObject(value, metadata)];
+        return [PROP_TYPE.Value, serializeObject(value, metadata, parents)];
       } else {
         return [PROP_TYPE.Value, value];
       }
     }
   }
 }
-let cyclicRefs = /* @__PURE__ */ new WeakSet();
 function serializeProps(props, metadata) {
   const serialized = JSON.stringify(serializeObject(props, metadata));
-  cyclicRefs = /* @__PURE__ */ new WeakSet();
   return serialized;
 }
 export {

package/dist/vite-plugin-astro/hmr.d.ts

@@ -1,7 +1,7 @@
 import type { HmrContext, ModuleNode } from 'vite';
 import type { AstroConfig } from '../@types/astro';
+import { cachedCompilation } from '../core/compile/index.js';
 import type { LogOptions } from '../core/logger/core.js';
-import { cachedCompilation } from './compile.js';
 export interface HandleHotUpdateOptions {
     config: AstroConfig;
     logging: LogOptions;

package/dist/vite-plugin-astro/hmr.js

@@ -1,7 +1,7 @@
 import { fileURLToPath } from "node:url";
+import { invalidateCompilation, isCached } from "../core/compile/index.js";
 import { info } from "../core/logger/core.js";
 import * as msg from "../core/messages.js";
-import { invalidateCompilation, isCached } from "./compile.js";
 import { isAstroScript } from "./query.js";
 const PKG_PREFIX = new URL("../../", import.meta.url);
 const isPkgFile = (id) => {
@@ -83,6 +83,8 @@ async function handleHotUpdate(ctx, { config, logging, compile }) {
   }
   const isSelfAccepting = mods.every((m) => m.isSelfAccepting || m.url.endsWith(".svelte"));
   if (isSelfAccepting) {
+    if (/astro\.config\.[cm][jt]s$/.test(file))
+      return mods;
     info(logging, "astro", msg.hmr({ file }));
   } else {
     info(logging, "astro", msg.reload({ file }));

package/dist/vite-plugin-astro/index.js

@@ -2,12 +2,16 @@ import ancestor from "common-ancestor-path";
 import esbuild from "esbuild";
 import slash from "slash";
 import { fileURLToPath } from "url";
-import { isRelativePath, startsWithForwardSlash } from "../core/path.js";
+import { cachedCompilation, getCachedSource } from "../core/compile/index.js";
+import { isRelativePath, prependForwardSlash, startsWithForwardSlash } from "../core/path.js";
+import { viteID } from "../core/util.js";
 import { getFileInfo } from "../vite-plugin-utils/index.js";
-import { cachedCompilation, getCachedSource } from "./compile.js";
+import {
+  createTransformStyles,
+  createViteStyleTransformer
+} from "../vite-style-transform/index.js";
 import { handleHotUpdate } from "./hmr.js";
 import { parseAstroRequest } from "./query.js";
-import { createTransformStyleWithViteFn } from "./styles.js";
 const FRONTMATTER_PARSE_REGEXP = /^\-\-\-(.*)^\-\-\-/ms;
 function astro({ config, logging }) {
   function normalizeFilename(filename) {
@@ -24,10 +28,11 @@ function astro({ config, logging }) {
     return slash(fileURLToPath(url)) + url.search;
   }
   let resolvedConfig;
-  let transformStyleWithVite;
+  let styleTransformer;
   let viteDevServer;
   const srcRootWeb = config.srcDir.pathname.slice(config.root.pathname.length - 1);
   const isBrowserPath = (path) => path.startsWith(srcRootWeb);
+  const isFullFilePath = (path) => path.startsWith(prependForwardSlash(slash(fileURLToPath(config.root))));
   function resolveRelativeFromAstroParent(id, parsedFrom) {
     const filename = normalizeFilename(parsedFrom.filename);
     const resolvedURL = new URL(id, `file://${filename}`);
@@ -42,10 +47,11 @@ function astro({ config, logging }) {
     enforce: "pre",
     configResolved(_resolvedConfig) {
       resolvedConfig = _resolvedConfig;
-      transformStyleWithVite = createTransformStyleWithViteFn(_resolvedConfig);
+      styleTransformer = createViteStyleTransformer(_resolvedConfig);
     },
     configureServer(server) {
       viteDevServer = server;
+      styleTransformer.viteDevServer = server;
     },
     async resolveId(id, from, opts) {
       if (from) {
@@ -63,6 +69,9 @@ function astro({ config, logging }) {
         if (query.type === "style" && isBrowserPath(id)) {
           return relativeToRoot(id);
         }
+        if (isFullFilePath(id)) {
+          return viteID(new URL("file://" + id));
+        }
         return id;
       }
     },
@@ -86,10 +95,7 @@ function astro({ config, logging }) {
         filename,
         moduleId: id,
         source,
-        ssr: Boolean(opts == null ? void 0 : opts.ssr),
-        transformStyleWithVite,
-        viteDevServer,
-        pluginContext: this
+        transformStyle: createTransformStyles(styleTransformer, filename, Boolean(opts == null ? void 0 : opts.ssr), this)
       };
       switch (query.type) {
         case "style": {
@@ -163,7 +169,7 @@ File: ${filename}`
       }
     },
     async transform(source, id, opts) {
-      var _a, _b;
+      var _a;
       const parsedId = parseAstroRequest(id);
       const query = parsedId.query;
       if (!id.endsWith(".astro") || query.astro) {
@@ -178,10 +184,7 @@ File: ${filename}`
         filename,
         moduleId: id,
         source,
-        ssr: Boolean(opts == null ? void 0 : opts.ssr),
-        transformStyleWithVite,
-        viteDevServer,
-        pluginContext: this
+        transformStyle: createTransformStyles(styleTransformer, filename, Boolean(opts == null ? void 0 : opts.ssr), this)
       };
       try {
         const transformResult = await cachedCompilation(compileProps);
@@ -203,16 +206,8 @@ const $$url = ${JSON.stringify(
         )};export { $$file as file, $$url as url };
 `;
         if (!resolvedConfig.isProduction) {
-          const metadata = transformResult.code.split("$$createMetadata(")[1].split("});\n")[0];
-          const pattern = /specifier:\s*'([^']*)'/g;
-          const deps = /* @__PURE__ */ new Set();
-          let match;
-          while (match = (_b = pattern.exec(metadata)) == null ? void 0 : _b[1]) {
-            deps.add(match);
-          }
           let i = 0;
           while (i < transformResult.scripts.length) {
-            deps.add(`${id}?astro&type=script&index=${i}&lang.ts`);
             SUFFIX += `import "${id}?astro&type=script&index=${i}&lang.ts";`;
             i++;
           }
@@ -288,10 +283,7 @@ ${source}
         filename: context.file,
         moduleId: context.file,
         source: await context.read(),
-        ssr: true,
-        transformStyleWithVite,
-        viteDevServer,
-        pluginContext: this
+        transformStyle: createTransformStyles(styleTransformer, context.file, true, this)
       };
       const compile = () => cachedCompilation(compileProps);
       return handleHotUpdate.call(this, context, {

package/dist/vite-plugin-markdown-legacy/index.js

@@ -5,12 +5,13 @@ import fs from "fs";
 import matter from "gray-matter";
 import { fileURLToPath } from "url";
 import { pagesVirtualModuleId } from "../core/app/index.js";
+import { cachedCompilation } from "../core/compile/index.js";
 import { collectErrorMetadata } from "../core/errors.js";
-import { cachedCompilation } from "../vite-plugin-astro/compile.js";
-import {
-  createTransformStyleWithViteFn
-} from "../vite-plugin-astro/styles.js";
 import { getFileInfo } from "../vite-plugin-utils/index.js";
+import {
+  createTransformStyles,
+  createViteStyleTransformer
+} from "../vite-style-transform/index.js";
 const MARKDOWN_IMPORT_FLAG = "?mdImport";
 const MARKDOWN_CONTENT_FLAG = "?content";
 function safeMatter(source, id) {
@@ -43,13 +44,16 @@ function markdown({ config, logging }) {
     }
     return false;
   }
-  let transformStyleWithVite;
+  let styleTransformer;
   let viteDevServer;
   return {
     name: "astro:markdown",
     enforce: "pre",
     configResolved(_resolvedConfig) {
-      transformStyleWithVite = createTransformStyleWithViteFn(_resolvedConfig);
+      styleTransformer = createViteStyleTransformer(_resolvedConfig);
+    },
+    configureServer(server) {
+      styleTransformer.viteDevServer = server;
     },
     async resolveId(id, importer, options) {
       if (id.endsWith(`.md${MARKDOWN_CONTENT_FLAG}`)) {
@@ -161,10 +165,12 @@ ${astroResult}
           filename,
           moduleId: id,
           source: astroResult,
-          ssr: Boolean(opts == null ? void 0 : opts.ssr),
-          transformStyleWithVite,
-          viteDevServer,
-          pluginContext: this
+          transformStyle: createTransformStyles(
+            styleTransformer,
+            filename,
+            Boolean(opts == null ? void 0 : opts.ssr),
+            this
+          )
         };
         let transformResult = await cachedCompilation(compileProps);
         let { code: tsResult } = transformResult;

package/dist/vite-style-transform/index.d.ts

@@ -0,0 +1,2 @@
+export type { ViteStyleTransformer } from './style-transform';
+export { createTransformStyles, createViteStyleTransformer } from './style-transform.js';

package/dist/vite-style-transform/index.js

@@ -0,0 +1,5 @@
+import { createTransformStyles, createViteStyleTransformer } from "./style-transform.js";
+export {
+  createTransformStyles,
+  createViteStyleTransformer
+};

package/dist/vite-style-transform/style-transform.d.ts

@@ -0,0 +1,10 @@
+import type { PluginContext } from 'rollup';
+import type { TransformStyle } from '../core/compile/index';
+import { TransformStyleWithVite } from './transform-with-vite.js';
+import type * as vite from 'vite';
+export declare type ViteStyleTransformer = {
+    viteDevServer?: vite.ViteDevServer;
+    transformStyleWithVite: TransformStyleWithVite;
+};
+export declare function createViteStyleTransformer(viteConfig: vite.ResolvedConfig): ViteStyleTransformer;
+export declare function createTransformStyles(viteStyleTransformer: ViteStyleTransformer, filename: string, ssr: boolean, pluginContext: PluginContext): TransformStyle;