@ifc-lite/codegen 1.15.12 → 1.17.0

package/dist/rust-type-name-parser.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"rust-type-name-parser.js","sourceRoot":"","sources":["../src/rust-type-name-parser.ts"],"names":[],"mappings":"AAKA,qEAAqE;AACrE,MAAM,UAAU,sBAAsB,CAAC,MAAqB;IAC1D,OAAO;;;;;;;;;;;;;;;;;;EAkBP,MAAM,CAAC,QAAQ,CAAC,GAAG,CAAC,MAAM,CAAC,EAAE,CAC3B,gBAAgB,MAAM,CAAC,IAAI,CAAC,WAAW,EAAE,cAAc,MAAM,CAAC,IAAI,GAAG,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC;;;;CAIpF,CAAC;AACF,CAAC"}

package/dist/schema-hierarchy.d.ts

@@ -0,0 +1,57 @@
+/**
+ * Schema-derived type-membership helpers.
+ *
+ * Every `generated/{ifc4,ifc4x3}/schema-registry.ts` bundle carries, per
+ * entity, an `inheritanceChain: string[]` running from the schema root down
+ * to the entity itself (inclusive) — e.g.
+ * `IfcMaterialConstituent.inheritanceChain = ['IfcMaterialDefinition', 'IfcMaterialConstituent']`.
+ * That is a schema fact, not a naming convention: it is the correct tool for
+ * "is this entity a subtype of X", a question three call sites answered with
+ * a string test (`startsWith`/`endsWith`/`includes`) and got wrong at three
+ * different edges (see ifc-lite issue #3999).
+ *
+ * This module is deliberately decoupled from any one generated bundle's
+ * concrete `SchemaRegistry`/`EntityMetadata` interfaces (each bundle
+ * re-declares its own, identically) — it only requires the shape it
+ * actually reads, so it works unchanged against `ifc4`'s registry, `ifc4x3`'s,
+ * or both.
+ */
+/** The minimal shape this module reads off a generated bundle's entity metadata. */
+export interface HierarchyEntity {
+    inheritanceChain?: string[];
+}
+/** The minimal shape this module reads off a generated bundle's `SchemaRegistry`. */
+export interface HierarchyRegistry {
+    entities: Record<string, HierarchyEntity>;
+}
+/**
+ * Is `type` the same entity as `ancestor`, or a (possibly transitive) subtype
+ * of it, according to `registry`? Reflexive: `isSubtypeOf(r, 'IfcWall',
+ * 'IfcWall')` is `true`, matching the chain's own inclusion of the entity
+ * itself. Case-insensitive on both arguments. Returns `false` for a `type`
+ * the registry does not know (including an abstract supertype with no
+ * `inheritanceChain` of its own, and any name from a *different* schema
+ * version's vocabulary) — never throws.
+ */
+export declare function isSubtypeOf(registry: HierarchyRegistry, type: string, ancestor: string): boolean;
+/**
+ * Is `type` a subtype of (or the same entity as) `ancestor` in ANY of the
+ * given registries? Use this to test membership against a schema-version
+ * union — e.g. a set of entity types that must be recognised whether the
+ * store was parsed against IFC4 or IFC4X3, mirroring how a hand-maintained
+ * "recognise it in either schema" allowlist used to be built by hand.
+ */
+export declare function isSubtypeOfAny(registries: readonly HierarchyRegistry[], type: string, ancestor: string): boolean;
+/**
+ * Is `type` a PROPER (strict) subtype of `ancestor` — i.e. `isSubtypeOf` is
+ * true AND `type` is not `ancestor` itself? Use this for an abstract
+ * supertype with no concrete instances (`IfcMaterialDefinition`,
+ * `IfcProfileDef`, …): no real IFC entity's `EntityRef.type` is ever the
+ * literal abstract-type name, so a caller asking "is this entity one of
+ * that abstract type's concrete members" wants the self-match excluded,
+ * not `isSubtypeOf`'s reflexive answer.
+ */
+export declare function isProperSubtypeOf(registry: HierarchyRegistry, type: string, ancestor: string): boolean;
+/** `isProperSubtypeOf`, checked against ANY of the given registries. */
+export declare function isProperSubtypeOfAny(registries: readonly HierarchyRegistry[], type: string, ancestor: string): boolean;
+//# sourceMappingURL=schema-hierarchy.d.ts.map

