brep-io-kernel 1.0.0

package/src/idbStorage.js

@@ -0,0 +1,254 @@
+/* idbStorage.js
+   Primary IndexedDB-backed app storage with a localStorage-like API.
+   - Synchronous reads via in-memory cache
+   - Async persistence to IndexedDB
+   - Same-tab + optional cross-tab change events
+*/
+
+const STORAGE_DB_NAME = '__LS_SHIM_DB__';
+const STORE_NAME = 'kv';
+const DB_VERSION = 1;
+const BC_NAME = '__BREP_STORAGE_BC__';
+
+const hasIndexedDB = typeof indexedDB !== 'undefined' && !!indexedDB.open;
+
+function toStringValue(v) {
+  // Match Web Storage semantics: everything is coerced to string
+  return v === undefined || v === null ? String(v) : String(v);
+}
+
+function tryDispatchStorageEvent(storage, { key, oldValue, newValue }) {
+  try {
+    if (typeof window !== 'undefined') {
+      let ev;
+      try {
+        ev = new StorageEvent('storage', {
+          key,
+          oldValue,
+          newValue,
+          url: window.location.href,
+          storageArea: storage,
+        });
+      } catch {
+        ev = new CustomEvent('storage', { detail: { key, oldValue, newValue } });
+      }
+      window.dispatchEvent(ev);
+    }
+  } catch {}
+}
+
+function promisifyRequest(req) {
+  return new Promise((resolve, reject) => {
+    req.onsuccess = () => resolve(req.result);
+    req.onerror = () => reject(req.error || new Error('IDB request failed'));
+  });
+}
+
+function openDB() {
+  return new Promise((resolve, reject) => {
+    const openReq = indexedDB.open(STORAGE_DB_NAME, DB_VERSION);
+    openReq.onupgradeneeded = () => {
+      const db = openReq.result;
+      if (!db.objectStoreNames.contains(STORE_NAME)) {
+        db.createObjectStore(STORE_NAME, { keyPath: 'key' });
+      }
+    };
+    openReq.onsuccess = () => resolve(openReq.result);
+    openReq.onerror = () => reject(openReq.error || new Error('Failed to open storage DB'));
+  });
+}
+
+function unwrapStoredValue(value) {
+  if (value && typeof value === 'object' && 'value' in value) return value.value;
+  return value;
+}
+
+async function idbGetAll(db) {
+  const tx = db.transaction([STORE_NAME], 'readonly');
+  const store = tx.objectStore(STORE_NAME);
+  if (store.getAll && store.getAllKeys) {
+    const [items, keys] = await Promise.all([promisifyRequest(store.getAll()), promisifyRequest(store.getAllKeys())]);
+    const out = new Map();
+    for (let i = 0; i < keys.length; i++) {
+      out.set(String(keys[i]), unwrapStoredValue(items[i]));
+    }
+    return out;
+  }
+  return new Promise((resolve, reject) => {
+    const out = new Map();
+    const req = store.openCursor();
+    req.onsuccess = (e) => {
+      const cursor = e.target.result;
+      if (cursor) {
+        out.set(String(cursor.key), unwrapStoredValue(cursor.value));
+        cursor.continue();
+      } else {
+        resolve(out);
+      }
+    };
+    req.onerror = () => reject(req.error || new Error('Cursor failed'));
+  });
+}
+
+async function idbPut(db, key, value) {
+  const tx = db.transaction([STORE_NAME], 'readwrite');
+  const store = tx.objectStore(STORE_NAME);
+  if (store.keyPath) {
+    store.put({ key, value });
+  } else {
+    store.put(value, key);
+  }
+  return new Promise((resolve, reject) => {
+    tx.oncomplete = () => resolve();
+    tx.onerror = () => reject(tx.error || new Error('IDB put failed'));
+  });
+}
+
+async function idbDelete(db, key) {
+  const tx = db.transaction([STORE_NAME], 'readwrite');
+  tx.objectStore(STORE_NAME).delete(key);
+  return new Promise((resolve, reject) => {
+    tx.oncomplete = () => resolve();
+    tx.onerror = () => reject(tx.error || new Error('IDB delete failed'));
+  });
+}
+
+async function idbClear(db) {
+  const tx = db.transaction([STORE_NAME], 'readwrite');
+  tx.objectStore(STORE_NAME).clear();
+  return new Promise((resolve, reject) => {
+    tx.oncomplete = () => resolve();
+    tx.onerror = () => reject(tx.error || new Error('IDB clear failed'));
+  });
+}
+
+class IdbStorage {
+  constructor() {
+    this._cache = new Map();
+    this._ready = false;
+    this._dbPromise = null;
+    this._bc = null;
+    this._idbEnabled = hasIndexedDB;
+    this._init();
+  }
+
+  async _init() {
+    if (!this._idbEnabled) {
+      this._ready = true;
+      return;
+    }
+
+    try {
+      this._dbPromise = openDB();
+      const db = await this._dbPromise;
+      const idbMap = await idbGetAll(db);
+      idbMap.forEach((v, k) => this._cache.set(k, toStringValue(v)));
+      this._setupBroadcast();
+    } catch (err) {
+      console.warn('[idb-storage] IndexedDB unavailable; using in-memory storage only.', err);
+      this._idbEnabled = false;
+    }
+
+    this._ready = true;
+  }
+
+  _setupBroadcast() {
+    try {
+      if (typeof BroadcastChannel !== 'undefined') {
+        this._bc = new BroadcastChannel(BC_NAME);
+        this._bc.onmessage = (ev) => {
+          const { type, key, newValue, oldValue } = ev.data || {};
+          if (type === 'set') {
+            const prev = this._cache.get(key) ?? null;
+            const next = toStringValue(newValue);
+            this._cache.set(key, next);
+            tryDispatchStorageEvent(this, { key, oldValue: prev, newValue: next });
+          } else if (type === 'remove') {
+            const prev = this._cache.get(key) ?? null;
+            this._cache.delete(key);
+            tryDispatchStorageEvent(this, { key, oldValue: prev, newValue: null });
+          } else if (type === 'clear') {
+            if (this._cache.size) {
+              this._cache.clear();
+              tryDispatchStorageEvent(this, { key: null, oldValue: null, newValue: null });
+            }
+          }
+        };
+      }
+    } catch {}
+  }
+
+  get length() {
+    return this._cache.size;
+  }
+
+  key(n) {
+    if (typeof n !== 'number' || n < 0 || n >= this._cache.size) return null;
+    return Array.from(this._cache.keys())[n] ?? null;
+  }
+
+  getItem(key) {
+    const k = toStringValue(key);
+    const v = this._cache.get(k);
+    return v === undefined ? null : v;
+  }
+
+  setItem(key, value) {
+    const k = toStringValue(key);
+    const v = toStringValue(value);
+    const oldValue = this._cache.get(k) ?? null;
+    this._cache.set(k, v);
+
+    if (this._idbEnabled) {
+      this._dbPromise?.then((db) => idbPut(db, k, v)).catch((e) => {
+        console.warn('[idb-storage] setItem persist failed:', e);
+      });
+    }
+
+    tryDispatchStorageEvent(this, { key: k, oldValue, newValue: v });
+    try { this._bc?.postMessage({ type: 'set', key: k, newValue: v, oldValue }); } catch {}
+  }
+
+  removeItem(key) {
+    const k = toStringValue(key);
+    const oldValue = this._cache.get(k) ?? null;
+    this._cache.delete(k);
+
+    if (this._idbEnabled) {
+      this._dbPromise?.then((db) => idbDelete(db, k)).catch((e) => {
+        console.warn('[idb-storage] removeItem persist failed:', e);
+      });
+    }
+
+    tryDispatchStorageEvent(this, { key: k, oldValue, newValue: null });
+    try { this._bc?.postMessage({ type: 'remove', key: k, oldValue, newValue: null }); } catch {}
+  }
+
+  clear() {
+    if (this._cache.size === 0) return;
+    this._cache.clear();
+
+    if (this._idbEnabled) {
+      this._dbPromise?.then((db) => idbClear(db)).catch((e) => {
+        console.warn('[idb-storage] clear persist failed:', e);
+      });
+    }
+
+    tryDispatchStorageEvent(this, { key: null, oldValue: null, newValue: null });
+    try { this._bc?.postMessage({ type: 'clear' }); } catch {}
+  }
+
+  *keys() {
+    yield* this._cache.keys();
+  }
+
+  ready() {
+    if (!this._idbEnabled) return Promise.resolve();
+    if (this._ready) return Promise.resolve();
+    return this._dbPromise.then(() => undefined).catch(() => undefined);
+  }
+}
+
+const localStorage = new IdbStorage();
+
+export { localStorage };

