brep-io-kernel 1.0.0

package/src/tools/assemblyConstraintDialogCapturePage.js

@@ -0,0 +1,56 @@
+import { AssemblyConstraintRegistry } from '../assemblyConstraints/AssemblyConstraintRegistry.js';
+import { renderDialogCapturePage } from './dialogCapturePageFactory.js';
+
+const registry = new AssemblyConstraintRegistry();
+
+const entries = registry.list()
+  .filter(Boolean)
+  .map((ConstraintClass) => {
+    const displayName = pickName(
+      ConstraintClass.longName,
+      ConstraintClass.constraintName,
+      ConstraintClass.name,
+      'Constraint',
+    );
+    const shortName = pickName(
+      ConstraintClass.shortName,
+      ConstraintClass.constraintShortName,
+      ConstraintClass.constraintType,
+      displayName,
+      'Constraint',
+    );
+    const schema = (ConstraintClass && typeof ConstraintClass.inputParamsSchema === 'object')
+      ? ConstraintClass.inputParamsSchema
+      : {};
+    const initialParams = buildConstraintParams(schema, shortName);
+    return {
+      displayName,
+      shortName,
+      captureName: displayName,
+      schema,
+      initialParams,
+    };
+  });
+
+renderDialogCapturePage({
+  title: 'Assembly Constraint Dialog Reference',
+  description: 'Dialogs for built-in assembly constraints captured from the constraint registry.',
+  entries,
+});
+
+function pickName(...values) {
+  for (const value of values) {
+    if (value == null && value !== 0) continue;
+    const str = String(value).trim();
+    if (str.length) return str;
+  }
+  return 'Constraint';
+}
+
+function buildConstraintParams(schema, shortName) {
+  if (!schema || typeof schema !== 'object') return {};
+  const idKey = Object.keys(schema).find((key) => key.toLowerCase() === 'constraintid');
+  if (!idKey) return {};
+  const safe = String(shortName || 'constraint').replace(/[^a-z0-9._-]+/gi, '_');
+  return { [idKey]: `${safe}-constraint` };
+}

package/src/tools/dialogCapturePageFactory.js

