@marko/vite 5.0.6 → 5.0.7

package/dist/esbuild-plugin.d.ts

@@ -1,5 +1,5 @@
-import type * as vite from "vite";
 import * as compiler from "@marko/compiler";
+import type * as vite from "vite";
 type ESBuildOptions = Exclude<vite.DepOptimizationConfig["esbuildOptions"], undefined>;
 type ESBuildPlugin = Exclude<ESBuildOptions["plugins"], undefined>[number];
 export default function esbuildPlugin(config: compiler.Config): ESBuildPlugin;

package/dist/index.d.ts

@@ -1,5 +1,5 @@
-import type * as vite from "vite";
 import * as compiler from "@marko/compiler";
+import type * as vite from "vite";
 export declare namespace API {
     type getMarkoAssetCodeForEntry = (id: string) => string | void;
 }

package/dist/index.mjs

@@ -1,166 +1,326 @@
 // src/index.ts
 import * as compiler2 from "@marko/compiler";
+import anyMatch from "anymatch";
+import crypto from "crypto";
+import glob2 from "fast-glob";
 import fs4 from "fs";
 import path6 from "path";
-import crypto from "crypto";
-import anyMatch from "anymatch";
 import { pathToFileURL } from "url";
 
-// src/server-entry-template.ts
-import path from "path";
-
-// src/render-assets-runtime.ts
-var renderAssetsRuntimeId = "\0marko-render-assets.mjs";
-function getRenderAssetsRuntime(opts) {
-  return `${opts.basePathVar && opts.isBuild ? `const base = globalThis.${opts.basePathVar};
-if (typeof base !== "string") throw new Error("${opts.basePathVar} must be defined when using basePathVar.");
-if (!base.endsWith("/")) throw new Error("${opts.basePathVar} must end with a '/' when using basePathVar.");` : "const base = import.meta.env.BASE_URL;"}
+// src/babel-plugin-cjs-interop.ts
+import * as t from "@babel/types";
 
-export function getPrepend(g) {
-  return (
-    g.___viteRenderAssets("head-prepend") +
-    g.___viteRenderAssets("head") +
-    g.___viteRenderAssets("body-prepend") 
-  );
+// src/resolve.ts
+import fs from "fs";
+import path from "path";
+import Resolve from "resolve";
+import { exports } from "resolve.exports";
+var exportsMainFile = `__package_exports__`;
+var modulePathReg = /^.*[/\\]node_modules[/\\](?:@[^/\\]+[/\\])?[^/\\]+[/\\]/;
+var cjsModuleLookup = /* @__PURE__ */ new Map();
+function isCJSModule(id) {
+  const modulePath = modulePathReg.exec(id)?.[0];
+  if (modulePath) {
+    const pkgPath = modulePath + "package.json";
+    let isCJS = cjsModuleLookup.get(pkgPath);
+    if (isCJS === void 0) {
+      try {
+        const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf8"));
+        isCJS = pkg.type !== "module" && !pkg.exports;
+      } catch {
+        isCJS = false;
+      }
+      cjsModuleLookup.set(pkgPath, isCJS);
+    }
+    return isCJS;
+  }
+  return false;
 }
-export function getAppend(g) {
-  return (
-    g.___viteRenderAssets("body-prepend") 
-  );
+function resolve(id, from, extensions, conditions) {
+  return Resolve.sync(id, {
+    basedir: path.dirname(from),
+    filename: from,
+    pathFilter,
+    packageFilter,
+    extensions
+  });
+  function pathFilter(pkg, pkgFile, relativePath) {
+    cjsModuleLookup.set(pkgFile, pkg.type !== "module" && !pkg.exports);
+    if (pkg.exports) {
+      return exports(
+        pkg,
+        relativePath === exportsMainFile ? "." : relativePath,
+        {
+          conditions
+        }
+      )?.[0];
+    }
+    return relativePath;
+  }
 }
-export function addAssets(g, newEntries) {
-  const entries = g.___viteEntries;
-  if (entries) {
-    g.___viteEntries = entries.concat(newEntries);
-    return true;
+function packageFilter(pkg) {
+  if (pkg.exports) {
+    pkg.main = exportsMainFile;
   }
-  g.___viteEntries = newEntries;
-  g.___viteRenderAssets = renderAssets;
-  g.___viteInjectAttrs = g.cspNonce
-    ? \` nonce="\${g.cspNonce.replace(/"/g, "'")}"\`
-    : "";
-  g.___viteSeenIds = new Set();
-  ${opts.runtimeId ? `g.runtimeId = ${JSON.stringify(opts.runtimeId)};` : ""}
+  return pkg;
 }
 
-function renderAssets(slot) {
-  const entries = this.___viteEntries;
-  let html = "";
-
-  if (entries) {
-    const seenIds = this.___viteSeenIds;
-    const slotWrittenEntriesKey = \`___viteWrittenEntries-\${slot}\`;
-    const lastWrittenEntry = this[slotWrittenEntriesKey] || 0;
-    const writtenEntries = (this[slotWrittenEntriesKey] = entries.length);
-
-    if(!this.___flushedMBP && slot !== "head-prepend") {
-        this.___flushedMBP = true;
-
-        html += \`<script\${this.___viteInjectAttrs}>${opts.runtimeId ? `$mbp_${opts.runtimeId}` : "$mbp"}=\${JSON.stringify(base)}</script>\`
-    }
-
-    for (let i = lastWrittenEntry; i < writtenEntries; i++) {
-      let entry = entries[i];
-
-      if (typeof entry === "string") {
-        entry = __MARKO_MANIFEST__[entry] || {};
-      }${opts.isBuild ? "" : ` else if (slot === "head") {
-        // In dev mode we have is a list entries of the top level modules that need to be imported.
-        // To avoid FOUC we will hide the page until all of these modules are loaded.
-        const { preload } = entry;
-        if (preload) {
-          html += \`<script class=marko-vite-preload async blocking=render type=module\${this.___viteInjectAttrs}>\`;
-          for (const id of preload) {
-            html += \`import \${JSON.stringify(base + id)};\`;
+// src/babel-plugin-cjs-interop.ts
+function plugin(options) {
+  return {
+    name: "marko-import-interop",
+    visitor: {
+      ImportDeclaration(path7) {
+        if (!path7.node.specifiers.length || /\.(?:mjs|marko)$|\?/.test(path7.node.source.value) || options.filter?.(path7.node.source.value) === false) {
+          return;
+        }
+        try {
+          const resolved = resolve(
+            path7.node.source.value,
+            path7.hub.file.opts.filename,
+            options.extensions,
+            options.conditions
+          );
+          if (!/\.c?js$/.test(resolved) || !isCJSModule(resolved)) {
+            return;
           }
-
-          html += "document.querySelectorAll('.marko-vite-preload').forEach((el) => el.remove());";
-          html += "document.documentElement.style.visibility='';";
-          html +=
-            "if(document.documentElement.getAttribute('style')==='')document.documentElement.removeAttribute('style');";
-          html += \`</script><script class=marko-vite-preload\${this.___viteInjectAttrs}>document.documentElement.style.visibility='hidden'</script>\`;
+        } catch (_) {
+          return;
         }
-      }`}
-
-      const parts = entry[slot];
-
-      if (parts) {
-        for (let i = 0; i < parts.length; i++) {
-          const part = parts[i];
-          switch (part) {
-            case 0: /** InjectType.AssetAttrs */
-              html += this.___viteInjectAttrs;
-              break;
-            case 1: /** InjectType.PublicPath */
-              html += base;
-              break;
-            case 2: /** InjectType.Dedupe */ {
-              const id = parts[++i];
-              const skipParts = parts[++i];
-              if (seenIds.has(id)) {
-                i += skipParts;
-              } else {
-                seenIds.add(id);
-              }
-              break;
-            }
-            default:
-              html += part;
-              break;
+        let namespaceId;
+        let defaultImportId;
+        let imports;
+        for (const s of path7.node.specifiers) {
+          if (t.isImportSpecifier(s)) {
+            (imports ||= []).push({
+              name: t.isStringLiteral(s.imported) ? s.imported.value : s.imported.name,
+              alias: s.local.name
+            });
+          } else if (t.isImportDefaultSpecifier(s)) {
+            defaultImportId = s.local;
+          } else if (t.isImportNamespaceSpecifier(s)) {
+            namespaceId = s.local;
           }
         }
+        const rawImport = path7.scope.generateUidIdentifier(
+          namespaceId?.name || defaultImportId?.name || path7.node.source.value
+        );
+        path7.node.specifiers = [t.importNamespaceSpecifier(rawImport)];
+        if (defaultImportId) {
+          path7.insertAfter(
+            t.variableDeclaration("const", [
+              t.variableDeclarator(
+                t.objectPattern([
+                  t.objectProperty(t.identifier("default"), defaultImportId)
+                ]),
+                t.conditionalExpression(
+                  t.optionalMemberExpression(
+                    t.memberExpression(rawImport, t.identifier("default")),
+                    t.identifier("__esModule"),
+                    false,
+                    true
+                  ),
+                  t.memberExpression(rawImport, t.identifier("default")),
+                  rawImport
+                )
+              )
+            ])
+          );
+        }
+        if (namespaceId) {
+          path7.insertAfter(
+            t.variableDeclaration("const", [
+              t.variableDeclarator(
+                namespaceId,
+                t.conditionalExpression(
+                  t.optionalMemberExpression(
+                    rawImport,
+                    t.identifier("__esModule"),
+                    false,
+                    true
+                  ),
+                  rawImport,
+                  t.memberExpression(rawImport, t.identifier("default"))
+                )
+              )
+            ])
+          );
+        }
+        if (imports) {
+          path7.insertAfter(
+            t.variableDeclaration("const", [
+              t.variableDeclarator(
+                t.objectPattern(
+                  imports.map(
+                    ({ name, alias }) => t.objectProperty(
+                      t.identifier(name),
+                      t.identifier(alias),
+                      false,
+                      name === alias
+                    )
+                  )
+                ),
+                t.conditionalExpression(
+                  t.optionalMemberExpression(
+                    rawImport,
+                    t.identifier("__esModule"),
+                    false,
+                    true
+                  ),
+                  rawImport,
+                  t.memberExpression(rawImport, t.identifier("default"))
+                )
+              )
+            ])
+          );
+        }
       }
     }
-  }
-
-  return html;
-}
-`;
+  };
 }
 
-// src/server-entry-template.ts
-var server_entry_template_default = async (opts) => {
-  const fileNameStr = JSON.stringify(`./${path.basename(opts.fileName)}`);
-  if (opts.tagsAPI) {
-    return `import Template from ${fileNameStr};
-export * from ${fileNameStr};
-import { addAssets, getPrepend, getAppend } from "${renderAssetsRuntimeId}";
-static function flush($global, html) {
-  return getPrepend($global) + html + getAppend($global);
-}
-static function setFlush($global) {
-  $global.__flush__ = flush;
+// src/esbuild-plugin.ts
+import * as compiler from "@marko/compiler";
+import fs2 from "fs";
+import path2 from "path";
+var markoErrorRegExp = /^(.+?)(?:\((\d+)(?:\s*,\s*(\d+))?\))?: (.*)$/gm;
+function esbuildPlugin(config) {
+  return {
+    name: "marko",
+    async setup(build) {
+      const { platform = "browser" } = build.initialOptions;
+      const isScan = build.initialOptions.plugins?.some(
+        (v) => v.name === "vite:dep-scan"
+      );
+      const virtualFiles2 = /* @__PURE__ */ new Map();
+      const finalConfig = {
+        ...config,
+        output: platform === "browser" ? "dom" : "html",
+        resolveVirtualDependency(from, dep) {
+          virtualFiles2.set(path2.join(from, "..", dep.virtualPath), dep);
+          return dep.virtualPath;
+        }
+      };
+      const scanConfig = {
+        ...finalConfig,
+        output: "hydrate"
+      };
+      build.onResolve({ filter: /\.marko\./ }, (args) => {
+        return {
+          namespace: "marko:virtual",
+          path: path2.resolve(args.resolveDir, args.path),
+          external: isScan
+        };
+      });
+      build.onLoad(
+        { filter: /\.marko\./, namespace: "marko:virtual" },
+        (args) => ({
+          contents: virtualFiles2.get(args.path).code,
+          loader: path2.extname(args.path).slice(1)
+        })
+      );
+      build.onLoad({ filter: /\.marko$/ }, async (args) => {
+        try {
+          const { code, meta } = await compiler.compileFile(
+            args.path,
+            isScan && args.namespace === "" ? scanConfig : finalConfig
+          );
+          return {
+            loader: "js",
+            contents: code,
+            watchFiles: meta.watchFiles,
+            resolveDir: path2.dirname(args.path)
+          };
+        } catch (e) {
+          const text = e.message;
+          const errors = [];
+          let match;
+          let lines;
+          while (match = markoErrorRegExp.exec(text)) {
+            const [, file, rawLine, rawCol, text2] = match;
+            const line = parseInt(rawLine, 10) || 1;
+            const column = parseInt(rawCol, 10) || 1;
+            lines ||= (await fs2.promises.readFile(args.path, "utf-8")).split(
+              /\n/g
+            );
+            errors.push({
+              text: text2,
+              location: {
+                file,
+                line,
+                column,
+                lineText: ` ${lines[line - 1]}`
+              }
+            });
+          }
+          if (!errors.length) {
+            errors.push({ text });
+          }
+          return {
+            errors
+          };
+        }
+      });
+    }
+  };
 }
-static const assets = [${opts.entryData.join(",")}];
-<const/writeSync=addAssets($global, assets) || setFlush($global)/>
--- $!{writeSync && getPrepend($global)}
-<Template ...input/>
--- $!{writeSync && getAppend($global)}
-`;
+
+// src/glob-import-transform.ts
+import { types as t2 } from "@marko/compiler";
+import glob from "fast-glob";
+import path3 from "path";
+var programGlobImports = /* @__PURE__ */ new WeakMap();
+var glob_import_transform_default = {
+  MetaProperty(tag) {
+    const memberExpression2 = tag.parentPath;
+    if (memberExpression2.node.type === "MemberExpression" && memberExpression2.node.property.type === "Identifier" && memberExpression2.node.property.name === "glob") {
+      const callExpression = memberExpression2.parentPath;
+      if (callExpression?.node.type === "CallExpression") {
+        const args = callExpression.get("arguments").map((arg) => arg.evaluate().value);
+        if (args[1]?.eager) {
+          const program = tag.hub.file.path;
+          const existing = programGlobImports.get(program);
+          if (!existing) {
+            programGlobImports.set(program, [args]);
+          } else {
+            existing.push(args);
+          }
+        }
+      }
+    }
+  },
+  Program: {
+    exit(tag) {
+      const globImports = programGlobImports.get(tag);
+      if (!globImports) {
+        return;
+      }
+      const { cwd, filename } = tag.hub.file.opts;
+      const dir = path3.dirname(filename);
+      const seen = /* @__PURE__ */ new Set();
+      for (const [patterns, options] of globImports) {
+        const resolvedPatterns = Array.isArray(patterns) ? patterns.map((p) => path3.resolve(dir, p)) : path3.resolve(dir, patterns);
+        const results = glob.globSync(resolvedPatterns, {
+          cwd,
+          absolute: true,
+          dot: !!options.exhaustive,
+          ignore: options.exhaustive ? [] : [path3.join(cwd, "**/node_modules/**")]
+        });
+        for (const file of results) {
+          if (file.endsWith(".marko") && file !== filename && !seen.has(file)) {
+            seen.add(file);
+            tag.node.body.push(t2.importDeclaration([], t2.stringLiteral(file)));
+          }
+        }
+      }
+    }
   }
-  return `import template from ${fileNameStr};
-export * from ${fileNameStr};
-import { addAssets, getPrepend, getAppend } from "${renderAssetsRuntimeId}";
-static const assets = [${opts.entryData.join(",")}];
-<if(addAssets($global, assets))>
-  $!{getPrepend($global)}
-  <\${template} ...input/>
-  $!{getAppend($global)}
-</>
-<else>
-  <__flush_here_and_after__>$!{getPrepend($global)}</>
-  <\${template} ...input/>
-  <init-components/>
-  <await-reorderer/>
-  <__flush_here_and_after__>$!{getAppend($global)}</>
-</>
-`;
 };
 
 // src/manifest-generator.ts
-import { Parser } from "htmlparser2";
 import { ElementType as ElementType2 } from "domelementtype";
 import { DomHandler } from "domhandler";
+import { Parser } from "htmlparser2";
 
 // src/serializer.ts
 import { ElementType } from "domelementtype";
@@ -364,285 +524,51 @@ function isElement(node) {
   return node.type === ElementType2.Tag;
 }
 
-// src/esbuild-plugin.ts
-import fs from "fs";
-import path2 from "path";
-import * as compiler from "@marko/compiler";
-var markoErrorRegExp = /^(.+?)(?:\((\d+)(?:\s*,\s*(\d+))?\))?: (.*)$/gm;
-function esbuildPlugin(config) {
-  return {
-    name: "marko",
-    async setup(build) {
-      const { platform = "browser" } = build.initialOptions;
-      const isScan = build.initialOptions.plugins?.some(
-        (v) => v.name === "vite:dep-scan"
-      );
-      const virtualFiles2 = /* @__PURE__ */ new Map();
-      const finalConfig = {
-        ...config,
-        output: platform === "browser" ? "dom" : "html",
-        resolveVirtualDependency(from, dep) {
-          virtualFiles2.set(path2.join(from, "..", dep.virtualPath), dep);
-          return dep.virtualPath;
-        }
-      };
-      const scanConfig = {
-        ...finalConfig,
-        output: "hydrate"
-      };
-      build.onResolve({ filter: /\.marko\./ }, (args) => {
-        return {
-          namespace: "marko:virtual",
-          path: path2.resolve(args.resolveDir, args.path),
-          external: isScan
-        };
-      });
-      build.onLoad(
-        { filter: /\.marko\./, namespace: "marko:virtual" },
-        (args) => ({
-          contents: virtualFiles2.get(args.path).code,
-          loader: path2.extname(args.path).slice(1)
-        })
-      );
-      build.onLoad({ filter: /\.marko$/ }, async (args) => {
-        try {
-          const { code, meta } = await compiler.compileFile(
-            args.path,
-            isScan && args.namespace === "" ? scanConfig : finalConfig
-          );
-          return {
-            loader: "js",
-            contents: code,
-            watchFiles: meta.watchFiles,
-            resolveDir: path2.dirname(args.path)
-          };
-        } catch (e) {
-          const text = e.message;
-          const errors = [];
-          let match;
-          let lines;
-          while (match = markoErrorRegExp.exec(text)) {
-            const [, file, rawLine, rawCol, text2] = match;
-            const line = parseInt(rawLine, 10) || 1;
-            const column = parseInt(rawCol, 10) || 1;
-            lines ||= (await fs.promises.readFile(args.path, "utf-8")).split(
-              /\n/g
-            );
-            errors.push({
-              text: text2,
-              location: {
-                file,
-                line,
-                column,
-                lineText: ` ${lines[line - 1]}`
-              }
-            });
-          }
-          if (!errors.length) {
-            errors.push({ text });
-          }
-          return {
-            errors
-          };
-        }
-      });
-    }
-  };
-}
-
-// src/babel-plugin-cjs-interop.ts
-import * as t from "@babel/types";
-
-// src/resolve.ts
-import { exports } from "resolve.exports";
-import Resolve from "resolve";
-import path3 from "path";
-import fs2 from "fs";
-var exportsMainFile = `__package_exports__`;
-var modulePathReg = /^.*[/\\]node_modules[/\\](?:@[^/\\]+[/\\])?[^/\\]+[/\\]/;
-var cjsModuleLookup = /* @__PURE__ */ new Map();
-function isCJSModule(id) {
-  const modulePath = modulePathReg.exec(id)?.[0];
-  if (modulePath) {
-    const pkgPath = modulePath + "package.json";
-    let isCJS = cjsModuleLookup.get(pkgPath);
-    if (isCJS === void 0) {
-      try {
-        const pkg = JSON.parse(fs2.readFileSync(pkgPath, "utf8"));
-        isCJS = pkg.type !== "module" && !pkg.exports;
-      } catch {
-        isCJS = false;
-      }
-      cjsModuleLookup.set(pkgPath, isCJS);
-    }
-    return isCJS;
-  }
-  return false;
-}
-function resolve(id, from, extensions, conditions) {
-  return Resolve.sync(id, {
-    basedir: path3.dirname(from),
-    filename: from,
-    pathFilter,
-    packageFilter,
-    extensions
-  });
-  function pathFilter(pkg, pkgFile, relativePath) {
-    cjsModuleLookup.set(pkgFile, pkg.type !== "module" && !pkg.exports);
-    if (pkg.exports) {
-      return exports(
-        pkg,
-        relativePath === exportsMainFile ? "." : relativePath,
-        {
-          conditions
-        }
-      )?.[0];
-    }
-    return relativePath;
+// src/read-once-persisted-store.ts
+import { promises as fs3 } from "fs";
+import os from "os";
+import path4 from "path";
+var noop = () => {
+};
+var tmpFile = path4.join(os.tmpdir(), "marko-vite-storage.json");
+var values = /* @__PURE__ */ new Map();
+var loadedFromDisk;
+var ReadOncePersistedStore = class {
+  constructor(uid) {
+    this.uid = uid;
   }
-}
-function packageFilter(pkg) {
-  if (pkg.exports) {
-    pkg.main = exportsMainFile;
+  write(value) {
+    values.set(this.uid, value);
   }
-  return pkg;
-}
-
-// src/babel-plugin-cjs-interop.ts
-function plugin(options) {
-  return {
-    name: "marko-import-interop",
-    visitor: {
-      ImportDeclaration(path7) {
-        if (!path7.node.specifiers.length || /\.(?:mjs|marko)$|\?/.test(path7.node.source.value) || options.filter?.(path7.node.source.value) === false) {
-          return;
-        }
-        try {
-          const resolved = resolve(
-            path7.node.source.value,
-            path7.hub.file.opts.filename,
-            options.extensions,
-            options.conditions
-          );
-          if (!/\.c?js$/.test(resolved) || !isCJSModule(resolved)) {
-            return;
-          }
-        } catch (_) {
-          return;
-        }
-        let namespaceId;
-        let defaultImportId;
-        let imports;
-        for (const s of path7.node.specifiers) {
-          if (t.isImportSpecifier(s)) {
-            (imports ||= []).push({
-              name: t.isStringLiteral(s.imported) ? s.imported.value : s.imported.name,
-              alias: s.local.name
-            });
-          } else if (t.isImportDefaultSpecifier(s)) {
-            defaultImportId = s.local;
-          } else if (t.isImportNamespaceSpecifier(s)) {
-            namespaceId = s.local;
-          }
-        }
-        const rawImport = path7.scope.generateUidIdentifier(
-          namespaceId?.name || defaultImportId?.name || path7.node.source.value
-        );
-        path7.node.specifiers = [t.importNamespaceSpecifier(rawImport)];
-        if (defaultImportId) {
-          path7.insertAfter(
-            t.variableDeclaration("const", [
-              t.variableDeclarator(
-                t.objectPattern([
-                  t.objectProperty(t.identifier("default"), defaultImportId)
-                ]),
-                t.conditionalExpression(
-                  t.optionalMemberExpression(
-                    t.memberExpression(rawImport, t.identifier("default")),
-                    t.identifier("__esModule"),
-                    false,
-                    true
-                  ),
-                  t.memberExpression(rawImport, t.identifier("default")),
-                  rawImport
-                )
-              )
-            ])
-          );
-        }
-        if (namespaceId) {
-          path7.insertAfter(
-            t.variableDeclaration("const", [
-              t.variableDeclarator(
-                namespaceId,
-                t.conditionalExpression(
-                  t.optionalMemberExpression(
-                    rawImport,
-                    t.identifier("__esModule"),
-                    false,
-                    true
-                  ),
-                  rawImport,
-                  t.memberExpression(rawImport, t.identifier("default"))
-                )
-              )
-            ])
-          );
-        }
-        if (imports) {
-          path7.insertAfter(
-            t.variableDeclaration("const", [
-              t.variableDeclarator(
-                t.objectPattern(
-                  imports.map(
-                    ({ name, alias }) => t.objectProperty(
-                      t.identifier(name),
-                      t.identifier(alias),
-                      false,
-                      name === alias
-                    )
-                  )
-                ),
-                t.conditionalExpression(
-                  t.optionalMemberExpression(
-                    rawImport,
-                    t.identifier("__esModule"),
-                    false,
-                    true
-                  ),
-                  rawImport,
-                  t.memberExpression(rawImport, t.identifier("default"))
-                )
-              )
-            ])
-          );
-        }
-      }
+  async read() {
+    const { uid } = this;
+    if (values.has(uid)) {
+      const value = values.get(uid);
+      values.delete(uid);
+      return value;
     }
-  };
-}
-
-// src/render-assets-transform.ts
-var render_assets_transform_default = (tag, t3) => {
-  if (tag.hub.file.markoOpts.markoViteLinked) {
-    const body = tag.get("body");
-    const tagName = tag.get("name").node.value;
-    body.unshiftContainer("body", renderAssetsCall(t3, `${tagName}-prepend`));
-    body.pushContainer("body", renderAssetsCall(t3, tagName));
+    if (loadedFromDisk === true) {
+      throw new Error(`Value for ${uid} could not be loaded.`);
+    }
+    await (loadedFromDisk ||= fs3.readFile(tmpFile, "utf-8").then(syncDataFromDisk).catch(finishLoadFromDisk));
+    return this.read();
   }
 };
-function renderAssetsCall(t3, slot) {
-  return t3.markoPlaceholder(
-    t3.callExpression(
-      t3.memberExpression(
-        t3.identifier("$global"),
-        t3.identifier("___viteRenderAssets")
-      ),
-      [t3.stringLiteral(slot)]
-    ),
-    false
-  );
+function syncDataFromDisk(data) {
+  finishLoadFromDisk();
+  fs3.unlink(tmpFile).catch(noop);
+  for (const [k, v] of JSON.parse(data)) {
+    values.set(k, v);
+  }
+}
+function finishLoadFromDisk() {
+  loadedFromDisk = true;
 }
+process.once("beforeExit", (code) => {
+  if (code === 0 && values.size) {
+    fs3.writeFile(tmpFile, JSON.stringify([...values])).catch(noop);
+  }
+});
 
 // src/relative-assets-transform.ts
 var attrSrc = /* @__PURE__ */ new Set(["src"]);
@@ -691,103 +617,176 @@ function transform(tag, t3) {
   }
 }
 
-// src/glob-import-transform.ts
-import { types as t2 } from "@marko/compiler";
-import glob from "fast-glob";
-import path4 from "path";
-var programGlobImports = /* @__PURE__ */ new WeakMap();
-var glob_import_transform_default = {
-  MetaProperty(tag) {
-    const memberExpression2 = tag.parentPath;
-    if (memberExpression2.node.type === "MemberExpression" && memberExpression2.node.property.type === "Identifier" && memberExpression2.node.property.name === "glob") {
-      const callExpression = memberExpression2.parentPath;
-      if (callExpression?.node.type === "CallExpression") {
-        const args = callExpression.get("arguments").map((arg) => arg.evaluate().value);
-        if (args[1]?.eager) {
-          const program = tag.hub.file.path;
-          const existing = programGlobImports.get(program);
-          if (!existing) {
-            programGlobImports.set(program, [args]);
-          } else {
-            existing.push(args);
+// src/render-assets-runtime.ts
+var renderAssetsRuntimeId = "\0marko-render-assets.mjs";
+function getRenderAssetsRuntime(opts) {
+  return `${opts.basePathVar && opts.isBuild ? `const base = globalThis.${opts.basePathVar};
+if (typeof base !== "string") throw new Error("${opts.basePathVar} must be defined when using basePathVar.");
+if (!base.endsWith("/")) throw new Error("${opts.basePathVar} must end with a '/' when using basePathVar.");` : "const base = import.meta.env.BASE_URL;"}
+
+export function getPrepend(g) {
+  return (
+    g.___viteRenderAssets("head-prepend") +
+    g.___viteRenderAssets("head") +
+    g.___viteRenderAssets("body-prepend") 
+  );
+}
+export function getAppend(g) {
+  return (
+    g.___viteRenderAssets("body-prepend") 
+  );
+}
+export function addAssets(g, newEntries) {
+  const entries = g.___viteEntries;
+  if (entries) {
+    g.___viteEntries = entries.concat(newEntries);
+    return true;
+  }
+  g.___viteEntries = newEntries;
+  g.___viteRenderAssets = renderAssets;
+  g.___viteInjectAttrs = g.cspNonce
+    ? \` nonce="\${g.cspNonce.replace(/"/g, "&#39;")}"\`
+    : "";
+  g.___viteSeenIds = new Set();
+  ${opts.runtimeId ? `g.runtimeId = ${JSON.stringify(opts.runtimeId)};` : ""}
+}
+
+function renderAssets(slot) {
+  const entries = this.___viteEntries;
+  let html = "";
+
+  if (entries) {
+    const seenIds = this.___viteSeenIds;
+    const slotWrittenEntriesKey = \`___viteWrittenEntries-\${slot}\`;
+    const lastWrittenEntry = this[slotWrittenEntriesKey] || 0;
+    const writtenEntries = (this[slotWrittenEntriesKey] = entries.length);
+
+    if(!this.___flushedMBP && slot !== "head-prepend") {
+        this.___flushedMBP = true;
+
+        html += \`<script\${this.___viteInjectAttrs}>${opts.runtimeId ? `$mbp_${opts.runtimeId}` : "$mbp"}=\${JSON.stringify(base)}</script>\`
+    }
+
+    for (let i = lastWrittenEntry; i < writtenEntries; i++) {
+      let entry = entries[i];
+
+      if (typeof entry === "string") {
+        entry = __MARKO_MANIFEST__[entry] || {};
+      }${opts.isBuild ? "" : ` else if (slot === "head") {
+        // In dev mode we have is a list entries of the top level modules that need to be imported.
+        // To avoid FOUC we will hide the page until all of these modules are loaded.
+        const { preload } = entry;
+        if (preload) {
+          html += \`<script class=marko-vite-preload async blocking=render type=module\${this.___viteInjectAttrs}>\`;
+          for (const id of preload) {
+            html += \`import \${JSON.stringify(base + id)};\`;
           }
+
+          html += "document.querySelectorAll('.marko-vite-preload').forEach((el) => el.remove());";
+          html += "document.documentElement.style.visibility='';";
+          html +=
+            "if(document.documentElement.getAttribute('style')==='')document.documentElement.removeAttribute('style');";
+          html += \`</script><script class=marko-vite-preload\${this.___viteInjectAttrs}>document.documentElement.style.visibility='hidden'</script>\`;
         }
-      }
-    }
-  },
-  Program: {
-    exit(tag) {
-      const globImports = programGlobImports.get(tag);
-      if (!globImports) {
-        return;
-      }
-      const { cwd, filename } = tag.hub.file.opts;
-      const dir = path4.dirname(filename);
-      const seen = /* @__PURE__ */ new Set();
-      for (const [patterns, options] of globImports) {
-        const resolvedPatterns = Array.isArray(patterns) ? patterns.map((p) => path4.resolve(dir, p)) : path4.resolve(dir, patterns);
-        const results = glob.globSync(resolvedPatterns, {
-          cwd,
-          absolute: true,
-          dot: !!options.exhaustive,
-          ignore: options.exhaustive ? [] : [path4.join(cwd, "**/node_modules/**")]
-        });
-        for (const file of results) {
-          if (file.endsWith(".marko") && file !== filename && !seen.has(file)) {
-            seen.add(file);
-            tag.node.body.push(t2.importDeclaration([], t2.stringLiteral(file)));
+      }`}
+
+      const parts = entry[slot];
+
+      if (parts) {
+        for (let i = 0; i < parts.length; i++) {
+          const part = parts[i];
+          switch (part) {
+            case 0: /** InjectType.AssetAttrs */
+              html += this.___viteInjectAttrs;
+              break;
+            case 1: /** InjectType.PublicPath */
+              html += base;
+              break;
+            case 2: /** InjectType.Dedupe */ {
+              const id = parts[++i];
+              const skipParts = parts[++i];
+              if (seenIds.has(id)) {
+                i += skipParts;
+              } else {
+                seenIds.add(id);
+              }
+              break;
+            }
+            default:
+              html += part;
+              break;
           }
         }
       }
     }
   }
-};
 
-// src/read-once-persisted-store.ts
-import os from "os";
-import path5 from "path";
-import { promises as fs3 } from "fs";
-var noop = () => {
-};
-var tmpFile = path5.join(os.tmpdir(), "marko-vite-storage.json");
-var values = /* @__PURE__ */ new Map();
-var loadedFromDisk;
-var ReadOncePersistedStore = class {
-  constructor(uid) {
-    this.uid = uid;
-  }
-  write(value) {
-    values.set(this.uid, value);
-  }
-  async read() {
-    const { uid } = this;
-    if (values.has(uid)) {
-      const value = values.get(uid);
-      values.delete(uid);
-      return value;
-    }
-    if (loadedFromDisk === true) {
-      throw new Error(`Value for ${uid} could not be loaded.`);
-    }
-    await (loadedFromDisk ||= fs3.readFile(tmpFile, "utf-8").then(syncDataFromDisk).catch(finishLoadFromDisk));
-    return this.read();
+  return html;
+}
+`;
+}
+
+// src/render-assets-transform.ts
+var render_assets_transform_default = (tag, t3) => {
+  if (tag.hub.file.markoOpts.markoViteLinked) {
+    const body = tag.get("body");
+    const tagName = tag.get("name").node.value;
+    body.unshiftContainer("body", renderAssetsCall(t3, `${tagName}-prepend`));
+    body.pushContainer("body", renderAssetsCall(t3, tagName));
   }
 };
-function syncDataFromDisk(data) {
-  finishLoadFromDisk();
-  fs3.unlink(tmpFile).catch(noop);
-  for (const [k, v] of JSON.parse(data)) {
-    values.set(k, v);
-  }
+function renderAssetsCall(t3, slot) {
+  return t3.markoPlaceholder(
+    t3.callExpression(
+      t3.memberExpression(
+        t3.identifier("$global"),
+        t3.identifier("___viteRenderAssets")
+      ),
+      [t3.stringLiteral(slot)]
+    ),
+    false
+  );
 }
-function finishLoadFromDisk() {
-  loadedFromDisk = true;
+
+// src/server-entry-template.ts
+import path5 from "path";
+var server_entry_template_default = async (opts) => {
+  const fileNameStr = JSON.stringify(`./${path5.basename(opts.fileName)}`);
+  if (opts.tagsAPI) {
+    return `import Template from ${fileNameStr};
+export * from ${fileNameStr};
+import { addAssets, getPrepend, getAppend } from "${renderAssetsRuntimeId}";
+static function flush($global, html) {
+  return getPrepend($global) + html + getAppend($global);
 }
-process.once("beforeExit", (code) => {
-  if (code === 0 && values.size) {
-    fs3.writeFile(tmpFile, JSON.stringify([...values])).catch(noop);
+static function setFlush($global) {
+  $global.__flush__ = flush;
+}
+static const assets = [${opts.entryData.join(",")}];
+<const/writeSync=addAssets($global, assets) || setFlush($global)/>
+-- $!{writeSync && getPrepend($global)}
+<Template ...input/>
+-- $!{writeSync && getAppend($global)}
+`;
   }
-});
+  return `import template from ${fileNameStr};
+export * from ${fileNameStr};
+import { addAssets, getPrepend, getAppend } from "${renderAssetsRuntimeId}";
+static const assets = [${opts.entryData.join(",")}];
+<if(addAssets($global, assets))>
+  $!{getPrepend($global)}
+  <\${template} ...input/>
+  $!{getAppend($global)}
+</>
+<else>
+  <__flush_here_and_after__>$!{getPrepend($global)}</>
+  <\${template} ...input/>
+  <init-components/>
+  <await-reorderer/>
+  <__flush_here_and_after__>$!{getAppend($global)}</>
+</>
+`;
+};
 
 // src/index.ts
 var POSIX_SEP = "/";
@@ -812,6 +811,7 @@ var babelCaller = {
   supportsTopLevelAwait: true,
   supportsExportNamespaceFrom: true
 };
+var optimizeKnownTemplatesForRoot = /* @__PURE__ */ new Map();
 var registeredTagLib = false;
 var cjsToEsm;
 function noop2() {
@@ -854,7 +854,6 @@ function markoPlugin(opts = {}) {
   );
   const entryIds = /* @__PURE__ */ new Set();
   const cachedSources = /* @__PURE__ */ new Map();
-  const optimizedRegisistyIdMap = /* @__PURE__ */ new Map();
   const transformWatchFiles = /* @__PURE__ */ new Map();
   const transformOptionalFiles = /* @__PURE__ */ new Map();
   const store = new ReadOncePersistedStore(
@@ -884,16 +883,7 @@ function markoPlugin(opts = {}) {
           runtimeId,
           sourceMaps: true,
           writeVersionComment: false,
-          optimizeRegistryId(id) {
-            let registryId = optimizedRegisistyIdMap.get(id);
-            if (registryId === void 0) {
-              optimizedRegisistyIdMap.set(
-                id,
-                registryId = optimizedRegisistyIdMap.size
-              );
-            }
-            return registryId;
-          },
+          optimizeKnownTemplates: optimize && linked ? getKnownTemplates(root) : void 0,
           babelConfig: opts.babelConfig ? {
             ...opts.babelConfig,
             caller: opts.babelConfig.caller ? {
@@ -1098,6 +1088,7 @@ function markoPlugin(opts = {}) {
       handleHotUpdate(ctx) {
         compiler2.taglib.clearCaches();
         baseConfig.cache.clear();
+        optimizeKnownTemplatesForRoot.clear();
         for (const [, cache2] of configsByFileSystem) {
           cache2.clear();
         }
@@ -1112,11 +1103,6 @@ function markoPlugin(opts = {}) {
           try {
             serverManifest = await store.read();
             inputOptions.input = toHTMLEntries(root, serverManifest.entries);
-            if (serverManifest.registered) {
-              for (let i = 0; i < serverManifest.registered.length; i++) {
-                optimizedRegisistyIdMap.set(serverManifest.registered[i], i);
-              }
-            }
             for (const entry in serverManifest.entrySources) {
               const id = normalizePath(path6.resolve(root, entry));
               entryIds.add(id);
@@ -1381,9 +1367,6 @@ if (import.meta.hot) import.meta.hot.accept(() => {});`;
               }
             }
           }
-          if (optimizedRegisistyIdMap.size) {
-            serverManifest.registered = [...optimizedRegisistyIdMap.keys()];
-          }
           store.write(serverManifest);
         } else {
           const browserManifest = {};
@@ -1512,6 +1495,33 @@ function getConfigForFileSystem(info, config) {
   }
   return configForFileSystem;
 }
+function getKnownTemplates(cwd) {
+  let knownTemplates = optimizeKnownTemplatesForRoot.get(cwd);
+  if (!knownTemplates) {
+    optimizeKnownTemplatesForRoot.set(
+      cwd,
+      knownTemplates = glob2.globSync(
+        ["**/*.marko", "**/node_modules/.marko/**/*.marko"],
+        {
+          cwd,
+          absolute: true,
+          ignore: [
+            "**/*.d.marko",
+            "**/*build*/**",
+            "**/*coverage*/**",
+            "**/*dist*/**",
+            "**/*example*/**",
+            "**/*fixture*/**",
+            "**/*snapshot*/**",
+            "**/*stories*/**",
+            "**/*test*/**"
+          ]
+        }
+      )
+    );
+  }
+  return knownTemplates;
+}
 export {
   markoPlugin as default
 };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@marko/vite",
   "description": "A Marko plugin for Vite",
-  "version": "5.0.6",
+  "version": "5.0.7",
   "author": "Dylan Piercey <dpiercey@ebay.com>",
   "bugs": "https://github.com/marko-js/vite/issues",
   "dependencies": {
@@ -17,29 +17,30 @@
   "devDependencies": {
     "@changesets/changelog-github": "^0.5.0",
     "@changesets/cli": "^2.27.10",
-    "@marko/compiler": "^5.38.0",
+    "@eslint/js": "^9.15.0",
+    "@marko/compiler": "^5.38.1",
     "@marko/fixture-snapshots": "^2.2.1",
     "@marko/testing-library": "^6.2.0",
     "@types/babel__core": "^7.20.5",
     "@types/diff": "^6.0.0",
     "@types/jsdom": "^21.1.7",
     "@types/mocha": "^10.0.10",
-    "@types/node": "^22.9.1",
+    "@types/node": "^22.9.3",
     "@types/resolve": "^1.20.6",
     "@types/serve-handler": "^6.1.4",
-    "@typescript-eslint/eslint-plugin": "^7.11.0",
-    "@typescript-eslint/parser": "^7.11.0",
     "cross-env": "^7.0.3",
     "diff": "^7.0.0",
     "esbuild": "^0.24.0",
-    "eslint": "^8.57.0",
-    "eslint-config-prettier": "^9.1.0",
+    "eslint": "^9.15.0",
+    "eslint-formatter-unix": "^8.40.0",
+    "eslint-plugin-simple-import-sort": "^12.1.1",
     "fixpack": "^4.0.0",
+    "globals": "^15.12.0",
     "husky": "^9.1.7",
     "jsdom": "^25.0.1",
-    "less": "^4.2.0",
+    "less": "^4.2.1",
     "lint-staged": "^15.2.10",
-    "marko": "^5.36.0",
+    "marko": "^5.36.1",
     "mocha": "^10.8.2",
     "mocha-snap": "^5.0.0",
     "nyc": "^17.1.0",
@@ -48,6 +49,7 @@
     "serve-handler": "^6.1.6",
     "tsx": "^4.19.2",
     "typescript": "^5.7.2",
+    "typescript-eslint": "^8.16.0",
     "vite": "^5.4.11"
   },
   "files": [
@@ -79,9 +81,9 @@
     "ci:test": "nyc npm test -- --forbid-only",
     "format": "npm run lint:eslint -- --fix && npm run lint:prettier -- --write && (fixpack || true)",
     "lint": "tsc -b && npm run lint:eslint && npm run lint:prettier -- -l && fixpack",
-    "lint:eslint": "eslint -f visualstudio .",
+    "lint:eslint": "eslint -f unix .",
     "lint:prettier": "prettier \"./**/*{.ts,.js,.json,.md,.yml,rc}\"",
-    "prepare": "husky install",
+    "prepare": "husky",
     "release": "npm run build && changeset publish",
     "report": "open ./coverage/lcov-report/index.html",
     "test": "cross-env NODE_ENV=test mocha \"./src/**/__tests__/*.test.ts\"",