@lensmap/astro-loader 0.2.1 → 0.3.0

package/dist/adapter.d.ts

@@ -1,4 +1,4 @@
-import { type SemanticGraph } from "@lensmap/document";
+import { type SemanticGraph, type VocabularyInput } from "@lensmap/document";
 export interface ExecutionOptions {
     /** Exact local files, compared after realpath. Admission is not sandboxing. */
     mdx?: {
@@ -20,6 +20,6 @@ export interface ParsedMap {
     authoredFrontmatter: Record<string, unknown>;
     graph: SemanticGraph;
 }
-export declare function parseMap(source: string, uri: string): ParsedMap;
+export declare function parseMap(source: string, uri: string, vocabulary?: VocabularyInput): ParsedMap;
 export declare function moduleStem(path: string): string;
 export declare function writeGenerated(path: string, content: string): boolean;

package/dist/index.js

@@ -1,7 +1,8 @@
 // src/index.ts
-import { mkdirSync, readFileSync as readFileSync2 } from "node:fs";
+import { mkdirSync, readFileSync as readFileSync2, realpathSync as realpathSync2 } from "node:fs";
 import { resolve } from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
+import { readProjectVocabulary } from "@lensmap/document/project";
 import { glob } from "astro/loaders";
 
 // src/adapter.ts
@@ -27,8 +28,13 @@ function canExecute(source, options, installed) {
     return false;
   }
 }
-function parseMap(source, uri) {
-  const snapshot = new DocumentSession(uri, source).snapshot();
+function parseMap(source, uri, vocabulary) {
+  const snapshot = new DocumentSession(
+    uri,
+    source,
+    void 0,
+    vocabulary
+  ).snapshot();
   if (!snapshot.valid || !snapshot.graph)
     throw new Error(
       `Invalid Lensmap ${uri}: ${JSON.stringify(snapshot.diagnostics)}`
@@ -98,10 +104,76 @@ function lensmap(options = {}) {
   let config;
   let renderer;
   let installedMdx = false;
+  let vocabulary = {};
+  let vocabularyFiles = [];
+  let generation = 0;
+  const maps = /* @__PURE__ */ new Map();
+  async function reloadVocabulary() {
+    const current = ++generation;
+    const root = realpathSync2(fileURLToPath2(config.root));
+    const loaded = await readProjectVocabulary(root);
+    if (current !== generation) return false;
+    vocabulary = loaded.input;
+    vocabularyFiles = loaded.files;
+    return true;
+  }
+  async function publishVocabulary(server) {
+    if (!await reloadVocabulary()) return [];
+    server.watcher.add(vocabularyFiles);
+    for (const [uri, map] of maps) {
+      try {
+        const { graph } = parseMap(map.source, uri, vocabulary);
+        server.ws.send("lensmap:vocabulary", {
+          id: map.id,
+          stale: false,
+          edges: graph.edges.map(
+            ({ key, from, to, kind, type, presentation }) => ({
+              key,
+              from,
+              to,
+              kind,
+              type,
+              presentation
+            })
+          ),
+          nodes: graph.nodes.map(({ key, destination }) => ({
+            key,
+            destination
+          }))
+        });
+      } catch (error) {
+        server.config.logger.error(
+          error instanceof Error ? error.message : String(error)
+        );
+        server.ws.send("lensmap:vocabulary", { id: map.id, stale: true });
+      }
+    }
+    for (const uri of maps.keys()) {
+      for (const environment of Object.values(server.environments)) {
+        for (const module of environment.moduleGraph.getModulesByFile(
+          fileURLToPath2(uri)
+        ) ?? []) {
+          environment.moduleGraph.invalidateModule(module);
+        }
+      }
+    }
+  }
   const mdxModules = /* @__PURE__ */ new Map();
   return {
     name: "@lensmap/astro-loader",
     hooks: {
+      "astro:server:setup": ({ server }) => {
+        server.watcher.add(vocabularyFiles);
+        const changed = (path) => {
+          if (vocabularyFiles.includes(path)) void publishVocabulary(server);
+        };
+        server.watcher.on("add", changed);
+        server.watcher.on("unlink", changed);
+        server.httpServer?.once("close", () => {
+          server.watcher.off("add", changed);
+          server.watcher.off("unlink", changed);
+        });
+      },
       "astro:config:setup": (setup) => {
         const version = JSON.parse(
           readFileSync2(
@@ -124,9 +196,22 @@ function lensmap(options = {}) {
               {
                 name: "lensmap-source-relative-mdx",
                 enforce: "pre",
-                resolveId(id) {
+                resolveId(id, _importer, resolveOptions) {
+                  if (resolveOptions.ssr && id === "@lensmap/document")
+                    return {
+                      id: fileURLToPath2(
+                        new URL(import.meta.resolve("@lensmap/document"))
+                      ),
+                      external: true
+                    };
                   if (mdxModules.has(id)) return id;
                 },
+                async hotUpdate(context) {
+                  if (!vocabularyFiles.includes(context.file)) return;
+                  if (this.environment.name !== "client") return [];
+                  await publishVocabulary(context.server);
+                  return [];
+                },
                 load(id) {
                   const module = mdxModules.get(id.split("?")[0] ?? id);
                   if (!module) return;
@@ -144,7 +229,8 @@ function lensmap(options = {}) {
           getEntryInfo({ contents, fileUrl }) {
             const { authoredFrontmatter: data, graph } = parseMap(
               contents,
-              fileUrl.href
+              fileUrl.href,
+              vocabulary
             );
             return {
               data,
@@ -155,9 +241,12 @@ function lensmap(options = {}) {
           },
           async getRenderModule({ contents, fileUrl }) {
             const path = fileURLToPath2(fileUrl);
+            const mapId = moduleStem(path);
+            maps.set(fileUrl.href, { source: contents, id: mapId });
             const { graph, authoredFrontmatter } = parseMap(
               contents,
-              fileUrl.href
+              fileUrl.href,
+              vocabulary
             );
             const executable = canExecute(
               { kind: "local", path },
@@ -216,7 +305,7 @@ ${imports.join("\n")}
 const graph = ${quote(graph)};
 const authoredFrontmatter = ${quote(authoredFrontmatter)};
 ---
-<MapContent {...Astro.props} graph={graph} authoredFrontmatter={authoredFrontmatter} executable={${executable}}>
+<MapContent {...Astro.props} graph={graph} mapId={${quote(mapId)}} authoredFrontmatter={authoredFrontmatter} executable={${executable}}>
 ${slots.join("\n")}
 </MapContent>
 `
@@ -228,8 +317,13 @@ ${slots.join("\n")}
           }
         });
       },
-      "astro:config:done": ({ config: resolved }) => {
+      "astro:config:done": async ({ config: resolved }) => {
         config = resolved;
+        await reloadVocabulary();
+        if (vocabulary.error)
+          throw new Error(
+            `Invalid Lensmap project vocabulary: ${vocabulary.error}`
+          );
         installedMdx = resolved.integrations.some(
           (integration) => integration.name === "@astrojs/mdx"
         );

package/package.json

@@ -1,5 +1,5 @@
 {
-  "version": "0.2.1",
+  "version": "0.3.0",
   "type": "module",
   "license": "MIT",
   "files": [
@@ -28,7 +28,7 @@
     "./components/*": "./dist/components/*"
   },
   "dependencies": {
-    "@lensmap/document": "0.2.1",
+    "@lensmap/document": "0.3.0",
     "rehype-parse": "9.0.1",
     "rehype-sanitize": "6.0.0",
     "rehype-stringify": "10.0.1",
@@ -36,15 +36,15 @@
     "yaml": "2.9.1"
   },
   "peerDependencies": {
-    "astro": "7.4.0",
-    "@astrojs/mdx": "8.1.0"
+    "@astrojs/mdx": "8.1.0",
+    "astro": "7.4.0"
   },
   "devDependencies": {
-    "astro": "7.4.0",
     "@astrojs/mdx": "8.1.0",
+    "@types/node": "24.19.2",
+    "astro": "7.4.0",
     "esbuild": "0.28.2",
-    "typescript": "7.0.2",
-    "@types/node": "24.19.2"
+    "typescript": "7.0.2"
   },
   "peerDependenciesMeta": {
     "@astrojs/mdx": {