opengeometry 2.0.18 → 3.0.0

package/src/{export/analytic-ifc.d.ts → dto/ifc-body.d.ts}

@@ -1,35 +1,35 @@
 export type IfcPreparedValue = {
-    kind: "Ref";
+    kind: 'Ref';
     id: number;
 } | {
-    kind: "List";
+    kind: 'List';
     values: IfcPreparedValue[];
 } | {
-    kind: "Real";
+    kind: 'Real';
     value: number;
 } | {
-    kind: "Integer";
+    kind: 'Integer';
     value: number;
 } | {
-    kind: "Text" | "Enum";
+    kind: 'Text' | 'Enum';
     value: string;
 } | {
-    kind: "Bool";
+    kind: 'Bool';
     value: boolean;
 } | {
-    kind: "Null" | "Derived";
+    kind: 'Null' | 'Derived';
 };
-export interface AnalyticExchangeBodyV2 {
+export type AnalyticExchangeBodyV2 = {
     schema_version: 2;
     revision: string;
-    length_unit: "metre";
-    up_axis: "Z";
-    coordinate_space: "world";
-    representation_type: "AdvancedBrep" | "CSG";
+    length_unit: 'metre';
+    up_axis: 'Z';
+    coordinate_space: 'world';
+    representation_type: 'AdvancedBrep' | 'CSG';
     quality: {
-        kind: "Analytic";
+        kind: 'Analytic';
     } | {
-        kind: "Approximate";
+        kind: 'Approximate';
         max_error: number;
     };
     geometric_tolerance: number;
@@ -52,10 +52,8 @@ export interface AnalyticExchangeBodyV2 {
                 key: string;
                 face: number;
             }[];
-            role: "Authored" | "Preserved" | "Split" | "Cut" | "Coincident";
+            role: 'Authored' | 'Preserved' | 'Split' | 'Cut' | 'Coincident';
             reversed: boolean;
         };
     }[];
-}
-/** Serializes Rust-prepared geometry; this function does not fit curves or tessellate surfaces. */
-export declare function analyticIfcText(body: AnalyticExchangeBodyV2, name?: string): string;
+};

package/src/dto/mark-stats.d.ts

@@ -0,0 +1,4 @@
+export type MarkStats = {
+    liveMarks: number;
+    retainedRevisions: number;
+};

package/src/dto/measure.d.ts

@@ -0,0 +1,16 @@
+export type Measure = {
+    volume: number;
+    area: number;
+    errorBound: number;
+    areaErrorBound: number;
+    deflection: number;
+};
+export type Validity = {
+    valid: boolean;
+    closed: boolean;
+    bodyType: 'Wire' | 'Sheet' | 'Solid' | null;
+    error?: {
+        code: string;
+        message: string;
+    };
+};

package/src/dto/mirror.d.ts

@@ -0,0 +1,4 @@
+export type MirrorPlane = {
+    origin: [number, number, number];
+    normal: [number, number, number];
+};

package/src/dto/node-info.d.ts

@@ -0,0 +1,11 @@
+export type NodeInfo = {
+    ogId: string;
+    handle: number;
+    generation: number;
+    parent: string | null;
+    children: string[];
+    kind: string;
+    shapeId: string | null;
+    shapeRevision: number | null;
+    bodyType: string | null;
+};

package/src/dto/pick-result.d.ts

@@ -0,0 +1,6 @@
+export type PickResult = {
+    ogId: string;
+    shapeRevision: number;
+    faceId?: number;
+    edgeId?: number;
+};

package/src/dto/placement.d.ts

@@ -0,0 +1,6 @@
+export type Placement = {
+    origin: [number, number, number];
+    xDirection: [number, number, number];
+    normal: [number, number, number];
+    scale: number;
+};

package/src/dto/primitives.d.ts