package/dist/schema-hierarchy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema-hierarchy.d.ts","sourceRoot":"","sources":["../src/schema-hierarchy.ts"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;;;;GAiBG;AAEH,oFAAoF;AACpF,MAAM,WAAW,eAAe;IAC9B,gBAAgB,CAAC,EAAE,MAAM,EAAE,CAAC;CAC7B;AAED,qFAAqF;AACrF,MAAM,WAAW,iBAAiB;IAChC,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,eAAe,CAAC,CAAC;CAC3C;AA+BD;;;;;;;;GAQG;AACH,wBAAgB,WAAW,CAAC,QAAQ,EAAE,iBAAiB,EAAE,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,OAAO,CAIhG;AAED;;;;;;GAMG;AACH,wBAAgB,cAAc,CAC5B,UAAU,EAAE,SAAS,iBAAiB,EAAE,EACxC,IAAI,EAAE,MAAM,EACZ,QAAQ,EAAE,MAAM,GACf,OAAO,CAET;AAED;;;;;;;;GAQG;AACH,wBAAgB,iBAAiB,CAAC,QAAQ,EAAE,iBAAiB,EAAE,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,OAAO,CAEtG;AAED,wEAAwE;AACxE,wBAAgB,oBAAoB,CAClC,UAAU,EAAE,SAAS,iBAAiB,EAAE,EACxC,IAAI,EAAE,MAAM,EACZ,QAAQ,EAAE,MAAM,GACf,OAAO,CAET"}

package/dist/schema-hierarchy.js

@@ -0,0 +1,69 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
+/**
+ * Per-registry index from upper-cased entity name to its upper-cased
+ * inheritance chain, built once per registry object and cached by identity
+ * (a generated bundle's `SCHEMA_REGISTRY` is a module-level singleton, so
+ * identity is stable for the process lifetime). IFC EXPRESS entity names are
+ * unique under case-folding, so upper-casing both the key and the chain
+ * entries is lossless and lets callers pass either the raw STEP/type-table
+ * spelling (already upper-case, e.g. `'IFCWALL'`) or the schema's own
+ * PascalCase spelling (`'IfcWall'`) without needing to know which.
+ */
+const chainIndexCache = new WeakMap();
+function chainIndexFor(registry) {
+    let index = chainIndexCache.get(registry);
+    if (!index) {
+        index = new Map();
+        for (const [name, meta] of Object.entries(registry.entities)) {
+            if (meta.inheritanceChain && meta.inheritanceChain.length > 0) {
+                index.set(name.toUpperCase(), meta.inheritanceChain.map((n) => n.toUpperCase()));
+            }
+        }
+        chainIndexCache.set(registry, index);
+    }
+    return index;
+}
+/**
+ * Is `type` the same entity as `ancestor`, or a (possibly transitive) subtype
+ * of it, according to `registry`? Reflexive: `isSubtypeOf(r, 'IfcWall',
+ * 'IfcWall')` is `true`, matching the chain's own inclusion of the entity
+ * itself. Case-insensitive on both arguments. Returns `false` for a `type`
+ * the registry does not know (including an abstract supertype with no
+ * `inheritanceChain` of its own, and any name from a *different* schema
+ * version's vocabulary) — never throws.
+ */
+export function isSubtypeOf(registry, type, ancestor) {
+    const chain = chainIndexFor(registry).get(type.toUpperCase());
+    if (!chain)
+        return false;
+    return chain.includes(ancestor.toUpperCase());
+}
+/**
+ * Is `type` a subtype of (or the same entity as) `ancestor` in ANY of the
+ * given registries? Use this to test membership against a schema-version
+ * union — e.g. a set of entity types that must be recognised whether the
+ * store was parsed against IFC4 or IFC4X3, mirroring how a hand-maintained
+ * "recognise it in either schema" allowlist used to be built by hand.
+ */
+export function isSubtypeOfAny(registries, type, ancestor) {
+    return registries.some((registry) => isSubtypeOf(registry, type, ancestor));
+}
+/**
+ * Is `type` a PROPER (strict) subtype of `ancestor` — i.e. `isSubtypeOf` is
+ * true AND `type` is not `ancestor` itself? Use this for an abstract
+ * supertype with no concrete instances (`IfcMaterialDefinition`,
+ * `IfcProfileDef`, …): no real IFC entity's `EntityRef.type` is ever the
+ * literal abstract-type name, so a caller asking "is this entity one of
+ * that abstract type's concrete members" wants the self-match excluded,
+ * not `isSubtypeOf`'s reflexive answer.
+ */
+export function isProperSubtypeOf(registry, type, ancestor) {
+    return type.toUpperCase() !== ancestor.toUpperCase() && isSubtypeOf(registry, type, ancestor);
+}
+/** `isProperSubtypeOf`, checked against ANY of the given registries. */
+export function isProperSubtypeOfAny(registries, type, ancestor) {
+    return registries.some((registry) => isProperSubtypeOf(registry, type, ancestor));
+}
+//# sourceMappingURL=schema-hierarchy.js.map

