@ifc-lite/export 2.9.4 → 3.0.1

package/dist/step-export-contexts.js

@@ -0,0 +1,50 @@
+/* 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/. */
+import { applySourceLineMutations } from './step-attribute-mutations.js';
+import { applyOverlayEntityOverrides } from './step-overlay-attribute-overrides.js';
+import { relationshipWithheldWarning } from './step-export-types.js';
+import { isGeometryEntity } from './step-geometry-types.js';
+/**
+ * The state `step-source-iteration.ts` cannot read off the pass (#2475 2d).
+ *
+ * No `allocateExpressId`: that phase never allocates an id, it only rewrites
+ * lines that already have one. `applySourceLineMutations` (a free function in
+ * `step-attribute-mutations.ts`, closed over `mutationView` here) and
+ * `isGeometryEntity` are injected rather than read off the pass because each
+ * has readers outside this phase — the mutation pipeline is shared with the
+ * type-object `HasPropertySets` rewrite (see `StepExporter`'s
+ * `propertySetContext`, which stays a method because it mints express ids) and
+ * with the overlay-created-entities block in `export()`; `isGeometryEntity`
+ * with the visible-only setup closure and that same block.
+ *
+ * `propertySetContext` arrives as a THUNK, not a value: the phase calls it
+ * per use and the original method rebuilt it per call, which is the behaviour
+ * being preserved.
+ */
+export function buildSourceIterationContext(dataStore, mutationView, propertySetContext) {
+    return {
+        dataStore,
+        applySourceLineMutations: (expressId, entityText, recordType, attributeMutations, sourceSchema, overlayActive, onRejected) => applySourceLineMutations(mutationView, expressId, entityText, recordType, attributeMutations, sourceSchema, overlayActive, onRejected),
+        isGeometryEntity,
+        propertySetContext,
+        relationshipWithheldWarning,
+    };
+}
+/**
+ * The state `step-overlay-entities.ts` cannot read off the pass (#2475
+ * step 2e). `applyOverlayEntityOverrides` is the free function
+ * `step-overlay-attribute-overrides.ts` exports; `isGeometryEntity` and
+ * `relationshipWithheldWarning` are the same shared readers
+ * {@link buildSourceIterationContext} already injects into the other output
+ * pass.
+ */
+export function buildOverlayEntitiesContext(mutationView) {
+    return {
+        mutationView,
+        applyOverlayEntityOverrides,
+        isGeometryEntity,
+        relationshipWithheldWarning,
+    };
+}
+//# sourceMappingURL=step-export-contexts.js.map

package/dist/step-export-contexts.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"step-export-contexts.js","sourceRoot":"","sources":["../src/step-export-contexts.ts"],"names":[],"mappings":"AAAA;;+DAE+D;AAiC/D,OAAO,EAAE,wBAAwB,EAAE,MAAM,+BAA+B,CAAC;AACzE,OAAO,EAAE,2BAA2B,EAAE,MAAM,uCAAuC,CAAC;AACpF,OAAO,EAAE,2BAA2B,EAAE,MAAM,wBAAwB,CAAC;AACrE,OAAO,EAAE,gBAAgB,EAAE,MAAM,0BAA0B,CAAC;AAK5D;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,UAAU,2BAA2B,CACzC,SAAuB,EACvB,YAAwC,EACxC,kBAA4C;IAE5C,OAAO;QACL,SAAS;QACT,wBAAwB,EAAE,CAAC,SAAS,EAAE,UAAU,EAAE,UAAU,EAAE,kBAAkB,EAAE,YAAY,EAAE,aAAa,EAAE,UAAU,EAAE,EAAE,CAC3H,wBAAwB,CAAC,YAAY,EAAE,SAAS,EAAE,UAAU,EAAE,UAAU,EAAE,kBAAkB,EAAE,YAAY,EAAE,aAAa,EAAE,UAAU,CAAC;QACxI,gBAAgB;QAChB,kBAAkB;QAClB,2BAA2B;KAC5B,CAAC;AACJ,CAAC;AAED;;;;;;;GAOG;AACH,MAAM,UAAU,2BAA2B,CACzC,YAAwC;IAExC,OAAO;QACL,YAAY;QACZ,2BAA2B;QAC3B,gBAAgB;QAChB,2BAA2B;KAC5B,CAAC;AACJ,CAAC"}

package/dist/step-export-types.d.ts

