brep-io-kernel 1.0.0

package/src/services/componentLibrary.js

@@ -0,0 +1,198 @@
+import JSZip from 'jszip';
+import { localStorage as LS } from '../idbStorage.js';
+
+export const MODEL_STORAGE_PREFIX = '__BREP_MODEL__:';
+
+function safeParse(json) {
+  try {
+    return JSON.parse(json);
+  } catch {
+    return null;
+  }
+}
+
+function decodeModelKey(key) {
+  try {
+    return decodeURIComponent(key.slice(MODEL_STORAGE_PREFIX.length));
+  } catch {
+    return key.slice(MODEL_STORAGE_PREFIX.length);
+  }
+}
+
+export function listComponentRecords() {
+  const items = [];
+  try {
+    for (let i = 0; i < LS.length; i++) {
+      const key = LS.key(i);
+      if (!key || !key.startsWith(MODEL_STORAGE_PREFIX)) continue;
+      const raw = LS.getItem(key);
+      if (!raw) continue;
+      const parsed = safeParse(raw);
+      if (!parsed || (!parsed.data3mf && !parsed.data)) continue;
+      const name = decodeModelKey(key);
+      items.push({
+        name,
+        savedAt: parsed.savedAt || null,
+        has3mf: typeof parsed.data3mf === 'string' && parsed.data3mf.length > 0,
+        record: parsed,
+      });
+    }
+  } catch {
+    // ignore storage issues
+  }
+
+  items.sort((a, b) => {
+    const aTime = a.savedAt ? Date.parse(a.savedAt) : 0;
+    const bTime = b.savedAt ? Date.parse(b.savedAt) : 0;
+    return bTime - aTime;
+  });
+
+  return items;
+}
+
+export function getComponentRecord(name) {
+  if (!name) return null;
+  const key = MODEL_STORAGE_PREFIX + encodeURIComponent(String(name));
+  try {
+    const raw = LS.getItem(key);
+    if (!raw) return null;
+    const parsed = safeParse(raw);
+    if (!parsed) return null;
+    return {
+      name,
+      savedAt: parsed.savedAt || null,
+      data3mf: typeof parsed.data3mf === 'string' ? parsed.data3mf : null,
+      data: parsed.data || null,
+      thumbnail: typeof parsed.thumbnail === 'string' ? parsed.thumbnail : null,
+    };
+  } catch {
+    return null;
+  }
+}
+
+export function base64ToUint8Array(b64) {
+  if (typeof b64 !== 'string' || b64.length === 0) return new Uint8Array();
+  let payload = b64;
+  if (payload.startsWith('data:') && payload.includes(';base64,')) {
+    payload = payload.split(';base64,')[1] || '';
+  }
+  try {
+    const binary = atob(payload);
+    const out = new Uint8Array(binary.length);
+    for (let i = 0; i < binary.length; i++) out[i] = binary.charCodeAt(i);
+    return out;
+  } catch {
+    return new Uint8Array();
+  }
+}
+
+export function uint8ArrayToBase64(uint8) {
+  if (!(uint8 instanceof Uint8Array) || uint8.length === 0) return '';
+  const chunk = 0x8000;
+  let binary = '';
+  for (let i = 0; i < uint8.length; i += chunk) {
+    const sub = uint8.subarray(i, i + chunk);
+    binary += String.fromCharCode.apply(null, sub);
+  }
+  return btoa(binary);
+}
+
+export function setComponentRecord(name, dataObj) {
+  if (!name) return;
+  const key = MODEL_STORAGE_PREFIX + encodeURIComponent(String(name));
+  try {
+    LS.setItem(key, JSON.stringify(dataObj || {}));
+  } catch {}
+}
+
+export function removeComponentRecord(name) {
+  if (!name) return;
+  const key = MODEL_STORAGE_PREFIX + encodeURIComponent(String(name));
+  try {
+    LS.removeItem(key);
+  } catch {}
+}
+
+export async function extractThumbnailFrom3MFBase64(b64) {
+  try {
+    if (!b64) return null;
+    let payload = b64;
+    if (payload.startsWith('data:') && payload.includes(';base64,')) {
+      payload = payload.split(';base64,')[1] || '';
+    }
+    const bytes = base64ToUint8Array(payload);
+    const zip = await JSZip.loadAsync(bytes.buffer);
+    const files = {};
+    Object.keys(zip.files || {}).forEach((p) => { files[p.toLowerCase()] = p; });
+
+    const readThumb = async (lfPath) => {
+      const real = files[lfPath];
+      if (!real) return null;
+      const mime = lfPath.endsWith('.png') ? 'image/png' : (lfPath.match(/\.(jpe?g)$/) ? 'image/jpeg' : 'application/octet-stream');
+      const imgU8 = await zip.file(real).async('uint8array');
+      return `data:${mime};base64,${uint8ArrayToBase64(imgU8)}`;
+    };
+
+    const relsRoot = files['_rels/.rels'];
+    if (relsRoot) {
+      try {
+        const relsXml = await zip.file(relsRoot).async('string');
+        const relRe = /<Relationship\s+[^>]*Type="[^"]*metadata\/thumbnail[^"]*"[^>]*>/ig;
+        const tgtRe = /Target="([^"]+)"/i;
+        let match;
+        while ((match = relRe.exec(relsXml))) {
+          const tag = match[0];
+          const tm = tgtRe.exec(tag);
+          if (tm && tm[1]) {
+            let target = tm[1];
+            if (target.startsWith('/')) target = target.replace(/^\/+/, '');
+            else target = target.replace(/^\/+/, '');
+            const lf = target.toLowerCase();
+            const thumb = await readThumb(lf);
+            if (thumb) return thumb;
+          }
+        }
+      } catch { /* ignore */ }
+    }
+
+    const relsModel = files['3d/_rels/3dmodel.model.rels'];
+    if (relsModel) {
+      try {
+        const relsXml = await zip.file(relsModel).async('string');
+        const relRe = /<Relationship\s+[^>]*Type="[^"]*metadata\/thumbnail[^"]*"[^>]*>/ig;
+        const tgtRe = /Target="([^"]+)"/i;
+        let match;
+        while ((match = relRe.exec(relsXml))) {
+          const tag = match[0];
+          const tm = tgtRe.exec(tag);
+          if (tm && tm[1]) {
+            let target = tm[1];
+            if (target.startsWith('/')) target = target.replace(/^\/+/, '');
+            else {
+              target = '3D/' + target;
+              target = target.replace(/(^|\/)\.{2}\/(?!\.{2}|$)/g, '/');
+              target = target.replace(/^\/+/, '');
+            }
+            const lf = target.toLowerCase();
+            const thumb = await readThumb(lf);
+            if (thumb) return thumb;
+          }
+        }
+      } catch { /* ignore */ }
+    }
+
+    let thumbPath = Object.keys(files).find((k) => k.startsWith('metadata/') && (k.endsWith('.png') || k.endsWith('.jpg') || k.endsWith('.jpeg')));
+    if (!thumbPath) {
+      thumbPath = Object.keys(files).find((k) => k.startsWith('thumbnails/') && (k.endsWith('.png') || k.endsWith('.jpg') || k.endsWith('.jpeg')));
+    }
+    if (thumbPath) {
+      const real = files[thumbPath];
+      const mime = thumbPath.endsWith('.png') ? 'image/png' : 'image/jpeg';
+      const imgU8 = await zip.file(real).async('uint8array');
+      return `data:${mime};base64,${uint8ArrayToBase64(imgU8)}`;
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}

