@ifc-lite/export 2.8.1 → 2.8.4

package/dist/step-argument-parser.d.ts

@@ -0,0 +1,90 @@
+/**
+ * The STEP argument parser and rewriter: reading a record's top-level argument
+ * list out of its text, and writing one slot back.
+ *
+ * This is the one text layer that goes the other way from the rest of the
+ * export path — everything in `step-serialization.ts` turns a value INTO a
+ * token, while these three read tokens back OUT of a line someone else wrote
+ * (or that an earlier pass rewrote) and hand them to a caller that edits by
+ * slot index. Nothing here depends on exporter state; the input is a string and
+ * the output is parts or a rewritten string.
+ *
+ * They live together because they share one set of rules — quote state,
+ * doubled-quote escapes, paren depth, what counts as a slot — and those rules
+ * are what a caller has to be able to find when a line comes out wrong. The
+ * failure they exist to prevent is silent: a mis-scanned list still produces
+ * parts, and writing a slot by index into those parts lands on the wrong
+ * argument while reporting success (LTplus-AG/ifc-lite#2470).
+ */
+/**
+ * Split a STEP argument list on top-level commas, respecting nested
+ * parentheses and quoted strings. Used by `applyAttributeMutations`.
+ */
+export declare function splitTopLevelArgs(text: string): string[];
+/**
+ * Replace ONE top-level argument of a STEP record, by zero-based slot, leaving
+ * every other token — and the record's class keyword and id — byte-identical.
+ *
+ * Takes the LINE, not an expressId: the caller may hold a line that is no
+ * longer what the source buffer says. The type-object `HasPropertySets`
+ * rewrite is exactly that case — it hands in a line the retype / attribute /
+ * positional pipeline has already rewritten, and re-reading the buffer here
+ * would throw all of that away (which is how that path used to drop every
+ * edit but the pset repoint).
+ *
+ * Returns null when the text is not a parseable single STEP record or the slot
+ * is past the end of the argument list; a null must not be treated as "no
+ * change", since the intended replacement did not happen.
+ *
+ * The regex only pins the two ENDS of the record — `#N=CLASS(` and `);`. Text
+ * malformed BETWEEN them is caught by {@link splitTopLevelStepArguments}, which
+ * rejects an argument list it could not scan cleanly rather than handing back
+ * whatever it accumulated: those parts are not the record's slots, so writing
+ * one lands on the wrong argument and reports a success that did not happen
+ * (#2470). Silently corrupted output instead of a dropped entity, same class.
+ */
+export declare function replaceStepArgument(entityText: string, attrIndex: number, replacement: string): string | null;
+/**
+ * Split a STEP argument list on top-level commas while preserving nested syntax,
+ * or null when the text is not a well-formed argument list.
+ *
+ * Similar to `splitTopLevelArgs` but uses a slightly different accumulation style
+ * suited for the {@link replaceStepArgument} call-site.
+ *
+ * ## Why it validates
+ *
+ * The scan already tracks quote state and paren depth to know where a top-level
+ * comma is. It used to ignore the final state, so text that never left a string
+ * or never closed a list still produced parts — parts whose boundaries are
+ * wherever the scanner happened to be, not the record's slots. Both callers then
+ * acted on them: `replaceStepArgument` wrote a slot by index and reported
+ * success, and the unit rescale multiplied numbers in whatever argument the
+ * mis-split had put them in. Neither could tell, because a broken split looks
+ * exactly like a good one.
+ *
+ * Rejected, because after either of these the parts are no longer the record's
+ * arguments — commas were swallowed and everything past them shifted:
+ *   - a quote left open at the end (unterminated string);
+ *   - a paren depth that does not return to zero, or that ever goes below it
+ *     (unbalanced or stray-closing nested list). Both ends matter: a depth that
+ *     dips negative and climbs back looks balanced at the end while every comma
+ *     in between was read as nested.
+ *
+ * An EMPTY top-level slot (`a,,b`, or a trailing comma) is deliberately NOT
+ * rejected, though it is invalid STEP. It costs no alignment: an empty argument
+ * is ONE part, exactly as the entity parser counts it, so every index still
+ * names the attribute it is meant to and the replacement lands where it should.
+ * Rejecting it made things strictly worse, and measurably: the parser resolves
+ * `HasPropertySets` on such a line, so a session deleting that type object's
+ * property set has already had the pset's lines WITHHELD by the time the repoint
+ * runs — refuse the repoint and the record keeps a `#id` pointing at a property
+ * set the export just dropped. A dangling reference is worse than a
+ * still-invalid-but-unchanged empty slot.
+ *
+ * An empty INPUT is not an empty slot: `#1=IFCFOO();` is a record with no
+ * arguments, so it splits to `[]` and any slot request then fails the bounds
+ * check in {@link replaceStepArgument} — which is the right answer for a record
+ * that has no slots.
+ */
+export declare function splitTopLevelStepArguments(input: string): string[] | null;
+//# sourceMappingURL=step-argument-parser.d.ts.map