package/src/index.js

@@ -0,0 +1,12 @@
+// Public entry point for the BREP kernel package
+// Expose the core BREP kernel and part history classes
+
+export { BREP } from './BREP/BREP.js';
+
+// Part history API
+export { PartHistory, extractDefaultValues } from './PartHistory.js';
+
+// Assembly constraints history and registry (useful when working with PartHistory)
+export { AssemblyConstraintHistory } from './assemblyConstraints/AssemblyConstraintHistory.js';
+export { AssemblyConstraintRegistry } from './assemblyConstraints/AssemblyConstraintRegistry.js';
+

package/src/main.js

@@ -0,0 +1,15 @@
+// App entry: create the main Viewer and expose as window.env
+import { Viewer } from './UI/viewer.js';
+
+const containerEl = document.getElementById('viewport');
+const sidebarEl = document.getElementById('sidebar');
+
+if (!containerEl) throw new Error('Missing #viewport element');
+
+const viewer = new Viewer({ container: containerEl, sidebar: sidebarEl });
+
+try { window.env = viewer; } catch {}
+
+// Viewer registers default toolbar buttons internally; the "tests" button
+// loads the Browser Testing UI on demand.
+

package/src/metadataManager.js

@@ -0,0 +1,64 @@
+// this will be used to store information against items in the scene that could be used to capture things like
+// material assignments, layer assignments, grouping information, etc.
+// For example if there is a particular type of weld that needs to be applied allong a particular edge, that information
+// could be stored here
+// This is a simple key/value store, where the key is the name of the object in the scene, and the value is an object
+// containing key/value pairs of metadata. There is also support for inheritance, so that if an object has an attribute
+// called "inheritsFrom", it will look up the metadata for that object and merge it with its own metadata, giving precedence
+// to its own metadata in case of inheritance giving precedence to its own metadata in case of conflicts.
+
+
+export class MetadataManager {
+    constructor() {
+        this.metadata = {};
+    }
+
+    getMetadata(targetObjectName) {
+        // look up the metadata for the given object name
+        const metadataForTarget = this.metadata[targetObjectName] || {};
+
+        // check if there is an attribute called inheritsFrom
+        if (metadataForTarget.inheritsFrom) {
+            const parentMetadata = this.getMetadata(metadataForTarget.inheritsFrom);
+            // merge parent metadata with current metadata, giving precedence to current metadata
+            return { ...parentMetadata, ...metadataForTarget };
+        }
+
+        return metadataForTarget;
+    }
+
+    getOwnMetadata(targetObjectName) {
+        // shallow clone to avoid exposing internal references
+        const raw = this.metadata[targetObjectName];
+        return raw ? { ...raw } : {};
+    }
+
+    setMetadata(targetObjectName, keyName, value) {
+        // grab the current metadata for the target object, or create a new object if it doesn't exist
+        if (!this.metadata[targetObjectName]) {
+            this.metadata[targetObjectName] = {};
+        }
+        this.metadata[targetObjectName][keyName] = value;
+    }
+
+    setMetadataObject(targetObjectName, metadataObject) {
+        if (metadataObject && Object.keys(metadataObject).length > 0) {
+            this.metadata[targetObjectName] = { ...metadataObject };
+        } else {
+            delete this.metadata[targetObjectName];
+        }
+    }
+
+    deleteMetadataKey(targetObjectName, keyName) {
+        const entry = this.metadata[targetObjectName];
+        if (!entry) return;
+        delete entry[keyName];
+        if (Object.keys(entry).length === 0) {
+            delete this.metadata[targetObjectName];
+        }
+    }
+
+    clearMetadata(targetObjectName) {
+        delete this.metadata[targetObjectName];
+    }
+}

