@canopy-iiif/app 0.7.17 → 0.7.18

package/lib/build/dev.js

@@ -2,7 +2,6 @@ const fs = require("fs");
 const fsp = fs.promises;
 const path = require("path");
 const { spawn, spawnSync } = require("child_process");
-const { build } = require("../build/build");
 const http = require("http");
 const url = require("url");
 const {
@@ -22,11 +21,29 @@ function resolveTailwindCli() {
   return { cmd: 'tailwindcss', args: [] };
 }
 const PORT = Number(process.env.PORT || 5001);
+const BUILD_MODULE_PATH = path.resolve(__dirname, "build.js");
 let onBuildSuccess = () => {};
 let onBuildStart = () => {};
 let onCssChange = () => {};
 let nextBuildSkipIiif = false; // hint set by watchers
 const UI_DIST_DIR = path.resolve(path.join(__dirname, "../../ui/dist"));
+const APP_PACKAGE_ROOT = path.resolve(path.join(__dirname, "..", ".."));
+const APP_LIB_DIR = path.join(APP_PACKAGE_ROOT, "lib");
+const APP_UI_DIR = path.join(APP_PACKAGE_ROOT, "ui");
+const APP_WATCH_TARGETS = [
+  { dir: APP_LIB_DIR, label: "@canopy-iiif/app/lib" },
+  { dir: APP_UI_DIR, label: "@canopy-iiif/app/ui" },
+];
+const HAS_APP_WORKSPACE = (() => {
+  try {
+    return fs.existsSync(path.join(APP_PACKAGE_ROOT, "package.json"));
+  } catch (_) {
+    return false;
+  }
+})();
+let pendingModuleReload = false;
+let building = false;
+let buildAgain = false;
 
 function prettyPath(p) {
   try {
@@ -40,16 +57,71 @@ function prettyPath(p) {
   }
 }
 
+function loadBuildFunction() {
+  let mod = null;
+  try {
+    mod = require(BUILD_MODULE_PATH);
+  } catch (error) {
+    throw new Error(
+      `[watch] Failed to load build module (${BUILD_MODULE_PATH}): ${
+        error && error.message ? error.message : error
+      }`
+    );
+  }
+  const fn =
+    mod && typeof mod.build === "function"
+      ? mod.build
+      : mod && mod.default && typeof mod.default.build === "function"
+      ? mod.default.build
+      : null;
+  if (typeof fn !== "function") {
+    throw new Error("[watch] Invalid build module export: expected build() function");
+  }
+  return fn;
+}
+
+function clearAppModuleCache() {
+  try {
+    const prefix = APP_PACKAGE_ROOT.endsWith(path.sep)
+      ? APP_PACKAGE_ROOT
+      : APP_PACKAGE_ROOT + path.sep;
+    for (const key of Object.keys(require.cache || {})) {
+      if (!key) continue;
+      try {
+        if (key === APP_PACKAGE_ROOT || key.startsWith(prefix)) {
+          delete require.cache[key];
+        }
+      } catch (_) {}
+    }
+  } catch (_) {}
+}
+
 async function runBuild() {
+  if (building) {
+    buildAgain = true;
+    return;
+  }
+  building = true;
+  const hint = { skipIiif: !!nextBuildSkipIiif };
+  nextBuildSkipIiif = false;
   try {
-    const hint = { skipIiif: !!nextBuildSkipIiif };
-    nextBuildSkipIiif = false;
-    await build(hint);
+    if (pendingModuleReload) {
+      clearAppModuleCache();
+      pendingModuleReload = false;
+    }
+    const buildFn = loadBuildFunction();
+    await buildFn(hint);
     try {
       onBuildSuccess();
     } catch (_) {}
   } catch (e) {
     console.error("Build failed:", e && e.message ? e.message : e);
+  } finally {
+    building = false;
+    if (buildAgain) {
+      buildAgain = false;
+      debounceBuild();
+    }
   }
 }
 
@@ -334,6 +406,131 @@ function watchUiDistPerDir() {
   };
 }
 
+const APP_WATCH_EXTENSIONS = new Set([".js", ".jsx", ".scss"]);
+
+function shouldIgnoreAppSourcePath(p) {
+  try {
+    const resolved = path.resolve(p);
+    const rel = path.relative(APP_PACKAGE_ROOT, resolved);
+    if (!rel || rel === "") return false;
+    if (rel.startsWith("..")) return true;
+    const segments = rel.split(path.sep).filter(Boolean);
+    if (!segments.length) return false;
+    if (segments.includes("node_modules")) return true;
+    if (segments.includes(".git")) return true;
+    if (segments[0] === "ui" && segments[1] === "dist") return true;
+    return false;
+  } catch (_) {
+    return true;
+  }
+}
+
+function handleAppSourceChange(baseDir, eventType, filename, label) {
+  if (!filename) return;
+  const full = path.resolve(baseDir, filename);
+  if (shouldIgnoreAppSourcePath(full)) return;
+  const ext = path.extname(full).toLowerCase();
+  if (!APP_WATCH_EXTENSIONS.has(ext)) return;
+  try {
+    const relLib = path.relative(APP_LIB_DIR, full);
+    if (!relLib.startsWith("..") && !path.isAbsolute(relLib)) {
+      pendingModuleReload = true;
+    }
+  } catch (_) {}
+  try {
+    console.log(
+      `[pkg] ${eventType}: ${prettyPath(full)}${label ? ` (${label})` : ""}`
+    );
+  } catch (_) {}
+  nextBuildSkipIiif = true;
+  try {
+    onBuildStart();
+  } catch (_) {}
+  debounceBuild();
+}
+
+function tryRecursiveWatchAppDir(dir, label) {
+  try {
+    return fs.watch(dir, { recursive: true }, (eventType, filename) => {
+      handleAppSourceChange(dir, eventType, filename, label);
+    });
+  } catch (_) {
+    return null;
+  }
+}
+
+function watchAppDirPerDir(dir, label) {
+  const watchers = new Map();
+
+  function watchDir(target) {
+    if (watchers.has(target)) return;
+    if (shouldIgnoreAppSourcePath(target)) return;
+    try {
+      const w = fs.watch(target, (eventType, filename) => {
+        if (filename) {
+          handleAppSourceChange(target, eventType, filename, label);
+        }
+        scan(target);
+      });
+      watchers.set(target, w);
+    } catch (_) {}
+  }
+
+  function scan(target) {
+    let entries;
+    try {
+      entries = fs.readdirSync(target, { withFileTypes: true });
+    } catch (_) {
+      return;
+    }
+    for (const entry of entries) {
+      if (!entry.isDirectory()) continue;
+      const sub = path.join(target, entry.name);
+      if (shouldIgnoreAppSourcePath(sub)) continue;
+      watchDir(sub);
+      scan(sub);
+    }
+  }
+
+  watchDir(dir);
+  scan(dir);
+
+  return () => {
+    for (const w of watchers.values()) {
+      try {
+        w.close();
+      } catch (_) {}
+    }
+  };
+}
+
+function watchAppSources() {
+  if (!HAS_APP_WORKSPACE) return () => {};
+  const stops = [];
+  for (const target of APP_WATCH_TARGETS) {
+    const { dir, label } = target;
+    if (!dir || !fs.existsSync(dir)) continue;
+    console.log(`[Watching] ${prettyPath(dir)} (${label})`);
+    const watcher = tryRecursiveWatchAppDir(dir, label);
+    if (!watcher) {
+      stops.push(watchAppDirPerDir(dir, label));
+    } else {
+      stops.push(() => {
+        try {
+          watcher.close();
+        } catch (_) {}
+      });
+    }
+  }
+  return () => {
+    for (const stop of stops) {
+      try {
+        if (typeof stop === "function") stop();
+      } catch (_) {}
+    }
+  };
+}
+
 const MIME = {
   ".html": "text/html; charset=utf-8",
   ".css": "text/css; charset=utf-8",
@@ -900,6 +1097,9 @@ async function dev() {
     const urw = tryRecursiveWatchUiDist();
     if (!urw) watchUiDistPerDir();
   }
+  if (HAS_APP_WORKSPACE) {
+    watchAppSources();
+  }
 }
 
 module.exports = { dev };

package/lib/orchestrator.js

@@ -0,0 +1,203 @@
+const { spawn } = require('child_process');
+const fs = require('fs');
+const path = require('path');
+
+const log = (msg) => console.log(`[canopy] ${msg}`);
+const warn = (msg) => console.warn(`[canopy][warn] ${msg}`);
+const err = (msg) => console.error(`[canopy][error] ${msg}`);
+
+let uiWatcherChild = null;
+
+const workspacePackageJsonPath = path.resolve(process.cwd(), 'packages/app/package.json');
+const hasAppWorkspace = fs.existsSync(workspacePackageJsonPath);
+
+function getMode(argv = process.argv.slice(2), env = process.env) {
+  const cli = new Set(argv);
+  if (cli.has('--dev')) return 'dev';
+  if (cli.has('--build')) return 'build';
+
+  if (env.CANOPY_MODE === 'dev') return 'dev';
+  if (env.CANOPY_MODE === 'build') return 'build';
+
+  const npmScript = env.npm_lifecycle_event;
+  if (npmScript === 'dev') return 'dev';
+  if (npmScript === 'build') return 'build';
+
+  return 'build';
+}
+
+function runOnce(cmd, args, opts = {}) {
+  return new Promise((resolve, reject) => {
+    const child = spawn(cmd, args, { stdio: 'inherit', shell: false, ...opts });
+    child.on('error', reject);
+    child.on('exit', (code) => {
+      if (code === 0) {
+        resolve();
+      } else {
+        reject(new Error(`${cmd} ${args.join(' ')} exited with code ${code}`));
+      }
+    });
+  });
+}
+
+function start(cmd, args, opts = {}) {
+  const child = spawn(cmd, args, { stdio: 'inherit', shell: false, ...opts });
+  child.on('error', (error) => {
+    const message = error && error.message ? error.message : String(error);
+    warn(`Subprocess error (${cmd}): ${message}`);
+  });
+  return child;
+}
+
+async function prepareUi(mode, env = process.env) {
+  if (!hasAppWorkspace) {
+    log('Using bundled UI assets from @canopy-iiif/app (workspace not detected)');
+    return null;
+  }
+
+  if (mode === 'build') {
+    log('Building UI assets (@canopy-iiif/app/ui)');
+    try {
+      await runOnce('npm', ['-w', '@canopy-iiif/app', 'run', 'ui:build'], { env });
+      log('UI assets built');
+    } catch (error) {
+      warn(`UI build skipped: ${(error && error.message) || String(error)}`);
+    }
+    return null;
+  }
+
+  try {
+    log('Prebuilding UI assets (@canopy-iiif/app/ui)');
+    await runOnce('npm', ['-w', '@canopy-iiif/app', 'run', 'ui:build'], { env });
+  } catch (error) {
+    warn(`UI prebuild skipped: ${(error && error.message) || String(error)}`);
+  }
+
+  log('Starting UI watcher (@canopy-iiif/app/ui)');
+  try {
+    uiWatcherChild = start('npm', ['-w', '@canopy-iiif/app', 'run', 'ui:watch'], { env });
+  } catch (error) {
+    warn(`UI watch skipped: ${(error && error.message) || String(error)}`);
+    uiWatcherChild = null;
+  }
+  return uiWatcherChild;
+}
+
+function loadLibraryApi() {
+  let lib;
+  try {
+    lib = require('./index.js');
+  } catch (e) {
+    const hint = [
+      'Unable to load @canopy-iiif/app.',
+      'Ensure dependencies are installed (npm install)',
+      "and that peer deps like 'react' are present.",
+    ].join(' ');
+    const detail = e && e.message ? `\nCaused by: ${e.message}` : '';
+    throw new Error(`${hint}${detail}`);
+  }
+
+  const api = lib && (typeof lib.build === 'function' || typeof lib.dev === 'function')
+    ? lib
+    : lib && lib.default
+    ? lib.default
+    : lib;
+
+  if (!api || (typeof api.build !== 'function' && typeof api.dev !== 'function')) {
+    throw new TypeError('Invalid @canopy-iiif/app export: expected functions build() and/or dev().');
+  }
+
+  return api;
+}
+
+function attachSignalHandlers() {
+  const clean = () => {
+    if (uiWatcherChild && !uiWatcherChild.killed) {
+      try { uiWatcherChild.kill(); } catch (_) {}
+    }
+  };
+
+  process.on('SIGINT', () => {
+    clean();
+    process.exit(130);
+  });
+  process.on('SIGTERM', () => {
+    clean();
+    process.exit(143);
+  });
+  process.on('exit', clean);
+}
+
+function verifyBuildOutput(outDir = 'site') {
+  const root = path.resolve(outDir);
+  function walk(dir) {
+    let count = 0;
+    if (!fs.existsSync(dir)) return 0;
+    const entries = fs.readdirSync(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      const p = path.join(dir, entry.name);
+      if (entry.isDirectory()) count += walk(p);
+      else if (entry.isFile() && p.toLowerCase().endsWith('.html')) count += 1;
+    }
+    return count;
+  }
+  const pages = walk(root);
+  if (!pages) {
+    throw new Error('CI check failed: no HTML pages generated in "site/".');
+  }
+  log(`CI check: found ${pages} HTML page(s) in ${root}.`);
+}
+
+async function orchestrate(options = {}) {
+  const argv = options.argv || process.argv.slice(2);
+  const env = options.env || process.env;
+
+  process.title = 'canopy-app';
+  const mode = getMode(argv, env);
+  log(`Mode: ${mode}`);
+
+  const cli = new Set(argv);
+  if (cli.has('--verify')) {
+    verifyBuildOutput(env.CANOPY_OUT_DIR || 'site');
+    return;
+  }
+
+  await prepareUi(mode, env);
+
+  const api = loadLibraryApi();
+  try {
+    if (mode === 'dev') {
+      attachSignalHandlers();
+      log('Starting dev server...');
+      await (typeof api.dev === 'function' ? api.dev() : Promise.resolve());
+    } else {
+      log('Building site...');
+      if (typeof api.build === 'function') {
+        await api.build();
+      }
+      log('Build complete');
+      if (env.CANOPY_VERIFY === '1' || env.CANOPY_VERIFY === 'true') {
+        verifyBuildOutput(env.CANOPY_OUT_DIR || 'site');
+      }
+    }
+  } finally {
+    if (uiWatcherChild && !uiWatcherChild.killed) {
+      try { uiWatcherChild.kill(); } catch (_) {}
+    }
+  }
+}
+
+module.exports = {
+  orchestrate,
+  verifyBuildOutput,
+  _internals: {
+    getMode,
+    prepareUi,
+    loadLibraryApi,
+    runOnce,
+    start,
+  },
+  log,
+  warn,
+  err,
+};

package/lib/search/command-runtime.js

@@ -346,10 +346,11 @@ async function attachCommand(host) {
 
   host.addEventListener('click', (event) => {
     const trigger = event.target && event.target.closest && event.target.closest('[data-canopy-command-trigger]');
-    if (trigger) {
-      event.preventDefault();
-      openPanel();
-    }
+    if (!trigger) return;
+    const mode = (trigger.dataset && trigger.dataset.canopyCommandTrigger) || '';
+    if (mode === 'submit' || mode === 'form') return;
+    event.preventDefault();
+    openPanel();
   });
 
   try {