brepjs-bim 0.15.2 → 0.16.0

package/dist/ids/idsEngine.d.ts

@@ -0,0 +1,10 @@
+import { Result } from 'brepjs';
+import { BimError } from '../errors/bimError.js';
+import { IdsCheckReport, IdsDocument } from './idsTypes.js';
+/**
+ * Checks IFC file bytes against an IDS document, evaluating every entity
+ * instance in the file against each specification. This is the
+ * conformance-grade checker validated against the official buildingSMART IDS
+ * test suite; see `scripts/idsConformance.ts`.
+ */
+export declare function checkIdsData(bytes: Uint8Array, ids: IdsDocument): Promise<Result<IdsCheckReport, BimError>>;

package/dist/ids/idsParser.d.ts

@@ -4,17 +4,18 @@ import { IdsDocument } from './idsTypes.js';
 /**
  * Parses an IDS 1.0 XML document string into a typed {@link IdsDocument}.
  *
- * Supported structure: `<ids><info><title/></info><specifications>` with one or
- * more `<specification>` carrying `<applicability>` and `<requirements>`. Inside
- * those, the facets `entity`, `attribute`, `property`, `classification`,
- * `material`, and `partOf` are recognised. Each value field accepts either a
- * `<simpleValue>` or an `<xs:restriction>` with `<xs:enumeration>` or
- * `<xs:pattern>` children.
+ * Value fields accept a `<simpleValue>` or an `<xs:restriction>` carrying any
+ * combination of `xs:enumeration`, `xs:pattern`, numeric bounds
+ * (`xs:minInclusive` / `xs:maxInclusive` / `xs:minExclusive` /
+ * `xs:maxExclusive`), and length constraints (`xs:length` / `xs:minLength` /
+ * `xs:maxLength`).
  *
- * Cardinality is read from the specification's `minOccurs`/`maxOccurs` (or the
- * `cardinality` attribute when present): `prohibited` when `maxOccurs="0"`,
- * `optional` when `minOccurs="0"`, otherwise `required`.
+ * Specification cardinality reads the applicability's `minOccurs`/`maxOccurs`:
+ * `prohibited` when `maxOccurs="0"`, `optional` when `minOccurs="0"`, else
+ * `required`. Requirement facets carry their own `cardinality` attribute.
+ * A prohibited specification with requirement facets is rejected as invalid,
+ * matching the official audit tool.
  *
- * Never throws — malformed XML or a missing root returns `err(idsError(...))`.
+ * Never throws — malformed XML or an invalid structure returns `err(...)`.
  */
 export declare function parseIdsXml(xml: string): Result<IdsDocument, BimError>;

package/dist/ids/idsSchema.generated.d.ts

@@ -0,0 +1 @@
+export declare const IFC_ENTITY_ATTRIBUTES: Readonly<Record<string, Readonly<Record<string, string>>>>;

package/dist/ids/idsTypes.d.ts

@@ -1,26 +1,31 @@
 import { ValidationIssue } from '../validation/severity.js';
 /**
- * A value constraint on an IDS facet field. IDS expresses these either as a
- * literal `<simpleValue>` or as an `<xs:restriction>` carrying an enumeration or
- * a pattern. The numeric bound dialect (`xs:minInclusive` etc.) is intentionally
- * not modelled — facets that use it fall through to a `pattern`-less restriction
- * and are reported as unsupported by the checker.
+ * A value constraint on an IDS facet field: a literal `<simpleValue>` or an
+ * `<xs:restriction>` carrying any combination of enumeration, pattern, numeric
+ * bounds, and length constraints. `base` is the xs type the restriction
+ * declares (e.g. `xs:double`), which drives typed comparison.
  */
