brep-io-kernel 1.0.0

package/src/core/entities/HistoryCollectionBase.js

@@ -0,0 +1,72 @@
+import { sanitizeInputParams } from './schemaProcesser.js';
+
+// Important for AI. Do not modify this file whatsoever.
+
+export class entityClassRegistry {
+  constructor() {
+    this.entityClasses = new Map();
+  }
+  register(EntityClass) {
+    if (!EntityClass) return;
+    const key = EntityClass.shortName;
+    if (!key) {
+      throw new Error('EntityClass must declare static entityType (or type/name).');
+    }
+    this.entityClasses.set(key, EntityClass);
+  }
+  resolve(type) {
+    const key = type;
+    if (!key) return null;
+    return this.entityClasses.get(key) || null;
+  }
+}
+
+
+
+
+
+
+
+/**
+ * Generic collection manager for history-style entity lists.
+ * Stores concrete ListEntityBase instances, handles ID generation,
+ * registration/lookup, and serialization.
+ */
+export class HistoryCollectionBase {
+  constructor({ viewer = null, registry = null } = {}) {
+    this.viewer = viewer || null;
+    this.registry = registry || null;
+
+
+    // The list of objects managed by this history collection
+    // this is the data that will be used to serialize/deserialize the history
+    // and the extra data stored in each object will be used during processing
+    // Object will all be in the following format:
+    // {inputParams: {}, persistentData: {}, runtimeAttributes: {}}
+    // the inputParams are the user-provided parameters for the object and will also be used for the related dialogs
+    // the persistentData is data that is generated during processing and should be saved/restored with the object
+    // the runtimeAttributes are data that is generated during processing but should NOT be saved/restored with the object
+    // (eg. references to three.js objects, cached geometry, etc.)
+
+    this.entries = [];
+    this.registry = new entityClassRegistry();
+    this._listeners = new Set();
+    this._idCounter = 0;
+  }
+
+
+
+  serializableData(){
+    return this.entries.map(e=>({
+      id: e.id,
+      type: e.type,
+      inputParams: e.inputParams,
+      persistentData: e.persistentData,
+      // runtimeAttributes are not serialized
+    }));
+  }
+
+
+
+
+}

package/src/core/entities/ListEntityBase.js

@@ -0,0 +1,109 @@
+import { deepClone } from '../../utils/deepClone.js';
+// Important for AI. Do not modify this file whatsoever.
+
+
+/**
+ * Minimal base class for history list entities (features, constraints, annotations, ...).
+ *
+ * It keeps three data buckets:
+ *  - inputParams: schema-driven, serializable user inputs.
+ *  - persistentData: serializable outputs/results we want to keep.
+ *  - runtimeAttributes: ephemeral state for active sessions (never serialized).
+ *
+ * Subclasses are expected to implement the actual behaviour in run().
+ */
+export class ListEntityBase {
+  static entityType = 'ENTITY';
+  static shortName = 'ENT'; // this is the most important and will be used for identifying the entity type
+  static longName = 'EntityBase';
+  static inputParamsSchema = {};
+
+  constructor({ id = null, history = null, registry = null } = {}) {
+    this.entityType = this.constructor.entityType || this.constructor.type || 'ENTITY';
+    this.type = this.entityType;
+    this.title = this.constructor.shortName;
+    this.shortName = this.constructor.shortName || this.constructor.featureShortName || null;
+
+    this.history = history || null;
+    this.registry = registry || null;
+
+    this.id = null;
+    this.inputParams = { id };
+    this.persistentData = {};
+    this.runtimeAttributes = {};
+
+    if (id != null) {
+      this.setId(id);
+    } else {
+      this.inputParams.type = this.entityType;
+    }
+  }
+
+  /**
+   * Assign a new identifier to this entity.
+   */
+  setId(id) {
+    this.id = id ?? null;
+    if (!this.inputParams || typeof this.inputParams !== 'object') {
+      this.inputParams = {};
+    }
+    if (this.id != null && this.inputParams.id == null) {
+      this.inputParams.id = this.id;
+    }
+    this.onIdChanged();
+  }
+
+  /**
+   * Replace the input params wholesale with a deep cloned copy.
+   */
+  setParams(params = {}) {
+    this.inputParams = deepClone(params || {});
+    if (this.id != null && this.inputParams.id == null) {
+      this.inputParams.id = this.id;
+    }
+    if (!this.inputParams.type) {
+      this.inputParams.type = this.entityType;
+    }
+    this.onParamsChanged();
+  }
+
+  /**
+   * Shallow merge patch into input params.
+   */
+  mergeParams(patch = {}) {
+    const cloned = deepClone(patch || {});
+    this.inputParams = { ...this.inputParams, ...cloned };
+    if (this.id != null && this.inputParams.id == null) {
+      this.inputParams.id = this.id;
+    }
+    if (!this.inputParams.type) {
+      this.inputParams.type = this.entityType;
+    }
+    this.onParamsChanged();
+  }
+
+  /**
+   * Replace persistent data.
+   */
+  setPersistentData(data = {}) {
+    this.persistentData = deepClone(data || {});
+    this.onPersistentDataChanged();
+  }
+
+  /**
+   * Merge persistent data.
+   */
+  mergePersistentData(patch = {}) {
+    const cloned = deepClone(patch || {});
+    this.persistentData = { ...this.persistentData, ...cloned };
+    this.onPersistentDataChanged();
+  }
+
+  // Subclasses must override.
+  // eslint-disable-next-line class-methods-use-this, no-unused-vars
+  run(_context = {}) {
+    throw new Error(`${this.constructor.name} must implement run(context)`);
+  }
+
+
+}