@@ -0,0 +1,262 @@
+/**
+ * The vocabulary of a STEP export: what a caller asks for, what it gets back,
+ * and the state one `export()` call threads through its phases.
+ *
+ * Split out of `step-exporter.ts` for #2475. These are declarations only -- no
+ * behaviour lives here beyond one message builder -- which is why they could
+ * move without touching a single guard.
+ *
+ * Two ways in, deliberately. The seven sibling modules that already imported
+ * `ExportPass` / `SourceLineMutations` still import them from
+ * `step-exporter.js`, which re-exports this file, so no existing call site
+ * moved and the package's public entry point is untouched. Code written since
+ * the split imports straight from here instead -- `step-pass-builder.ts` does
+ * -- because the re-export exists to avoid churning callers, not as a channel
+ * anything new should be routed through.
+ */
+import type { IfcAttributeValue, IfcSourceHeader, MapConversion, ProjectedCRS } from '@ifc-lite/parser';
+import type { PropertySet, QuantitySet } from '@ifc-lite/data';
+import type { RandomSource } from '@ifc-lite/encoding';
+import type { IfcSchemaVersion } from './schema-converter.js';
+import type { ModificationLedger, SourceLineDelivery } from './delta-modification-ledger.js';
+import type { EffectiveEntityIndex } from './effective-index.js';
+import type { createSourceRefReader } from './source-ref-bounds.js';
+/**
+ * Options for STEP export
+ */
+export interface StepExportOptions {
+    /** IFC schema version for the output file (any version, will convert if needed) */
+    schema: 'IFC2X3' | 'IFC4' | 'IFC4X3' | 'IFC5';
+    /** File description */
+    description?: string;
+    /** Author name */
+    author?: string;
+    /** Organization name */
+    organization?: string;
+    /** Application name (defaults to 'ifc-lite') */
+    application?: string;
+    /** Output filename */
+    filename?: string;
+    /** Include original geometry entities (default: true) */
+    includeGeometry?: boolean;
+    /** Include property sets (default: true) */
+    includeProperties?: boolean;
+    /** Include quantity sets (default: true) */
+    includeQuantities?: boolean;
+    /** Include relationships (default: true) */
+    includeRelationships?: boolean;
+    /** Apply mutations from MutablePropertyView (default: true if provided) */
+    applyMutations?: boolean;
+    /** Only export entities with mutations (delta export) */
+    deltaOnly?: boolean;
+    /** Only export entities currently visible in the viewer */
+    visibleOnly?: boolean;
+    /** Hidden entity IDs (local expressIds) — required when visibleOnly is true */
+    hiddenEntityIds?: Set<number>;
+    /** Isolated entity IDs (local expressIds, null = no isolation active) */
+    isolatedEntityIds?: Set<number> | null;
+    /** Georeferencing mutations to apply (IfcProjectedCRS / IfcMapConversion edits) */
+    georefMutations?: {
+        projectedCRS?: Partial<ProjectedCRS>;
+        mapConversion?: Partial<MapConversion>;
+    };
+    /**
+     * Seeded randomness for the GlobalIds this exporter SYNTHESIZES:
+     * the `IfcPropertySet` / `IfcElementQuantity` roots regenerated for
+     * mutated (or overlay-created) property and quantity sets, their
+     * `IfcRelDefinesByProperties` links. Without it those come from the platform
+     * CSPRNG, so two exports of the same model differ in exactly those bytes -
+     * which breaks byte-reproducibility for in-store builds that call
+     * `addPropertySet` / `addQuantitySet` (the sets themselves live in the
+     * mutation overlay and only become IFC roots here). Pass the same seeded
+     * source used for `SpatialAnchor.guidRandom` to close that gap. Default
+     * (omitted) behaviour for THESE ids is unchanged: random.
+     *
+     * NOT the `IFCPROXY` placeholders any more (#2733). Those used to be minted
+     * from this source too, so an omitted `guidRandom` made every downgraded
+     * IFC4X3 entity differ on re-export. They are now derived from the source
+     * line when this is omitted, and only fall back to this source when it is
+     * supplied - so passing a seeded source still pins them, but NOT passing one
+     * no longer makes them random. See `convertStepLine`.
+     */
+    guidRandom?: RandomSource;
+    /**
+     * Pin the STEP header `FILE_NAME` timestamp (STEP format, e.g.
+     * `20240101T000000`). Omitted = the wall clock, as before. Required for
+     * genuinely byte-identical exports, since the header otherwise carries the
+     * export instant.
+     */
+    timeStamp?: string;
+    /** Progress callback for async export */
+    onProgress?: (progress: StepExportProgress) => void;
+}
+/**
+ * Progress information during STEP export
+ */
+export interface StepExportProgress {
+    /** Current phase of export */
+    phase: 'preparing' | 'entities' | 'assembling';
+    /** Progress 0-1 */
+    percent: number;
+    /** Number of entities processed so far */
+    entitiesProcessed: number;
+    /** Total entities to process */
+    entitiesTotal: number;
+}
+/**
+ * Result of STEP export
+ */
+export interface StepExportResult {
+    /** STEP file content as bytes (avoids V8 string length limit for large files) */
+    content: Uint8Array;
+    /** Statistics about the export */
+    stats: {
+        /** Total entities exported */
+        entityCount: number;
+        /** New entities created for mutations */
+        newEntityCount: number;
+        /** Entities modified by mutations */
+        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 one case: 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).
+         *
+         * A WITHHELD RELATIONSHIP is the other: when a relationship names an
+         * entity this export is not writing, in a slot with no spelling for an
+         * omitted reference, the whole relationship line is dropped rather than
+         * shipped dangling — see {@link relationshipWithheldWarning}. This can
+         * happen on a plain full export with no options set at all, so it is
+         * reported rather than left to be discovered by a diff.
+         *
+         * Same `string[]` shape as `MergeExportResult.stats.warnings`.
+         */
+        warnings: string[];
+    };
+}
+/**
+ * Message for a relationship this export DROPPED rather than rewrote.
+ *
+ * `filterHiddenRefsFromRelationshipLine` removes an omitted `#N` from a
+ * SET/LIST attribute, but a single-valued attribute has no STEP spelling for
+ * "omitted" and an empty SET is not the same statement as the original — so in
+ * both of those cases it withholds the whole line and the relationship simply
+ * is not in the output. Withholding beats shipping a dangling `#N`, but it is
+ * not free: every OTHER entity that relationship named loses the association.
+ * A visible element can therefore come out of a plain full export with one
+ * fewer pset than it went in with, and before this warning existed nothing in
+ * the result said so (adversarial review of #2668).
+ *
+ * Deliberately reports the relationship rather than the omitted target: the
+ * target's own omission is already the caller's own doing in every reason but
+ * the unreadable-ref one, whereas the lost association is the surprise.
+ */
+export declare const relationshipWithheldWarning: (expressId: number, type: string) => string;
+/**
+ * What `step-attribute-mutations.ts`'s `applySourceLineMutations` produced: the rewritten
+ * line, plus which edit kinds that rewrite actually delivered. The delivery
+ * half is {@link SourceLineDelivery} rather than three loose booleans so that
+ * the pipeline and the ledger cannot disagree about what a source line carries
+ * — an added kind has one place to be added.
+ */
+export type SourceLineMutations = SourceLineDelivery & {
+    text: string;
+};
+/**
+ * The state one `export()` call shares across its seven phases.
+ *
+ * Introduced by step 1 of #2475: `export()` is ~1267 lines and the phases a
+ * split would separate are held together by ~30 local bindings, most of which
+ * are read in three or more phases. Naming that set once — as an interface
+ * with a single construction site at the top of `export()` — is what lets a
+ * later phase extraction take one parameter instead of fifteen.
+ *
+ * Two properties of this object are load-bearing and must survive every later
+ * move:
+ *
+ * 1. **The predicates are members, not duplicated expressions.** Six of them
+ *    (`isOverlayCreated`, `isReadableSourceRef`, `isGeometryExcluded`,
+ *    `hasEmittableHostBytes`, `willBeEmitted`,
+ *    `isRefExcludedDuringClosureWalk`) exist precisely so two phases cannot
+ *    disagree about a gate — see the comments at their construction sites for
+ *    the corrupt files the earlier, per-phase versions let through (#2491,
+ *    #2414, #2398, #2637). A phase that reimplements one of these instead of
+ *    reading it off the pass reintroduces exactly that class of defect.
+ * 2. **`allowedEntityIds` and `hiddenProductIds` are mutable, and the
+ *    predicates close over the pass rather than over a snapshot.** Both are
+ *    assigned AFTER construction, in `step-collection.ts`, and the order there
+ *    matters more than it looks: `hiddenProductIds` is set first, and
+ *    `allowedEntityIds` is the value the closure walk on the next line is
+ *    computing — so `isRefExcludedDuringClosureWalk` is handed to that walk
+ *    as one of that call's own arguments — while `allowedEntityIds`, and only
+ *    it, is still null. The
+ *    output-line filter reads both later, through `isOmittedFromOutput` ->
+ *    `willBeEmitted`, so neither can be a snapshot taken before the walk ran —
+ *    that is the invariant the #2637 regression broke.
+ *
+ * Deliberately NOT on the pass, and why: `isOmittedFromOutput`,
+ * `mayNameOmittedRefs` and
+ * `overlayNewEntityCount` are eagerly-computed values whose value is only
+ * defined after work that runs past this construction site, so hoisting them
+ * would change what they compute rather than where they are named;
+ * `generatedTypeOwnedPsetIds` is read in one phase only — a local inside
+ * `step-property-sets.ts:generatePropertyAndQuantitySetEntities`, which holds
+ * both the loop that writes it and the loop that reads it (#2475).
+ */
+export interface ExportPass {
+    /** Output accumulator: every DATA-section line this export will write. */
+    readonly entities: string[];
+    /** Lines contributed by entities that have no source record. */
+    newEntityCount: number;
+    readonly schema: IfcSchemaVersion;
+    readonly sourceSchema: IfcSchemaVersion;
+    readonly converting: boolean;
+    readonly sourceHeader: IfcSourceHeader | undefined;
+    readonly schemaToken: string;
+    readonly overlayActive: boolean;
+    readonly effective: EffectiveEntityIndex;
+    readonly modifications: ModificationLedger;
+    /** Widened from the imported `InPlaceNominees` (whose sets are readonly)
+     *  because the collection passes below add to them. */
+    readonly inPlaceNominees: {
+        attribute: Set<number>;
+        georeferencing: Set<number>;
+    };
+    allowedEntityIds: Set<number> | null;
+    hiddenProductIds: ReadonlySet<number> | null;
+    readonly modifiedEntities: Set<number>;
+    readonly modifiedAttributes: Map<number, Map<string, string>>;
+    readonly newPropertySets: Array<{
+        entityId: number;
+        psets: PropertySet[];
+    }>;
+    readonly newQuantitySets: Array<{
+        entityId: number;
+        qsets: QuantitySet[];
+    }>;
+    readonly typeOwnedPsetNamesByEntity: Map<number, Set<string>>;
+    readonly typeOwnedPsetIdsByEntity: Map<number, number[]>;
+    readonly rewrittenEntityIds: Set<number>;
+    readonly rewrittenEntityLines: Map<number, string>;
+    readonly overlayTypeOwnedPsets: Map<number, IfcAttributeValue>;
+    readonly skipPropertySetIds: Set<number>;
+    readonly skipRelationshipIds: Set<number>;
+    readonly newGeorefLines: string[];
+    readonly warnings: string[];
+    readonly buildHeader: (modifications: number) => string;
+    readonly isOverlayCreated: (entityId: number) => boolean;
+    readonly isReadableSourceRef: ReturnType<typeof createSourceRefReader>;
+    readonly isGeometryExcluded: (entityId: number, recordType: string) => boolean;
+    readonly hasEmittableHostBytes: (entityId: number) => boolean;
+    readonly willBeEmitted: (entityId: number) => boolean;
+    readonly isRefExcludedDuringClosureWalk: (id: number) => boolean;
+}
+//# sourceMappingURL=step-export-types.d.ts.map