+export interface IdsRestrictionConstraints {
+    readonly base: string | undefined;
+    readonly values?: readonly string[] | undefined;
+    readonly pattern?: readonly string[] | undefined;
+    readonly minInclusive?: number | undefined;
+    readonly maxInclusive?: number | undefined;
+    readonly minExclusive?: number | undefined;
+    readonly maxExclusive?: number | undefined;
+    readonly length?: number | undefined;
+    readonly minLength?: number | undefined;
+    readonly maxLength?: number | undefined;
+}
 export type IdsRestriction = {
     readonly kind: 'simple';
     readonly value: string;
-} | {
-    readonly kind: 'enumeration';
-    readonly values: readonly string[];
-} | {
-    readonly kind: 'pattern';
-    readonly pattern: string;
-};
-/**
- * The IDS facet kinds this subset understands. `PartOf` is parsed but always
- * reported as unsupported by the checker (spatial-tree resolution is out of
- * scope); every other kind is fully evaluated.
- */
+} | ({
+    readonly kind: 'restriction';
+} & IdsRestrictionConstraints);
+/** Cardinality of a specification or of an individual requirement facet. */
+export type IdsCardinality = 'required' | 'optional' | 'prohibited';
+export type IdsPartOfRelation = 'IFCRELAGGREGATES' | 'IFCRELASSIGNSTOGROUP' | 'IFCRELCONTAINEDINSPATIALSTRUCTURE' | 'IFCRELNESTS';
 export type IdsFacet = {
     readonly kind: 'Entity';
     readonly name: IdsRestriction;
@@ -29,32 +34,43 @@ export type IdsFacet = {
     readonly kind: 'Attribute';
     readonly name: IdsRestriction;
     readonly value?: IdsRestriction | undefined;
+    readonly cardinality: IdsCardinality;
 } | {
     readonly kind: 'Property';
     readonly psetName: IdsRestriction;
     readonly baseName: IdsRestriction;
     readonly value?: IdsRestriction | undefined;
+    readonly dataType?: string | undefined;
+    readonly cardinality: IdsCardinality;
 } | {
     readonly kind: 'Classification';
     readonly system?: IdsRestriction | undefined;
     readonly value?: IdsRestriction | undefined;
+    readonly cardinality: IdsCardinality;
 } | {
     readonly kind: 'Material';
     readonly value?: IdsRestriction | undefined;
+    readonly cardinality: IdsCardinality;
 } | {
     readonly kind: 'PartOf';
-    readonly relation?: string | undefined;
+    readonly entity?: {
+        readonly name: IdsRestriction;
+        readonly predefinedType?: IdsRestriction | undefined;
+    } | undefined;
+    readonly relation?: IdsPartOfRelation | undefined;
+    readonly cardinality: IdsCardinality;
 };
-export type IdsCardinality = 'required' | 'optional' | 'prohibited';
 export interface IdsSpecification {
     readonly name: string;
+    /** Declared schema versions. Purely metadata: never filters checking. */
     readonly ifcVersion: readonly string[];
     /**
-     * Cardinality of the *requirements* against applicable elements:
-     * - `required` — every applicable element must satisfy all requirement facets.
-     * - `optional` — requirements are informational; failures are reported as
-     *   warnings and do not fail the spec.
-     * - `prohibited` — applicable elements must *not* satisfy the requirements.
+     * Cardinality of the applicability set:
+     * - `required` — at least one element must be applicable, and every
+     *   applicable element must satisfy the requirements.
+     * - `optional` — applicable elements must satisfy the requirements, but an
+     *   empty applicability set still passes.
+     * - `prohibited` — no element may match the applicability at all.
      */
     readonly cardinality: IdsCardinality;
     readonly applicability: readonly IdsFacet[];
@@ -67,11 +83,11 @@ export interface IdsDocument {
 export interface IdsCheckResult {
     readonly specificationName: string;
     readonly pass: boolean;
-    /** Number of model elements matched by the applicability facets. */
+    /** Number of model entity instances matched by the applicability facets. */
     readonly applicableCount: number;
-    /** Applicable elements that satisfied the cardinality contract. */
+    /** Applicable instances that satisfied every requirement. */
     readonly passedCount: number;
-    /** Applicable elements that violated the cardinality contract. */
+    /** Applicable instances that violated at least one requirement. */
     readonly failedCount: number;
     readonly issues: readonly ValidationIssue[];
 }
@@ -80,8 +96,8 @@ export interface IdsCheckReport {
     readonly results: readonly IdsCheckResult[];
     /**
      * Human-readable identifiers of facet features that were encountered but not
-     * evaluated (e.g. `PartOf in 'spec name'`). Their presence never aborts the
-     * check; the affected requirement is skipped with a warning.
+     * evaluated. Their presence never aborts the check; the affected requirement
+     * is skipped with a warning.
      */
     readonly unsupportedFacets: readonly string[];
 }

package/dist/ids/index.d.ts

@@ -1,3 +1,3 @@
 export { parseIdsXml } from './idsParser.js';
-export { checkModelAgainstIds } from './idsCheck.js';
+export { checkIdsData } from './idsEngine.js';
 export type { IdsDocument, IdsSpecification, IdsFacet, IdsRestriction, IdsCardinality, IdsCheckReport, IdsCheckResult, } from './idsTypes.js';

package/dist/import/spfReader.d.ts

@@ -30,6 +30,8 @@ export declare class SpfReader {
     /** Express ids of every line in the model. */
     getAllLines(): number[];
     /** IFC type code for an express id. */
+    /** Uppercased IFC entity name of the instance (e.g. `IFCWALL`). */
+    typeNameOf(expressId: number): string;
     getLineType(expressId: number): number;
     /** Builds web-ifc's internal GUID→expressId index; call before guid lookups. */
     buildGuidMap(): void;

package/dist/index.d.ts

@@ -91,7 +91,7 @@ export type { IfcSchema } from './ifc-writer/schemaVersion.js';
 export type { OwnerHistoryAuthor, OwnerHistoryMeta } from './ifc-writer/ownerHistoryWriter.js';
 export { deriveCobieModel, deriveCobieModel as exportCobie, serializeCobieToCsv, serializeCobieToJson, } from './cobie/index.js';
 export type { CobieModel, CobieJson, CobieExportMeta, CobieContactMeta, CobieContactRow, CobieFacilityRow, CobieFloorRow, CobieSpaceRow, CobieZoneRow, CobieTypeRow, CobieComponentRow, CobieSystemRow, CobieAttributeRow, } from './cobie/index.js';
-export { parseIdsXml, checkModelAgainstIds, checkModelAgainstIds as checkIds, } from './ids/index.js';
+export { parseIdsXml, checkIdsData, checkIdsData as checkIds } from './ids/index.js';
 export type { IdsDocument, IdsSpecification, IdsFacet, IdsRestriction, IdsCardinality, IdsCheckReport, IdsCheckResult, } from './ids/index.js';
 export { serializeBcfFiles, parseBcfFiles } from './bcf/index.js';
 export type { BcfColoring, BcfComment, BcfComponent, BcfComponents, BcfContainerData, BcfFiles, BcfProject, BcfTopic, BcfVersion, BcfViewpoint, BcfVisibility, } from './bcf/index.js';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "brepjs-bim",
-  "version": "0.15.2",
+  "version": "0.16.0",
   "description": "BIM layer for brepjs — IFC4-aligned parametric building elements",
   "keywords": [
     "bim",

package/dist/ids/idsCheck.d.ts

@@ -1,22 +0,0 @@
-import { ImportedModel } from '../import/importedModel.js';
-import { IdsCheckReport, IdsDocument } from './idsTypes.js';
-/**
- * Checks an imported model against an IDS document, returning a per-specification
- * pass/fail report keyed by the specification name. The check is synchronous,
- * never throws, and surfaces all problems as {@link ValidationIssue}s.
- *
- * For each specification the applicability facets select the matching elements,
- * then the requirement facets are evaluated against each applicable element per
- * the spec's cardinality:
- * - `required` — every applicable element must satisfy all requirements
- *   (a failure is an `error`).
- * - `optional` — requirement failures are reported as `info` and never fail.
- * - `prohibited` — an applicable element that *does* satisfy the requirements is
- *   a violation (`error`).
- *
- * Unsupported facet features (the `PartOf` facet, numeric-bound restrictions,
- * and invalid `xs:pattern` dialects) are recorded in
- * {@link IdsCheckReport.unsupportedFacets} and the affected requirement is
- * skipped rather than failing the element.
- */
-export declare function checkModelAgainstIds(model: ImportedModel, ids: IdsDocument): IdsCheckReport;

package/dist/ids/idsFacets.d.ts

@@ -1,21 +0,0 @@
-import { ImportedElement, ImportedElementCategory } from '../import/importedModel.js';
-import { IdsRestriction } from './idsTypes.js';
-/** Returns the categories an entity-name restriction can resolve to. */
-export declare function categoriesForRestriction(name: IdsRestriction): ReadonlySet<ImportedElementCategory>;
-/** Tests whether a candidate string satisfies an IDS value restriction. */
-export declare function matchesRestriction(candidate: string, restriction: IdsRestriction): boolean;
-export declare function isValidPattern(pattern: string): boolean;
-/** True when the element's category matches the entity name (and predefined type). */
-export declare function evalEntityFacet(element: ImportedElement, name: IdsRestriction, predefinedType: IdsRestriction | undefined): boolean;
-/**
- * True when the element exposes the named property in the named pset, optionally
- * with a value matching `value`. Reads from both IfcPropertySet-derived psets and
- * IfcElementQuantity-derived ones.
- */
-export declare function evalPropertyFacet(element: ImportedElement, psetName: IdsRestriction, baseName: IdsRestriction, value: IdsRestriction | undefined): boolean;
-/** True when an element attribute (Name/PredefinedType) matches the facet. */
-export declare function evalAttributeFacet(element: ImportedElement, name: IdsRestriction, value: IdsRestriction | undefined): boolean;
-/** True when the element's classification system/value match the facet. */
-export declare function evalClassificationFacet(element: ImportedElement, system: IdsRestriction | undefined, value: IdsRestriction | undefined): boolean;
-/** True when the element's material name matches the facet value. */
-export declare function evalMaterialFacet(element: ImportedElement, value: IdsRestriction | undefined): boolean;