@marko/vite 4.1.16 → 4.1.18

package/dist/glob-import-transform.d.ts

@@ -0,0 +1,8 @@
+import { types as t } from "@marko/compiler";
+declare const _default: {
+    MetaProperty(tag: t.NodePath<t.MetaProperty>): void;
+    Program: {
+        exit(tag: t.NodePath<t.Program>): void;
+    };
+};
+export default _default;

package/dist/index.mjs

@@ -1,6 +1,6 @@
 // src/index.ts
 import fs4 from "fs";
-import path5 from "path";
+import path6 from "path";
 import crypto from "crypto";
 import anyMatch from "anymatch";
 import { pathToFileURL } from "url";
@@ -18,14 +18,15 @@ export function addAssets(g, newEntries) {
   const entries = g.___viteEntries;
   if (entries) {
     g.___viteEntries = entries.concat(newEntries);
-  } else {
-    g.___viteEntries = newEntries;
-    g.___viteRenderAssets = renderAssets;
-    g.___viteInjectAttrs = g.cspNonce
-      ? \` nonce="\${g.cspNonce.replace(/"/g, "'")}"\`
-      : "";
-    ${opts.runtimeId ? `g.runtimeId = ${JSON.stringify(opts.runtimeId)};` : ""}
+    return true;
   }
+  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)};` : ""}
 }
 
 function renderAssets(slot) {
@@ -33,6 +34,7 @@ function renderAssets(slot) {
   let html = "";
 
   if (entries) {
+    const seenIds = this.___viteSeenIds;
     const slotWrittenEntriesKey = \`___viteWrittenEntries-\${slot}\`;
     const lastWrittenEntry = this[slotWrittenEntriesKey] || 0;
     const writtenEntries = (this[slotWrittenEntriesKey] = entries.length);
@@ -69,13 +71,29 @@ function renderAssets(slot) {
       const parts = entry[slot];
 
       if (parts) {
-        for (const part of parts) {
-          html +=
-            part === 0 /** InjectType.AssetAttrs */
-              ? this.___viteInjectAttrs
-              : part === 1 /** InjectType.PublicPath */
-              ? base
-              : part;
+        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;
+          }
         }
       }
     }
@@ -94,23 +112,37 @@ export * from ${fileNameStr};
 import { addAssets } from "${renderAssetsRuntimeId}";
 
 $ const g = out.global;
-$ addAssets(g, [${opts.entryData.join(",")}]);
+$ const writeSync = addAssets(g, [${opts.entryData.join(",")}]);
 
-<__flush_here_and_after__>
+<if(writeSync)>
   $!{
     g.___viteRenderAssets("head-prepend") +
     g.___viteRenderAssets("head") +
     g.___viteRenderAssets("body-prepend")
   }
-</__flush_here_and_after__>
+</>
+<else>
+  <__flush_here_and_after__>
+    $!{
+      g.___viteRenderAssets("head-prepend") +
+      g.___viteRenderAssets("head") +
+      g.___viteRenderAssets("body-prepend")
+    }
+  </__flush_here_and_after__>
+</>
 
 <\${template} ...input/>
 <init-components/>
 <await-reorderer/>
 
-<__flush_here_and_after__>
+<if(writeSync)>
   $!{g.___viteRenderAssets("body")}
-</__flush_here_and_after__>
+</>
+<else>
+  <__flush_here_and_after__>
+    $!{g.___viteRenderAssets("body")}
+  </__flush_here_and_after__>
+</>
 `;
 };
 
@@ -148,24 +180,47 @@ function serialize(basePath, nodes, preload, parts) {
         const tag = node;
         const { name } = tag;
         let urlAttr;
-        curString += `<${name}`;
+        let isDedupe = 0;
         switch (tag.tagName) {
           case "script":
-            parts.push(curString, 0 /* AssetAttrs */);
-            urlAttr = "src";
+            if (tag.attribs.src) {
+              if (curString) {
+                parts.push(curString);
+                curString = "";
+              }
+              isDedupe = parts.push(2 /* Dedupe */, tag.attribs.src, 0) - 1;
+            }
+            parts.push(`${curString}<${name}`, 0 /* AssetAttrs */);
             curString = "";
+            urlAttr = "src";
             break;
           case "style":
-            parts.push(curString, 0 /* AssetAttrs */);
+            parts.push(`${curString}<${name}`, 0 /* AssetAttrs */);
             curString = "";
             break;
           case "link":
+            if (tag.attribs.href) {
+              if (curString) {
+                parts.push(curString);
+                curString = "";
+              }
+              isDedupe = parts.push(
+                2 /* Dedupe */,
+                [tag.attribs.rel || "", tag.attribs.href, tag.attribs.as].filter((it) => it != null).join("#"),
+                0
+              ) - 1;
+            }
             urlAttr = "href";
             if (tag.attribs.rel === "stylesheet" || tag.attribs.rel === "modulepreload" || tag.attribs.as === "style" || tag.attribs.as === "script") {
-              parts.push(curString, 0 /* AssetAttrs */);
+              parts.push(`${curString}<${name}`, 0 /* AssetAttrs */);
               curString = "";
+            } else {
+              curString += `<${name}`;
             }
             break;
+          default:
+            curString += `<${name}`;
+            break;
         }
         for (const attr of tag.attributes) {
           if (attr.value === "") {
@@ -195,6 +250,13 @@ function serialize(basePath, nodes, preload, parts) {
         if (!voidElements.has(name)) {
           curString += `</${name}>`;
         }
+        if (isDedupe) {
+          if (curString) {
+            parts.push(curString);
+            curString = "";
+          }
+          parts[isDedupe] = parts.length - isDedupe - 1;
+        }
         break;
       }
       case ElementType.Text: {
@@ -214,9 +276,9 @@ function serialize(basePath, nodes, preload, parts) {
   }
   return parts;
 }
-function stripBasePath(basePath, path6) {
-  if (path6.startsWith(basePath)) return path6.slice(basePath.length);
-  return path6;
+function stripBasePath(basePath, path7) {
+  if (path7.startsWith(basePath)) return path7.slice(basePath.length);
+  return path7;
 }
 
 // src/manifest-generator.ts
@@ -439,14 +501,14 @@ function plugin(options) {
   return {
     name: "marko-import-interop",
     visitor: {
-      ImportDeclaration(path6) {
-        if (!path6.node.specifiers.length || /\.(?:mjs|marko)$|\?/.test(path6.node.source.value) || options.filter?.(path6.node.source.value) === false) {
+      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(
-            path6.node.source.value,
-            path6.hub.file.opts.filename,
+            path7.node.source.value,
+            path7.hub.file.opts.filename,
             options.extensions,
             options.conditions
           );
@@ -459,7 +521,7 @@ function plugin(options) {
         let namespaceId;
         let defaultImportId;
         let imports;
-        for (const s of path6.node.specifiers) {
+        for (const s of path7.node.specifiers) {
           if (t.isImportSpecifier(s)) {
             (imports ||= []).push({
               name: t.isStringLiteral(s.imported) ? s.imported.value : s.imported.name,
@@ -471,12 +533,12 @@ function plugin(options) {
             namespaceId = s.local;
           }
         }
-        namespaceId ||= path6.scope.generateUidIdentifier(
-          defaultImportId?.name || path6.node.source.value
+        namespaceId ||= path7.scope.generateUidIdentifier(
+          defaultImportId?.name || path7.node.source.value
         );
-        path6.node.specifiers = [t.importDefaultSpecifier(namespaceId)];
+        path7.node.specifiers = [t.importDefaultSpecifier(namespaceId)];
         if (defaultImportId) {
-          path6.insertAfter(
+          path7.insertAfter(
             t.variableDeclaration("const", [
               t.variableDeclarator(
                 defaultImportId,
@@ -495,7 +557,7 @@ function plugin(options) {
           );
         }
         if (imports) {
-          path6.insertAfter(
+          path7.insertAfter(
             t.variableDeclaration("const", [
               t.variableDeclarator(
                 t.objectPattern(
@@ -519,22 +581,22 @@ function plugin(options) {
 }
 
 // src/render-assets-transform.ts
-var render_assets_transform_default = (tag, t2) => {
+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(t2, `${tagName}-prepend`));
-    body.pushContainer("body", renderAssetsCall(t2, tagName));
+    body.unshiftContainer("body", renderAssetsCall(t3, `${tagName}-prepend`));
+    body.pushContainer("body", renderAssetsCall(t3, tagName));
   }
 };
-function renderAssetsCall(t2, slot) {
-  return t2.markoPlaceholder(
-    t2.callExpression(
-      t2.memberExpression(
-        t2.memberExpression(t2.identifier("out"), t2.identifier("global")),
-        t2.identifier("___viteRenderAssets")
+function renderAssetsCall(t3, slot) {
+  return t3.markoPlaceholder(
+    t3.callExpression(
+      t3.memberExpression(
+        t3.memberExpression(t3.identifier("out"), t3.identifier("global")),
+        t3.identifier("___viteRenderAssets")
       ),
-      [t2.stringLiteral(slot)]
+      [t3.stringLiteral(slot)]
     ),
     false
   );
@@ -560,7 +622,7 @@ var assetAttrsByTag = /* @__PURE__ */ new Map([
   ["script", /* @__PURE__ */ new Set(["src"])]
 ]);
 var assetFileReg = /(?:^\..*\.(?:a?png|jpe?g|jfif|pipeg|pjp|gif|svg|ico|web[pm]|avif|mp4|ogg|mp3|wav|flac|aac|opus|woff2?|eot|[ot]tf|webmanifest|pdf|txt)(\?|$)|\?url\b)/;
-function transform(tag, t2) {
+function transform(tag, t3) {
   const { name, attributes } = tag.node;
   if (name.type !== "StringLiteral") {
     return;
@@ -574,12 +636,12 @@ function transform(tag, t2) {
       const { value } = attr.value;
       if (assetFileReg.test(value)) {
         const importedId = tag.scope.generateUid(value);
-        attr.value = t2.identifier(importedId);
+        attr.value = t3.identifier(importedId);
         tag.hub.file.path.unshiftContainer(
           "body",
-          t2.importDeclaration(
-            [t2.importDefaultSpecifier(t2.identifier(importedId))],
-            t2.stringLiteral(value)
+          t3.importDeclaration(
+            [t3.importDefaultSpecifier(t3.identifier(importedId))],
+            t3.stringLiteral(value)
           )
         );
       }
@@ -587,13 +649,65 @@ function transform(tag, t2) {
   }
 }
 
+// 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);
+          }
+        }
+      }
+    }
+  },
+  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)));
+          }
+        }
+      }
+    }
+  }
+};
+
 // src/read-once-persisted-store.ts
 import os from "os";
-import path4 from "path";
+import path5 from "path";
 import { promises as fs3 } from "fs";
 var noop = () => {
 };
-var tmpFile = path4.join(os.tmpdir(), "marko-vite-storage.json");
+var tmpFile = path5.join(os.tmpdir(), "marko-vite-storage.json");
 var values = /* @__PURE__ */ new Map();
 var loadedFromDisk;
 var ReadOncePersistedStore = class {
@@ -636,7 +750,7 @@ process.once("beforeExit", (code) => {
 // src/index.ts
 var POSIX_SEP = "/";
 var WINDOWS_SEP = "\\";
-var normalizePath = path5.sep === WINDOWS_SEP ? (id) => id.replace(/\\/g, POSIX_SEP) : (id) => id;
+var normalizePath = path6.sep === WINDOWS_SEP ? (id) => id.replace(/\\/g, POSIX_SEP) : (id) => id;
 var virtualFiles = /* @__PURE__ */ new Map();
 var extReg = /\.[^.]+$/;
 var queryReg = /\?marko-[^?]+$/;
@@ -670,7 +784,7 @@ function markoPlugin(opts = {}) {
   let hydrateConfig;
   const resolveVirtualDependency = (from, dep) => {
     const normalizedFrom = normalizePath(from);
-    const query = `${virtualFileQuery}&id=${Buffer.from(dep.virtualPath).toString("base64url") + path5.extname(dep.virtualPath)}`;
+    const query = `${virtualFileQuery}&id=${Buffer.from(dep.virtualPath).toString("base64url") + path6.extname(dep.virtualPath)}`;
     const id = normalizePath(normalizedFrom) + query;
     if (devServer) {
       const prev = virtualFiles.get(id);
@@ -679,7 +793,7 @@ function markoPlugin(opts = {}) {
       }
     }
     virtualFiles.set(id, dep);
-    return `./${path5.posix.basename(normalizedFrom) + query}`;
+    return `./${path6.posix.basename(normalizedFrom) + query}`;
   };
   let root;
   let devEntryFile;
@@ -762,7 +876,7 @@ function markoPlugin(opts = {}) {
         };
         compiler.configure(baseConfig);
         root = normalizePath(config.root || process.cwd());
-        devEntryFile = path5.join(root, "index.html");
+        devEntryFile = path6.join(root, "index.html");
         devEntryFilePosix = normalizePath(devEntryFile);
         isTest = env.mode === "test";
         isBuild = env.command === "build";
@@ -788,18 +902,21 @@ function markoPlugin(opts = {}) {
         if (!registeredTagLib) {
           registeredTagLib = true;
           compiler.taglib.register("@marko/vite", {
+            transform: glob_import_transform_default,
             "<head>": { transformer: render_assets_transform_default },
             "<body>": { transformer: render_assets_transform_default },
             "<*>": { transformer: transform }
           });
         }
         const optimizeDeps = config.optimizeDeps ??= {};
-        optimizeDeps.entries ??= [
-          "**/*.marko",
-          "!**/__snapshots__/**",
-          `!**/__tests__/**`,
-          `!**/coverage/**`
-        ];
+        if (!isTest) {
+          optimizeDeps.entries ??= [
+            "**/*.marko",
+            "!**/__snapshots__/**",
+            `!**/__tests__/**`,
+            `!**/coverage/**`
+          ];
+        }
         const domDeps = compiler.getRuntimeEntryFiles("dom", opts.translator);
         optimizeDeps.include = optimizeDeps.include ? [...optimizeDeps.include, ...domDeps] : domDeps;
         const optimizeExtensions = optimizeDeps.extensions ??= [];
@@ -882,7 +999,7 @@ function markoPlugin(opts = {}) {
               plugin({
                 extensions: config.resolve.extensions,
                 conditions: config.resolve.conditions,
-                filter: isBuild ? void 0 : (path6) => !/^\./.test(path6)
+                filter: isBuild ? void 0 : (path7) => !/^\./.test(path7)
               })
             )
           }
@@ -942,7 +1059,7 @@ function markoPlugin(opts = {}) {
             serverManifest = await store.read();
             inputOptions.input = toHTMLEntries(root, serverManifest.entries);
             for (const entry in serverManifest.entrySources) {
-              const id = normalizePath(path5.resolve(root, entry));
+              const id = normalizePath(path6.resolve(root, entry));
               entryIds.add(id);
               cachedSources.set(id, serverManifest.entrySources[entry]);
             }
@@ -979,7 +1096,7 @@ function markoPlugin(opts = {}) {
         if (importeeQuery) {
           const resolved = importee[0] === "." ? {
             id: normalizePath(
-              importer ? path5.resolve(importer, "..", importee) : path5.resolve(root, importee)
+              importer ? path6.resolve(importer, "..", importee) : path6.resolve(root, importee)
             )
           } : await this.resolve(importee, importer, resolveOpts);
           if (resolved) {
@@ -993,7 +1110,7 @@ function markoPlugin(opts = {}) {
             importer = importer.slice(0, -importerQuery.length);
             if (importee[0] === ".") {
               const resolved = normalizePath(
-                path5.resolve(importer, "..", importee)
+                path6.resolve(importer, "..", importee)
               );
               if (resolved === normalizePath(importer)) return resolved;
             }
@@ -1038,7 +1155,7 @@ function markoPlugin(opts = {}) {
             id = `${id.slice(0, -markoExt.length)}.entry.marko`;
             cachedSources.set(fileName, source);
             if (isBuild) {
-              const relativeFileName = path5.posix.relative(root, fileName);
+              const relativeFileName = path6.posix.relative(root, fileName);
               const entryId = toEntryId(relativeFileName);
               serverManifest ??= {
                 entries: {},
@@ -1080,7 +1197,7 @@ function markoPlugin(opts = {}) {
         }
         if (!isMarkoFile(id)) {
           if (!isBuild) {
-            const ext = path5.extname(id);
+            const ext = path6.extname(id);
             if (ext === ".cjs" || ext === ".js" && isCJSModule(id)) {
               if (cjsToEsm === void 0) {
                 try {
@@ -1136,7 +1253,7 @@ if (import.meta.hot) import.meta.hot.accept(() => {});`;
         }
         if (devServer) {
           const templateName = getPosixBasenameWithoutExt(id);
-          const optionalFilePrefix = path5.dirname(id) + path5.sep + (templateName === "index" ? "" : `${templateName}.`);
+          const optionalFilePrefix = path6.dirname(id) + path6.sep + (templateName === "index" ? "" : `${templateName}.`);
           for (const file of meta.watchFiles) {
             this.addWatchFile(file);
           }
@@ -1175,13 +1292,13 @@ if (import.meta.hot) import.meta.hot.accept(() => {});`;
           );
         }
         if (isSSRBuild) {
-          const dir = outputOptions.dir ? path5.resolve(outputOptions.dir) : path5.resolve(outputOptions.file, "..");
+          const dir = outputOptions.dir ? path6.resolve(outputOptions.dir) : path6.resolve(outputOptions.file, "..");
           for (const fileName in bundle) {
             const chunk = bundle[fileName];
             if (chunk.type === "chunk") {
               if (chunk.moduleIds.includes(renderAssetsRuntimeId)) {
                 serverManifest.chunksNeedingAssets.push(
-                  path5.resolve(dir, fileName)
+                  path6.resolve(dir, fileName)
                 );
               }
             }
@@ -1230,7 +1347,7 @@ function isMarkoFile(id) {
 function toHTMLEntries(root, serverEntries) {
   const result = [];
   for (const id in serverEntries) {
-    const markoFile = path5.posix.join(root, serverEntries[id]);
+    const markoFile = path6.posix.join(root, serverEntries[id]);
     const htmlFile = markoFile + htmlExt;
     virtualFiles.set(htmlFile, {
       code: generateInputDoc(markoFile + browserEntryQuery)
@@ -1251,7 +1368,7 @@ function toEntryId(id) {
   return `${name}_${crypto.createHash("SHA1").update(id).digest("base64").replace(/[/+]/g, "-").slice(0, 4)}`;
 }
 function posixFileNameToURL(fileName, root) {
-  const relativeURL = path5.posix.relative(
+  const relativeURL = path6.posix.relative(
     pathToFileURL(root).pathname,
     pathToFileURL(fileName).pathname
   );

package/dist/serializer.d.ts

@@ -1,7 +1,8 @@
 import type { Node } from "domhandler";
 declare enum InjectType {
     AssetAttrs = 0,
-    PublicPath = 1
+    PublicPath = 1,
+    Dedupe = 2
 }
 export default function serialize(basePath: string, nodes: Node[], preload: string[], parts?: (string | InjectType)[]): (string | InjectType)[];
 export {};

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@marko/vite",
   "description": "A Marko plugin for Vite",
-  "version": "4.1.16",
+  "version": "4.1.18",
   "author": "Dylan Piercey <dpiercey@ebay.com>",
   "bugs": "https://github.com/marko-js/vite/issues",
   "dependencies": {