@ifc-lite/codegen 1.15.3 → 1.15.4

package/.turbo/turbo-build.log

@@ -1,4 +1,4 @@
 
-> @ifc-lite/codegen@1.15.3 build /home/runner/work/ifc-lite/ifc-lite/packages/codegen
+> @ifc-lite/codegen@1.15.4 build /home/runner/work/ifc-lite/ifc-lite/packages/codegen
 > pnpm exec tsc
 

package/CHANGELOG.md

@@ -1,5 +1,53 @@
 # @ifc-lite/codegen
 
+## 1.15.4
+
+### Patch Changes
+
+- [#1151](https://github.com/LTplus-AG/ifc-lite/pull/1151) [`bfd9004`](https://github.com/LTplus-AG/ifc-lite/commit/bfd9004daa17f481a7b33b5c3c11f620e6cd894d) Thanks [@louistrue](https://github.com/louistrue)! - De-duplicate the STEP serializer into a single source of truth. The
+  schema-agnostic STEP serialization logic (`serializeValue`, `generateHeader`,
+  `parseStepValue`, `ref`/`enumVal`/`isEntityRef`/`isEnumValue`, and the
+  registry-injected `toStepLineWithRegistry` / `generateStepFileWithRegistry`)
+  previously existed as four hand-synced copies — the codegen template plus three
+  generated `serializers.ts` files — which had already silently drifted (the
+  runtime copy carried a `?? []` hardening the template lacked). It now lives once
+  in `@ifc-lite/data`; the per-schema bundles (parser runtime + codegen outputs)
+  are thin re-exports that only bind their own `SCHEMA_REGISTRY` to the
+  registry-coupled helpers, so the copies can never diverge again. A codegen test
+  asserts the generated bundle stays a thin re-export rather than re-inlining
+  logic.
+
+  Also fixes the broken `generate:ifc4` script (it pointed at a non-existent
+  `schemas/IFC4.exp`; the real file is `schemas/IFC4_ADD2_TC1.exp`). No public
+  behaviour change: `@ifc-lite/parser` re-exports the same serializer symbols as
+  before; `@ifc-lite/data` gains the shared primitives; `@ifc-lite/codegen` now
+  declares `@ifc-lite/data` as a dependency since the generated bundle imports it.
+
+- [#1143](https://github.com/LTplus-AG/ifc-lite/pull/1143) [`248f2c0`](https://github.com/LTplus-AG/ifc-lite/commit/248f2c09a4d61fa27dfeaba5511a2a641d4cd278) Thanks [@louistrue](https://github.com/louistrue)! - Preserve source IFC HEADER fields on round-trip export. Re-exporting an
+  imported file previously regenerated a fresh ifc-lite header, silently dropping
+  the source `FILE_DESCRIPTION` items (any `ViewDefinition [...]` label and vendor
+  identifier / coordinate-reference strings) and flattening the exact
+  `FILE_SCHEMA` token (e.g. `IFC4X3_ADD2` → `IFC4X3`, which some toolchains
+  reject).
+
+  The parser now captures the verbatim HEADER onto a new
+  `IfcDataStore.sourceHeader` (`IfcSourceHeader`, exported from `@ifc-lite/data`;
+  parser also exports `parseSourceHeader`), threaded through the worker transport.
+  `StepExporter` reproduces the source `FILE_DESCRIPTION` items and the exact
+  `FILE_SCHEMA` token when not converting schemas, falling back to parsing the
+  source bytes for cache-restored stores. Provenance stays honest:
+  `preprocessor_version` is set to `ifc-lite` while the source authoring tool is
+  kept as `originating_system`, and when mutations exist exactly one
+  `Re-exported by ifc-lite, N modification(s)` item is appended without removing
+  the source items. `generateHeader` now accepts description/author/organization
+  arrays plus a free-form schema token and STEP-escapes all fields; it also emits
+  a properly parenthesised `FILE_DESCRIPTION` list (the prior single-string form
+  was malformed STEP). Created-from-scratch (`IfcCreator`) and federated/merged
+  exports are unaffected — they keep their own provenance headers by design.
+
+- Updated dependencies [[`bfd9004`](https://github.com/LTplus-AG/ifc-lite/commit/bfd9004daa17f481a7b33b5c3c11f620e6cd894d), [`248f2c0`](https://github.com/LTplus-AG/ifc-lite/commit/248f2c09a4d61fa27dfeaba5511a2a641d4cd278), [`ddae2b0`](https://github.com/LTplus-AG/ifc-lite/commit/ddae2b0024f071d00f9e6e4b77e0be3965412ec3)]:
+  - @ifc-lite/data@2.1.0
+
 ## 1.15.3
 
 ### Patch Changes

package/INTEGRATION.md

@@ -44,6 +44,12 @@ npm run generate:ifc4x3
 
 Generated files: `packages/codegen/generated/ifc4/` or `generated/ifc4x3/`
 
+> **Runtime dependency:** the generated `serializers.ts` is a thin re-export of
+> the schema-agnostic STEP serializer in `@ifc-lite/data` (it only binds the
+> bundle's `SCHEMA_REGISTRY`). Any project that consumes a generated bundle must
+> therefore have `@ifc-lite/data` installed. This keeps the serialization logic
+> in one place so the per-schema copies can never drift.
+
 ### Step 2: Copy Generated Files to Parser
 
 Option A: **Direct Copy** (recommended for testing)

package/dist/serialization-generator.d.ts

@@ -1,11 +1,16 @@
 /**
  * Serialization Generator
  *
- * Generates TypeScript code for serializing IFC entities to STEP format.
+ * Emits the per-schema STEP serializer bundle file. The serialization LOGIC is
+ * schema-agnostic and lives once in `@ifc-lite/data`; this generator emits only
+ * a thin binding that re-exports those primitives and binds the bundle's
+ * `SCHEMA_REGISTRY` to the registry-coupled helpers. Keeping the logic in a
+ * single place means the generated copies can never drift from the runtime.
  */
 import type { ExpressSchema } from './express-parser.js';
 /**
- * Generate serialization support code
+ * Generate serialization support code — a thin re-export of the shared
+ * `@ifc-lite/data` STEP serializer with this schema's registry bound in.
  */
 export declare function generateSerializers(schema: ExpressSchema): string;
 //# sourceMappingURL=serialization-generator.d.ts.map

package/dist/serialization-generator.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"serialization-generator.d.ts","sourceRoot":"","sources":["../src/serialization-generator.ts"],"names":[],"mappings":"AAIA;;;;GAIG;AAEH,OAAO,KAAK,EAAE,aAAa,EAAyC,MAAM,qBAAqB,CAAC;AAGhG;;GAEG;AACH,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,aAAa,GAAG,MAAM,CAsUjE"}
+{"version":3,"file":"serialization-generator.d.ts","sourceRoot":"","sources":["../src/serialization-generator.ts"],"names":[],"mappings":"AAIA;;;;;;;;GAQG;AAEH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AAEzD;;;GAGG;AACH,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,aAAa,GAAG,MAAM,CAqDjE"}

package/dist/serialization-generator.js

@@ -2,10 +2,11 @@
  * 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/. */
 /**
- * Generate serialization support code
+ * Generate serialization support code — a thin re-export of the shared
+ * `@ifc-lite/data` STEP serializer with this schema's registry bound in.
  */
 export function generateSerializers(schema) {
-    let code = `/* This Source Code Form is subject to the terms of the Mozilla Public
+    return `/* 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/. */
 
@@ -13,321 +14,49 @@ export function generateSerializers(schema) {
  * IFC Serialization Support
  * Generated from EXPRESS schema: ${schema.name}
  *
- * Utilities for serializing IFC entities to STEP format.
+ * Thin binding over the shared, schema-agnostic STEP serializer in
+ * \`@ifc-lite/data\`. All serialization logic lives there (single source of
+ * truth); only this bundle's \`SCHEMA_REGISTRY\` is bound to the registry-coupled
+ * helpers below.
  *
  * DO NOT EDIT - This file is auto-generated
  */
 
 import { SCHEMA_REGISTRY } from './schema-registry.js';
-
-/**
- * STEP value types
- */
-export type StepValue =
-  | string
-  | number
-  | boolean
-  | null
-  | undefined
-  | StepValue[]
-  | EntityRef
-  | EnumValue;
-
-/**
- * Entity reference (#123)
- */
-export interface EntityRef {
-  ref: number;
-}
-
-/**
- * Enum value (.VALUE.)
- */
-export interface EnumValue {
-  enum: string;
-}
-
-/**
- * Check if value is an entity reference
- */
-export function isEntityRef(value: unknown): value is EntityRef {
-  return typeof value === 'object' && value !== null && 'ref' in value;
-}
-
-/**
- * Check if value is an enum value
- */
-export function isEnumValue(value: unknown): value is EnumValue {
-  return typeof value === 'object' && value !== null && 'enum' in value;
-}
-
-/**
- * Create an entity reference
- */
-export function ref(id: number): EntityRef {
-  return { ref: id };
-}
-
-/**
- * Create an enum value
- */
-export function enumVal(value: string): EnumValue {
-  return { enum: value };
-}
-
-/**
- * Base interface for serializable entities
- */
-export interface StepEntity {
-  /** Express ID (#123) */
-  expressId: number;
-  /** IFC type name */
-  type: string;
-  /** Attribute values */
-  [key: string]: unknown;
-}
-
-/**
- * Serialize a single value to STEP format
- */
-export function serializeValue(value: StepValue): string {
-  // Null/undefined -> $
-  if (value === null || value === undefined) {
-    return '$';
-  }
-
-  // Derived value -> *
-  if (value === '*') {
-    return '*';
-  }
-
-  // Boolean
-  if (typeof value === 'boolean') {
-    return value ? '.T.' : '.F.';
-  }
-
-  // Number
-  if (typeof value === 'number') {
-    if (!Number.isFinite(value)) {
-      return '$';
-    }
-    // Use exponential notation for large/small numbers
-    if (Math.abs(value) > 1e10 || (Math.abs(value) < 1e-10 && value !== 0)) {
-      return value.toExponential(10).toUpperCase().replace('E+', 'E');
-    }
-    // Otherwise use fixed notation
-    const str = value.toString();
-    // Ensure there's a decimal point for REAL values
-    return str.includes('.') ? str : str + '.';
-  }
-
-  // String
-  if (typeof value === 'string') {
-    return "'" + escapeStepString(value) + "'";
-  }
-
-  // Entity reference
-  if (isEntityRef(value)) {
-    return '#' + value.ref;
-  }
-
-  // Enum value
-  if (isEnumValue(value)) {
-    return '.' + value.enum + '.';
-  }
-
-  // Array/List
-  if (Array.isArray(value)) {
-    if (value.length === 0) {
-      return '()';
-    }
-    return '(' + value.map(v => serializeValue(v as StepValue)).join(',') + ')';
-  }
-
-  // Object (shouldn't happen for valid STEP values)
-  return '$';
-}
-
-/**
- * Escape a string for STEP format
- */
-function escapeStepString(str: string): string {
-  return str
-    .replace(/\\\\/g, '\\\\\\\\')  // Backslash
-    .replace(/'/g, "''");           // Single quote
-}
-
-/**
- * Serialize an entity to a STEP line
+import {
+  generateHeader,
+  generateStepFileWithRegistry,
+  toStepLineWithRegistry,
+  type StepEntity,
+} from '@ifc-lite/data';
+
+export {
+  isEntityRef,
+  isEnumValue,
+  ref,
+  enumVal,
+  serializeValue,
+  generateHeader,
+  parseStepValue,
+} from '@ifc-lite/data';
+export type { StepValue, EntityRef, EnumValue, StepEntity } from '@ifc-lite/data';
+
+/**
+ * Serialize an entity to a STEP line (bound to this bundle's schema).
  */
 export function toStepLine(entity: StepEntity): string {
-  const schema = SCHEMA_REGISTRY.entities[entity.type];
-  if (!schema) {
-    throw new Error(\`Unknown entity type: \${entity.type}\`);
-  }
-
-  // Get all attributes in order
-  const values: string[] = [];
-  for (const attr of schema.allAttributes) {
-    const value = entity[attr.name];
-    values.push(serializeValue(value as StepValue));
-  }
-
-  return \`#\${entity.expressId}=\${entity.type.toUpperCase()}(\${values.join(',')});\`;
+  return toStepLineWithRegistry(SCHEMA_REGISTRY, entity);
 }
 
 /**
- * Generate STEP file header
- */
-export function generateHeader(options: {
-  description?: string;
-  author?: string;
-  organization?: string;
-  application?: string;
-  schema: 'IFC2X3' | 'IFC4' | 'IFC4X3' | 'IFC5';
-  filename?: string;
-}): string {
-  const now = new Date().toISOString().replace(/[-:]/g, '').split('.')[0];
-  const desc = options.description || 'ViewDefinition [CoordinationView]';
-  const author = options.author || '';
-  const org = options.organization || '';
-  const app = options.application || 'ifc-lite';
-  const filename = options.filename || 'output.ifc';
-
-  return \`ISO-10303-21;
-HEADER;
-FILE_DESCRIPTION('\${desc}','2;1');
-FILE_NAME('\${filename}','\${now}',('\${author}'),('\${org}'),'\${app}','\${app}','');
-FILE_SCHEMA(('\${options.schema}'));
-ENDSEC;
-\`;
-}
-
-/**
- * Generate complete STEP file content
+ * Generate complete STEP file content (bound to this bundle's schema).
  */
 export function generateStepFile(
   entities: StepEntity[],
   options: Parameters<typeof generateHeader>[0]
 ): string {
-  const header = generateHeader(options);
-
-  // Sort entities by ID for deterministic output
-  const sorted = [...entities].sort((a, b) => a.expressId - b.expressId);
-
-  const data = sorted.map(e => toStepLine(e)).join('\\n');
-
-  return \`\${header}DATA;
-\${data}
-ENDSEC;
-END-ISO-10303-21;
-\`;
-}
-
-/**
- * Parse a STEP value from string
- */
-export function parseStepValue(str: string): StepValue {
-  str = str.trim();
-
-  // Null
-  if (str === '$') {
-    return null;
-  }
-
-  // Derived
-  if (str === '*') {
-    return '*' as unknown as StepValue;
-  }
-
-  // Boolean
-  if (str === '.T.') {
-    return true;
-  }
-  if (str === '.F.') {
-    return false;
-  }
-  if (str === '.U.') {
-    return null; // Unknown/indeterminate
-  }
-
-  // Entity reference
-  if (str.startsWith('#')) {
-    return { ref: parseInt(str.substring(1), 10) };
-  }
-
-  // Enum
-  if (str.startsWith('.') && str.endsWith('.')) {
-    return { enum: str.substring(1, str.length - 1) };
-  }
-
-  // String
-  if (str.startsWith("'") && str.endsWith("'")) {
-    return unescapeStepString(str.substring(1, str.length - 1));
-  }
-
-  // List
-  if (str.startsWith('(') && str.endsWith(')')) {
-    return parseStepList(str);
-  }
-
-  // Number
-  const num = parseFloat(str);
-  if (!isNaN(num)) {
-    return num;
-  }
-
-  // Unknown
-  return str;
-}
-
-/**
- * Parse a STEP list
- */
-function parseStepList(str: string): StepValue[] {
-  // Remove outer parentheses
-  const inner = str.substring(1, str.length - 1).trim();
-  if (inner === '') {
-    return [];
-  }
-
-  const values: StepValue[] = [];
-  let depth = 0;
-  let current = '';
-
-  for (let i = 0; i < inner.length; i++) {
-    const char = inner[i];
-
-    if (char === '(' || char === '[') {
-      depth++;
-      current += char;
-    } else if (char === ')' || char === ']') {
-      depth--;
-      current += char;
-    } else if (char === ',' && depth === 0) {
-      values.push(parseStepValue(current));
-      current = '';
-    } else {
-      current += char;
-    }
-  }
-
-  if (current.trim()) {
-    values.push(parseStepValue(current));
-  }
-
-  return values;
-}
-
-/**
- * Unescape a STEP string
- */
-function unescapeStepString(str: string): string {
-  return str
-    .replace(/''/g, "'")
-    .replace(/\\\\\\\\/g, '\\\\');
+  return generateStepFileWithRegistry(SCHEMA_REGISTRY, entities, options);
 }
 `;
-    return code;
 }
 //# sourceMappingURL=serialization-generator.js.map

package/dist/serialization-generator.js.map

@@ -1 +1 @@
-{"version":3,"file":"serialization-generator.js","sourceRoot":"","sources":["../src/serialization-generator.ts"],"names":[],"mappings":"AAAA;;+DAE+D;AAW/D;;GAEG;AACH,MAAM,UAAU,mBAAmB,CAAC,MAAqB;IACvD,IAAI,IAAI,GAAG;;;;;;oCAMuB,MAAM,CAAC,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA4T9C,CAAC;IAEA,OAAO,IAAI,CAAC;AACd,CAAC"}
+{"version":3,"file":"serialization-generator.js","sourceRoot":"","sources":["../src/serialization-generator.ts"],"names":[],"mappings":"AAAA;;+DAE+D;AAc/D;;;GAGG;AACH,MAAM,UAAU,mBAAmB,CAAC,MAAqB;IACvD,OAAO;;;;;;oCAM2B,MAAM,CAAC,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA6C9C,CAAC;AACF,CAAC"}