@bldrs-ai/conway 1.346.1102 → 1.348.1109

package/compiled/src/compat/web-ifc/ap214_properties.js

@@ -1,51 +1,292 @@
-/* eslint-disable */
-import { shape_definition_representation } from "../../AP214E3_2010/AP214E3_2010_gen/shape_definition_representation.gen.js";
-import { product } from "../../AP214E3_2010/AP214E3_2010_gen/product.gen.js";
+import { AP214ProductStructureExtraction, } from "../../AP214E3_2010/ap214_product_structure_extraction.js";
+import { AP214PropertyExtraction, } from "../../AP214E3_2010/ap214_property_extraction.js";
+/**
+ * web-ifc tape type code for an entity reference. `unpackHelper` rejects any
+ * `HasProperties` entry whose `type` is not this.
+ */
+const WEB_IFC_REF_TYPE = 5;
+/** Express id used for a synthetic root when a file has multiple roots. */
+const SYNTHETIC_ROOT_EXPRESS_ID = 0;
+/**
+ * web-ifc-compatible property/spatial surface over an AP214/AP242 step model.
+ *
+ * Backed by {@link AP214ProductStructureExtraction} and
+ * {@link AP214PropertyExtraction}: `getSpatialStructure` returns the real
+ * nested, named, occurrence-keyed tree (replacing the old flat, nameless stub);
+ * `getItemProperties` / `getPropertySets` return the extracted attribute and
+ * validation rows; `getAllItemsOfType` is backed by the model type index.
+ *
+ * This is the seam Share consumes (via `IfcApiProxyAP214`); nothing in Share
+ * changes — it lights up the moment this returns a real tree.
+ */
 export class AP214Properties {
+    /**
+     * @param api The AP214 passthrough proxy owning the step model.
+     */
     constructor(api) {
         this.api = api;
     }
+    /**
+     * No-op type-name lookup retained for interface compatibility; AP214 surfaces
+     * STEP entity names directly on the nodes.
+     *
+     * @param type The numeric type code.
+     * @return {string} The empty string (AP214 has no IFC type-name map).
+     */
     getIfcType(type) {
         return "";
     }
+    /**
+     * Resolve one express id to a web-ifc-shaped item, dispatching on what the id
+     * denotes:
+     *
+     * - a **property single** (a `descriptive_/measure_representation_item` id,
+     *   referenced from a pset's `HasProperties`) → `{ expressID, Name: {value},
+     *   NominalValue: {value} }`, the shape `unpackHelper` reads after it
+     *   dereferences a `HasProperties` handle;
+     * - a **tree node** (NAUO occurrence id, or `product_definition[_shape]` id
+     *   for single-part files) → `{ expressID, Name: {value} }`, the part's
+     *   identity row.
+     *
+     * Property-single ids and node ids are disjoint (distinct STEP entities), so
+     * the lookup is unambiguous.
+     *
+     * @param id Express id to resolve.
+     * @param recursive Unused; kept for web-ifc signature parity.
+     * @return {Promise<object>} The web-ifc-shaped item.
+     */
     async getItemProperties(id, recursive = false) {
-        return this.api.getLine(id, recursive);
+        this.buildIndexes();
+        const property = this.propertyByItemId_.get(id);
+        if (property !== void 0) {
+            return {
+                expressID: id,
+                Name: { value: property.name },
+                NominalValue: { value: property.numericValue ?? property.value },
+            };
+        }
+        return {
+            expressID: id,
+            Name: { value: this.nodeNameByExpressID_.get(id) ?? "" },
+        };
     }
+    /**
+     * Get a part's property sets: one `IfcPropertySet`-shaped set per grouping
+     * label (plain attributes vs. validation properties). Each set's
+     * `HasProperties` is an array of web-ifc reference handles
+     * (`{ type: 5, value: itemExpressID }`) that Share's Properties panel resolves
+     * back to individual properties via `getItemProperties` — emitting inline
+     * property objects instead would trip `unpackHelper`'s reference-type guard.
+     *
+     * @param elementID Node express id.
+     * @param recursive Unused; kept for web-ifc signature parity.
+     * @return {Promise<any[]>} The property sets for the element.
+     */
     async getPropertySets(elementID, recursive = false) {
-        return [];
+        const rows = this.rowsForElement(elementID);
+        if (rows.length === 0) {
+            return [];
+        }
+        const byGroup = new Map();
+        for (const row of rows) {
+            let groupRows = byGroup.get(row.group);
+            if (groupRows === void 0) {
+                groupRows = [];
+                byGroup.set(row.group, groupRows);
+            }
+            groupRows.push(row);
+        }
+        const propertySets = [];
+        for (const [group, groupRows] of byGroup) {
+            const hasProperties = [];
+            for (const row of groupRows) {
+                if (row.expressID !== void 0) {
+                    hasProperties.push({ type: WEB_IFC_REF_TYPE, value: row.expressID });
+                }
+            }
+            if (hasProperties.length === 0) {
+                continue;
+            }
+            propertySets.push({
+                // The set's own id is never dereferenced by the panel; use the first
+                // member's id so it is stable and distinct per group.
+                expressID: hasProperties[0].value,
+                Name: { value: group.length > 0 ? group : "Attributes" },
+                HasProperties: hasProperties,
+            });
+        }
+        return propertySets;
     }
+    /**
+     * Type properties are not modeled for AP214 at the Simplified tier.
+     *
+     * @param elementID Node express id.
+     * @param recursive Unused; kept for web-ifc signature parity.
+     * @return {Promise<any[]>} An empty array.
+     */
     async getTypeProperties(elementID, recursive = false) {
         return [];
     }
+    /**
+     * Material properties are not modeled for AP214 at the Simplified tier.
+     *
+     * @param elementID Node express id.
+     * @param recursive Unused; kept for web-ifc signature parity.
+     * @return {Promise<any[]>} An empty array.
+     */
     async getMaterialsProperties(elementID, recursive = false) {
         return [];
     }
+    /**
+     * Get the real nested, named, occurrence-keyed product structure.
+     *
+     * @param includeProperties When true, merge each node's item properties onto
+     * the node (mirrors the IFC surface's `includeProperties`).
+     * @return {Promise<Node>} The root node. A single-root file returns its root
+     * directly; a multi-root file is wrapped in a synthetic container root.
+     */
     async getSpatialStructure(includeProperties) {
-        const model = this.api.StepModel;
-        const products = Array.from(model.types(product));
-        const productObj = products[0];
-        const productNode = AP214Properties.newAP214Product(productObj.expressID);
-        const shapeDefinitions = model.types(shape_definition_representation);
-        for (const shapeDefinition of shapeDefinitions) {
-            const nodeExpressID = shapeDefinition.expressID;
-            if (nodeExpressID !== void 0) {
-                productNode.children.push({
-                    expressID: nodeExpressID,
-                    type: "shape_definition",
-                    children: [],
-                });
-            }
+        const roots = this.productStructure();
+        const nodes = await Promise.all(roots.map((root) => this.toSpatialNode(root, includeProperties)));
+        if (nodes.length === 1) {
+            return nodes[0];
         }
-        return productNode;
+        const syntheticRoot = {
+            expressID: SYNTHETIC_ROOT_EXPRESS_ID,
+            type: "product_structure",
+            Name: { value: "Model" },
+            productDefinitionExpressID: SYNTHETIC_ROOT_EXPRESS_ID,
+            occurrencePath: [],
+            children: nodes,
+        };
+        return syntheticRoot;
     }
+    /**
+     * Get every element of a STEP entity type, backed by the model type index.
+     *
+     * @param type The numeric AP214 entity type id.
+     * @param verbose When true, return raw line data; otherwise express ids.
+     * @return {Promise<any[]>} The matching elements (ids or raw lines).
+     */
     async getAllItemsOfType(type, verbose) {
-        return [];
+        const model = this.api.StepModel;
+        const results = [];
+        for (const element of model.typeIDs(type)) {
+            const expressID = element.expressID;
+            if (expressID === void 0) {
+                continue;
+            }
+            results.push(verbose ? this.api.getRawLineData(expressID) : expressID);
+        }
+        return results;
     }
-    static newAP214Product(id) {
-        return {
-            expressID: id,
-            type: "product",
-            children: [],
+    /**
+     * Convert an extracted structure node into a spatial node for the compat
+     * surface, recursing into children.
+     *
+     * @param node The extracted product-structure node.
+     * @param includeProperties When true, merge the node's item properties.
+     * @return {Promise<AP214Node>} The converted spatial node.
+     */
+    async toSpatialNode(node, includeProperties) {
+        const children = await Promise.all(node.children.map((childNode) => this.toSpatialNode(childNode, includeProperties)));
+        let spatialNode = {
+            expressID: node.expressID,
+            type: node.type,
+            Name: { value: node.name },
+            productDefinitionExpressID: node.productDefinitionExpressID,
+            occurrencePath: node.occurrencePath,
+            children,
         };
+        if (includeProperties) {
+            const properties = await this.getItemProperties(node.expressID);
+            spatialNode = { ...properties, ...spatialNode };
+        }
+        return spatialNode;
+    }
+    /**
+     * Resolve the property rows for an element, mapping an occurrence node id back
+     * to its owning product definition (where properties are keyed).
+     *
+     * @param id Node express id.
+     * @return {AP214PropertyRow[]} The element's property rows (possibly empty).
+     */
+    rowsForElement(id) {
+        this.buildIndexes();
+        const ownerId = this.ownerByExpressID_.get(id) ?? id;
+        const extracted = this.properties().get(ownerId);
+        if (extracted === void 0) {
+            return [];
+        }
+        return extracted.map((property) => ({
+            expressID: property.expressID,
+            Name: property.name,
+            value: property.numericValue ?? property.value,
+            group: property.group,
+        }));
+    }
+    /**
+     * Lazily build and cache every index the surface reads in one pass:
+     * - `structureRoots_` — the assembly forest;
+     * - `ownerByExpressID_` — node id → owning product-definition id (where the
+     *   property map is keyed);
+     * - `nodeNameByExpressID_` — node id → display name (for `getItemProperties`
+     *   identity rows);
+     * - `propertyByItemId_` — representation-item id → property (so a pset's
+     *   `HasProperties` reference resolves back to its key/value).
+     */
+    buildIndexes() {
+        if (this.structureRoots_ !== void 0) {
+            return;
+        }
+        const model = this.api.StepModel;
+        this.structureRoots_ =
+            new AP214ProductStructureExtraction(model).extractProductStructure();
+        this.ownerByExpressID_ = new Map();
+        this.nodeNameByExpressID_ = new Map();
+        for (const root of this.structureRoots_) {
+            this.indexNodes(root);
+        }
+        this.propertyByItemId_ = new Map();
+        for (const rows of this.properties().values()) {
+            for (const property of rows) {
+                if (property.expressID !== void 0) {
+                    this.propertyByItemId_.set(property.expressID, property);
+                }
+            }
+        }
+    }
+    /**
+     * Record a node's owning product-definition id and display name, recursing
+     * into children.
+     *
+     * @param node The node to index.
+     */
+    indexNodes(node) {
+        this.ownerByExpressID_.set(node.expressID, node.productDefinitionExpressID);
+        this.nodeNameByExpressID_.set(node.expressID, node.name);
+        for (const childNode of node.children) {
+            this.indexNodes(childNode);
+        }
+    }
+    /**
+     * Return the cached product-structure forest, building the indexes if needed.
+     *
+     * @return {ProductStructureNode[]} The cached assembly roots.
+     */
+    productStructure() {
+        this.buildIndexes();
+        return this.structureRoots_;
+    }
+    /**
+     * Lazily build and cache the extracted property map.
+     *
+     * @return {ExtractedPropertyMap} The cached per-part property map.
+     */
+    properties() {
+        if (this.propertyMap_ === void 0) {
+            this.propertyMap_ = new AP214PropertyExtraction(this.api.StepModel).extractProperties();
+        }
+        return this.propertyMap_;
     }
 }

package/compiled/src/compat/web-ifc/ap214_properties.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=ap214_properties.test.d.ts.map

package/compiled/src/compat/web-ifc/ap214_properties.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ap214_properties.test.d.ts","sourceRoot":"","sources":["../../../../src/compat/web-ifc/ap214_properties.test.ts"],"names":[],"mappings":""}

package/compiled/src/compat/web-ifc/ap214_properties.test.js

@@ -0,0 +1,85 @@
+import fs from "fs";
+import { describe, expect, test } from "@jest/globals";
+import AP214StepParser from "../../AP214E3_2010/ap214_step_parser.js";
+import ParsingBuffer from "../../parsing/parsing_buffer.js";
+import { ParseResult } from "../../step/parsing/step_parser.js";
+import { AP214Properties } from "./ap214_properties.js";
+const parser = AP214StepParser.Instance;
+/** web-ifc tape type code for an entity reference (a `HasProperties` handle). */
+const WEB_IFC_REF_TYPE = 5;
+/** Express id of the single CTC part (`product_definition`) in the fixture. */
+const CTC_PRODUCT_DEFINITION_EXPRESS_ID = 4368;
+/**
+ * Parse a hermetic STEP fixture and wrap it in an {@link AP214Properties} over a
+ * minimal proxy stub exposing only `StepModel` (all the spatial/property methods
+ * read just that).
+ *
+ * @param {string} path Fixture path.
+ * @return {AP214Properties} The compat surface over the parsed model.
+ */
+function compatSurfaceFor(path) {
+    const buffer = fs.readFileSync(path);
+    const bufferInput = new ParsingBuffer(buffer);
+    expect(parser.parseHeader(bufferInput)[1]).toBe(ParseResult.COMPLETE);
+    const [result, model] = parser.parseDataToModel(bufferInput);
+    expect(model).not.toBe(void 0);
+    expect(result === ParseResult.COMPLETE || result === ParseResult.INCOMPLETE).toBe(true);
+    return new AP214Properties({ StepModel: model });
+}
+describe("compat/web-ifc/AP214Properties", () => {
+    test("getSpatialStructure emits Name as a web-ifc {value} handle", async () => {
+        const root = await compatSurfaceFor("data/as1-assembly.step").getSpatialStructure();
+        // Name must be { value: 'as1' } — a plain string would make Share's
+        // reifyName fall back to the type label, dropping the name.
+        expect(typeof root.Name).toBe("object");
+        expect(root.Name.value).toBe("as1");
+        expect(root.children.length).toBeGreaterThan(0);
+        for (const child of root.children) {
+            expect(child.Name.value.length).toBeGreaterThan(0);
+            expect(Array.isArray(child.occurrencePath)).toBe(true);
+        }
+    });
+    test("getItemProperties returns a {value}-wrapped identity for a node", async () => {
+        const surface = compatSurfaceFor("data/as1-assembly.step");
+        const root = await surface.getSpatialStructure();
+        const item = await surface.getItemProperties(root.expressID);
+        expect(item.expressID).toBe(root.expressID);
+        expect(item.Name.value).toBe("as1");
+    });
+    test("getPropertySets emits IfcPropertySet-shaped sets with reference HasProperties", async () => {
+        const surface = compatSurfaceFor("data/nist-ctc-properties.step");
+        const psets = await surface.getPropertySets(CTC_PRODUCT_DEFINITION_EXPRESS_ID);
+        expect(psets.length).toBeGreaterThan(0);
+        for (const pset of psets) {
+            // Set name is a {value} handle; HasProperties are reference handles
+            // ({type: 5, value: id}) so Share's unpackHelper can dereference them.
+            expect(pset.Name.value.length).toBeGreaterThan(0);
+            expect(pset.HasProperties.length).toBeGreaterThan(0);
+            for (const ref of pset.HasProperties) {
+                expect(ref.type).toBe(WEB_IFC_REF_TYPE);
+                expect(typeof ref.value).toBe("number");
+            }
+        }
+    });
+    test("a HasProperties reference resolves through getItemProperties to key/value", async () => {
+        const surface = compatSurfaceFor("data/nist-ctc-properties.step");
+        const psets = await surface.getPropertySets(CTC_PRODUCT_DEFINITION_EXPRESS_ID);
+        const resolved = new Map();
+        for (const pset of psets) {
+            for (const ref of pset.HasProperties) {
+                const prop = await surface.getItemProperties(ref.value);
+                expect(prop.expressID).toBe(ref.value);
+                resolved.set(prop.Name.value, prop.NominalValue.value);
+            }
+        }
+        // The NIST attribute key/values, surfaced through the reference round-trip.
+        expect(resolved.get("Modeled By")).toBe("Engineer");
+        expect(resolved.get("CAGE Code")).toBe("64JW1");
+        expect(resolved.get("Company")).toBe("ACME");
+    });
+    test("getPropertySets is empty for an element with no properties", async () => {
+        const surface = compatSurfaceFor("data/as1-assembly.step");
+        const root = await surface.getSpatialStructure();
+        expect(await surface.getPropertySets(root.expressID)).toEqual([]);
+    });
+});

package/compiled/src/version/version.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"version.d.ts","sourceRoot":"","sources":["../../../src/version/version.ts"],"names":[],"mappings":"AAAA,QAAA,MAAM,aAAa,EAAE,MAA0C,CAAA;AAG/D,OAAO,EAAC,aAAa,EAAC,CAAA"}
+{"version":3,"file":"version.d.ts","sourceRoot":"","sources":["../../../src/version/version.ts"],"names":[],"mappings":"AAOA,QAAA,MAAM,aAAa,EAAE,MAA0C,CAAA;AAG/D,OAAO,EAAC,aAAa,EAAC,CAAA"}

package/compiled/src/version/version.js

@@ -1,2 +1,9 @@
-const versionString = 'Conway Web-Ifc Shim v1.346.1102';
+// Placeholder version for source/dev builds. CI's auto-publish job stamps the
+// real `<major>.<PR>.<commit>` here (and into package.json) at publish time and
+// does NOT commit it back to main — see .github/workflows/build.yml (auto-publish).
+// So on main and in any unstamped local build this intentionally reads 1.0.0;
+// only the first segment (major) is meaningful and is the one CI carries forward.
+// Must stay in `vN.N.N` shape: the CI stamp regex, scripts/updateVersion.mjs, and
+// statistics.ts all match `v\d+\.\d+\.\d+`.
+const versionString = 'Conway Web-Ifc Shim v1.348.1109';
 export { versionString };