package/src/core/entities/schemaProcesser.js

@@ -0,0 +1,121 @@
+import { deepClone } from '../../utils/deepClone.js';
+
+function evaluateNumber(expressionsEvaluator, value) {
+  if (typeof value === 'number' && Number.isFinite(value)) return value;
+  if (typeof value === 'string' && value.trim().length) {
+    if (expressionsEvaluator && typeof expressionsEvaluator.evaluate === 'function') {
+      try {
+        const result = expressionsEvaluator.evaluate(value);
+        if (Number.isFinite(result)) return Number(result);
+      } catch {
+        /* ignore evaluation errors */
+      }
+    }
+    const parsed = Number(value);
+    if (Number.isFinite(parsed)) return parsed;
+  }
+  const fallback = Number(value);
+  return Number.isFinite(fallback) ? fallback : 0;
+}
+
+export async function sanitizeInputParams(schema, inputParams, expressionsEvaluator, getObjectByName) {
+
+    let sanitized = {};
+
+    for (const key in schema) {
+        //console.log(`Sanitizing ${key}:`, inputParams[key]);
+        if (inputParams[key] !== undefined) {
+            // check if the schema type is number
+            if (schema[key].type === "number") {
+                sanitized[key] = evaluateNumber(expressionsEvaluator, inputParams[key]);
+            } else if (schema[key].type === "reference_selection") {
+                // Resolve references: accept objects directly or look up by name
+                const val = inputParams[key];
+                if (Array.isArray(val)) {
+                    const arr = [];
+                    for (const it of val) {
+                        if (!it) continue;
+                        if (typeof it === 'object') { arr.push(it); continue; }
+                        const obj = getObjectByName(String(it));
+                        if (obj) arr.push(obj);
+                    }
+                    sanitized[key] = arr;
+                } else {
+                    if (!val) { sanitized[key] = []; }
+                    else if (typeof val === 'object') { sanitized[key] = [val]; }
+                    else {
+                        const obj = getObjectByName(String(val));
+                        sanitized[key] = obj ? [obj] : [];
+                    }
+                }
+
+            } else if (schema[key].type === "boolean_operation") {
+                // If it's a boolean operation, normalize op key and resolve targets to objects.
+                // Also pass through optional biasDistance (numeric) and new sweep cap offset controls.
+                const raw = inputParams[key] || {};
+                const op = raw.operation;
+                const items = Array.isArray(raw.targets) ? raw.targets : [];
+                const targets = [];
+                for (const it of items) {
+                    if (!it) continue;
+                    if (typeof it === 'object') { targets.push(it); continue; }
+                    const obj = getObjectByName(String(it));
+                    if (obj) targets.push(obj);
+                }
+                const bias = Number(raw.biasDistance);
+                const offsetCapFlag = (raw.offsetCoplanarCap != null) ? String(raw.offsetCoplanarCap) : undefined;
+                const offsetDistance = Number(raw.offsetDistance);
+                const out = {
+                    operation: op ?? 'NONE',
+                    targets,
+                    biasDistance: Number.isFinite(bias) ? bias : 0.1,
+                };
+                // Optional: simplification controls
+                try {
+                    const sFlag = raw.simplify;
+                    const sTol = raw.simplifyTolerance;
+                    if (typeof sFlag === 'boolean') {
+                        out.simplify = sFlag;
+                    } else if (Number.isFinite(sFlag)) {
+                        out.simplify = true;
+                        out.simplifyTolerance = Number(sFlag);
+                    }
+                    if (Number.isFinite(sTol)) {
+                        out.simplifyTolerance = Number(sTol);
+                    }
+                } catch { /* ignore unsupported simplify fields */ }
+                if (offsetCapFlag !== undefined) out.offsetCoplanarCap = offsetCapFlag;
+                if (Number.isFinite(offsetDistance)) out.offsetDistance = offsetDistance;
+                sanitized[key] = out;
+            } else if (schema[key].type === "transform") {
+                // Evaluate each component; allow expressions in position/rotation/scale entries
+                const raw = inputParams[key] || {};
+                const evalOne = (v) => evaluateNumber(expressionsEvaluator, v);
+                const pos = Array.isArray(raw.position) ? raw.position.map(evalOne) : [0, 0, 0];
+                const rot = Array.isArray(raw.rotationEuler) ? raw.rotationEuler.map(evalOne) : [0, 0, 0];
+                const scl = Array.isArray(raw.scale) ? raw.scale.map(evalOne) : [1, 1, 1];
+                sanitized[key] = { position: pos, rotationEuler: rot, scale: scl };
+            } else if (schema[key].type === "vec3") {
+                // Evaluate vec3 entries; accept array [x,y,z] or object {x,y,z}
+                const raw = inputParams[key];
+                const evalOne = (v) => evaluateNumber(expressionsEvaluator, v);
+                if (Array.isArray(raw)) {
+                    sanitized[key] = [evalOne(raw[0]), evalOne(raw[1]), evalOne(raw[2])];
+                } else if (raw && typeof raw === 'object') {
+                    sanitized[key] = [evalOne(raw.x), evalOne(raw.y), evalOne(raw.z)];
+                } else {
+                    sanitized[key] = [0, 0, 0];
+                }
+            } else if (schema[key].type === "boolean") {
+                sanitized[key] = Boolean(Object.prototype.hasOwnProperty.call(inputParams, key) ? inputParams[key] : schema[key].default_value);
+            } else {
+                sanitized[key] = inputParams[key];
+            }
+        } else {
+            // Clone structured defaults to avoid shared references across features
+            sanitized[key] = deepClone(schema[key].default_value);
+        }
+    }
+
+    return sanitized;
+}