@glossarist/concept-browser 0.7.114 → 0.7.116

package/scripts/process-about-pages.js

@@ -0,0 +1,241 @@
+#!/usr/bin/env node
+
+// scripts/process-about-pages.ts
+import { readFileSync as readFileSync2, writeFileSync, existsSync as existsSync2, mkdirSync, readdirSync, statSync, realpathSync } from "node:fs";
+import { join, basename, extname, resolve as resolve2 } from "node:path";
+import { cwd } from "node:process";
+import { fileURLToPath as fileURLToPath2 } from "node:url";
+
+// scripts/load-site-config.ts
+import { readFileSync, existsSync } from "fs";
+import { resolve, dirname } from "path";
+import { fileURLToPath } from "url";
+import yaml from "js-yaml";
+var __dirname = dirname(fileURLToPath(import.meta.url));
+var projectRoot = resolve(__dirname, "..");
+var SNAKE_TO_CAMEL = {
+  // Site-level
+  uri_base: "uriBase",
+  base_path: "basePath",
+  ui_languages: "uiLanguages",
+  dataset_groups: "datasetGroups",
+  dataset_translations: "datasetTranslations",
+  primary_color: "primaryColor",
+  dark_color: "darkColor",
+  owner_name: "ownerName",
+  owner_url: "ownerUrl",
+  powered_by: "poweredBy",
+  footer_nav: "footerNav",
+  footer_logo: "footerLogo",
+  news_dir: "newsDir",
+  // Dataset-level
+  gcr_package: "gcrPackage",
+  source_repo: "sourceRepo",
+  local_path: "localPath",
+  local_light: "localLight",
+  local_dark: "localDark",
+  uri_aliases: "uriAliases",
+  language_order: "languageOrder",
+  ref_aliases: "refAliases",
+  urn_aliases: "urnAliases",
+  existing_site_url: "existingSiteUrl",
+  edition_status: "editionStatus",
+  dataset_uri: "datasetUri",
+  schema_version: "schemaVersion"
+};
+function normalizeKey(key) {
+  if (typeof key !== "string") return key;
+  if (Object.prototype.hasOwnProperty.call(SNAKE_TO_CAMEL, key)) {
+    return SNAKE_TO_CAMEL[key];
+  }
+  if (key.includes("_") && /^[a-z][a-z0-9_]*$/.test(key)) {
+    return key.replace(/_([a-z])/g, (_, c) => c.toUpperCase());
+  }
+  return key;
+}
+function normalizeObject(obj) {
+  if (Array.isArray(obj)) return obj.map(normalizeObject);
+  if (obj && typeof obj === "object") {
+    const out = {};
+    for (const [k, v] of Object.entries(obj)) {
+      out[normalizeKey(k)] = normalizeObject(v);
+    }
+    return out;
+  }
+  return obj;
+}
+function findConfigFile(args = []) {
+  if (process.env.SITE_CONFIG) {
+    return resolve(process.env.SITE_CONFIG);
+  }
+  for (const dir of [process.cwd(), projectRoot]) {
+    const p = resolve(dir, "site-config.yml");
+    if (existsSync(p)) return p;
+  }
+  throw new Error("No site config found. Set SITE_CONFIG or create site-config.yml");
+}
+function loadSiteConfig(args = []) {
+  const configPath = findConfigFile(args);
+  const raw = yaml.load(readFileSync(configPath, "utf-8"));
+  const config = normalizeObject(raw);
+  return { config, configPath };
+}
+
+// scripts/process-about-pages.ts
+function loadSiteConfigForAbout() {
+  try {
+    const { config } = loadSiteConfig([]);
+    return config;
+  } catch {
+    return null;
+  }
+}
+function roots() {
+  const ROOT = cwd();
+  return {
+    ROOT,
+    PUBLIC_PAGES: join(ROOT, "public", "pages"),
+    DATASETS_DIR: join(ROOT, ".datasets"),
+    GROUPS_CONTENT_DIR: join(ROOT, "site-content", "groups")
+  };
+}
+function renderMarkdown(text) {
+  const lines = text.split("\n");
+  const html = [];
+  let inList = false;
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (!trimmed) {
+      if (inList) {
+        html.push("</ul>");
+        inList = false;
+      }
+      continue;
+    }
+    if (/^#{1}\s/.test(trimmed)) {
+      if (inList) {
+        html.push("</ul>");
+        inList = false;
+      }
+      html.push(`<h1>${inline(trimmed.replace(/^#\s/, ""))}</h1>`);
+    } else if (/^#{2}\s/.test(trimmed)) {
+      if (inList) {
+        html.push("</ul>");
+        inList = false;
+      }
+      html.push(`<h2>${inline(trimmed.replace(/^##\s/, ""))}</h2>`);
+    } else if (/^#{3}\s/.test(trimmed)) {
+      if (inList) {
+        html.push("</ul>");
+        inList = false;
+      }
+      html.push(`<h3>${inline(trimmed.replace(/^###\s/, ""))}</h3>`);
+    } else if (/^[-*]\s/.test(trimmed)) {
+      if (!inList) {
+        html.push("<ul>");
+        inList = true;
+      }
+      html.push(`<li>${inline(trimmed.replace(/^[-*]\s/, ""))}</li>`);
+    } else {
+      if (inList) {
+        html.push("</ul>");
+        inList = false;
+      }
+      html.push(`<p>${inline(trimmed)}</p>`);
+    }
+  }
+  if (inList) html.push("</ul>");
+  return html.join("\n");
+}
+function inline(text) {
+  return text.replace(/\*\*(.+?)\*\*/g, "<strong>$1</strong>").replace(/\*(.+?)\*/g, "<em>$1</em>").replace(/\[(.+?)\]\((.+?)\)/g, '<a href="$2">$1</a>').replace(/`(.+?)`/g, "<code>$1</code>");
+}
+function processAboutDir(sourceDir, outputPrefix, publicPagesDir) {
+  if (!existsSync2(sourceDir)) return 0;
+  let count = 0;
+  for (const file of readdirSync(sourceDir)) {
+    const fullPath = join(sourceDir, file);
+    if (!statSync(fullPath).isFile()) continue;
+    const ext = extname(file);
+    if (ext !== ".md" && ext !== ".adoc" && ext !== ".html") continue;
+    const base = basename(file, ext);
+    const langMatch = base.match(/^about\.(\w+)$/);
+    const lang = langMatch ? langMatch[1] : "eng";
+    const outputName = lang === "eng" ? `${outputPrefix}.json` : `${outputPrefix}.${lang}.json`;
+    const raw = readFileSync2(fullPath, "utf8");
+    let html;
+    let title;
+    if (ext === ".html") {
+      html = raw;
+      const titleMatch = raw.match(/<h1[^>]*>(.+?)<\/h1>/);
+      title = titleMatch ? titleMatch[1] : "About";
+    } else if (ext === ".md") {
+      html = renderMarkdown(raw);
+      const titleMatch = raw.match(/^#\s+(.+)$/m);
+      title = titleMatch ? titleMatch[1] : "About";
+    } else {
+      html = `<p>${raw.split("\n").filter((l) => l.trim() && !l.startsWith("=")).join("</p>\n<p>")}</p>`;
+      const titleMatch = raw.match(/^=\s+(.+)$/m);
+      title = titleMatch ? titleMatch[1] : "About";
+    }
+    const output = { title, html };
+    mkdirSync(publicPagesDir, { recursive: true });
+    writeFileSync(join(publicPagesDir, outputName), JSON.stringify(output));
+    count++;
+    console.log(`  Compiled: ${file} \u2192 public/pages/${outputName}`);
+  }
+  return count;
+}
+function main() {
+  const { ROOT, PUBLIC_PAGES, DATASETS_DIR, GROUPS_CONTENT_DIR } = roots();
+  mkdirSync(PUBLIC_PAGES, { recursive: true });
+  let total = 0;
+  const siteConfig = loadSiteConfigForAbout();
+  const localPathMap = /* @__PURE__ */ new Map();
+  for (const ds of siteConfig?.datasets || []) {
+    if (ds.id && ds.localPath) {
+      localPathMap.set(ds.id, resolve2(ROOT, ds.localPath));
+    }
+  }
+  const seenIds = /* @__PURE__ */ new Set();
+  if (existsSync2(DATASETS_DIR)) {
+    for (const dsId of readdirSync(DATASETS_DIR)) {
+      seenIds.add(dsId);
+      const aboutDir = join(DATASETS_DIR, dsId, "about");
+      if (existsSync2(aboutDir) && statSync(aboutDir).isDirectory()) {
+        console.log(`Processing dataset: ${dsId}`);
+        total += processAboutDir(aboutDir, `dataset-${dsId}-about`, PUBLIC_PAGES);
+      }
+    }
+  }
+  for (const [dsId, dsPath] of localPathMap) {
+    if (seenIds.has(dsId)) continue;
+    const aboutDir = join(dsPath, "about");
+    if (existsSync2(aboutDir) && statSync(aboutDir).isDirectory()) {
+      console.log(`Processing dataset (localPath): ${dsId}`);
+      total += processAboutDir(aboutDir, `dataset-${dsId}-about`, PUBLIC_PAGES);
+    }
+  }
+  if (existsSync2(GROUPS_CONTENT_DIR)) {
+    for (const groupId of readdirSync(GROUPS_CONTENT_DIR)) {
+      const aboutDir = join(GROUPS_CONTENT_DIR, groupId, "about");
+      if (existsSync2(aboutDir) && statSync(aboutDir).isDirectory()) {
+        console.log(`Processing group: ${groupId}`);
+        total += processAboutDir(aboutDir, `group-${groupId}-about`, PUBLIC_PAGES);
+      }
+    }
+  }
+  console.log(total > 0 ? `
+Compiled ${total} about page(s).` : "\nNo about pages found.");
+}
+var isDirectInvocation = process.argv[1] && realpathSync(process.argv[1]) === realpathSync(fileURLToPath2(import.meta.url));
+if (isDirectInvocation) {
+  main();
+}
+export {
+  loadSiteConfigForAbout,
+  main,
+  processAboutDir,
+  renderMarkdown,
+  roots
+};

package/scripts/{process-about-pages.mjs → process-about-pages.ts}

@@ -19,7 +19,7 @@ import { join, basename, extname, resolve } from 'node:path';
 import { cwd } from 'node:process';
 import { fileURLToPath } from 'node:url';
 
-import { loadSiteConfig } from './load-site-config.mjs';
+import { loadSiteConfig } from './load-site-config';
 
 export function loadSiteConfigForAbout() {
   try {

package/scripts/smoke.js

@@ -0,0 +1,211 @@
+#!/usr/bin/env node
+
+// scripts/smoke.ts
+import { chromium } from "playwright";
+import { createServer } from "http";
+import { statSync, createReadStream } from "fs";
+import { extname, join, normalize, resolve as pathResolve } from "path";
+import { fileURLToPath } from "url";
+var __dirname = fileURLToPath(new URL(".", import.meta.url));
+var DIST = pathResolve(__dirname, "..", "dist");
+var MIME = {
+  ".html": "text/html; charset=utf-8",
+  ".js": "application/javascript; charset=utf-8",
+  "": "application/javascript; charset=utf-8",
+  ".css": "text/css; charset=utf-8",
+  ".json": "application/json; charset=utf-8",
+  ".svg": "image/svg+xml",
+  ".png": "image/png",
+  ".jpg": "image/jpeg",
+  ".ico": "image/x-icon",
+  ".webp": "image/webp",
+  ".woff": "font/woff",
+  ".woff2": "font/woff2",
+  ".ttf": "font/ttf",
+  ".map": "application/json; charset=utf-8",
+  ".xml": "application/xml; charset=utf-8",
+  ".txt": "text/plain; charset=utf-8",
+  ".webmanifest": "application/manifest+json; charset=utf-8"
+};
+function serveDist(root) {
+  return new Promise((resolve) => {
+    const server = createServer((req, res) => {
+      try {
+        const urlPath = decodeURIComponent((req.url ?? "/").split("?")[0]);
+        let filePath = join(root, urlPath);
+        if (!extname(filePath)) {
+          if (statSafe(filePath)?.isFile()) {
+            return sendFile(res, filePath);
+          }
+          const candidates = [
+            filePath + ".html",
+            join(filePath, "index.html"),
+            join(root, "200.html"),
+            join(root, "index.html")
+          ];
+          for (const c of candidates) {
+            if (statSafe(c)?.isFile()) {
+              return sendFile(res, c);
+            }
+          }
+          res.writeHead(404);
+          return res.end("Not found");
+        }
+        if (statSafe(filePath)?.isFile()) {
+          return sendFile(res, filePath);
+        }
+        res.writeHead(404);
+        return res.end("Not found");
+      } catch (e) {
+        res.writeHead(500);
+        res.end(String(e ?? "server error"));
+      }
+    });
+    server.listen(0, "127.0.0.1", () => {
+      const addr = server.address();
+      const port = typeof addr === "object" && addr ? addr.port : 0;
+      resolve({ server, origin: `http://127.0.0.1:${port}` });
+    });
+  });
+}
+function statSafe(p) {
+  try {
+    return statSync(p);
+  } catch {
+    return null;
+  }
+}
+function sendFile(res, filePath) {
+  const safe = normalize(filePath);
+  const ct = MIME[extname(safe)] ?? "application/octet-stream";
+  res.writeHead(200, { "Content-Type": ct });
+  createReadStream(safe).pipe(res);
+}
+var PAGE_PATHS = [
+  "/",
+  "/learn/",
+  "/learn/relationships/",
+  "/learn/designations/",
+  "/learn/statuses/"
+];
+var CONSUMER_DATA_FILES = [
+  "/datasets.json",
+  "/site-config.json",
+  "/data/cross-ref-index.json"
+];
+function isConsumerDataFile(url) {
+  try {
+    const u = new URL(url);
+    return CONSUMER_DATA_FILES.some((f) => u.pathname === f || u.pathname.startsWith("/data/"));
+  } catch {
+    return false;
+  }
+}
+async function probePage(browser, origin, path) {
+  const url = new URL(path, origin).toString();
+  const page = await browser.newPage();
+  const errors = [];
+  const failedRequests = [];
+  page.on("pageerror", (e) => {
+    errors.push({ kind: "pageerror", message: e.message, stack: e.stack ?? "" });
+  });
+  page.on("console", (msg) => {
+    if (msg.type() !== "error") return;
+    const text = msg.text();
+    if (/Failed to load resource/i.test(text)) return;
+    if (/fonts\.g(oogle|static)\.com/.test(text)) return;
+    errors.push({ kind: "console.error", message: text });
+  });
+  page.on("requestfailed", (req) => {
+    const u = req.url();
+    if (u.startsWith(origin) && !isConsumerDataFile(u)) {
+      failedRequests.push({ url: u, failure: req.failure()?.errorText ?? "failed" });
+    }
+  });
+  page.on("response", (resp) => {
+    const u = resp.url();
+    if (u.startsWith(origin) && resp.status() >= 400 && !isConsumerDataFile(u)) {
+      failedRequests.push({ url: u, status: resp.status() });
+    }
+  });
+  try {
+    const resp = await page.goto(url, { waitUntil: "networkidle", timeout: 15e3 });
+    if (resp && resp.status() >= 400) {
+      return { path, url, status: resp.status(), bodyLen: 0, errors, failedRequests, skipped: path !== "/" };
+    }
+    await page.waitForTimeout(500);
+    const bodyLen = await page.evaluate(() => document.body?.innerText?.length ?? 0);
+    return { path, url, status: resp?.status() ?? 0, bodyLen, errors, failedRequests, skipped: false };
+  } catch (e) {
+    errors.push({ kind: "navigation", message: String(e) });
+    return { path, url, status: 0, bodyLen: 0, errors, failedRequests, skipped: false };
+  } finally {
+    await page.close();
+  }
+}
+function formatFindings(results) {
+  const lines = [];
+  for (const r of results) {
+    if (r.skipped) {
+      lines.push(`
+  ${r.path}  (HTTP ${r.status} \u2014 skipped, not in this build)`);
+      continue;
+    }
+    if (r.errors.length === 0 && r.failedRequests.length === 0 && r.bodyLen > 0) continue;
+    lines.push(`
+  ${r.path}  (HTTP ${r.status}, body ${r.bodyLen} chars)`);
+    for (const e of r.errors) {
+      lines.push(`    [${e.kind}] ${e.message}`);
+    }
+    for (const f of r.failedRequests) {
+      lines.push(`    [request] ${f.status ?? f.failure}  ${f.url}`);
+    }
+  }
+  return lines.join("\n");
+}
+async function ensureDist() {
+  if (!statSafe(DIST)?.isDirectory()) {
+    console.error(`smoke: dist/ not found at ${DIST}`);
+    console.error(`       run \`npm run build\` first, or use \`npm run build:full\`.`);
+    process.exit(2);
+  }
+  if (!statSafe(join(DIST, "index.html"))?.isFile()) {
+    console.error(`smoke: dist/index.html missing \u2014 build did not complete.`);
+    process.exit(2);
+  }
+}
+async function main() {
+  await ensureDist();
+  const { server, origin } = await serveDist(DIST);
+  let exitCode = 0;
+  const browser = await chromium.launch({ headless: true });
+  try {
+    const results = [];
+    for (const path of PAGE_PATHS) {
+      const r = await probePage(browser, origin, path);
+      results.push(r);
+    }
+    const anyFail = results.some(
+      (r) => !r.skipped && (r.errors.length > 0 || r.failedRequests.length > 0 || r.bodyLen === 0)
+    );
+    const findings = formatFindings(results);
+    if (anyFail) {
+      exitCode = 1;
+      console.error(`
+  FAIL  smoke test found problems:${findings}
+`);
+    } else {
+      const skipped = results.filter((r) => r.skipped).length;
+      console.log(`
+  OK    smoke test passed (${results.length - skipped} pages, ${skipped} skipped, 0 errors).`);
+    }
+  } finally {
+    await browser.close();
+    server.close();
+  }
+  process.exit(exitCode);
+}
+main().catch((e) => {
+  console.error("smoke: fatal error", e);
+  process.exit(1);
+});

package/scripts/{smoke.mjs → smoke.ts}

@@ -36,7 +36,7 @@ const DIST = pathResolve(__dirname, '..', 'dist');
 const MIME = {
   '.html': 'text/html; charset=utf-8',
   '.js':   'application/javascript; charset=utf-8',
-  '.mjs':  'application/javascript; charset=utf-8',
+  '':  'application/javascript; charset=utf-8',
   '.css':  'text/css; charset=utf-8',
   '.json': 'application/json; charset=utf-8',
   '.svg':  'image/svg+xml',
@@ -53,7 +53,7 @@ const MIME = {
   '.webmanifest': 'application/manifest+json; charset=utf-8',
 };
 
-function serveDist(root) {
+function serveDist(root: string): Promise<{ server: ReturnType<typeof createServer>; origin: string }> {
   return new Promise((resolve) => {
     const server = createServer((req, res) => {
       try {
@@ -91,7 +91,8 @@ function serveDist(root) {
     });
     // Use port 0 to let the OS pick a free port; retrieve it after listen.
     server.listen(0, '127.0.0.1', () => {
-      const { port } = server.address();
+      const addr = server.address();
+      const port = typeof addr === 'object' && addr ? addr.port : 0;
       resolve({ server, origin: `http://127.0.0.1:${port}` });
     });
   });

package/scripts/sync-concept-model.js

@@ -0,0 +1,63 @@
+#!/usr/bin/env node
+
+// scripts/sync-concept-model.ts
+import { mkdirSync, writeFileSync } from "node:fs";
+import { dirname, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { execSync } from "node:child_process";
+var ROOT = resolve(dirname(fileURLToPath(import.meta.url)), "..");
+var OUT_DIR = resolve(ROOT, "data", "concept-model");
+var REPO = "glossarist/concept-model";
+function parseArgs(argv) {
+  const out = { ref: null };
+  for (let i = 2; i < argv.length; i++) {
+    const a = argv[i];
+    if (a === "--ref") out.ref = argv[++i];
+    else if (!a.startsWith("--")) out.ref = a;
+  }
+  return out;
+}
+function latestTag() {
+  return execSync(`gh api repos/${REPO}/releases/latest --jq .tag_name`, { encoding: "utf8" }).trim();
+}
+function fetchFile(ref2, path) {
+  const url = `https://raw.githubusercontent.com/${REPO}/${ref2}/${path}`;
+  return execSync(`curl -fsSL ${url}`, { encoding: "utf8" });
+}
+var args = parseArgs(process.argv);
+var ref = args.ref || latestTag();
+if (!ref) {
+  console.error("Could not determine concept-model ref to sync.");
+  process.exit(1);
+}
+console.log(`Syncing from ${REPO}@${ref}`);
+mkdirSync(resolve(OUT_DIR, "shapes"), { recursive: true });
+function fetchAny(ref2, candidates) {
+  for (const p of candidates) {
+    try {
+      return fetchFile(ref2, p);
+    } catch (e) {
+    }
+  }
+  throw new Error(`Could not fetch any of: ${candidates.join(", ")}`);
+}
+var targets = {
+  "glossarist.context.jsonld": ["ontologies/glossarist.context.jsonld", "glossarist.context.jsonld"],
+  "glossarist.ttl": ["ontologies/glossarist.ttl", "glossarist.ttl"],
+  "prefixes.ttl": ["ontologies/prefixes.ttl"],
+  "shapes/glossarist.shacl.ttl": ["ontologies/shapes/glossarist.shacl.ttl", "shapes/glossarist.shacl.ttl"]
+};
+var updated = 0;
+for (const [outPath, candidates] of Object.entries(targets)) {
+  const content = fetchAny(ref, candidates);
+  writeFileSync(resolve(OUT_DIR, outPath), content);
+  console.log(`  \u2713 ${outPath} (${content.length} bytes)`);
+  updated++;
+}
+writeFileSync(
+  resolve(OUT_DIR, "SOURCE.json"),
+  JSON.stringify({ repo: REPO, ref, syncedAt: (/* @__PURE__ */ new Date()).toISOString() }, null, 2) + "\n"
+);
+console.log(`
+Synced ${updated} file(s) from ${REPO}@${ref}.`);
+console.log("Review the diff, then commit.");