@@ -0,0 +1,77 @@
+export type ProfileArc = {
+    center: [number, number];
+    counterClockwise: boolean;
+};
+export type ProfileSegment = {
+    to: [number, number];
+    arc?: ProfileArc;
+};
+export type ProfileParams = {
+    start: [number, number];
+    segments: ProfileSegment[];
+    closed: boolean;
+};
+export type ArcParams = {
+    radius: number;
+    startAngle: number;
+    sweepAngle: number;
+};
+export type CylinderSectorParams = {
+    radius: number;
+    height: number;
+    startAngle: number;
+    sweepAngle: number;
+};
+export type PolyhedronParams = {
+    points: [number, number, number][];
+    faces: number[][];
+};
+export type SphereParams = {
+    radius: number;
+};
+export type ConeParams = {
+    radiusBottom: number;
+    radiusTop: number;
+    height: number;
+};
+export type TorusParams = {
+    majorRadius: number;
+    minorRadius: number;
+};
+export type SlotPrismParams = {
+    length: number;
+    width: number;
+    height: number;
+};
+export type RoundedBoxParams = {
+    width: number;
+    height: number;
+    depth: number;
+    radius: number;
+};
+export type PipeSegmentParams = {
+    outerRadius: number;
+    innerRadius: number;
+    height: number;
+    startAngle: number;
+    sweepAngle: number;
+};
+export type PolysolidParams = {
+    path: ProfileParams;
+    width: number;
+    height: number;
+    justify?: 'centre' | 'left' | 'right';
+};
+export type RegularPolygonParams = {
+    sides: number;
+    radius: number;
+};
+export type SlotParams = {
+    length: number;
+    width: number;
+};
+export type RoundedRectangleParams = {
+    width: number;
+    breadth: number;
+    radius: number;
+};

package/src/dto/regions.d.ts

@@ -0,0 +1,42 @@
+export type OffsetRegion = {
+    outer: {
+        x: number;
+        y: number;
+        z: number;
+    }[];
+    holes: {
+        x: number;
+        y: number;
+        z: number;
+    }[][];
+};
+export type CurvedRegionEdge = {
+    kind: 'line';
+    from: [number, number];
+    to: [number, number];
+} | {
+    kind: 'arc';
+    center: [number, number];
+    radius: number;
+    start_angle: number;
+    sweep_angle: number;
+};
+export type CurvedRegion2D = {
+    outer: CurvedRegionEdge[];
+    holes: CurvedRegionEdge[][];
+};
+export type RegionOperation = 'union' | 'intersection' | 'subtraction';
+export type OffsetHole = {
+    ring: readonly number[] | Float64Array;
+    distances: readonly number[] | Float64Array;
+};
+export type OffsetPolylineOptions = {
+    acuteThresholdDegrees?: number;
+    bevel?: boolean;
+    closed?: boolean;
+};
+export type OffsetPath2D = {
+    edges: CurvedRegionEdge[];
+    bevelled: number[];
+    closed: boolean;
+};

package/src/dto/step-export.d.ts

@@ -0,0 +1,42 @@
+export type StepBodyReport = {
+    ogId: string;
+    shapeId: string;
+    shapeRevision: number;
+    solids: number;
+    faces: number;
+    edges: number;
+    cavityShells: number;
+    collapsedChartUses: number;
+    fittedCurves: number;
+    pcurvelessEdges: number;
+    exchangeErrorBound: number;
+    geometricTolerance: number;
+};
+export type StepSkipped = {
+    ogId: string;
+    reason: string;
+};
+export type StepExportReport = {
+    unit: string;
+    upAxis: string;
+    timestamp: string;
+    products: number;
+    solids: number;
+    faces: number;
+    edges: number;
+    cavityShells: number;
+    collapsedChartUses: number;
+    fittedCurves: number;
+    pcurvelessEdges: number;
+    entities: number;
+    bytes: number;
+    exchangeErrorBound: number;
+    geometricTolerance: number;
+    validationLevel: string;
+    bodies: StepBodyReport[];
+    skipped: StepSkipped[];
+};
+export type StepExport = {
+    text: string;
+    report: StepExportReport;
+};

package/src/errors.d.ts

@@ -0,0 +1,20 @@
+import type { OperateErrorDetails } from './dto/boolean-report.js';
+export type ErrorDetails = Partial<OperateErrorDetails> & Record<string, unknown>;
+export declare class OGError extends Error {
+    readonly code: string;
+    readonly call: string;
+    readonly details: ErrorDetails;
+    constructor(code: string, call: string, message: string, details?: unknown);
+    toJSON(): {
+        code: string;
+        call: string;
+        message: string;
+        details: unknown;
+    };
+    static fromJSON(value: {
+        code: string;
+        call: string;
+        message: string;
+        details?: unknown;
+    }): OGError;
+}