package/dist/schema-hierarchy.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema-hierarchy.js","sourceRoot":"","sources":["../src/schema-hierarchy.ts"],"names":[],"mappings":"AAAA;;+DAE+D;AA+B/D;;;;;;;;;GASG;AACH,MAAM,eAAe,GAAG,IAAI,OAAO,EAA4C,CAAC;AAEhF,SAAS,aAAa,CAAC,QAA2B;IAChD,IAAI,KAAK,GAAG,eAAe,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAC;IAC1C,IAAI,CAAC,KAAK,EAAE,CAAC;QACX,KAAK,GAAG,IAAI,GAAG,EAAE,CAAC;QAClB,KAAK,MAAM,CAAC,IAAI,EAAE,IAAI,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAC,EAAE,CAAC;YAC7D,IAAI,IAAI,CAAC,gBAAgB,IAAI,IAAI,CAAC,gBAAgB,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;gBAC9D,KAAK,CAAC,GAAG,CACP,IAAI,CAAC,WAAW,EAAE,EAClB,IAAI,CAAC,gBAAgB,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,WAAW,EAAE,CAAC,CAClD,CAAC;YACJ,CAAC;QACH,CAAC;QACD,eAAe,CAAC,GAAG,CAAC,QAAQ,EAAE,KAAK,CAAC,CAAC;IACvC,CAAC;IACD,OAAO,KAAK,CAAC;AACf,CAAC;AAED;;;;;;;;GAQG;AACH,MAAM,UAAU,WAAW,CAAC,QAA2B,EAAE,IAAY,EAAE,QAAgB;IACrF,MAAM,KAAK,GAAG,aAAa,CAAC,QAAQ,CAAC,CAAC,GAAG,CAAC,IAAI,CAAC,WAAW,EAAE,CAAC,CAAC;IAC9D,IAAI,CAAC,KAAK;QAAE,OAAO,KAAK,CAAC;IACzB,OAAO,KAAK,CAAC,QAAQ,CAAC,QAAQ,CAAC,WAAW,EAAE,CAAC,CAAC;AAChD,CAAC;AAED;;;;;;GAMG;AACH,MAAM,UAAU,cAAc,CAC5B,UAAwC,EACxC,IAAY,EACZ,QAAgB;IAEhB,OAAO,UAAU,CAAC,IAAI,CAAC,CAAC,QAAQ,EAAE,EAAE,CAAC,WAAW,CAAC,QAAQ,EAAE,IAAI,EAAE,QAAQ,CAAC,CAAC,CAAC;AAC9E,CAAC;AAED;;;;;;;;GAQG;AACH,MAAM,UAAU,iBAAiB,CAAC,QAA2B,EAAE,IAAY,EAAE,QAAgB;IAC3F,OAAO,IAAI,CAAC,WAAW,EAAE,KAAK,QAAQ,CAAC,WAAW,EAAE,IAAI,WAAW,CAAC,QAAQ,EAAE,IAAI,EAAE,QAAQ,CAAC,CAAC;AAChG,CAAC;AAED,wEAAwE;AACxE,MAAM,UAAU,oBAAoB,CAClC,UAAwC,EACxC,IAAY,EACZ,QAAgB;IAEhB,OAAO,UAAU,CAAC,IAAI,CAAC,CAAC,QAAQ,EAAE,EAAE,CAAC,iBAAiB,CAAC,QAAQ,EAAE,IAAI,EAAE,QAAQ,CAAC,CAAC,CAAC;AACpF,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ifc-lite/codegen",
-  "version": "1.15.12",
+  "version": "1.17.0",
   "description": "TypeScript code generator from IFC EXPRESS schemas",
   "type": "module",
   "repository": {
@@ -10,6 +10,33 @@
   },
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    },
+    "./schema-hierarchy": {
+      "types": "./dist/schema-hierarchy.d.ts",
+      "import": "./dist/schema-hierarchy.js",
+      "default": "./dist/schema-hierarchy.js"
+    },
+    "./ifc4": {
+      "types": "./dist/generated/ifc4/index.d.ts",
+      "import": "./dist/generated/ifc4/index.js",
+      "default": "./dist/generated/ifc4/index.js"
+    },
+    "./ifc4x3": {
+      "types": "./dist/generated/ifc4x3/index.d.ts",
+      "import": "./dist/generated/ifc4x3/index.js",
+      "default": "./dist/generated/ifc4x3/index.js"
+    },
+    "./ifc2x3": {
+      "types": "./dist/generated/ifc2x3/index.d.ts",
+      "import": "./dist/generated/ifc2x3/index.js",
+      "default": "./dist/generated/ifc2x3/index.js"
+    }
+  },
   "keywords": [
     "ifc",
     "express",
@@ -20,10 +47,10 @@
   "license": "MPL-2.0",
   "dependencies": {
     "commander": "^15.0.0",
-    "@ifc-lite/data": "^4.0.0"
+    "@ifc-lite/data": "^4.2.0"
   },
   "devDependencies": {
-    "@types/node": "^26.4.0",
+    "@types/node": "^26.4.1",
     "typescript": "^6.0.3",
     "vitest": "^4.1.11"
   },
@@ -38,12 +65,13 @@
     "README.md"
   ],
   "scripts": {
-    "build": "pnpm exec tsc",
+    "build": "pnpm exec tsc && pnpm exec tsc -p tsconfig.generated.json",
     "typecheck": "node ../../scripts/typecheck-tests.mjs",
     "dev": "pnpm exec tsc --watch",
     "test": "vitest run",
     "generate": "node dist/cli.js",
     "generate:ifc4": "node dist/cli.js schemas/IFC4_ADD2_TC1.exp -o generated/ifc4",
-    "generate:ifc4x3": "node dist/cli.js schemas/IFC4X3.exp -o generated/ifc4x3"
+    "generate:ifc4x3": "node dist/cli.js schemas/IFC4X3.exp -o generated/ifc4x3",
+    "generate:ifc2x3": "node dist/cli.js schemas/IFC2X3_TC1.exp -o generated/ifc2x3"
   }
 }