astro 1.6.4 → 1.6.5

package/dist/core/constants.js

@@ -1,4 +1,4 @@
-const ASTRO_VERSION = "1.6.4";
+const ASTRO_VERSION = "1.6.5";
 const SUPPORTED_MARKDOWN_FILE_EXTENSIONS = [
   ".markdown",
   ".mdown",

package/dist/core/dev/dev.js

@@ -30,7 +30,7 @@ async function dev(settings, options) {
       isRestart: options.isRestart
     })
   );
-  const currentVersion = "1.6.4";
+  const currentVersion = "1.6.5";
   if (currentVersion.includes("-")) {
     warn(options.logging, null, msg.prerelease({ currentVersion }));
   }

package/dist/core/messages.js

@@ -47,7 +47,7 @@ function serverStart({
   site,
   isRestart = false
 }) {
-  const version = "1.6.4";
+  const version = "1.6.5";
   const rootPath = site ? site.pathname : "/";
   const localPrefix = `${dim("\u2503")} Local    `;
   const networkPrefix = `${dim("\u2503")} Network  `;
@@ -255,7 +255,7 @@ function printHelp({
     message.push(
       linebreak(),
       `  ${bgGreen(black(` ${commandName} `))} ${green(
-        `v${"1.6.4"}`
+        `v${"1.6.5"}`
       )} ${headline}`
     );
   }

package/dist/core/render/result.js

@@ -18,7 +18,7 @@ var __privateSet = (obj, member, value, setter) => {
 };
 var _cache, _result, _slots, _loggingOpts;
 import { bold } from "kleur/colors";
-import { renderSlot } from "../../runtime/server/index.js";
+import { renderSlot, stringifyChunk } from "../../runtime/server/index.js";
 import { renderJSX } from "../../runtime/server/jsx.js";
 import { AstroCookies } from "../cookies/index.js";
 import { warn } from "../logger/core.js";
@@ -102,12 +102,11 @@ Please update the name of this slot.`
         }
       }
     }
-    const content = await renderSlot(__privateGet(this, _result), __privateGet(this, _slots)[name]).then(
-      (res) => res != null ? String(res) : res
-    );
+    const content = await renderSlot(__privateGet(this, _result), __privateGet(this, _slots)[name]);
+    const outHTML = stringifyChunk(__privateGet(this, _result), content);
     if (cacheable)
-      __privateGet(this, _cache).set(name, content);
-    return content;
+      __privateGet(this, _cache).set(name, outHTML);
+    return outHTML;
   }
 }
 _cache = new WeakMap();

package/dist/runtime/server/render/common.d.ts

@@ -1,11 +1,12 @@
 import type { SSRResult } from '../../../@types/astro';
 import type { RenderInstruction } from './types.js';
 import { HTMLBytes } from '../escape.js';
+import { type SlotString } from './slot.js';
 export declare const Fragment: unique symbol;
 export declare const Renderer: unique symbol;
 export declare const encoder: TextEncoder;
 export declare const decoder: TextDecoder;
-export declare function stringifyChunk(result: SSRResult, chunk: string | RenderInstruction): any;
+export declare function stringifyChunk(result: SSRResult, chunk: string | SlotString | RenderInstruction): any;
 export declare class HTMLParts {
     parts: string;
     constructor();

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

@@ -4,6 +4,7 @@ import {
   determinesIfNeedsDirectiveScript,
   getPrescripts
 } from "../scripts.js";
+import { isSlotString } from "./slot.js";
 const Fragment = Symbol.for("astro:fragment");
 const Renderer = Symbol.for("astro:renderer");
 const encoder = new TextEncoder();
@@ -23,6 +24,17 @@ function stringifyChunk(result, chunk) {
       }
     }
     default: {
+      if (isSlotString(chunk)) {
+        let out = "";
+        const c = chunk;
+        if (c.instructions) {
+          for (const instr of c.instructions) {
+            out += stringifyChunk(result, instr);
+          }
+        }
+        out += chunk.toString();
+        return out;
+      }
       return chunk.toString();
     }
   }

package/dist/runtime/server/render/slot.d.ts

@@ -1,10 +1,13 @@
 import type { SSRResult } from '../../../@types/astro.js';
 import type { RenderInstruction } from './types.js';
 import { HTMLString } from '../escape.js';
+declare const slotString: unique symbol;
 export declare class SlotString extends HTMLString {
     instructions: null | RenderInstruction[];
+    [slotString]: boolean;
     constructor(content: string, instructions: null | RenderInstruction[]);
 }
+export declare function isSlotString(str: string): str is any;
 export declare function renderSlot(_result: any, slotted: string, fallback?: any): Promise<string>;
 interface RenderSlotsResult {
     slotInstructions: null | RenderInstruction[];

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

@@ -1,11 +1,17 @@
 import { HTMLString, markHTMLString } from "../escape.js";
 import { renderChild } from "./any.js";
+const slotString = Symbol.for("astro:slot-string");
 class SlotString extends HTMLString {
   constructor(content, instructions) {
     super(content);
     this.instructions = instructions;
+    this[slotString] = true;
   }
 }
+slotString;
+function isSlotString(str) {
+  return !!str[slotString];
+}
 async function renderSlot(_result, slotted, fallback) {
   if (slotted) {
     let iterator = renderChild(slotted);
@@ -47,6 +53,7 @@ async function renderSlots(result, slots = {}) {
 }
 export {
   SlotString,
+  isSlotString,
   renderSlot,
   renderSlots
 };

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

@@ -11,27 +11,24 @@ function getPrivateEnv(viteConfig, astroConfig) {
     viteConfig.envDir ?? fileURLToPath(astroConfig.root),
     ""
   );
-  const privateKeys = Object.keys(fullEnv).filter((key) => {
-    for (const envPrefix of envPrefixes) {
-      if (key.startsWith(envPrefix))
-        return false;
+  const privateEnv = {};
+  for (const key in fullEnv) {
+    if (envPrefixes.every((prefix) => !key.startsWith(prefix))) {
+      if (typeof process.env[key] !== "undefined") {
+        privateEnv[key] = `process.env.${key}`;
+      } else {
+        privateEnv[key] = JSON.stringify(fullEnv[key]);
+      }
     }
-    return true;
-  });
-  if (privateKeys.length === 0) {
-    return null;
   }
-  return Object.fromEntries(
-    privateKeys.map((key) => {
-      if (typeof process.env[key] !== "undefined")
-        return [key, `process.env.${key}`];
-      return [key, JSON.stringify(fullEnv[key])];
-    })
-  );
+  privateEnv.SITE = astroConfig.site ? `'${astroConfig.site}'` : "undefined";
+  privateEnv.SSR = JSON.stringify(true);
+  privateEnv.BASE_URL = astroConfig.base ? `'${astroConfig.base}'` : "undefined";
+  return privateEnv;
 }
 function getReferencedPrivateKeys(source, privateEnv) {
   const references = /* @__PURE__ */ new Set();
-  for (const key of Object.keys(privateEnv)) {
+  for (const key in privateEnv) {
     if (source.includes(key)) {
       references.add(key);
     }
@@ -40,73 +37,52 @@ function getReferencedPrivateKeys(source, privateEnv) {
 }
 function envVitePlugin({ settings }) {
   let privateEnv;
-  let config;
-  let replacements;
-  let pattern;
+  let viteConfig;
   const { config: astroConfig } = settings;
   return {
     name: "astro:vite-plugin-env",
     enforce: "pre",
     configResolved(resolvedConfig) {
-      config = resolvedConfig;
+      viteConfig = resolvedConfig;
     },
     async transform(source, id, options) {
-      const ssr = (options == null ? void 0 : options.ssr) === true;
-      if (!ssr) {
+      if (!(options == null ? void 0 : options.ssr) || !source.includes("import.meta.env")) {
         return;
       }
-      if (!source.includes("import.meta") || !/\benv\b/.test(source)) {
-        return;
-      }
-      if (typeof privateEnv === "undefined") {
-        privateEnv = getPrivateEnv(config, astroConfig);
-        if (privateEnv) {
-          privateEnv.SITE = astroConfig.site ? `'${astroConfig.site}'` : "undefined";
-          privateEnv.SSR = JSON.stringify(true);
-          privateEnv.BASE_URL = astroConfig.base ? `'${astroConfig.base}'` : void 0;
-          const entries = Object.entries(privateEnv).map(([key, value]) => [
-            `import.meta.env.${key}`,
-            value
-          ]);
-          replacements = Object.fromEntries(entries);
-          replacements = Object.assign(replacements, {
-            "import.meta.env.SITE": astroConfig.site ? `'${astroConfig.site}'` : "undefined",
-            "import.meta.env.SSR": JSON.stringify(true),
-            "import.meta.env.BASE_URL": astroConfig.base ? `'${astroConfig.base}'` : void 0,
-            "import.meta.env": `({})`
-          });
-          pattern = new RegExp(
-            "(?<!(?<!\\.\\.)\\.)\\b(" + Object.keys(replacements).map((str) => {
-              return str.replace(/[-[\]/{}()*+?.\\^$|]/g, "\\$&");
-            }).join("|") + ")\\b(?!\\s*?=[^=])",
-            "g"
-          );
-        }
-      }
-      if (!privateEnv || !pattern)
-        return;
-      const references = getReferencedPrivateKeys(source, privateEnv);
-      if (references.size === 0)
-        return;
-      const s = new MagicString(source);
+      let s;
+      const pattern = new RegExp(
+        `(?<!(?<!\\.\\.)\\.)\\b(import\\.meta\\.env\\.(.+?)|import\\.meta\\.env)\\b(?!\\s*?=[^=])`,
+        "g"
+      );
+      let references;
       let match;
       while (match = pattern.exec(source)) {
-        const start = match.index;
-        const end = start + match[0].length;
-        let replacement = "" + replacements[match[1]];
+        let replacement;
         if (match[0] === "import.meta.env") {
+          privateEnv ?? (privateEnv = getPrivateEnv(viteConfig, astroConfig));
+          references ?? (references = getReferencedPrivateKeys(source, privateEnv));
           replacement = `(Object.assign(import.meta.env,{`;
           for (const key of references.values()) {
             replacement += `${key}:${privateEnv[key]},`;
           }
           replacement += "}))";
+        } else if (match[2]) {
+          privateEnv ?? (privateEnv = getPrivateEnv(viteConfig, astroConfig));
+          replacement = privateEnv[match[2]];
         }
-        s.overwrite(start, end, replacement);
+        if (replacement) {
+          const start = match.index;
+          const end = start + match[0].length;
+          s ?? (s = new MagicString(source));
+          s.overwrite(start, end, replacement);
+        }
+      }
+      if (s) {
+        return {
+          code: s.toString(),
+          map: s.generateMap()
+        };
       }
-      return {
-        code: s.toString(),
-        map: s.generateMap()
-      };
     }
   };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "astro",
-  "version": "1.6.4",
+  "version": "1.6.5",
   "description": "Astro is a modern site builder with web best practices, performance, and DX front-of-mind.",
   "type": "module",
   "author": "withastro",