package/src/export/export-step.d.ts

@@ -0,0 +1,10 @@
+import type { Body } from '../bodies/body.js';
+import { SystemAssembly } from '../bodies/system-assembly.js';
+import type { StepExport } from '../dto/step-export.js';
+export declare function exportStep(options: {
+    nodes: (Body | SystemAssembly | string)[];
+    unit?: 'metre' | 'millimetre';
+    upAxis?: 'Y' | 'Z';
+    name?: string;
+    timestamp?: string;
+}): Promise<StepExport>;

package/src/export/ifc-body.d.ts

@@ -0,0 +1,4 @@
+import type { Body } from '../bodies/body.js';
+import { SystemAssembly } from '../bodies/system-assembly.js';
+import type { AnalyticExchangeBodyV2 } from '../dto/ifc-body.js';
+export declare function exportIfcBody(node: Body | SystemAssembly): AnalyticExchangeBodyV2;

package/src/kernel/kernel-errors.d.ts

@@ -0,0 +1,5 @@
+export declare function parseKernelError(text: string): {
+    code: string;
+    message: string;
+    details: unknown;
+} | undefined;

package/src/kernel/kernel-loader.d.ts

@@ -0,0 +1,5 @@
+import initializeKernel, { initSync, OGTessellator, OGWorldGraph, type InitOutput } from '../../opengeometry/pkg/opengeometry.js';
+export { initializeKernel, initSync, OGTessellator, OGWorldGraph };
+export declare function compileKernel(wasmURL: string | URL): Promise<WebAssembly.Module>;
+export declare function initKernel(module: WebAssembly.Module): Promise<InitOutput>;
+export declare function takePanicMessage(): string | undefined;

package/src/kernel/kernel-session.d.ts

@@ -0,0 +1,2 @@
+export declare function kernelCall<T>(call: string, fn: () => T): T;
+export declare function call<T>(name: string, fn: () => T): T;

package/src/limits.d.ts

@@ -0,0 +1,12 @@
+export declare const ACCURACY: {
+    readonly geometric: 1e-8;
+    readonly intersection: 1e-9;
+    readonly tessellation: 0.01;
+    readonly exchange: 0.000001;
+};
+export declare const MAX_TRIANGLES: 2000000;
+export declare const HYSTERESIS_KEEP: readonly [0.75, 4];
+export declare const PIXELS_AT_REST: 0.5;
+export declare const PIXELS_MOVING: 2;
+export declare const EVALUATION_INTERVAL_MS: 100;
+export declare const MOTION_WINDOW_MS: 150;

package/src/marks/limbo.d.ts

@@ -0,0 +1,6 @@
+import type { Body } from '../bodies/body.js';
+import { type Runtime } from '../runtime/runtime-state.js';
+export declare function enterLimbo(body: Body): void;
+export declare function finalizeSettled(state: Runtime): void;
+export declare function revive(body: Body): void;
+export declare function finalizeNow(body: Body): void;

package/src/marks/og-mark.d.ts

@@ -0,0 +1,10 @@
+import type { MarkStats } from '../dto/mark-stats.js';
+export declare class OGMark {
+    private slot;
+    constructor(slot: number);
+    private get active();
+    rollback(): void;
+    release(): void;
+}
+export declare function createMark(): OGMark;
+export declare function markStats(): MarkStats;

package/src/marks/transaction.d.ts

@@ -0,0 +1,3 @@
+export declare function transaction<T>(fn: () => T, options?: {
+    dryRun?: boolean;
+}): T;

package/src/opengeometry.d.ts