package/src/path.proxy.js

@@ -0,0 +1,277 @@
+// universal-path.js (ESM, no dependencies, ES6)
+// POSIX-only path replacement that works in Node and the browser.
+// Node: proxies to node:path.posix when possible (CJS); falls back to shim in ESM.
+// Browser: minimal POSIX path implementation compatible with Node's API.
+
+const isNode =
+  typeof process !== 'undefined' &&
+  process.versions &&
+  process.versions.node &&
+  typeof window === 'undefined';
+
+// -------------------- Node path passthrough (POSIX) --------------------
+let nodePosix = null;
+async function loadNodePathIfNeeded() {
+  if (!isNode) return;
+  if (!nodePosix) {
+    const mod = await import('node:path');
+    nodePosix = (mod.default ?? mod).posix;
+  }
+}
+
+// IMPORTANT: Never assume `require` exists in ESM.
+// In CJS we use `require('node:path')`; in ESM we fall back to the shim.
+function getNodePosixSync() {
+  if (!isNode) return browserPosix;
+
+  // CJS: require is available
+  /* eslint-disable no-undef */
+  if (typeof require === 'function') {
+    const mod = require('node:path');
+    return (mod.default ?? mod).posix;
+  }
+  /* eslint-enable no-undef */
+
+  // Some runtimes expose module.createRequire in CJS-like contexts
+  if (typeof module !== 'undefined' && module && typeof module.createRequire === 'function') {
+    const req = module.createRequire(typeof __filename !== 'undefined' ? __filename : process.cwd());
+    const mod = req('node:path');
+    return (mod.default ?? mod).posix;
+  }
+
+  // Pure ESM: no sync loader available - use the shim (POSIX semantics).
+  return browserPosix;
+}
+
+// -------------------- Browser POSIX implementation --------------------
+const SEP = '/';
+const DELIM = ':';
+
+function _assertString(p) {
+  if (typeof p !== 'string') throw new TypeError('Path must be a string');
+}
+
+function _isAbsolute(p) {
+  return p.startsWith(SEP);
+}
+
+function _normalizeString(path, allowAboveRoot) {
+  const parts = path.split('/');
+  const newParts = [];
+  for (let i = 0; i < parts.length; i++) {
+    const part = parts[i];
+    if (!part || part === '.') continue;
+    if (part === '..') {
+      if (newParts.length && newParts[newParts.length - 1] !== '..') {
+        newParts.pop();
+      } else if (allowAboveRoot) {
+        newParts.push('..');
+      }
+    } else {
+      newParts.push(part);
+    }
+  }
+  return newParts.join('/');
+}
+
+function _normalize(path) {
+  _assertString(path);
+  if (path === '') return '.';
+  const isAbs = _isAbsolute(path);
+  const trailingSlash = path.endsWith('/');
+  let res = _normalizeString(path, !isAbs);
+  if (res === '' && !isAbs) res = '.';
+  if (res !== '' && trailingSlash) res += '/';
+  return (isAbs ? '/' : '') + res;
+}
+
+function _join(...paths) {
+  let joined = '';
+  for (let i = 0; i < paths.length; i++) {
+    const segment = paths[i];
+    _assertString(segment);
+    if (segment !== '') {
+      if (joined === '') joined = segment;
+      else joined += '/' + segment;
+    }
+  }
+  return _normalize(joined);
+}
+
+function _resolve(...paths) {
+  // For browser & ESM fallback: base is '/', to match VFS root
+  let resolvedPath = '';
+  let resolvedAbsolute = false;
+
+  for (let i = paths.length - 1; i >= 0; i--) {
+    const p = paths[i];
+    if (p === undefined) continue;
+    _assertString(p);
+    if (p === '') continue;
+    resolvedPath = p + '/' + resolvedPath;
+    if (p.startsWith('/')) {
+      resolvedAbsolute = true;
+      break;
+    }
+  }
+
+  if (!resolvedAbsolute) {
+    resolvedPath = '/' + resolvedPath;
+    resolvedAbsolute = true;
+  }
+
+  const normalized = _normalizeString(resolvedPath, false);
+  return (resolvedAbsolute ? '/' : '') + normalized || (resolvedAbsolute ? '/' : '.');
+}
+
+function _relative(from, to) {
+  _assertString(from); _assertString(to);
+  if (from === to) return '';
+  from = _resolve(from);
+  to = _resolve(to);
+
+  if (from === to) return '';
+
+  const fromParts = from.slice(1).split('/').filter(Boolean);
+  const toParts = to.slice(1).split('/').filter(Boolean);
+
+  let i = 0;
+  const len = Math.min(fromParts.length, toParts.length);
+  for (; i < len; i++) {
+    if (fromParts[i] !== toParts[i]) break;
+  }
+
+  const up = fromParts.slice(i).map(() => '..');
+  const down = toParts.slice(i);
+  const rel = up.concat(down).join('/');
+  return rel || '';
+}
+
+function _dirname(path) {
+  _assertString(path);
+  if (path.length === 0) return '.';
+  const isAbs = _isAbsolute(path);
+  const end = path.endsWith('/') ? path.length - 1 : path.length;
+  let slashIndex = -1;
+  for (let i = end - 1; i >= 0; --i) {
+    if (path.charCodeAt(i) === 47) { slashIndex = i; break; }
+  }
+  if (slashIndex === -1) return isAbs ? '/' : '.';
+  if (isAbs && slashIndex === 0) return '/';
+  return path.slice(0, slashIndex);
+}
+
+function _basename(path, ext = '') {
+  _assertString(path);
+  if (ext !== undefined && typeof ext !== 'string') throw new TypeError('ext must be a string');
+  let end = path.length;
+  if (end === 0) return '';
+  while (end > 0 && path.charCodeAt(end - 1) === 47) end--;
+  if (end === 0) return '/';
+
+  let start = 0;
+  for (let i = end - 1; i >= 0; --i) {
+    if (path.charCodeAt(i) === 47) { start = i + 1; break; }
+  }
+  let base = path.slice(start, end);
+  if (ext && base.endsWith(ext) && ext !== '' && ext !== base) {
+    base = base.slice(0, base.length - ext.length);
+  }
+  return base;
+}
+
+function _extname(path) {
+  _assertString(path);
+  let startDot = -1;
+  let startPart = 0;
+  let end = -1;
+  let preDotState = 0;
+  for (let i = path.length - 1; i >= 0; --i) {
+    const code = path.charCodeAt(i);
+    if (code === 47) {
+      if (end !== -1) { startPart = i + 1; break; }
+      continue;
+    }
+    if (end === -1) end = i + 1;
+    if (code === 46) {
+      if (startDot === -1) startDot = i;
+      else if (preDotState !== 1) preDotState = 1;
+    } else if (startDot !== -1) {
+      preDotState = -1;
+    }
+  }
+  if (startDot === -1 || end === -1 || preDotState === 0 || (startDot === startPart)) return '';
+  return path.slice(startDot, end);
+}
+
+function _parse(path) {
+  _assertString(path);
+  const root = _isAbsolute(path) ? '/' : '';
+  const dir = _dirname(path);
+  const base = _basename(path);
+  const ext = _extname(base);
+  const name = ext ? base.slice(0, base.length - ext.length) : base;
+  return { root, dir, base, ext, name };
+}
+
+function _format(obj) {
+  const dir = obj.dir || obj.root || '';
+  const base = obj.base || (obj.name || '') + (obj.ext || '');
+  if (!dir) return base || '.';
+  if (dir.endsWith('/')) return dir + base;
+  return dir + '/' + base;
+}
+
+function _toNamespacedPath(p) { return p; }
+
+// The browser POSIX object (also used as Node ESM fallback)
+const browserPosix = {
+  sep: SEP,
+  delimiter: DELIM,
+  normalize: _normalize,
+  join: _join,
+  resolve: _resolve,
+  isAbsolute: _isAbsolute,
+  relative: _relative,
+  dirname: _dirname,
+  basename: _basename,
+  extname: _extname,
+  parse: _parse,
+  format: _format,
+  toNamespacedPath: _toNamespacedPath,
+  posix: null, // set below
+  win32: null, // shimbed
+};
+browserPosix.posix = browserPosix;
+
+// -------------------- Unified export --------------------
+const universalPosix = {
+  get sep() { return isNode ? getNodePosixSync().sep : browserPosix.sep; },
+  get delimiter() { return isNode ? getNodePosixSync().delimiter : browserPosix.delimiter; },
+
+  normalize: (...args) => isNode ? getNodePosixSync().normalize(...args) : browserPosix.normalize(...args),
+  join: (...args) => isNode ? getNodePosixSync().join(...args) : browserPosix.join(...args),
+  resolve: (...args) => isNode ? getNodePosixSync().resolve(...args) : browserPosix.resolve(...args),
+  isAbsolute: (...args) => isNode ? getNodePosixSync().isAbsolute(...args) : browserPosix.isAbsolute(...args),
+  relative: (...args) => isNode ? getNodePosixSync().relative(...args) : browserPosix.relative(...args),
+  dirname: (...args) => isNode ? getNodePosixSync().dirname(...args) : browserPosix.dirname(...args),
+  basename: (...args) => isNode ? getNodePosixSync().basename(...args) : browserPosix.basename(...args),
+  extname: (...args) => isNode ? getNodePosixSync().extname(...args) : browserPosix.extname(...args),
+  parse: (...args) => isNode ? getNodePosixSync().parse(...args) : browserPosix.parse(...args),
+  format: (...args) => isNode ? getNodePosixSync().format(...args) : browserPosix.format(...args),
+  toNamespacedPath: (...args) => isNode ? getNodePosixSync().toNamespacedPath(...args) : browserPosix.toNamespacedPath(...args),
+
+  posix: null,
+  win32: null,
+};
+
+universalPosix.posix = universalPosix;
+const win32Shim = new Proxy({}, {
+  get() {
+    throw new Error("POSIX-only path module: use the named export `posix` with your VFS.");
+  }
+});
+universalPosix.win32 = win32Shim;
+export const posix = universalPosix;
+export const win32 = win32Shim;
+export const ensureNodePathLoaded = loadNodePathIfNeeded;