brep-io-kernel 1.0.0-ci.10

package/src/plugins/ghLoader.worker.js

@@ -0,0 +1,151 @@
+// Module Worker: Fetches plugin entry from candidate URLs (preferring GitHub Raw),
+// and builds a small in-memory module graph where all relative and raw.githubusercontent.com
+// imports are fetched from Raw and rewritten to blob: URLs, avoiding MIME issues.
+// Input:  { type: 'load', urls: string[], bases: string[], ts?: number }
+// Output: { ok: true, code, usedUrl, usedBase } or { ok: false, error }
+
+const RAW_HOST = 'raw.githubusercontent.com';
+
+function isRawUrl(u) {
+  try { return new URL(u).hostname === RAW_HOST; } catch { return false; }
+}
+
+function dirOf(u) {
+  try { return new URL('.', u).href; } catch { return u; }
+}
+
+function normalize(u) {
+  try {
+    const url = new URL(u);
+    // strip query/hash for graph keys
+    url.search = '';
+    url.hash = '';
+    return url.href;
+  } catch { return u; }
+}
+
+// Find string-literal specifiers in static and dynamic imports
+function findSpecifiers(code) {
+  const out = [];
+  const reStatic = /\b(?:import|export)\s+(?:[^'";]*?\sfrom\s+)?(["'])([^"']+)(\1)/g;
+  const reDyn = /\bimport\s*\(\s*(["'])([^"']+)(\1)\s*\)/g;
+  let m;
+  while ((m = reStatic.exec(code))) {
+    const q = m[1];
+    const spec = m[2];
+    out.push({ kind: 'static', q, spec });
+  }
+  while ((m = reDyn.exec(code))) {
+    const q = m[1];
+    const spec = m[2];
+    out.push({ kind: 'dynamic', q, spec });
+  }
+  return out;
+}
+
+async function fetchText(url) {
+  const res = await fetch(url, { mode: 'cors', credentials: 'omit' });
+  if (!res || !res.ok) throw new Error(`HTTP ${res && res.status}`);
+  return res.text();
+}
+
+// Build module graph, rewriting target module code to import blob: URLs for its deps.
+async function buildGraph(entryUrl) {
+  const blobBySrc = new Map(); // srcAbs -> blobUrl
+  const codeBySrc = new Map(); // srcAbs -> rewritten code
+  const loading = new Set();
+
+  async function loadModule(srcAbs) {
+    const key = normalize(srcAbs);
+    if (blobBySrc.has(key)) return blobBySrc.get(key);
+    if (loading.has(key)) {
+      // Circular import: emit minimal stub to break the cycle.
+      const stub = URL.createObjectURL(new Blob([`export {};`], { type: 'application/javascript' }));
+      blobBySrc.set(key, stub);
+      return stub;
+    }
+    loading.add(key);
+    const rawCode = await fetchText(srcAbs);
+    const baseDir = dirOf(srcAbs);
+    const specs = findSpecifiers(rawCode).filter(s => s && typeof s.spec === 'string');
+
+    // Determine which specifiers we will fetch and rewrite: relative or raw absolute.
+    const targets = [];
+    for (const s of specs) {
+      const spec = s.spec.trim();
+      if (!spec) continue;
+      const isRel = spec.startsWith('.') || spec.startsWith('..');
+      const isRawAbs = spec.startsWith('http://') || spec.startsWith('https://') ? isRawUrl(spec) : false;
+      if (!isRel && !isRawAbs) continue;
+      const abs = isRel ? new URL(spec, baseDir).href : spec;
+      targets.push({ lit: spec, abs });
+    }
+
+    // Deduplicate by absolute URL
+    const uniq = new Map();
+    for (const t of targets) { const k = normalize(t.abs); if (!uniq.has(k)) uniq.set(k, t); }
+
+    // Recursively load children first
+    const mapLitToBlob = new Map();
+    for (const [k, t] of uniq.entries()) {
+      const childBlob = await loadModule(t.abs);
+      mapLitToBlob.set(t.lit, childBlob);
+    }
+
+    // Rewrite code: replace each matched literal spec with its blob URL
+    let out = rawCode;
+    // Static
+    out = out.replace(/\b(?:import|export)\s+(?:[^'";]*?\sfrom\s+)?(["'])([^"']+)(\1)/g, (m, q, spec) => {
+      const repl = mapLitToBlob.get(spec);
+      if (repl) return m.replace(`${q}${spec}${q}`, `${q}${repl}${q}`);
+      // If relative import and base is raw, rewrite to absolute raw so it resolves consistently
+      if (spec.startsWith('.') || spec.startsWith('..')) {
+        try { const abs = new URL(spec, baseDir).href; return m.replace(`${q}${spec}${q}`, `${q}${abs}${q}`); } catch {}
+      }
+      return m;
+    });
+    // Dynamic
+    out = out.replace(/\bimport\s*\(\s*(["'])([^"']+)(\1)\s*\)/g, (m, q, spec) => {
+      const repl = mapLitToBlob.get(spec);
+      if (repl) return m.replace(`${q}${spec}${q}`, `${q}${repl}${q}`);
+      if (spec.startsWith('.') || spec.startsWith('..')) {
+        try { const abs = new URL(spec, baseDir).href; return m.replace(`${q}${spec}${q}`, `${q}${abs}${q}`); } catch {}
+      }
+      return m;
+    });
+
+    // Create blob for this module
+    const blob = URL.createObjectURL(new Blob([out], { type: 'application/javascript' }));
+    blobBySrc.set(key, blob);
+    codeBySrc.set(key, out);
+    loading.delete(key);
+    return blob;
+  }
+
+  const entryBlob = await loadModule(entryUrl);
+  // Return the rewritten code of the entry so the main thread can wrap or import it.
+  const entryCode = codeBySrc.get(normalize(entryUrl)) || '';
+  return { code: entryCode, entryBlob };
+}
+
+self.addEventListener('message', async (ev) => {
+  const msg = ev.data || {};
+  if (msg.type !== 'load') return;
+  const urls = Array.isArray(msg.urls) ? msg.urls : [];
+  const bases = Array.isArray(msg.bases) ? msg.bases : [];
+  let lastErr = null;
+  for (let i = 0; i < urls.length; i++) {
+    const url = urls[i];
+    const base = bases[i] || '';
+    try {
+      // Build a blob-based module graph starting at the chosen candidate URL.
+      const { code } = await buildGraph(url);
+      self.postMessage({ ok: true, code, usedUrl: url, usedBase: base });
+      return;
+    } catch (e) {
+      lastErr = e;
+      // try next candidate
+    }
+  }
+  self.postMessage({ ok: false, error: String(lastErr || 'Failed to load plugin') });
+});

package/src/plugins/pluginManager.js

@@ -0,0 +1,286 @@
+// Plugin loader utilities.
+// - GitHub repos: try GitHub Raw first, then fall back to jsDelivr.
+// - Generic URLs: load from any HTTP(S) base or a direct plugin entry URL.
+
+// Parse common GitHub URL shapes.
+// Supports:
+//  - https://github.com/USER/REPO
+//  - https://github.com/USER/REPO/tree/REF
+//  - https://github.com/USER/REPO/tree/REF/sub/dir
+import { BREP } from "../BREP/BREP.js";
+import { localStorage as LS } from "../idbStorage.js";
+
+
+
+
+export function parseGithubUrl(input) {
+  const url = new URL(input);
+  const parts = url.pathname.split('/').filter(Boolean);
+  const user = parts[0];
+  const repo = parts[1];
+  let ref = null;
+  let subdir = '';
+  const idx = parts.indexOf('tree');
+  if (idx !== -1) {
+    ref = parts[idx + 1] || null;
+    const rest = parts.slice(idx + 2);
+    subdir = rest.length ? '/' + rest.join('/') : '';
+  }
+  if (!user || !repo) throw new Error('Invalid GitHub repo URL');
+  return { user, repo, ref, subdir };
+}
+
+function isGithubRepoUrl(u) {
+  try { return new URL(u).hostname === 'github.com'; } catch { return false; }
+}
+
+function dirOf(u) {
+  try { return new URL('.', u).href; } catch { return u; }
+}
+
+async function fetchAndPrepareEntryViaWorker(entryUrls, baseUrls, ts) {
+  return new Promise((resolve, reject) => {
+    const worker = new Worker(new URL('./ghLoader.worker.js', import.meta.url), { type: 'module' });
+    const cleanup = () => { try { worker.terminate(); } catch { } };
+    worker.onmessage = (ev) => {
+      const data = ev.data || {};
+      if (data.ok) {
+        // Do NOT terminate here; caller will keep the worker alive
+        // long enough for blob: dependencies to load.
+        resolve({ ...data, __worker: worker, __cleanup: cleanup });
+      } else {
+        cleanup();
+        reject(new Error(data.error || 'Worker failed'));
+      }
+    };
+    worker.onerror = (e) => { cleanup(); reject(new Error(String(e?.message || e))); };
+    worker.postMessage({ type: 'load', urls: entryUrls, bases: baseUrls, ts: ts ?? Date.now() });
+  });
+}
+
+export async function importGithubPlugin(repoUrl) {
+  const { user, repo, ref, subdir } = parseGithubUrl(repoUrl);
+  const t = Date.now();
+
+  // Build candidate sources in order: GitHub Raw first (ref/main/master), then jsDelivr (ref/latest)
+  const entryUrls = [];
+  const baseUrls = [];
+
+  // 1) GitHub Raw candidates
+  if (ref) {
+    const rawBase = `https://raw.githubusercontent.com/${user}/${repo}/${ref}${subdir || ''}`;
+    entryUrls.push(`${rawBase}/plugin.js?t=${t}`);
+    baseUrls.push(rawBase);
+  } else {
+    for (const branch of ['main', 'master']) {
+      const rawBase = `https://raw.githubusercontent.com/${user}/${repo}/${branch}${subdir || ''}`;
+      entryUrls.push(`${rawBase}/plugin.js?t=${t}`);
+      baseUrls.push(rawBase);
+    }
+  }
+
+  // 2) jsDelivr fallback (prefer specific ref if provided, else @latest)
+  const cdnRef = ref ? ref : 'latest';
+  const jsdBase = `https://cdn.jsdelivr.net/gh/${user}/${repo}@${cdnRef}${subdir || ''}`;
+  entryUrls.push(`${jsdBase}/plugin.js?t=${t}`);
+  baseUrls.push(jsdBase);
+
+  // Web worker fetch + rewrite to absolute imports for the chosen base
+  const { code, usedUrl, usedBase, __worker, __cleanup } = await fetchAndPrepareEntryViaWorker(entryUrls, baseUrls, t);
+  const blob = new Blob([code], { type: 'application/javascript' });
+  const url = URL.createObjectURL(blob);
+  try {
+    const mod = await import(/* webpackIgnore: true */ /* @vite-ignore */ url);
+    return mod;
+  } finally {
+    // Clean up the blob URL; module stays cached
+    setTimeout(() => {
+      try { URL.revokeObjectURL(url); } catch { }
+      // Now safe to terminate worker that created dependency blob: URLs.
+      try { (__cleanup || (()=>{}))(); } catch { }
+      try { __worker && __worker.terminate && __worker.terminate(); } catch { }
+    }, 0);
+  }
+}
+
+// Generic URL importer. Accepts either a base URL (serving plugin files with entry as plugin.js)
+// or a direct entry URL ending in .js. Example: http://localhost:8080/ or https://host/path/plugin.js
+export async function importUrlPlugin(rawUrl) {
+  const t = Date.now();
+  let entryUrl = '';
+  let baseUrl = '';
+  try {
+    const u = new URL(String(rawUrl));
+    // If it looks like a direct JS entry, use it as-is; otherwise, append plugin.js to the base.
+    const path = u.pathname || '';
+    const isJsEntry = /\.m?js$/i.test(path);
+    if (isJsEntry) {
+      entryUrl = u.href;
+      baseUrl = dirOf(u.href);
+    } else {
+      // Ensure trailing slash so URL('plugin.js', base) works consistently
+      if (!u.pathname.endsWith('/')) u.pathname = (u.pathname || '') + '/';
+      baseUrl = u.href;
+      entryUrl = new URL('plugin.js', baseUrl).href;
+    }
+  } catch (e) {
+    throw new Error('Invalid URL');
+  }
+
+  const entryUrls = [`${entryUrl}${entryUrl.includes('?') ? '&' : '?'}t=${t}`];
+  const baseUrls = [baseUrl];
+
+  const { code, __worker, __cleanup } = await fetchAndPrepareEntryViaWorker(entryUrls, baseUrls, t);
+  const blob = new Blob([code], { type: 'application/javascript' });
+  const url = URL.createObjectURL(blob);
+  try {
+    const mod = await import(/* webpackIgnore: true */ /* @vite-ignore */ url);
+    return mod;
+  } finally {
+    setTimeout(() => {
+      try { URL.revokeObjectURL(url); } catch { }
+      try { (__cleanup || (()=>{}))(); } catch { }
+      try { __worker && __worker.terminate && __worker.terminate(); } catch { }
+    }, 0);
+  }
+}
+
+// Plugin app object: exposes the full viewer and helper hooks for plugins.
+function buildApp(viewer) {
+  const app = {
+    BREP,
+    viewer,
+    registerFeature(FeatureClass) {
+      try {
+        FeatureClass.fromPlugin = true;
+        const baseShort = FeatureClass?.shortName || FeatureClass?.name || 'Feature';
+        const baseLong = FeatureClass?.longName || FeatureClass?.name || baseShort;
+        FeatureClass.shortName = `🔌${baseShort}`;
+        FeatureClass.longName = `🔌 ${baseLong}`;
+
+        viewer?.partHistory?.featureRegistry?.register?.(FeatureClass);
+
+      } catch { }
+    },
+    registerAnnotation(AnnotationHandler) {
+      try {
+        // Optional: prefix plugin marker in titles if present
+        if (AnnotationHandler && typeof AnnotationHandler === 'object') {
+          if (AnnotationHandler.title) AnnotationHandler.title = `🔌 ${AnnotationHandler.title}`;
+        }
+        viewer?.annotationRegistry?.register?.(AnnotationHandler);
+      } catch {}
+    },
+    addToolbarButton(label, title, onClick) {
+      if (!viewer) return;
+      try { viewer.addToolbarButton(label, title, onClick); } catch { }
+    },
+    async addSidePanel(title, content) {
+      try {
+        if (typeof viewer?.addPluginSidePanel === 'function') {
+          return await viewer.addPluginSidePanel(title, content);
+        }
+        // Fallback: add immediately if helper is unavailable
+        const sec = await viewer?.accordion?.addSection?.(String(title || 'Plugin'));
+        if (!sec) return null;
+        if (typeof content === 'function') {
+          const el = await content();
+          if (el) sec.uiElement.appendChild(el);
+        } else if (content instanceof HTMLElement) {
+          sec.uiElement.appendChild(content);
+        } else if (content != null) {
+          const pre = document.createElement('pre');
+          pre.textContent = String(content);
+          sec.uiElement.appendChild(pre);
+        }
+        return sec;
+      } catch { return null; }
+    },
+  };
+  return app;
+}
+
+export async function loadPluginFromRepoUrl(viewer, repoUrl) {
+  // Route based on host: GitHub repo URL vs arbitrary base/entry URL
+  const isGh = isGithubRepoUrl(repoUrl);
+  const mod = isGh ? await importGithubPlugin(repoUrl) : await importUrlPlugin(repoUrl);
+  const app = buildApp(viewer);
+  if (typeof mod?.default === 'function') {
+    await mod.default(app);
+    return true;
+  }
+  if (typeof mod?.install === 'function') {
+    await mod.install(app);
+    return true;
+  }
+  console.warn('Plugin loaded but no default() or install() found:', repoUrl);
+  return false;
+}
+
+export async function loadPlugins(viewer, repoUrls) {
+  const urls = (Array.isArray(repoUrls) ? repoUrls : []).map(s => String(s || '').trim()).filter(Boolean);
+  const results = [];
+  for (const u of urls) {
+    try {
+      // eslint-disable-next-line no-await-in-loop
+      const ok = await loadPluginFromRepoUrl(viewer, u);
+      results.push({ url: u, ok, error: null });
+    } catch (e) {
+      console.error('Failed to load plugin:', u, e);
+      results.push({ url: u, ok: false, error: e });
+    }
+  }
+  return results;
+}
+
+const STORAGE_KEY = '__BREP_PLUGIN_URLS__';
+const STORAGE_ENABLED_KEY = '__BREP_PLUGIN_ENABLED__';
+
+export function getSavedPluginUrls() {
+  try {
+    const raw = LS.getItem(STORAGE_KEY);
+    if (!raw) return [];
+    const arr = JSON.parse(raw);
+    if (!Array.isArray(arr)) return [];
+    return arr.map(s => String(s || '').trim()).filter(Boolean);
+  } catch { return []; }
+}
+
+export function savePluginUrls(urls) {
+  try { LS.setItem(STORAGE_KEY, JSON.stringify((urls || []).map(s => String(s || '').trim()).filter(Boolean))); } catch { }
+}
+
+// Enabled/disabled state per plugin URL. Defaults to enabled if missing.
+export function getPluginEnabledMap() {
+  try {
+    const raw = LS.getItem(STORAGE_ENABLED_KEY);
+    if (!raw) return {};
+    const obj = JSON.parse(raw);
+    return (obj && typeof obj === 'object') ? obj : {};
+  } catch { return {}; }
+}
+
+export function savePluginEnabledMap(map) {
+  try {
+    const obj = (map && typeof map === 'object') ? map : {};
+    LS.setItem(STORAGE_ENABLED_KEY, JSON.stringify(obj));
+  } catch { }
+}
+
+export function setPluginEnabled(url, enabled) {
+  try {
+    const m = getPluginEnabledMap();
+    if (!url) return;
+    m[String(url)] = Boolean(enabled);
+    savePluginEnabledMap(m);
+  } catch { }
+}
+
+export async function loadSavedPlugins(viewer) {
+  const urls = getSavedPluginUrls();
+  if (!urls.length) return [];
+  const enabled = getPluginEnabledMap();
+  // Default to enabled when state not yet saved
+  const urlsToLoad = urls.filter(u => enabled[u] !== false);
+  return loadPlugins(viewer, urlsToLoad);
+}

package/src/pmi/PMIViewsManager.js

@@ -0,0 +1,134 @@
+// PMIViewsManager.js
+// Encapsulates storage and lifecycle for PMI views associated with a PartHistory instance.
+
+import { deepClone } from '../utils/deepClone.js';
+
+export class PMIViewsManager {
+  constructor(partHistory) {
+    this.partHistory = partHistory || null;
+    this.views = [];
+    this._listeners = new Set();
+  }
+
+  reset() {
+    this.views = [];
+    this._emit();
+  }
+
+  getViews() {
+    this._normalizeViewsArray(this.views);
+    return this.views;
+  }
+
+  setViews(views) {
+    const arr = Array.isArray(views) ? Array.from(views) : [];
+    this.views = arr;
+    this._normalizeViewsArray(this.views);
+    this._emit();
+    return this.views;
+  }
+
+  addView(view) {
+    const list = this.getViews();
+    const normalized = this._normalizeView(view, list.length);
+    list.push(normalized);
+    this._emit();
+    return normalized;
+  }
+
+  updateView(index, updater) {
+    const list = this.getViews();
+    const idx = Number(index);
+    if (!Number.isInteger(idx) || idx < 0 || idx >= list.length) return null;
+    const current = list[idx];
+    let next = current;
+    if (typeof updater === 'function') {
+      try {
+        const result = updater(current);
+        if (result && typeof result === 'object') {
+          next = result;
+        }
+      } catch {
+        // ignore updater errors
+      }
+    } else if (updater && typeof updater === 'object' && updater !== current) {
+      next = Object.assign({}, current, updater);
+    }
+    if (next !== current) {
+      list[idx] = next;
+    }
+    list[idx] = this._normalizeView(list[idx], idx);
+    this._emit();
+    return list[idx];
+  }
+
+  removeView(index) {
+    const list = this.getViews();
+    const idx = Number(index);
+    if (!Number.isInteger(idx) || idx < 0 || idx >= list.length) return null;
+    const [removed] = list.splice(idx, 1);
+    for (let i = 0; i < list.length; i++) {
+      list[i] = this._normalizeView(list[i], i);
+    }
+    this._emit();
+    return removed || null;
+  }
+
+  addListener(listener) {
+    if (typeof listener !== 'function') return () => {};
+    this._listeners.add(listener);
+    return () => {
+      try { this._listeners.delete(listener); } catch { }
+    };
+  }
+
+  removeListener(listener) {
+    if (typeof listener !== 'function') return;
+    try { this._listeners.delete(listener); } catch { }
+  }
+
+  notifyChanged() {
+    this._emit();
+  }
+
+  toSerializable() {
+    return this.getViews().map(view => deepClone(view));
+  }
+
+  _normalizeViewsArray(arrayRef) {
+    if (!Array.isArray(arrayRef)) {
+      this.views = [];
+      return this.views;
+    }
+    for (let i = 0; i < arrayRef.length; i++) {
+      arrayRef[i] = this._normalizeView(arrayRef[i], i);
+    }
+    return arrayRef;
+  }
+
+  _normalizeView(raw, index) {
+    const fallbackIndex = Number.isInteger(index) ? index : 0;
+    const view = (raw && typeof raw === 'object') ? raw : {};
+    const legacyName = typeof view.name === 'string' ? view.name.trim() : '';
+    const currentName = typeof view.viewName === 'string' ? view.viewName.trim() : '';
+    const finalName = currentName || legacyName || `View ${fallbackIndex + 1}`;
+    view.viewName = finalName;
+    view.name = finalName;
+
+    if (!Array.isArray(view.annotations)) view.annotations = [];
+    if (!view.camera || typeof view.camera !== 'object') view.camera = {};
+    if (!view.viewSettings || typeof view.viewSettings !== 'object') view.viewSettings = {};
+    if (view.annotationHistory && typeof view.annotationHistory !== 'object') {
+      delete view.annotationHistory;
+    }
+    return view;
+  }
+
+  _emit() {
+    if (!this._listeners || this._listeners.size === 0) return;
+    const views = this.getViews();
+    for (const listener of Array.from(this._listeners)) {
+      try { listener(views, this.partHistory || null); } catch { }
+    }
+  }
+}