package/dist/step-argument-parser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"step-argument-parser.d.ts","sourceRoot":"","sources":["../src/step-argument-parser.ts"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;;;;GAiBG;AAEH;;;GAGG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE,CAsDxD;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,mBAAmB,CACjC,UAAU,EAAE,MAAM,EAClB,SAAS,EAAE,MAAM,EACjB,WAAW,EAAE,MAAM,GAClB,MAAM,GAAG,IAAI,CAyBf;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyCG;AACH,wBAAgB,0BAA0B,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,EAAE,GAAG,IAAI,CA0CzE"}

package/dist/step-argument-parser.js

@@ -0,0 +1,207 @@
+/* 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/. */
+/**
+ * The STEP argument parser and rewriter: reading a record's top-level argument
+ * list out of its text, and writing one slot back.
+ *
+ * This is the one text layer that goes the other way from the rest of the
+ * export path — everything in `step-serialization.ts` turns a value INTO a
+ * token, while these three read tokens back OUT of a line someone else wrote
+ * (or that an earlier pass rewrote) and hand them to a caller that edits by
+ * slot index. Nothing here depends on exporter state; the input is a string and
+ * the output is parts or a rewritten string.
+ *
+ * They live together because they share one set of rules — quote state,
+ * doubled-quote escapes, paren depth, what counts as a slot — and those rules
+ * are what a caller has to be able to find when a line comes out wrong. The
+ * failure they exist to prevent is silent: a mis-scanned list still produces
+ * parts, and writing a slot by index into those parts lands on the wrong
+ * argument while reporting success (LTplus-AG/ifc-lite#2470).
+ */
+/**
+ * Split a STEP argument list on top-level commas, respecting nested
+ * parentheses and quoted strings. Used by `applyAttributeMutations`.
+ */
+export function splitTopLevelArgs(text) {
+    const parts = [];
+    let current = '';
+    let depth = 0;
+    let inString = false;
+    for (let i = 0; i < text.length; i++) {
+        const char = text[i];
+        current += char;
+        if (inString) {
+            if (char === '\'') {
+                if (text[i + 1] === '\'') {
+                    current += text[i + 1];
+                    i++;
+                }
+                else {
+                    inString = false;
+                }
+            }
+            continue;
+        }
+        if (char === '\'') {
+            inString = true;
+            continue;
+        }
+        if (char === '(') {
+            depth++;
+            continue;
+        }
+        if (char === ')') {
+            depth--;
+            continue;
+        }
+        if (char === ',' && depth === 0) {
+            parts.push(current.slice(0, -1).trim());
+            current = '';
+        }
+    }
+    // Trailing tokens: only push if there's actual content. The previous
+    // `text.endsWith(',')` check pushed an empty trailing token for inputs
+    // like `"a,"`, producing `['a', '']` — STEP doesn't allow trailing
+    // commas, so the right answer is just `['a']`. Empty interior args
+    // (e.g. `"a,,b"` → `['a', '', 'b']`) are still produced because the
+    // comma branch above handles them.
+    if (current.trim()) {
+        parts.push(current.trim());
+    }
+    return parts;
+}
+/**
+ * Replace ONE top-level argument of a STEP record, by zero-based slot, leaving
+ * every other token — and the record's class keyword and id — byte-identical.
+ *
+ * Takes the LINE, not an expressId: the caller may hold a line that is no
+ * longer what the source buffer says. The type-object `HasPropertySets`
+ * rewrite is exactly that case — it hands in a line the retype / attribute /
+ * positional pipeline has already rewritten, and re-reading the buffer here
+ * would throw all of that away (which is how that path used to drop every
+ * edit but the pset repoint).
+ *
+ * Returns null when the text is not a parseable single STEP record or the slot
+ * is past the end of the argument list; a null must not be treated as "no
+ * change", since the intended replacement did not happen.
+ *
+ * The regex only pins the two ENDS of the record — `#N=CLASS(` and `);`. Text
+ * malformed BETWEEN them is caught by {@link splitTopLevelStepArguments}, which
+ * rejects an argument list it could not scan cleanly rather than handing back
+ * whatever it accumulated: those parts are not the record's slots, so writing
+ * one lands on the wrong argument and reports a success that did not happen
+ * (#2470). Silently corrupted output instead of a dropped entity, same class.
+ */
+export function replaceStepArgument(entityText, attrIndex, replacement) {
+    const match = entityText.match(/^(#\d+\s*=\s*\w+\()([\s\S]*)(\)\s*;)\s*$/);
+    if (!match)
+        return null;
+    const [, prefix, attrsText, suffix] = match;
+    const attrs = splitTopLevelStepArguments(attrsText);
+    // Load-bearing, and covered: the bounds check below READS `attrs.length`, so a
+    // null reaches it as a TypeError rather than falling through to a rejection.
+    // Deleting this line fails exactly the three malformed-input cases in
+    // `step-argument-parser.test.ts` — unterminated string, unbalanced list, stray
+    // closing paren — which throw instead of returning null. Kept as its own line,
+    // not folded into that check, because "could not scan it" and "that slot is
+    // past the end" are different facts about the input.
+    if (attrs === null)
+        return null;
+    // A negative or fractional slot must not reach the assignment below: it would
+    // set a NAMED PROPERTY on the array rather than an element, `join` would skip
+    // it, and this would hand back the line unchanged — but non-null, which the
+    // contract above says means the replacement happened. `rewriteTypeOwnedPsetLine`
+    // reads that as `repointed: true` and would report a repoint that never
+    // occurred. Unreachable today (the only slot is a constant), guarded because
+    // the function is exported and the non-null contract is load-bearing.
+    if (!Number.isInteger(attrIndex) || attrIndex < 0 || attrIndex >= attrs.length)
+        return null;
+    attrs[attrIndex] = replacement;
+    return `${prefix}${attrs.join(',')}${suffix}`;
+}
+/**
+ * Split a STEP argument list on top-level commas while preserving nested syntax,
+ * or null when the text is not a well-formed argument list.
+ *
+ * Similar to `splitTopLevelArgs` but uses a slightly different accumulation style
+ * suited for the {@link replaceStepArgument} call-site.
+ *
+ * ## Why it validates
+ *
+ * The scan already tracks quote state and paren depth to know where a top-level
+ * comma is. It used to ignore the final state, so text that never left a string
+ * or never closed a list still produced parts — parts whose boundaries are
+ * wherever the scanner happened to be, not the record's slots. Both callers then
+ * acted on them: `replaceStepArgument` wrote a slot by index and reported
+ * success, and the unit rescale multiplied numbers in whatever argument the
+ * mis-split had put them in. Neither could tell, because a broken split looks
+ * exactly like a good one.
+ *
+ * Rejected, because after either of these the parts are no longer the record's
+ * arguments — commas were swallowed and everything past them shifted:
+ *   - a quote left open at the end (unterminated string);
+ *   - a paren depth that does not return to zero, or that ever goes below it
+ *     (unbalanced or stray-closing nested list). Both ends matter: a depth that
+ *     dips negative and climbs back looks balanced at the end while every comma
+ *     in between was read as nested.
+ *
+ * An EMPTY top-level slot (`a,,b`, or a trailing comma) is deliberately NOT
+ * rejected, though it is invalid STEP. It costs no alignment: an empty argument
+ * is ONE part, exactly as the entity parser counts it, so every index still
+ * names the attribute it is meant to and the replacement lands where it should.
+ * Rejecting it made things strictly worse, and measurably: the parser resolves
+ * `HasPropertySets` on such a line, so a session deleting that type object's
+ * property set has already had the pset's lines WITHHELD by the time the repoint
+ * runs — refuse the repoint and the record keeps a `#id` pointing at a property
+ * set the export just dropped. A dangling reference is worse than a
+ * still-invalid-but-unchanged empty slot.
+ *
+ * An empty INPUT is not an empty slot: `#1=IFCFOO();` is a record with no
+ * arguments, so it splits to `[]` and any slot request then fails the bounds
+ * check in {@link replaceStepArgument} — which is the right answer for a record
+ * that has no slots.
+ */
+export function splitTopLevelStepArguments(input) {
+    if (input.trim() === '')
+        return [];
+    const parts = [];
+    let current = '';
+    let depth = 0;
+    let inString = false;
+    for (let i = 0; i < input.length; i++) {
+        const char = input[i];
+        if (char === "'") {
+            current += char;
+            if (inString && i + 1 < input.length && input[i + 1] === "'") {
+                current += input[i + 1];
+                i++;
+                continue;
+            }
+            inString = !inString;
+            continue;
+        }
+        if (!inString) {
+            if (char === '(')
+                depth++;
+            else if (char === ')') {
+                depth--;
+                // Already past the record's own closing paren: every comma from here
+                // would be read as nested and the split is meaningless.
+                if (depth < 0)
+                    return null;
+            }
+            else if (char === ',' && depth === 0) {
+                parts.push(current);
+                current = '';
+                continue;
+            }
+        }
+        current += char;
+    }
+    if (inString || depth !== 0)
+        return null;
+    parts.push(current);
+    return parts;
+}
+//# sourceMappingURL=step-argument-parser.js.map

package/dist/step-argument-parser.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"step-argument-parser.js","sourceRoot":"","sources":["../src/step-argument-parser.ts"],"names":[],"mappings":"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"}

package/dist/step-exporter.d.ts

@@ -100,6 +100,19 @@ export interface StepExportResult {
         modifiedEntityCount: number;
         /** File size in bytes */
         fileSize: number;
+        /**
+         * Non-fatal refusals: things the caller asked for that this export could
+         * not write. Empty when the export did everything it was asked to do.
+         *
+         * A requested `georefMutations.mapConversion` is the one case today: with
+         * no `IfcGeometricRepresentationContext` to reference as `SourceCRS`, the
+         * `IfcMapConversion` is skipped (writing it would produce a dangling
+         * reference) while the `IfcProjectedCRS` is still written — so the output
+         * is indistinguishable from "no map conversion was requested" unless the
+         * caller reads this (#2067). Same `string[]` shape as
+         * `MergeExportResult.stats.warnings`.
+         */
+        warnings: string[];
     };
 }
 /**
@@ -176,6 +189,51 @@ export declare class StepExporter {
      * Generate STEP entities for quantity sets (IfcElementQuantity)
      */
     private generateQuantitySetEntities;
+    /**
+     * THE mutation pipeline for a line read out of the source buffer: retype,
+     * then named attribute edits, then positional edits.
+     *
+     * **One implementation, two call sites**, and that is the whole point. Two
+     * passes can write the defining line of a source entity — the
+     * source-iteration pass, and the type-object `HasPropertySets` rewrite that
+     * REPLACES it (`rewrittenEntityIds` makes the source pass skip those ids).
+     * The rewrite used to do its own thing (replace slot 5, nothing else), so
+     * every other edit to a type object with a type-owned pset edit was dropped
+     * in silence: first the renames (#2462 follow-up), and after those were
+     * special-cased here, still the retypes and the positional edits. Whatever
+     * the source pass applies, the rewrite has to apply too, or the next edit
+     * kind added to one site goes missing at the other.
+     *
+     * The order is load-bearing:
+     *
+     *   - the retype runs FIRST so named attribute edits resolve against the
+     *     TARGET class's attribute names, and so positional slots are indexed
+     *     into the retyped argument list;
+     *   - the `HasPropertySets` replacement (rewrite path only) runs LAST, on
+     *     the text this returns. Run it first and a positional edit to slot 5 —
+     *     or a retype's argument-list rebuild — overwrites the resolved pset
+     *     list with the stale one, which is the same silent drop one slot over.
+     *
+     * The expressId is unchanged by all of this, so geometry / placement /
+     * representation and every IfcRel* reference (keyed by #id) carry over.
+     *
+     * All three flags report EFFECT, not intent — each is the answer to "did this
+     * operation change the line", measured across that operation alone. The count
+     * and the ledger are claims about the FILE, so an edit that resolves to the
+     * text already there has delivered nothing and must not be reported: retyping
+     * an entity to the class it already is, or writing a positional slot the token
+     * it already holds, used to count as a modification and reach the ledger as a
+     * landed edit, over a byte-identical line. Discarded edits read the same way:
+     * `applyAttributeMutations` drops a name its class has no slot for and
+     * `retypeStepLine` returns an unparseable line untouched, and neither is a
+     * modification of anything.
+     *
+     * `retyped` / `positional` matter most in a FULL export, which is where the
+     * two are nominated (their edits have no earlier nomination site); named
+     * attribute edits are nominated by the collection pass and `attributed` only
+     * settles their delivery.
+     */
+    private applySourceLineMutations;
     /**
      * Rewrite root IFC attributes directly on the original STEP entity line.
      */
@@ -233,7 +291,32 @@ export declare class StepExporter {
     private serializePositionalOverride;
     private resolveMapUnitReference;
     private normalizeMapUnitName;
+    /**
+     * `effective` filters the candidates the same way the georef reads above do:
+     * returning a tombstoned unit id hands the caller a `#id` for a line the
+     * export never writes. Returning null instead makes `resolveMapUnitReference`
+     * synthesise a fresh unit, which is the outcome a deleted unit deserves.
+     */
     private findLengthUnitReference;
+    /**
+     * Record that a requested IfcMapConversion could not be written. Emitting it
+     * anyway would leave `SourceCRS` pointing at nothing, so the refusal is the
+     * correct output — but the file alone cannot express it, which is why it goes
+     * back to the caller in `stats.warnings` as well as to the console (#2067).
+     */
+    private reportMapConversionRefused;
+    /**
+     * Record that a requested IfcMapConversion could not be written because
+     * there is no IfcProjectedCRS to attach it to — a different refusal from
+     * {@link reportMapConversionRefused}: "no CRS to attach it to" rather than
+     * "no context to reference" (#2105).
+     */
+    private reportMapConversionRefusedNoCrs;
+    /**
+     * `effective` again: the id returned here becomes the new IfcMapConversion's
+     * SourceCRS, so a tombstoned context would leave the created line pointing at
+     * a record the export skips — a dangling reference and an invalid file.
+     */
     private findPreferredGeometricRepresentationContextId;
     /**
      * Generate a new IFC GlobalId (22 character base64). `random` is the
@@ -309,10 +392,6 @@ export declare class StepExporter {
      * relation instead (#2012).
      */
     private getTypeOwnedHasPropertySetIds;
-    /**
-     * Replace a single top-level STEP attribute in an entity line.
-     */
-    private replaceEntityAttribute;
 }
 /**
  * Quick export function for simple use cases.

package/dist/step-exporter.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"step-exporter.d.ts","sourceRoot":"","sources":["../src/step-exporter.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"step-exporter.d.ts","sourceRoot":"","sources":["../src/step-exporter.ts"],"names":[],"mappings":"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"}