@bldrs-ai/conway 1.379.1191 → 1.380.1215

package/compiled/examples/browser-bundled.cjs

@@ -30,7 +30,7 @@ var import_node_process = require("node:process");
 var readline = __toESM(require("node:readline"), 1);
 
 // compiled/src/version/version.js
-var versionString = "Conway Web-Ifc Shim v1.379.1191";
+var versionString = "Conway v1.380.1215";
 
 // compiled/dependencies/conway-geom/interface/conway_geometry.js
 var wasmType = "";
@@ -187,6 +187,52 @@ var Statistics = class {
   setMemoryStatistics(value) {
     this.memoryStatistics = value;
   }
+  /**
+   *
+   * @return {number | undefined} - number of products extracted
+   */
+  getProductCount() {
+    return this.productCount;
+  }
+  /**
+   *
+   * @param value - number of products extracted
+   */
+  setProductCount(value) {
+    this.productCount = value;
+  }
+  /**
+   *
+   * @return {Map<string, number> | undefined} - geometry type breakdown
+   * (entity type name -> count of unique geometry definitions extracted)
+   */
+  getGeometryTypeCounts() {
+    return this.geometryTypeCounts;
+  }
+  /**
+   *
+   * @param value - geometry type breakdown map
+   */
+  setGeometryTypeCounts(value) {
+    this.geometryTypeCounts = value;
+  }
+  /**
+   * Format the geometry-type breakdown as a compact sorted list, e.g.
+   * "IFCEXTRUDEDAREASOLID×3421 IFCFACETEDBREP×212 (+3 more)".
+   *
+   * @param maxEntries - cap on listed types (rest summarized)
+   * @return {string | undefined} the formatted breakdown, if any
+   */
+  // eslint-disable-next-line no-magic-numbers
+  formatGeometryTypeCounts(maxEntries = 12) {
+    if (this.geometryTypeCounts === void 0 || this.geometryTypeCounts.size === 0) {
+      return void 0;
+    }
+    const sorted = Array.from(this.geometryTypeCounts.entries()).sort((leftEntry, rightEntry) => rightEntry[1] - leftEntry[1]);
+    const shown = sorted.slice(0, maxEntries).map(([name, count]) => `${name}\xD7${count}`).join(" ");
+    const remainder = sorted.length - maxEntries;
+    return remainder > 0 ? `${shown} (+${remainder} more)` : shown;
+  }
   /**
    * prints statistics
    */
@@ -229,7 +275,10 @@ var Statistics = class {
     } else {
       versionStr = "Version not defined";
     }
-    return `[${dateString}]: Load Status: ${this.loadStatus}, Project Name: ${this.projectName}, Version: ${versionStr}, Conway Version: ${conwayVersionNumber}-${wasmType}, Parse Time: ${this.parseTime} ms, Geometry Time: ${this.geometryTime} ms, Total Time: ${this.totalTime} ms, Geometry Memory: ${this.geometryMemory?.toFixed(3)} MB, Memory Statistics: ${this.memoryStatistics}, Preprocessor Version: ${this.preprocessorVersion}, Originating System: ${this.originatingSystem}`;
+    const products = this.productCount !== void 0 ? `Products: ${this.productCount}, ` : "";
+    const breakdown = this.formatGeometryTypeCounts();
+    const geometryTypes = breakdown !== void 0 ? `, Geometry Types: ${breakdown}` : "";
+    return `[${dateString}]: Load Status: ${this.loadStatus}, Project Name: ${this.projectName}, Version: ${versionStr}, Conway Version: ${conwayVersionNumber}-${wasmType}, Parse Time: ${this.parseTime} ms, Geometry Time: ${this.geometryTime} ms, Total Time: ${this.totalTime} ms, Geometry Memory: ${this.geometryMemory?.toFixed(3)} MB, ` + products + `Memory Statistics: ${this.memoryStatistics}, Preprocessor Version: ${this.preprocessorVersion}, Originating System: ${this.originatingSystem}` + geometryTypes;
   }
 };
 
@@ -5403,6 +5452,41 @@ var StepModelBase = class {
     const distinctTypes = types.length === 1 ? types[0].query : new Set(types.flatMap((type) => type.query));
     return this.typeIndex.count(...distinctTypes);
   }
+  /**
+   * Iterate the express IDs of entities of a set of types (including sub-types)
+   * without materializing entity descriptors or touching the source buffer —
+   * only the type index and the express ID column are read, so this stays cheap
+   * and safe even when the model source has been spilled to an external store.
+   *
+   * Multi-mapped elements (e.g. complex/multi-entity mappings) may be yielded
+   * once per matching mapping, so callers that need distinct IDs should dedupe.
+   *
+   * @param types The list of types to iterate.
+   * @return {IterableIterator} A lazy iterator of express IDs for matching entities.
+   * @yields {number} The express ID of each matching entity.
+   */
+  *expressIDsOfTypes(...types) {
+    const distinctTypes = types.length === 1 ? types[0].query : new Set(types.flatMap((type) => type.query));
+    const cursor = this.typeIndex.cursor(...distinctTypes);
+    const expressIDs = this.expressID_;
+    const firstInlineElement = this.firstInlineElement_;
+    try {
+      while (cursor.step()) {
+        const high = cursor.high;
+        let low = cursor.low;
+        while (low !== 0) {
+          const lowestOneHot = extractOneHotLow(low);
+          low ^= 1 << lowestOneHot;
+          const localID = high | lowestOneHot;
+          if (localID < firstInlineElement) {
+            yield expressIDs[localID];
+          }
+        }
+      }
+    } finally {
+      cursor.free();
+    }
+  }
   /**
    * Get the non empty type IDs for this.
    *