Initial commit: New MoreminiMore website with fresh design

node_modules/astro/dist/vite-plugin-head/index.d.ts

@@ -0,0 +1,4 @@
+import type * as vite from 'vite';
+import type { BuildInternals } from '../core/build/internal.js';
+export default function configHeadVitePlugin(): vite.Plugin;
+export declare function astroHeadBuildPlugin(internals: BuildInternals): vite.Plugin;

node_modules/astro/dist/vite-plugin-head/index.js

@@ -0,0 +1,188 @@
+import { hasHeadInjectComment } from "../core/head-propagation/comment.js";
+import {
+  buildImporterGraphFromModuleInfo,
+  computeInTreeAncestors
+} from "../core/head-propagation/graph.js";
+import { getTopLevelPageModuleInfos } from "../core/build/graph.js";
+import { getAstroMetadata } from "../vite-plugin-astro/index.js";
+import { ASTRO_VITE_ENVIRONMENT_NAMES } from "../core/constants.js";
+const VIRTUAL_COMPONENT_METADATA = "virtual:astro:component-metadata";
+const RESOLVED_VIRTUAL_COMPONENT_METADATA = `\0${VIRTUAL_COMPONENT_METADATA}`;
+function configHeadVitePlugin() {
+  let environment;
+  function invalidateComponentMetadataModule() {
+    const virtualMod = environment.moduleGraph.getModuleById(RESOLVED_VIRTUAL_COMPONENT_METADATA);
+    if (virtualMod) {
+      environment.moduleGraph.invalidateModule(virtualMod);
+    }
+  }
+  function buildImporterGraphFromEnvironment(seed) {
+    const queue = [seed];
+    const collected = /* @__PURE__ */ new Set();
+    while (queue.length > 0) {
+      const current = queue.pop();
+      if (collected.has(current)) continue;
+      collected.add(current);
+      const mod = environment.moduleGraph.getModuleById(current);
+      for (const importer of mod?.importers ?? []) {
+        if (importer.id) {
+          queue.push(importer.id);
+        }
+      }
+    }
+    return buildImporterGraphFromModuleInfo(collected, (id) => {
+      const mod = environment.moduleGraph.getModuleById(id);
+      if (!mod) return null;
+      return {
+        importers: Array.from(mod.importers).map((importer) => importer.id).filter((moduleId) => !!moduleId),
+        dynamicImporters: []
+      };
+    });
+  }
+  function propagateMetadata(seed, prop, value) {
+    const importerGraph = buildImporterGraphFromEnvironment(seed);
+    const allAncestors = computeInTreeAncestors({
+      seeds: [seed],
+      importerGraph
+    });
+    for (const id of allAncestors) {
+      const info = this.getModuleInfo(id);
+      if (info?.meta.astro) {
+        const astroMetadata = getAstroMetadata(info);
+        if (astroMetadata) {
+          Reflect.set(astroMetadata, prop, value);
+        }
+      }
+    }
+    invalidateComponentMetadataModule();
+  }
+  return {
+    name: "astro:head-metadata",
+    enforce: "pre",
+    apply: "serve",
+    configureServer(devServer) {
+      environment = devServer.environments[ASTRO_VITE_ENVIRONMENT_NAMES.ssr];
+      devServer.watcher.on("add", invalidateComponentMetadataModule);
+      devServer.watcher.on("unlink", invalidateComponentMetadataModule);
+      devServer.watcher.on("change", invalidateComponentMetadataModule);
+    },
+    load(id) {
+      if (id !== RESOLVED_VIRTUAL_COMPONENT_METADATA) {
+        return;
+      }
+      const componentMetadataEntries = [];
+      for (const [moduleId, mod] of environment.moduleGraph.idToModuleMap) {
+        const info = this.getModuleInfo(moduleId) ?? (mod.id ? this.getModuleInfo(mod.id) : null);
+        if (!info) continue;
+        const astro = getAstroMetadata(info);
+        if (!astro) continue;
+        componentMetadataEntries.push([
+          moduleId,
+          {
+            containsHead: astro.containsHead,
+            propagation: astro.propagation
+          }
+        ]);
+      }
+      return {
+        code: `export const componentMetadataEntries = ${JSON.stringify(componentMetadataEntries)};`
+      };
+    },
+    resolveId(source, importer) {
+      if (source === VIRTUAL_COMPONENT_METADATA) {
+        return RESOLVED_VIRTUAL_COMPONENT_METADATA;
+      }
+      if (importer) {
+        return this.resolve(source, importer, { skipSelf: true }).then((result) => {
+          if (result) {
+            let info = this.getModuleInfo(result.id);
+            const astro = info && getAstroMetadata(info);
+            if (astro) {
+              if (astro.propagation === "self" || astro.propagation === "in-tree") {
+                propagateMetadata.call(this, importer, "propagation", "in-tree");
+              }
+              if (astro.containsHead) {
+                propagateMetadata.call(this, importer, "containsHead", true);
+              }
+            }
+          }
+          return result;
+        });
+      }
+    },
+    transform(source, id) {
+      let info = this.getModuleInfo(id);
+      if (info && getAstroMetadata(info)?.containsHead) {
+        propagateMetadata.call(this, id, "containsHead", true);
+      }
+      if (hasHeadInjectComment(source)) {
+        propagateMetadata.call(this, id, "propagation", "in-tree");
+      }
+      invalidateComponentMetadataModule();
+    }
+  };
+}
+function astroHeadBuildPlugin(internals) {
+  return {
+    name: "astro:head-metadata-build",
+    applyToEnvironment(environment) {
+      return environment.name === ASTRO_VITE_ENVIRONMENT_NAMES.ssr || environment.name === ASTRO_VITE_ENVIRONMENT_NAMES.prerender;
+    },
+    generateBundle(_opts, bundle) {
+      const map = internals.componentMetadata;
+      const moduleIds = /* @__PURE__ */ new Set();
+      const selfPropagationSeeds = /* @__PURE__ */ new Set();
+      const commentPropagationSeeds = /* @__PURE__ */ new Set();
+      function getOrCreateMetadata(id) {
+        if (map.has(id)) return map.get(id);
+        const metadata = {
+          propagation: "none",
+          containsHead: false
+        };
+        map.set(id, metadata);
+        return metadata;
+      }
+      for (const [, output] of Object.entries(bundle)) {
+        if (output.type !== "chunk") continue;
+        for (const [id, mod] of Object.entries(output.modules)) {
+          moduleIds.add(id);
+          const modinfo = this.getModuleInfo(id);
+          if (modinfo) {
+            const meta = getAstroMetadata(modinfo);
+            if (meta?.containsHead) {
+              for (const pageInfo of getTopLevelPageModuleInfos(id, this)) {
+                let metadata = getOrCreateMetadata(pageInfo.id);
+                metadata.containsHead = true;
+              }
+            }
+            if (meta?.propagation === "self") {
+              selfPropagationSeeds.add(id);
+            }
+          }
+          if (mod.code && hasHeadInjectComment(mod.code)) {
+            commentPropagationSeeds.add(id);
+          }
+        }
+      }
+      const importerGraph = buildImporterGraphFromModuleInfo(
+        moduleIds,
+        (id) => this.getModuleInfo(id)
+      );
+      const allPropagationSeeds = /* @__PURE__ */ new Set([...selfPropagationSeeds, ...commentPropagationSeeds]);
+      const allAncestors = computeInTreeAncestors({
+        seeds: allPropagationSeeds,
+        importerGraph
+      });
+      for (const id of allAncestors) {
+        const metadata = getOrCreateMetadata(id);
+        if (metadata.propagation !== "self") {
+          metadata.propagation = "in-tree";
+        }
+      }
+    }
+  };
+}
+export {
+  astroHeadBuildPlugin,
+  configHeadVitePlugin as default
+};