@glossarist/concept-browser 0.7.114 → 0.7.116

package/scripts/{check-syntax.mjs → check-syntax.ts}

@@ -7,7 +7,8 @@ import process from "node:process";
 const ROOT = path.resolve(path.dirname(new URL(import.meta.url).pathname), "..");
 
 const TARGET_DIRS = ["scripts", "cli"];
-const EXTENSIONS = new Set([".mjs", ".js", ".cjs"]);
+const JS_EXTENSIONS = new Set([".mjs", ".js", ".cjs"]);
+const ALL_EXTENSIONS = new Set([".ts", ...JS_EXTENSIONS]);
 const SKIP_DIRS = new Set(["__tests__", "node_modules"]);
 
 function walk(dir) {
@@ -18,7 +19,7 @@ function walk(dir) {
     const st = statSync(full);
     if (st.isDirectory()) {
       out.push(...walk(full));
-    } else if (EXTENSIONS.has(path.extname(entry))) {
+    } else if (ALL_EXTENSIONS.has(path.extname(entry))) {
       out.push(full);
     }
   }
@@ -39,15 +40,24 @@ export function checkAllScripts({ root = ROOT } = {}) {
   files.sort();
 
   const failures = [];
-  for (const file of files) {
-    const result = spawnSync(process.execPath, ["--check", file], {
+
+  // JS files: syntax-check with node --check
+  for (const file of files.filter(f => JS_EXTENSIONS.has(path.extname(f)))) {
+    const result = spawnSync(process.execPath, ["--check", file], { encoding: "utf8" });
+    if (result.status !== 0) {
+      failures.push({ file: path.relative(root, file), stderr: result.stderr || "" });
+    }
+  }
+
+  // TS files: type-check with tsc (authoritative for TypeScript)
+  if (files.some(f => path.extname(f) === ".ts")) {
+    const tsconfig = path.join(root, "tsconfig.scripts.json");
+    const result = spawnSync("npx", ["tsc", "-p", tsconfig, "--noEmit"], {
       encoding: "utf8",
+      cwd: root,
     });
     if (result.status !== 0) {
-      failures.push({
-        file: path.relative(root, file),
-        stderr: result.stderr || "",
-      });
+      failures.push({ file: "tsconfig.scripts.json (tsc)", stderr: result.stdout || result.stderr || "" });
     }
   }
 
@@ -60,9 +70,7 @@ function main() {
     process.stdout.write(`syntax OK: ${files.length} file(s) checked\n`);
     return;
   }
-  process.stderr.write(
-    `syntax check failed: ${failures.length} of ${files.length} file(s)\n\n`,
-  );
+  process.stderr.write(`syntax check failed: ${failures.length} of ${files.length} file(s)\n\n`);
   for (const { file, stderr } of failures) {
     process.stderr.write(`--- ${file} ---\n${stderr}\n`);
   }
@@ -70,8 +78,7 @@ function main() {
 }
 
 const isDirectEntry = process.argv[1] &&
-  path.resolve(process.argv[1]) ===
-    path.resolve(new URL(import.meta.url).pathname);
+  path.resolve(process.argv[1]) === path.resolve(new URL(import.meta.url).pathname);
 
 if (isDirectEntry) {
   main();

package/scripts/doctor.js

@@ -0,0 +1,278 @@
+#!/usr/bin/env node
+
+// scripts/doctor.ts
+import { existsSync, readFileSync } from "node:fs";
+import { resolve, dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import yaml from "js-yaml";
+var __dirname = dirname(fileURLToPath(import.meta.url));
+var PKG_ROOT = resolve(__dirname, "..");
+var NODE_MIN_MAJOR = 18;
+function safe(id, check) {
+  const wrapped = async (ctx) => {
+    try {
+      return await check(ctx);
+    } catch (err) {
+      return {
+        id: "unexpected",
+        label: "Unexpected error",
+        status: "fail",
+        detail: err?.message ?? String(err)
+      };
+    }
+  };
+  Object.defineProperty(wrapped, "name", { value: id });
+  return wrapped;
+}
+function nodeVersionCheck() {
+  const major = Number.parseInt(process.versions.node.split(".")[0], 10);
+  return {
+    id: "node-version",
+    label: `Node.js v${process.versions.node}`,
+    status: major >= NODE_MIN_MAJOR ? "pass" : "fail",
+    detail: major < NODE_MIN_MAJOR ? `requires >= v${NODE_MIN_MAJOR}` : void 0,
+    hint: major < NODE_MIN_MAJOR ? "upgrade via nvm or your package manager" : void 0
+  };
+}
+function packageDepsCheck(ctx) {
+  const nm = resolve(ctx.pkgRoot, "node_modules");
+  if (!existsSync(nm)) {
+    return {
+      id: "package-deps",
+      label: "Dependencies installed",
+      status: "fail",
+      detail: "node_modules missing",
+      hint: "run `npm install`"
+    };
+  }
+  const required = ["vue", "vue-router", "pinia", "vite", "n3", "glossarist", "@rdfjs/dataset"];
+  const missing = required.filter((p) => !existsSync(join(nm, p)));
+  if (missing.length) {
+    return {
+      id: "package-deps",
+      label: "Dependencies installed",
+      status: "fail",
+      detail: `missing: ${missing.join(", ")}`,
+      hint: "run `npm install`"
+    };
+  }
+  return { id: "package-deps", label: "Dependencies installed", status: "pass" };
+}
+function datasetsYmlCheck(ctx) {
+  const path = resolve(ctx.cwd, "datasets.yml");
+  if (!existsSync(path)) {
+    return {
+      id: "datasets-yml",
+      label: "datasets.yml present",
+      status: "warn",
+      detail: "file not found at project root",
+      hint: "datasets.yml registers every dataset the browser serves"
+    };
+  }
+  if (ctx.datasetsYmlError) {
+    return {
+      id: "datasets-yml",
+      label: "datasets.yml parses",
+      status: "fail",
+      detail: ctx.datasetsYmlError,
+      hint: "fix the YAML syntax error"
+    };
+  }
+  const datasets = ctx.datasetsYml?.datasets;
+  if (!Array.isArray(datasets) || datasets.length === 0) {
+    return {
+      id: "datasets-yml",
+      label: "datasets.yml lists datasets",
+      status: "warn",
+      detail: "`datasets` key is empty or missing",
+      hint: "add at least one dataset entry; see docs/adding-a-dataset.md"
+    };
+  }
+  return {
+    id: "datasets-yml",
+    label: `datasets.yml lists ${datasets.length} dataset(s)`,
+    status: "pass"
+  };
+}
+function datasetsFetchedCheck(ctx) {
+  const datasets = ctx.datasetsYml?.datasets ?? [];
+  if (!datasets.length) {
+    return { id: "datasets-fetched", label: "Source datasets fetched", status: "warn", detail: "no datasets registered" };
+  }
+  const dotDatasets = resolve(ctx.cwd, ".datasets");
+  const missing = datasets.filter((d) => !existsSync(join(dotDatasets, d.id, "concepts"))).map((d) => d.id);
+  if (missing.length) {
+    return {
+      id: "datasets-fetched",
+      label: "Source datasets fetched",
+      status: "fail",
+      detail: `.datasets/ missing: ${missing.join(", ")}`,
+      hint: "run `npm run fetch-datasets`"
+    };
+  }
+  return { id: "datasets-fetched", label: "Source datasets fetched", status: "pass" };
+}
+function datasetsGeneratedCheck(ctx) {
+  const datasets = ctx.datasetsYml?.datasets ?? [];
+  if (!datasets.length) {
+    return { id: "datasets-generated", label: "Generated data present", status: "warn", detail: "no datasets registered" };
+  }
+  const publicData = resolve(ctx.cwd, "public", "data");
+  const missing = datasets.filter((d) => !existsSync(join(publicData, d.id, "manifest.json"))).map((d) => d.id);
+  if (missing.length) {
+    return {
+      id: "datasets-generated",
+      label: "Generated data present",
+      status: "fail",
+      detail: `public/data/ missing manifest for: ${missing.join(", ")}`,
+      hint: "run `npm run generate-data`"
+    };
+  }
+  return { id: "datasets-generated", label: "Generated data present", status: "pass" };
+}
+function publicDatasetsJsonCheck(ctx) {
+  const path = resolve(ctx.cwd, "public", "datasets.json");
+  if (!existsSync(path)) {
+    return {
+      id: "public-datasets-json",
+      label: "public/datasets.json present",
+      status: "fail",
+      hint: "run `npm run generate-data`"
+    };
+  }
+  try {
+    const doc = JSON.parse(readFileSync(path, "utf8"));
+    if (!Array.isArray(doc) || doc.length === 0) {
+      return {
+        id: "public-datasets-json",
+        label: "public/datasets.json non-empty",
+        status: "warn",
+        detail: "datasets list is empty"
+      };
+    }
+    return { id: "public-datasets-json", label: "public/datasets.json parses", status: "pass" };
+  } catch (err) {
+    return {
+      id: "public-datasets-json",
+      label: "public/datasets.json parses",
+      status: "fail",
+      detail: err.message
+    };
+  }
+}
+function shaclShapesCheck(ctx) {
+  const shapesPath = resolve(ctx.pkgRoot, "data", "concept-model", "shapes", "glossarist.shacl.ttl");
+  if (!existsSync(shapesPath)) {
+    return {
+      id: "shacl-shapes",
+      label: "SHACL shapes present",
+      status: "fail",
+      hint: "run `npm run sync:model` to vendor shapes from concept-model"
+    };
+  }
+  const ttl = readFileSync(shapesPath, "utf8");
+  const looksLikeShapes = /sh:\s*(NodeShape|PropertyShape|targetClass)/.test(ttl) || /a\s+sh:NodeShape/.test(ttl);
+  if (!looksLikeShapes) {
+    return {
+      id: "shacl-shapes",
+      label: "SHACL shapes well-formed",
+      status: "fail",
+      detail: "file exists but does not declare any sh:NodeShape",
+      hint: "re-sync from glossarist/concept-model"
+    };
+  }
+  return { id: "shacl-shapes", label: "SHACL shapes present", status: "pass" };
+}
+function jsonldContextCheck(ctx) {
+  const ctxPath = resolve(ctx.pkgRoot, "data", "concept-model", "glossarist.context.jsonld");
+  if (!existsSync(ctxPath)) {
+    return {
+      id: "jsonld-context",
+      label: "JSON-LD context present",
+      status: "fail",
+      hint: "run `npm run sync:model` to vendor the context"
+    };
+  }
+  try {
+    const doc = JSON.parse(readFileSync(ctxPath, "utf8"));
+    if (!doc["@context"] || typeof doc["@context"] !== "object") {
+      return {
+        id: "jsonld-context",
+        label: "JSON-LD context well-formed",
+        status: "fail",
+        detail: "missing or invalid @context key"
+      };
+    }
+    return { id: "jsonld-context", label: "JSON-LD context present", status: "pass" };
+  } catch (err) {
+    return {
+      id: "jsonld-context",
+      label: "JSON-LD context parses",
+      status: "fail",
+      detail: err.message
+    };
+  }
+}
+var CHECKS = [
+  safe("node-version", nodeVersionCheck),
+  safe("package-deps", packageDepsCheck),
+  safe("datasets-yml", datasetsYmlCheck),
+  safe("datasets-fetched", datasetsFetchedCheck),
+  safe("datasets-generated", datasetsGeneratedCheck),
+  safe("public-datasets-json", publicDatasetsJsonCheck),
+  safe("shacl-shapes", shaclShapesCheck),
+  safe("jsonld-context", jsonldContextCheck)
+];
+async function runDoctor(cwd = process.cwd()) {
+  const datasetsYmlPath = resolve(cwd, "datasets.yml");
+  let datasetsYml;
+  let datasetsYmlError;
+  if (existsSync(datasetsYmlPath)) {
+    try {
+      datasetsYml = yaml.load(readFileSync(datasetsYmlPath, "utf8"));
+    } catch (err) {
+      datasetsYmlError = err.message;
+    }
+  }
+  const ctx = { cwd, pkgRoot: PKG_ROOT, datasetsYml, datasetsYmlError };
+  const results = [];
+  for (const check of CHECKS) {
+    results.push(await check(ctx));
+  }
+  const failed = results.filter((r) => r.status === "fail").length;
+  const exitCode = failed > 0 ? 1 : 0;
+  return { results, exitCode };
+}
+var STATUS_GLYPH = { pass: "\u2713", fail: "\u2717", warn: "!" };
+function formatResults(results) {
+  const lines = [];
+  for (const r of results) {
+    lines.push(`${STATUS_GLYPH[r.status]} ${r.label}`);
+    if (r.detail) lines.push(`    ${r.detail}`);
+    if (r.hint) lines.push(`    \u2192 ${r.hint}`);
+  }
+  const pass = results.filter((r) => r.status === "pass").length;
+  const fail = results.filter((r) => r.status === "fail").length;
+  const warn = results.filter((r) => r.status === "warn").length;
+  lines.push("");
+  lines.push(`${pass} passed, ${fail} failed, ${warn} warnings (${results.length} total)`);
+  return lines.join("\n");
+}
+async function main() {
+  const { results, exitCode } = await runDoctor();
+  console.log(formatResults(results));
+  process.exit(exitCode);
+}
+if (process.argv[1] && resolve(process.argv[1]) === fileURLToPath(import.meta.url)) {
+  main().catch((err) => {
+    console.error(err);
+    process.exit(1);
+  });
+}
+export {
+  CHECKS,
+  NODE_MIN_MAJOR,
+  formatResults,
+  main,
+  runDoctor
+};

package/scripts/extract-source-refs.js

@@ -1,32 +1,24 @@
-/**
- * Source reference extraction for citation linking.
- *
- * Scans concept JSON-LD for source strings in gl:source fields.
- * Used by build-edges.js to generate source-refs.json.
- */
-
-export function extractSourceRefs(concept, registerId) {
-  const refs = new Set();
-
-  // Managed concept-level sources
-  for (const src of concept['gl:source'] || []) {
-    const origin = src['gl:origin'];
+// scripts/extract-source-refs.ts
+function extractSourceRefs(concept, registerId) {
+  const refs = /* @__PURE__ */ new Set();
+  for (const src of concept["gl:source"] || []) {
+    const origin = src["gl:origin"];
     if (origin) {
-      const ref = origin['gl:ref'];
-      if (ref?.['gl:source']) refs.add(ref['gl:source']);
+      const ref = origin["gl:ref"];
+      if (ref?.["gl:source"]) refs.add(ref["gl:source"]);
     }
   }
-
-  // Localized concept-level sources
-  for (const lc of Object.values(concept['gl:localizedConcept'] || {})) {
-    for (const src of lc['gl:source'] || []) {
-      const origin = src['gl:origin'];
+  for (const lc of Object.values(concept["gl:localizedConcept"] || {})) {
+    for (const src of lc["gl:source"] || []) {
+      const origin = src["gl:origin"];
       if (origin) {
-        const ref = origin['gl:ref'];
-        if (ref?.['gl:source']) refs.add(ref['gl:source']);
+        const ref = origin["gl:ref"];
+        if (ref?.["gl:source"]) refs.add(ref["gl:source"]);
       }
     }
   }
-
-  return [...refs].map(source => ({ source, registerId }));
+  return [...refs].map((source) => ({ source, registerId }));
 }
+export {
+  extractSourceRefs
+};

package/scripts/extract-source-refs.ts

@@ -0,0 +1,32 @@
+/**
+ * Source reference extraction for citation linking.
+ *
+ * Scans concept JSON-LD for source strings in gl:source fields.
+ * Used by build-edges.js to generate source-refs.json.
+ */
+
+export function extractSourceRefs(concept, registerId) {
+  const refs = new Set();
+
+  // Managed concept-level sources
+  for (const src of concept['gl:source'] || []) {
+    const origin = src['gl:origin'];
+    if (origin) {
+      const ref = origin['gl:ref'];
+      if (ref?.['gl:source']) refs.add(ref['gl:source']);
+    }
+  }
+
+  // Localized concept-level sources
+  for (const lc of Object.values(concept['gl:localizedConcept'] || {})) {
+    for (const src of lc['gl:source'] || []) {
+      const origin = src['gl:origin'];
+      if (origin) {
+        const ref = origin['gl:ref'];
+        if (ref?.['gl:source']) refs.add(ref['gl:source']);
+      }
+    }
+  }
+
+  return [...refs].map(source => ({ source, registerId }));
+}