@@ -0,0 +1,69 @@
+import type * as THREE from 'three';
+import type { Body } from './bodies/body.js';
+import type { SystemAssembly } from './bodies/system-assembly.js';
+import type { Events, Listener } from './dto/events.js';
+import type { AnalyticExchangeBodyV2 } from './dto/ifc-body.js';
+import type { MarkStats } from './dto/mark-stats.js';
+import type { CurvedRegion2D, OffsetHole, OffsetPath2D, OffsetPolylineOptions, OffsetRegion, RegionOperation } from './dto/regions.js';
+import type { StepExport } from './dto/step-export.js';
+import { type OGMark } from './marks/og-mark.js';
+import { HostGroup } from './rendering/geometry/host-group.js';
+export declare class OpenGeometry {
+    static create(input?: {
+        wasmURL?: string | URL;
+        wasmModule?: WebAssembly.Module;
+    }, options?: {
+        workerURL?: string | URL;
+        tessellation?: 'worker' | 'inline';
+    }): Promise<typeof OpenGeometry>;
+    static on(event: Events, handler: Listener): () => boolean;
+    static flush(options?: {
+        geometry?: 'sync';
+        bodies?: readonly Body[];
+    }): void;
+    static markDisplayed(bodies: readonly Body[]): void;
+    static setHostDrawn(bodies: readonly Body[], hostDrawn: boolean): void;
+    static hostGroup(bodies: readonly Body[]): HostGroup;
+    static settled(options?: {
+        deflection?: number;
+    }): Promise<{
+        failed: {
+            ogId: string;
+            error: unknown;
+        }[];
+    }>;
+    static setDisplayDeflection(world?: number): void;
+    static releaseIdleGeometry(): {
+        records: number;
+        bytes: number;
+    };
+    static setCameraMotion(moving: boolean): void;
+    static observeCamera(renderer: THREE.WebGLRenderer, camera: THREE.Camera): void;
+    static resolveHit(hit: THREE.Intersection): {
+        ogId: string;
+        shapeRevision: number;
+        faceId?: number;
+        edgeId?: number;
+    } | undefined;
+    static exportStep(options: {
+        nodes: (Body | SystemAssembly | string)[];
+        unit?: 'metre' | 'millimetre';
+        upAxis?: 'Y' | 'Z';
+        name?: string;
+        timestamp?: string;
+    }): Promise<StepExport>;
+    static exportIfcBody(node: Body | SystemAssembly): AnalyticExchangeBodyV2;
+    static booleanRegions2D(a: readonly OffsetRegion[], b: readonly OffsetRegion[], operation: RegionOperation): OffsetRegion[];
+    static booleanCurvedRegions2D(a: readonly CurvedRegion2D[], b: readonly CurvedRegion2D[], operation: RegionOperation): CurvedRegion2D[];
+    static insetCurvedRegion2D(region: CurvedRegion2D, distance: number): CurvedRegion2D[];
+    static offsetRingVariable(ring: readonly number[] | Float64Array, distances: readonly number[] | Float64Array, holes?: readonly OffsetHole[]): CurvedRegion2D[];
+    static offsetCurvedRingVariable(region: CurvedRegion2D, distances: readonly number[] | Float64Array, holeDistances?: readonly (readonly number[] | Float64Array)[]): CurvedRegion2D[];
+    static offsetPolylineRegions(path: readonly number[] | Float64Array, width: number, closed: boolean, miterLimit?: number): CurvedRegion2D[];
+    static offsetPolyline(path: readonly number[] | Float64Array, distance: number, options?: OffsetPolylineOptions): OffsetPath2D;
+    static mark(): OGMark;
+    static markStats(): MarkStats;
+    static transaction<T>(fn: () => T, options?: {
+        dryRun?: boolean;
+    }): T;
+    static reset(): void;
+}

package/src/operations/offsets.d.ts

@@ -0,0 +1,5 @@
+import type { CurvedRegion2D, OffsetHole, OffsetPath2D, OffsetPolylineOptions } from '../dto/regions.js';
+export declare function offsetRingVariable(ring: readonly number[] | Float64Array, distances: readonly number[] | Float64Array, holes?: readonly OffsetHole[]): CurvedRegion2D[];
+export declare function offsetCurvedRingVariable(region: CurvedRegion2D, distances: readonly number[] | Float64Array, holeDistances?: readonly (readonly number[] | Float64Array)[]): CurvedRegion2D[];
+export declare function offsetPolylineRegions(path: readonly number[] | Float64Array, width: number, closed: boolean, miterLimit?: number): CurvedRegion2D[];
+export declare function offsetPolyline(path: readonly number[] | Float64Array, distance: number, options?: OffsetPolylineOptions): OffsetPath2D;