package/src/tests/ConsoleCapture.js

@@ -0,0 +1,189 @@
+// ES6, zero-dependency, drop-in console interceptor.
+// Creates a capturing proxy for the global `console` on instantiation,
+// forwards everything to the original console, and lets you read/clear logs.
+//
+// Usage:
+//   import ConsoleCapture from './ConsoleCapture.js'
+//   const cap = new ConsoleCapture({ captureStack: false });
+//   console.log('hello');             // still prints
+//   cap.getLogs();                    // -> [{ level:'log', args:['hello'], ... }]
+//   cap.clearLogs();
+//   cap.pause(); cap.resume();        // toggle capture
+//   cap.restore();                    // put the original console back
+
+export class ConsoleCapture {
+  constructor(options = {}) {
+    this.options = {
+      captureStack: Boolean(options.captureStack),
+      withTimestamp: options.withTimestamp !== false, // default true
+      levels: options.levels || null, // e.g., ['log','warn','error']
+      maxEntries: Number.isFinite(options.maxEntries) ? options.maxEntries : Infinity,
+    };
+
+    this._orig = (typeof window !== 'undefined' ? window.console : console) || {};
+    this._installed = false;
+    this._capturing = true;
+    this._logs = [];
+    this._nextId = 1;
+
+    this._proxy = this._buildProxy();
+    this.install(); // start intercepting upon creation
+  }
+
+  // ---------------- Public API ----------------
+
+  install() {
+    if (this._installed) return;
+    const target = typeof window !== 'undefined' ? window : globalThis;
+    this._prevConsole = target.console;
+    target.console = this._proxy;
+    this._installed = true;
+  }
+
+  restore() {
+    if (!this._installed) return;
+    const target = typeof window !== 'undefined' ? window : globalThis;
+    target.console = this._prevConsole || this._orig;
+    this._installed = false;
+  }
+
+  pause() { this._capturing = false; }
+  resume() { this._capturing = true; }
+
+  getLogs(filter = {}) {
+    const { level, since, until } = filter;
+    return this._logs.filter(entry => {
+      if (level && entry.level !== level) return false;
+      if (since && entry.time && entry.time < since) return false;
+      if (until && entry.time && entry.time > until) return false;
+      return true;
+    }).slice(); // shallow copy
+  }
+
+  clearLogs() {
+    this._logs.length = 0;
+  }
+
+  // For symmetry with your example; same names, same behavior.
+  get logs() { return this.getLogs(); }
+  getLogsAll() { return this.getLogs(); }
+
+  // ---------------- Internal ----------------
+
+  _buildProxy() {
+    const orig = this._orig;
+    const proxy = {};
+
+    // Collect all property names (functions + others) from the original console
+    const names = new Set([
+      ...Object.getOwnPropertyNames(orig),
+      ...Object.keys(orig)
+    ]);
+
+    // Common console methods across browsers/environments
+    const knownMethods = [
+      'log','info','warn','error','debug','trace',
+      'group','groupCollapsed','groupEnd',
+      'table','time','timeEnd','timeLog',
+      'count','countReset','assert','clear','dir','dirxml'
+    ];
+    knownMethods.forEach(n => names.add(n));
+
+    // Bind/wrap every function; copy over non-functions.
+    for (const name of names) {
+      const desc = this._safeGetDescriptor(orig, name);
+      if (!desc) continue;
+
+      if (typeof desc.value === 'function') {
+        proxy[name] = this._wrapMethod(name, orig[name]);
+      } else if (desc.get || desc.set) {
+        // Recreate getters/setters to retain behavior
+        Object.defineProperty(proxy, name, {
+          configurable: true,
+          enumerable: desc.enumerable,
+          get: desc.get ? desc.get.bind(orig) : undefined,
+          set: desc.set ? desc.set.bind(orig) : undefined
+        });
+      } else {
+        // Copy primitives/objects as-is
+        try {
+          proxy[name] = orig[name];
+        } catch {
+          // Some environments may throw on access; ignore
+        }
+      }
+    }
+
+    // Make it obvious (optional)
+    Object.defineProperty(proxy, '__capturing__', {
+      value: true, enumerable: false
+    });
+
+    return proxy;
+  }
+
+  _safeGetDescriptor(obj, prop) {
+    try {
+      return Object.getOwnPropertyDescriptor(obj, prop);
+    } catch {
+      return null;
+    }
+  }
+
+  _wrapMethod(level, fn) {
+    const self = this;
+
+    // Respect optional level filtering
+    const levelAllowed =
+      !self.options.levels || self.options.levels.includes(level);
+
+    function wrapped(...args) {
+      // Special-case assert: only logs if first arg is falsy
+      const isAssert = level === 'assert';
+      const shouldCaptureAssert = isAssert ? !args[0] : true;
+
+      if (self._capturing && levelAllowed && shouldCaptureAssert) {
+        const entry = {
+          id: self._nextId++,
+          level,
+          args, // keep original values (objects by reference)
+        };
+        if (self.options.withTimestamp) {
+          entry.time = new Date();
+        }
+        if (self.options.captureStack) {
+          // Discard the first two lines (Error + this wrapper)
+          const stack = new Error().stack || '';
+          entry.stack = stack.split('\n').slice(2).join('\n');
+        }
+
+        // Enforce maxEntries as a ring buffer if set
+        if (self.options.maxEntries !== Infinity && self._logs.length >= self.options.maxEntries) {
+          self._logs.shift();
+        }
+        self._logs.push(entry);
+      }
+
+      // Forward to the original function (if it exists), preserving the original `this`
+      try {
+        if (typeof fn === 'function') {
+          return fn.apply(self._orig, args);
+        }
+      } catch (err) {
+        // If the original console throws, avoid breaking the app
+        try {
+          // Last-resort fallback to native console if available
+          return self._orig && typeof self._orig.log === 'function'
+            ? self._orig.log('ConsoleCapture forwarding error:', err)
+            : undefined;
+        } catch { /* ignore */ }
+      }
+      return undefined;
+    }
+
+    // Keep function name for nicer stacks (non-critical)
+    try { Object.defineProperty(wrapped, 'name', { value: `capture_${level}` }); } catch {}
+
+    return wrapped;
+  }
+}