@@ -0,0 +1,227 @@
+import { SchemaForm } from '../UI/featureDialogs.js';
+
+let stylesInjected = false;
+
+const DEFAULT_DESCRIPTION = 'Dialogs are rendered live using SchemaForm. Use the automated capture script to export PNGs.';
+
+export function renderDialogCapturePage({
+  title = 'Dialog Reference',
+  description = DEFAULT_DESCRIPTION,
+  entries = [],
+} = {}) {
+  injectPageStyles();
+
+  const appRoot = document.getElementById('app') || document.body;
+  appRoot.classList.add('dialog-capture-page');
+  appRoot.innerHTML = '';
+
+  const header = document.createElement('header');
+  header.className = 'dialog-capture-header';
+  header.innerHTML = `
+    <h1>${escapeHtml(title)}</h1>
+    <p>${escapeHtml(description || DEFAULT_DESCRIPTION)}</p>
+  `;
+
+  const grid = document.createElement('section');
+  grid.className = 'dialog-capture-grid';
+
+  entries.forEach((entry) => {
+    const displayName = formatName(entry?.displayName, 'Dialog');
+    const shortName = formatName(entry?.shortName, displayName || 'Dialog');
+    const captureName = entry?.captureName
+      ? formatName(entry.captureName, displayName)
+      : displayName;
+
+    const params = clone(entry?.initialParams) || {};
+    const schema = sanitizeSchema(entry?.schema);
+    const options = entry?.formOptions && typeof entry.formOptions === 'object'
+      ? entry.formOptions
+      : undefined;
+
+    let formHost = null;
+    try {
+      const form = new SchemaForm(schema, params, options);
+      try { form.refreshFromParams?.(); } catch { /* ignore */ }
+      formHost = form.uiElement;
+      try {
+        if (formHost) {
+          formHost.style.width = '100%';
+          formHost.style.maxWidth = '100%';
+        }
+      } catch {
+        /* ignore width styling errors */
+      }
+    } catch (error) {
+      formHost = buildErrorState(error);
+    }
+
+    const card = document.createElement('article');
+    card.className = 'dialog-card';
+    card.dataset.featureName = captureName;
+    card.dataset.featureShortName = shortName;
+
+    const head = document.createElement('div');
+    head.className = 'dialog-card-head';
+
+    const badge = document.createElement('span');
+    badge.className = 'dialog-short';
+    badge.textContent = shortName;
+
+    const titleEl = document.createElement('h2');
+    titleEl.className = 'dialog-title';
+    titleEl.textContent = displayName;
+
+    head.append(badge, titleEl);
+
+    const formWrap = document.createElement('div');
+    formWrap.className = 'dialog-form';
+    if (formHost) {
+      formWrap.appendChild(formHost);
+    } else {
+      formWrap.appendChild(buildErrorState(new Error('Form host missing')));
+    }
+
+    card.append(head, formWrap);
+    grid.appendChild(card);
+  });
+
+  appRoot.append(header, grid);
+}
+
+function sanitizeSchema(schema) {
+  if (!schema || typeof schema !== 'object') return {};
+  return schema;
+}
+
+function formatName(value, fallback = '') {
+  if (value == null && value !== 0) return fallback;
+  const trimmed = String(value).trim();
+  return trimmed.length ? trimmed : fallback;
+}
+
+function clone(value) {
+  if (Array.isArray(value)) {
+    return value.map((item) => clone(item));
+  }
+  if (value && typeof value === 'object') {
+    const out = {};
+    for (const key of Object.keys(value)) {
+      out[key] = clone(value[key]);
+    }
+    return out;
+  }
+  return value;
+}
+
+function buildErrorState(error) {
+  const container = document.createElement('div');
+  container.className = 'dialog-error';
+  container.textContent = `Failed to render: ${error?.message || error || 'Unknown error'}`;
+  return container;
+}
+
+function escapeHtml(value) {
+  return String(value ?? '')
+    .replace(/&/g, '&amp;')
+    .replace(/</g, '&lt;')
+    .replace(/>/g, '&gt;')
+    .replace(/"/g, '&quot;')
+    .replace(/'/g, '&#39;');
+}
+
+function injectPageStyles() {
+  if (stylesInjected) return;
+  stylesInjected = true;
+    const style = document.createElement('style');
+    style.textContent = `
+    :root {
+      color-scheme: dark;
+      font-family: ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas, "Liberation Mono", "Courier New", monospace;
+      background: #05070d;
+      color: #e5ecff;
+    }
+    body {
+      margin: 0;
+      padding: 32px;
+      min-height: 100vh;
+      background: radial-gradient(circle at top, rgba(19,27,47,0.75), rgba(8,11,20,1) 55%);
+      display: flex;
+      justify-content: center;
+    }
+    .dialog-capture-page {
+      width: min(1040px, 100%);
+    }
+    .dialog-capture-header {
+      text-align: center;
+      margin-bottom: 32px;
+    }
+    .dialog-capture-header h1 {
+      margin: 0 0 12px 0;
+      font-size: clamp(26px, 4vw, 38px);
+      font-weight: 600;
+      letter-spacing: -0.01em;
+    }
+    .dialog-capture-header p {
+      margin: 0;
+      color: #94a3b8;
+      font-size: 14px;
+    }
+    .dialog-capture-grid {
+      display: flex;
+      flex-direction: column;
+      gap: 32px;
+      padding-bottom: 80px;
+    }
+    .dialog-card {
+      background: rgba(13,17,27,0.92);
+      border-radius: 18px;
+      border: 1px solid rgba(71,85,105,0.42);
+      padding: 24px;
+      box-shadow: 0 20px 40px rgba(0,0,0,0.45);
+      display: flex;
+      flex-direction: column;
+      gap: 20px;
+    }
+    .dialog-card-head {
+      display: flex;
+      align-items: baseline;
+      gap: 14px;
+    }
+    .dialog-short {
+      display: inline-flex;
+      align-items: center;
+      justify-content: center;
+      min-width: 64px;
+      padding: 4px 14px;
+      border-radius: 999px;
+      border: 1px solid rgba(96, 165, 250, 0.45);
+      background: rgba(51, 65, 85, 0.45);
+      color: #cbd5ff;
+      font-weight: 600;
+      letter-spacing: 0.08em;
+      font-size: 13px;
+      text-transform: uppercase;
+    }
+    .dialog-title {
+      margin: 0;
+      font-size: 20px;
+      font-weight: 600;
+      color: #f8fafc;
+    }
+    .dialog-form {
+      background: #0b0f16;
+      width: 300px;
+      border-radius: 16px;
+      padding: 20px;
+      border: 1px solid rgba(59,77,109,0.45);
+      box-shadow: inset 0 0 0 1px rgba(71,85,105,0.18);
+      box-sizing: border-box;
+    }
+    .dialog-error {
+      font-size: 13px;
+      color: #f87171;
+      line-height: 1.4;
+    }
+  `;
+  document.head.appendChild(style);
+}

package/src/tools/featureDialogCapturePage.js

@@ -0,0 +1,47 @@
+import { FeatureRegistry } from '../FeatureRegistry.js';
+import { renderDialogCapturePage } from './dialogCapturePageFactory.js';
+
+const registry = new FeatureRegistry();
+
+const entries = registry.features
+  .filter(Boolean)
+  .map((FeatureClass) => {
+    const featureName = pickName(FeatureClass.longName, FeatureClass.featureName, FeatureClass.name, 'Feature');
+    const shortName = pickName(FeatureClass.shortName, FeatureClass.featureShortName, featureName, 'Feature');
+    const schema = (FeatureClass && typeof FeatureClass.inputParamsSchema === 'object')
+      ? FeatureClass.inputParamsSchema
+      : {};
+    const initialParams = buildFeatureParams(schema, shortName);
+    return {
+      displayName: featureName,
+      shortName,
+      captureName: featureName,
+      schema,
+      initialParams,
+    };
+  });
+
+renderDialogCapturePage({
+  title: 'Feature Dialog Reference',
+  description: 'Dialogs are rendered live using SchemaForm. Use the automated capture script to export PNGs.',
+  entries,
+});
+
+function pickName(...values) {
+  for (const value of values) {
+    if (value == null && value !== 0) continue;
+    const str = String(value).trim();
+    if (str.length) return str;
+  }
+  return 'Feature';
+}
+
+function buildFeatureParams(schema, shortName) {
+  if (!schema || typeof schema !== 'object') return {};
+  let key = null;
+  if (Object.prototype.hasOwnProperty.call(schema, 'id')) key = 'id';
+  else if (Object.prototype.hasOwnProperty.call(schema, 'featureID')) key = 'featureID';
+  if (!key) return {};
+  const fallback = String(shortName || 'feature').replace(/[^a-z0-9._-]+/gi, '_');
+  return { [key]: `${fallback}-capture` };
+}

package/src/tools/pmiAnnotationDialogCapturePage.js

@@ -0,0 +1,60 @@
+import { annotationRegistry } from '../UI/pmi/AnnotationRegistry.js';
+import { renderDialogCapturePage } from './dialogCapturePageFactory.js';
+
+const handlers = annotationRegistry.list();
+
+const entries = handlers
+  .filter(Boolean)
+  .map((Handler) => {
+    const displayName = pickName(
+      Handler.longName,
+      Handler.title,
+      Handler.featureName,
+      Handler.name,
+      'Annotation',
+    );
+    const shortName = pickName(
+      Handler.shortName,
+      Handler.featureShortName,
+      Handler.type,
+      displayName,
+      'Annotation',
+    );
+    const schema = (Handler && typeof Handler.inputParamsSchema === 'object')
+      ? Handler.inputParamsSchema
+      : {};
+    const initialParams = buildAnnotationParams(schema, shortName);
+    return {
+      displayName,
+      shortName,
+      captureName: displayName,
+      schema,
+      initialParams,
+    };
+  });
+
+renderDialogCapturePage({
+  title: 'PMI Annotation Dialog Reference',
+  description: 'PMI annotation dialogs rendered directly from the annotation registry.',
+  entries,
+});
+
+function pickName(...values) {
+  for (const value of values) {
+    if (value == null && value !== 0) continue;
+    const str = String(value).trim();
+    if (str.length) return str;
+  }
+  return 'Annotation';
+}
+
+function buildAnnotationParams(schema, shortName) {
+  if (!schema || typeof schema !== 'object') return {};
+  const idKey = Object.keys(schema).find((key) => {
+    const lower = key.toLowerCase();
+    return lower === 'id' || lower === 'annotationid';
+  });
+  if (!idKey) return {};
+  const safe = String(shortName || 'annotation').replace(/[^a-z0-9._-]+/gi, '_');
+  return { [idKey]: `${safe}-annotation` };
+}

package/src/utils/axisHelpers.js

@@ -0,0 +1,99 @@
+import { BREP } from "../BREP/BREP.js";
+import { Line2, LineGeometry, LineMaterial } from "three/examples/jsm/Addons.js";
+
+const THREE = BREP.THREE;
+
+export const DEFAULT_AXIS_HELPER_PX = 70;
+
+const DEFAULT_AXIS_COLORS = {
+  x: 0xff4d4d,
+  y: 0x4dff4d,
+  z: 0x4d7dff,
+};
+
+function buildAxisLine({
+  axis,
+  dir,
+  color,
+  name,
+  selectable,
+  lineWidth,
+  depthTest,
+  opacity,
+  renderOrder,
+}) {
+  const geom = new LineGeometry();
+  geom.setPositions([0, 0, 0, dir[0], dir[1], dir[2]]);
+  const mat = new LineMaterial({
+    color,
+    linewidth: lineWidth,
+    transparent: true,
+    opacity,
+    dashed: false,
+    worldUnits: false,
+    depthTest,
+    depthWrite: false,
+  });
+
+  let line = null;
+  if (selectable) {
+    line = new BREP.Edge(geom);
+    line.material = mat;
+  } else {
+    line = new Line2(geom, mat);
+    line.type = "AXIS_HELPER";
+  }
+
+  line.name = `${name}:${axis}`;
+  line.renderOrder = renderOrder;
+  line.userData = line.userData || {};
+  line.userData.axisHelperAxis = axis;
+  line.userData.__baseMaterial = mat;
+  line.userData.__defaultMaterial = mat;
+  line.userData.polylineLocal = [
+    [0, 0, 0],
+    [dir[0], dir[1], dir[2]],
+  ];
+  line.userData.polylineWorld = false;
+  return line;
+}
+
+export function createAxisHelperGroup(options = {}) {
+  const {
+    name = "AxisHelper",
+    selectable = false,
+    axisHelperPx = DEFAULT_AXIS_HELPER_PX,
+    lineWidth = 2,
+    depthTest = false,
+    opacity = 1,
+    renderOrder = 1000,
+    colors = DEFAULT_AXIS_COLORS,
+  } = options;
+
+  const group = new THREE.Group();
+  group.name = name;
+  group.userData = group.userData || {};
+  group.userData.axisHelper = true;
+  group.userData.axisHelperPx = Number.isFinite(axisHelperPx)
+    ? axisHelperPx
+    : DEFAULT_AXIS_HELPER_PX;
+  group.userData.axisHelperCompensateScale = true;
+  group.userData.excludeFromFit = true;
+
+  const base = {
+    name,
+    selectable,
+    lineWidth,
+    depthTest,
+    opacity,
+    renderOrder,
+  };
+
+  group.add(
+    buildAxisLine({ axis: "X", dir: [1, 0, 0], color: colors.x, ...base }),
+    buildAxisLine({ axis: "Y", dir: [0, 1, 0], color: colors.y, ...base }),
+    buildAxisLine({ axis: "Z", dir: [0, 0, 1], color: colors.z, ...base }),
+  );
+
+  return group;
+}

package/src/utils/deepClone.js

@@ -0,0 +1,69 @@
+// deepClone.js
+// Shared deep clone utility for plain objects, arrays, Maps/Sets, and simple primitives.
+
+function clonePlainObject(obj) {
+  const out = {};
+  for (const key of Object.keys(obj)) {
+    out[key] = deepClone(obj[key]);
+  }
+  return out;
+}
+
+function cloneMap(map) {
+  const out = new Map();
+  for (const [key, value] of map.entries()) {
+    out.set(key, deepClone(value));
+  }
+  return out;
+}
+
+function cloneSet(set) {
+  const out = new Set();
+  for (const value of set.values()) {
+    out.add(deepClone(value));
+  }
+  return out;
+}
+
+function cloneTypedArray(value) {
+  if (typeof value.slice === 'function') {
+    try { return value.slice(); } catch { /* fallthrough */ }
+  }
+  const Ctor = value.constructor;
+  try { return new Ctor(value); } catch { return value; }
+}
+
+export function deepClone(value) {
+  if (value == null) return value;
+
+  if (Array.isArray(value)) {
+    return value.map((item) => deepClone(item));
+  }
+
+  if (value instanceof Date) {
+    return new Date(value.getTime());
+  }
+
+  if (value instanceof Map) {
+    return cloneMap(value);
+  }
+
+  if (value instanceof Set) {
+    return cloneSet(value);
+  }
+
+  if (ArrayBuffer.isView(value) && !(value instanceof DataView)) {
+    return cloneTypedArray(value);
+  }
+
+  if (typeof value === 'object') {
+    const proto = Object.getPrototypeOf(value);
+    if (proto === Object.prototype || proto === null) {
+      return clonePlainObject(value);
+    }
+    // Fall back to identity for non-plain objects (class instances, DOM nodes, etc.)
+    return value;
+  }
+
+  return value;
+}

package/src/utils/geometryTolerance.js

@@ -0,0 +1,37 @@
+export function deriveTolerance(polys, baseTol = 1e-5) {
+  if (!Array.isArray(polys) || polys.length === 0) return baseTol;
+  if (baseTol !== 1e-5) return baseTol;
+
+  let minX = Infinity, minY = Infinity, minZ = Infinity;
+  let maxX = -Infinity, maxY = -Infinity, maxZ = -Infinity;
+  const segLens = [];
+  for (const p of polys) {
+    for (let i = 0; i < p.length; i++) {
+      const v = p[i];
+      if (v[0] < minX) minX = v[0]; if (v[0] > maxX) maxX = v[0];
+      if (v[1] < minY) minY = v[1]; if (v[1] > maxY) maxY = v[1];
+      if (v[2] < minZ) minZ = v[2]; if (v[2] > maxZ) maxZ = v[2];
+      if (i > 0) {
+        const a = p[i - 1];
+        const dx = a[0] - v[0], dy = a[1] - v[1], dz = a[2] - v[2];
+        segLens.push(Math.hypot(dx, dy, dz));
+      }
+    }
+  }
+  const dx = maxX - minX, dy = maxY - minY, dz = maxZ - minZ;
+  const diag = Math.hypot(dx, dy, dz) || 1;
+  segLens.sort((a, b) => a - b);
+  const med = segLens.length ? segLens[(segLens.length >> 1)] : diag;
+  return Math.min(Math.max(1e-5, diag * 1e-3), med * 0.1);
+}
+
+export function createQuantizer(tol) {
+  const t = tol || 1e-5;
+  const q = (v) => [
+    Math.round(v[0] / t) * t,
+    Math.round(v[1] / t) * t,
+    Math.round(v[2] / t) * t,
+  ];
+  const k = (v) => `${v[0]},${v[1]},${v[2]}`;
+  return { q, k };
+}

package/src/utils/normalizeTypeString.js

@@ -0,0 +1,8 @@
+// normalizeTypeString.js
+// Shared helper to coerce type-like values into trimmed strings.
+
+export function normalizeTypeString(type) {
+  if (type === 0) return '0';
+  if (!type) return '';
+  return String(type).trim();
+}

package/src/utils/xformMath.js

@@ -0,0 +1,51 @@
+import * as THREE_NS from 'three';
+
+// Utility: compose a Matrix4 from TRS values where rotationEuler is in degrees.
+// Accepts an optional THREE-like namespace; defaults to imported three.
+export function composeTrsMatrixDeg(trs, THREE = THREE_NS) {
+  const p = Array.isArray(trs?.position) ? trs.position : [0, 0, 0];
+  const r = Array.isArray(trs?.rotationEuler) ? trs.rotationEuler : [0, 0, 0];
+  const s = Array.isArray(trs?.scale) ? trs.scale : [1, 1, 1];
+  const pos = new THREE.Vector3(
+    Number(p[0] || 0),
+    Number(p[1] || 0),
+    Number(p[2] || 0)
+  );
+  const eul = new THREE.Euler(
+    THREE.MathUtils.degToRad(Number(r[0] || 0)),
+    THREE.MathUtils.degToRad(Number(r[1] || 0)),
+    THREE.MathUtils.degToRad(Number(r[2] || 0)),
+    'XYZ'
+  );
+  const quat = new THREE.Quaternion().setFromEuler(eul);
+  const scl = new THREE.Vector3(
+    Number(s[0] || 1),
+    Number(s[1] || 1),
+    Number(s[2] || 1)
+  );
+  return new THREE.Matrix4().compose(pos, quat, scl);
+}
+
+// Compose absolute transform matrix from a base (pos, quaternion, scale arrays)
+// and a delta TRS where rotationEuler is degrees.
+export function combineBaseWithDeltaDeg(base, delta, THREE = THREE_NS) {
+  const basePos = new THREE.Vector3(
+    Number(base?.position?.[0] || 0),
+    Number(base?.position?.[1] || 0),
+    Number(base?.position?.[2] || 0)
+  );
+  const baseQuat = new THREE.Quaternion().fromArray(
+    Array.isArray(base?.quaternion) && base.quaternion.length >= 4
+      ? base.quaternion
+      : [0, 0, 0, 1]
+  );
+  const baseScale = new THREE.Vector3(
+    Number(base?.scale?.[0] || 1),
+    Number(base?.scale?.[1] || 1),
+    Number(base?.scale?.[2] || 1)
+  );
+  const Mbase = new THREE.Matrix4().compose(basePos, baseQuat, baseScale);
+  const Mdelta = composeTrsMatrixDeg(delta, THREE);
+  return Mbase.multiply(Mdelta);
+}
+