package/src/operations/regions.d.ts

@@ -0,0 +1,4 @@
+import type { CurvedRegion2D, OffsetRegion, RegionOperation } from '../dto/regions.js';
+export declare function booleanRegions2D(a: readonly OffsetRegion[], b: readonly OffsetRegion[], operation: RegionOperation): OffsetRegion[];
+export declare function booleanCurvedRegions2D(a: readonly CurvedRegion2D[], b: readonly CurvedRegion2D[], operation: RegionOperation): CurvedRegion2D[];
+export declare function insetCurvedRegion2D(region: CurvedRegion2D, distance: number): CurvedRegion2D[];

package/src/picking/pick-targets.d.ts

@@ -0,0 +1,6 @@
+import type * as THREE from 'three';
+import type { Body } from '../bodies/body.js';
+import type { GeometryRecord } from '../rendering/records/geometry-record.js';
+export declare function pickTarget(object: THREE.Object3D): Body | undefined;
+export declare function faceIdAt(ranges: Uint32Array, faceIndex: number): number | undefined;
+export declare function edgeIdAt(record: GeometryRecord, index: number): number | undefined;

package/src/picking/resolve-hit.d.ts

@@ -0,0 +1,3 @@
+import type * as THREE from 'three';
+import type { PickResult } from '../dto/pick-result.js';
+export declare function resolveHit(hit: THREE.Intersection): PickResult | undefined;

package/src/rendering/deferred.d.ts

@@ -0,0 +1,7 @@
+import type { OGError } from '../errors.js';
+export declare class Deferred<T> {
+    resolve: (value: T) => void;
+    reject: (reason: OGError) => void;
+    readonly promise: Promise<T>;
+    constructor();
+}

package/src/rendering/geometry/geometry-scheduler.d.ts

@@ -0,0 +1,12 @@
+import type { Body } from '../../bodies/body.js';
+import { type Runtime } from '../../runtime/runtime-state.js';
+export type FlushOptions = {
+    geometry?: 'sync';
+    bodies?: readonly Body[];
+};
+export declare function flush(options?: FlushOptions): void;
+export declare function checkedBodies(state: Runtime, bodies: readonly Body[], label: string, skipDisposed?: boolean): readonly Body[];
+export declare function flushForDispose(): void;
+export declare function notifyBody(body: Body, type: 'geometrychanged' | 'placementchanged'): void;
+export declare function wanted(body: Body): number | undefined;
+export declare function ensureGeometry(body: Body, sync?: boolean): void;

package/src/rendering/geometry/host-group.d.ts

@@ -0,0 +1,10 @@
+import type { Body } from '../../bodies/body.js';
+export declare class HostGroup {
+    private readonly state;
+    private readonly group;
+    private disposed;
+    constructor(bodies: readonly Body[]);
+    drawn(): void;
+    set(bodies: readonly Body[]): void;
+    dispose(): void;
+}

package/src/rendering/geometry/render-pass.d.ts

@@ -0,0 +1,8 @@
+import type { Body } from '../../bodies/body.js';
+import { type Runtime } from '../../runtime/runtime-state.js';
+export declare function noteDisplayed(body: Body): void;
+export declare function noteDrawn(body: Body): void;
+export declare function markDisplayed(bodies: readonly Body[]): void;
+export declare function setHostDrawn(bodies: readonly Body[], hostDrawn: boolean): void;
+export declare function beginPass(state: Runtime): boolean;
+export declare function refreshDisplayed(state: Runtime): void;

package/src/rendering/geometry/settle.d.ts

@@ -0,0 +1,10 @@
+type Failure = {
+    ogId: string;
+    error: unknown;
+};
+export declare function settled(options?: {
+    deflection?: number;
+}): Promise<{
+    failed: Failure[];
+}>;
+export {};

package/src/rendering/inline-backend.d.ts

@@ -0,0 +1,14 @@
+import type { DisplayBuffers } from '../dto/display-buffers.js';
+import type { OGWorldGraph } from '../kernel/kernel-loader.js';
+import type { TessellationProvider, TessellationRequest } from './provider.js';
+export declare class InlineBackend implements TessellationProvider {
+    private graph;
+    readonly activeBackend: "inline";
+    constructor(graph: OGWorldGraph);
+    ensureSnapshot(): Promise<void>;
+    compute(value: TessellationRequest): DisplayBuffers;
+    request(value: TessellationRequest): Promise<DisplayBuffers>;
+    cancelShape(): void;
+    drop(): void;
+    dispose(): void;
+}