package/dist/step-export-types.d.ts.map

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

package/dist/step-export-types.js

@@ -0,0 +1,22 @@
+/* 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/. */
+/**
+ * Message for a relationship this export DROPPED rather than rewrote.
+ *
+ * `filterHiddenRefsFromRelationshipLine` removes an omitted `#N` from a
+ * SET/LIST attribute, but a single-valued attribute has no STEP spelling for
+ * "omitted" and an empty SET is not the same statement as the original — so in
+ * both of those cases it withholds the whole line and the relationship simply
+ * is not in the output. Withholding beats shipping a dangling `#N`, but it is
+ * not free: every OTHER entity that relationship named loses the association.
+ * A visible element can therefore come out of a plain full export with one
+ * fewer pset than it went in with, and before this warning existed nothing in
+ * the result said so (adversarial review of #2668).
+ *
+ * Deliberately reports the relationship rather than the omitted target: the
+ * target's own omission is already the caller's own doing in every reason but
+ * the unreadable-ref one, whereas the lost association is the surprise.
+ */
+export const relationshipWithheldWarning = (expressId, type) => `Relationship #${expressId} (${type}) was withheld from the export: it names at least one entity that has no line in this export, in a slot with no spelling for an omitted reference (a single-valued attribute, or a set whose every member is omitted). Anything else that relationship associated is no longer associated in the output.`;
+//# sourceMappingURL=step-export-types.js.map

package/dist/step-export-types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"step-export-types.js","sourceRoot":"","sources":["../src/step-export-types.ts"],"names":[],"mappings":"AAAA;;+DAE+D;AAkK/D;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,CAAC,MAAM,2BAA2B,GAAG,CAAC,SAAiB,EAAE,IAAY,EAAU,EAAE,CACrF,iBAAiB,SAAS,KAAK,IAAI,0SAA0S,CAAC"}