package/src/rendering/lod/body-size.d.ts

@@ -0,0 +1,11 @@
+import type { Body } from '../../bodies/body.js';
+import type { Runtime } from '../../runtime/runtime-state.js';
+export type ShapeBuckets = {
+    revision: number;
+    floor: number;
+    static: number;
+    error?: unknown;
+};
+export declare function shapeBuckets(state: Runtime, body: Body): ShapeBuckets | undefined;
+export declare function localTarget(world: number, body: Body): number | undefined;
+export declare function finestLocal(bodies: Iterable<Body>, valueOf: (body: Body) => number | undefined): number | undefined;

package/src/rendering/lod/camera-observer.d.ts

@@ -0,0 +1,2 @@
+import type * as THREE from 'three';
+export declare function observeCamera(renderer: THREE.WebGLRenderer, camera: THREE.Camera): void;

package/src/rendering/lod/deflection.d.ts

@@ -0,0 +1,2 @@
+export declare function deflectionBucket(target: number): number;
+export declare function wantedBucket(target: number, floor: number, previous?: number, moving?: boolean): number;

package/src/rendering/lod/display-bounds.d.ts

@@ -0,0 +1,4 @@
+import type { Body } from '../../bodies/body.js';
+import type { Bounds } from '../../dto/bounds.js';
+import type { Runtime } from '../../runtime/runtime-state.js';
+export declare function displayBounds(state: Runtime, body: Body, revision: bigint): Bounds | null;

package/src/rendering/lod/displayed.d.ts

@@ -0,0 +1,7 @@
+import type { Body } from '../../bodies/body.js';
+import type { Runtime } from '../../runtime/runtime-state.js';
+export declare function isDisplayed(state: Runtime, body: Body): boolean;
+export declare function displayedBodies(state: Runtime): Body[];
+export declare function stampedCount(state: Runtime): number;
+export declare function stampDisplayed(state: Runtime, body: Body): void;
+export declare function wakeDisplayed(state: Runtime, body: Body): void;

package/src/rendering/lod/host-drawn.d.ts

@@ -0,0 +1,5 @@
+import type { Body } from '../../bodies/body.js';
+import type { Runtime } from '../../runtime/runtime-state.js';
+export declare function shown(state: Runtime, body: Body): boolean;
+export declare function setShown(state: Runtime, body: Body, value: boolean): void;
+export declare function handToHost(state: Runtime, body: Body, hostDrawn: boolean): void;

package/src/rendering/lod/host-groups.d.ts

@@ -0,0 +1,28 @@
+import type { Body } from '../../bodies/body.js';
+import type { Runtime } from '../../runtime/runtime-state.js';
+export type GroupState = {
+    pass: number;
+    members: Set<Body>;
+};
+export type HostGroups = {
+    live: Set<GroupState>;
+    of: WeakMap<Body, GroupState[]>;
+    woken: Set<GroupState>;
+    pending: Set<Body>;
+    drawn: boolean;
+    revision: number;
+    dropped: FinalizationRegistry<GroupState>;
+};
+export declare function createHostGroups(release: (group: GroupState) => void): HostGroups;
+export declare function groupShown(state: Runtime, group: GroupState): boolean;
+export declare function groupDisplayed(state: Runtime, body: Body): boolean;
+export declare function stampGroup(state: Runtime, group: GroupState): void;
+export declare function setMembers(state: Runtime, group: GroupState, members: readonly Body[]): void;
+export declare function dropGroup(state: Runtime, group: GroupState): void;
+export declare function dropMember(state: Runtime, body: Body): void;
+export declare function groupedBodies(state: Runtime): Body[];
+export declare function groupsKey(state: Runtime): number;
+export declare function queueGrouped(state: Runtime, body: Body): void;
+export declare function shownChanged(state: Runtime, body: Body): void;
+export declare function queueShapes(state: Runtime, shapeId?: string): void;
+export declare function takeWaiting(state: Runtime): Set<Body>;