opengeometry 2.0.18 → 3.0.0

package/src/operations/offset-regions.d.ts

@@ -1,76 +0,0 @@
-/** A point of a returned offset region ring (kernel `Vector3` shape). */
-export interface OffsetRegionPoint {
-    x: number;
-    y: number;
-    z: number;
-}
-/** One offset region: a CW outer ring + its CCW inner-void hole rings. */
-export interface OffsetRegion {
-    /** Outer ring (CW, canonical start). */
-    outer: OffsetRegionPoint[];
-    /** Inner-void hole rings (CCW), e.g. the interior void of a closed loop. */
-    holes: OffsetRegionPoint[][];
-}
-/**
- * Offset a centreline by ±half-width into one or more filled REGIONS, via the
- * deterministic analytic offset — miters / flat bevels at `miterLimit`, concave
- * trims, and nonzero-winding resolution of reflex / closed loops. NO boolean union
- * (so it is deterministic, unlike the 3D-mesh CSG path). A simple centreline returns
- * one region; a self-crossing closed centreline (e.g. a figure-8) returns one per
- * simple sub-loop. Returns an EMPTY array for a collapsed input (does
- * not throw, so it never looks like a kernel crash). Rings are CW-outer / CCW-holes.
- *
- * @param centrelineFlat centreline points as `[x,y,z, …]`.
- * @param width full stroke width (offset ±width/2 on each side).
- * @param miterLimit SVG stroke-miterlimit; corners sharper than this bevel. Default 4.
- */
-export declare function offsetPolylineRegions(centrelineFlat: number[] | Float64Array, width: number, closed: boolean, miterLimit?: number): OffsetRegion[];
-/** An excluded interior ring of a variable inset. Its closed ring has one
- * clearance distance per edge; the inset grows the hole by those distances. */
-export interface OffsetHole {
-    ring: number[] | Float64Array;
-    distances: number[] | Float64Array;
-}
-/**
- * Inset a CLOSED ring inward with one distance per edge (edge i =
- * `ring[i] → ring[i+1]`; an explicit closing duplicate point is accepted and
- * stripped, the distance count stays one per unique edge). The result is a
- * clearance-exact inset region: the ring's interior minus every point within
- * `distances[i]` of edge i's segment. Distant boundary segments remain
- * effective across notches; different distances produce circumscribed
- * clearance arcs. There is no
- * `miterLimit` parameter, deliberately: miters and bevels only approximate the
- * clearance arc, and a bevel would claim points inside the required distance.
- *
- * `holes` are excluded interior rings, each grown outward by its own per-edge
- * distances — the region keeps clear of a hole's edges exactly as it keeps
- * clear of the outer boundary, so a hole can split the region or swallow it.
- *
- * Returns CW-outer / CCW-hole regions (canonical start vertex), possibly
- * SEVERAL when a deep inset (or a hole) splits a waisted ring into disjoint
- * lobes, and an EMPTY array when the inset collapses or the outer ring is
- * degenerate (< 3 unique points, zero area, self-intersecting). THROWS on
- * malformed arguments: a distance count that does not match an edge count, a
- * negative / non-finite distance, or a degenerate hole — those are caller
- * bugs, not geometry.
- *
- * @param ring closed ring points as `[x,y,z, …]` (Y is carried through).
- * @param distances inward inset distance per edge, metres, each >= 0
- *                  (0 keeps that boundary edge in place).
- * @param holes excluded interior rings with their own per-edge distances.
- */
-export declare function offsetRingVariable(ring: number[] | Float64Array, distances: number[] | Float64Array, holes?: OffsetHole[]): OffsetRegion[];
-/** One polyline in an offset group: centreline `[x,y,z, …]`, stroke width, closed flag. */
-export interface OffsetPolyline {
-    centreline: number[];
-    width: number;
-    closed: boolean;
-}
-/**
- * Merge a GROUP of separate polylines (a crossing T / X / L overlap) into one clean
- * region by nonzero-winding union of their mitered bands — the overlapping strokes
- * merge into a single region with mitered/bevelled corners, no internal edges.
- * Returns CW-outer / CCW-hole regions (one or more); empty if no region remains.
- * No CSG. Used to render/extrude an overlapping crossing as one joined mass.
- */
-export declare function offsetPolylineGroupRegions(polylines: OffsetPolyline[]): OffsetRegion[];

package/src/primitives/analytic-curve.d.ts

@@ -1,42 +0,0 @@
-import * as THREE from "three";
-import { OGAnalyticBrep } from "../../opengeometry/pkg/opengeometry.js";
-import type { AnalyticAccuracy, AnalyticFrame } from "../shapes/analytic-solid.js";
-export type AnalyticCurveOptions = {
-    ogid?: string;
-    frame?: AnalyticFrame;
-    accuracy?: AnalyticAccuracy;
-    startAngle: number;
-    sweepAngle: number;
-    deflection?: number;
-    color?: THREE.ColorRepresentation;
-} & ({
-    kind: "arc";
-    radius: number;
-} | {
-    kind: "ellipticalArc";
-    majorRadius: number;
-    minorRadius: number;
-});
-export interface AnalyticCurveStats {
-    requestedDeflection: number;
-    achievedDeflection: number;
-    segmentCount: number;
-    revision: bigint;
-}
-export declare class AnalyticCurve extends THREE.Group {
-    readonly ogid: string;
-    readonly line: THREE.LineSegments<THREE.BufferGeometry, THREE.LineBasicMaterial>;
-    protected kernel: OGAnalyticBrep;
-    private segmentEdges;
-    private disposed;
-    get color(): THREE.Color;
-    set color(value: THREE.ColorRepresentation);
-    constructor(options: AnalyticCurveOptions);
-    getBrepSerialized(): string;
-    getBrepData(): Record<string, unknown>;
-    protected replaceDefinition(options: AnalyticCurveOptions): AnalyticCurveStats;
-    edgeIdForSegment(segment: number): number | undefined;
-    retessellate(deflection: number): AnalyticCurveStats;
-    dispose(): void;
-    private checkActive;
-}

package/src/primitives/arc.d.ts

@@ -1,36 +0,0 @@
-import * as THREE from "three";
-import { Vector3 } from "../../opengeometry/pkg/opengeometry.js";
-import { AnalyticCurve, type AnalyticCurveStats } from "./analytic-curve.js";
-import type { AnalyticAccuracy } from "../shapes/analytic-solid.js";
-export interface IArcOptions {
-    ogid?: string;
-    center?: Vector3;
-    radius?: number;
-    startAngle?: number;
-    sweepAngle?: number;
-    deflection?: number;
-    accuracy?: AnalyticAccuracy;
-    color?: THREE.ColorRepresentation;
-}
-export type ArcConfigUpdate = Partial<Omit<IArcOptions, "ogid">>;
-interface NormalizedArcOptions {
-    ogid?: string;
-    center: Vector3;
-    radius: number;
-    startAngle: number;
-    sweepAngle: number;
-    deflection: number;
-    accuracy?: AnalyticAccuracy;
-    color: THREE.ColorRepresentation;
-}
-/** Authoritative circular edge with transient deflection tessellation. */
-export declare class Arc extends AnalyticCurve {
-    options: Readonly<NormalizedArcOptions>;
-    constructor(options?: IArcOptions);
-    getAnchor(): Vector3;
-    getConfig(): Readonly<NormalizedArcOptions>;
-    setConfig(update: ArcConfigUpdate): AnalyticCurveStats;
-    getBrep(): Record<string, unknown>;
-    retessellate(deflection: number): AnalyticCurveStats;
-}
-export {};

package/src/primitives/curve.d.ts

@@ -1,64 +0,0 @@
-import * as THREE from "three";
-import { Vector3 } from "../../opengeometry/pkg/opengeometry.js";
-/**
- * Construction options for a control-point-driven curve.
- */
-export interface ICurveOptions {
-    ogid?: string;
-    controlPoints: Vector3[];
-    color: number;
-    translation?: Vector3;
-    rotation?: Vector3;
-    scale?: Vector3;
-}
-/**
- * Placement updates accepted by `Curve`.
- */
-export interface CurvePlacementOptions {
-    translation?: Vector3;
-    rotation?: Vector3;
-    scale?: Vector3;
-}
-/**
- * Partial config payload accepted by `Curve.setConfig(...)`.
- */
-export type CurveConfigUpdate = Partial<Omit<ICurveOptions, "translation" | "rotation" | "scale">>;
-/**
- * Alias for `Curve` placement updates.
- */
-export type CurvePlacementUpdate = CurvePlacementOptions;
-/**
- * Offset result returned by `Curve.offset(...)`.
- */
-export interface ICurveOffsetResult {
-    points: Vector3[];
-    beveledVertexIndices: number[];
-    isClosed: boolean;
-}
-/**
- * Curve wrapper backed by the kernel OGCurve primitive.
- */
-export declare class Curve extends THREE.Line {
-    ogid: string;
-    options: ICurveOptions;
-    private curve;
-    set color(color: number);
-    constructor(options?: ICurveOptions);
-    setConfig(options: CurveConfigUpdate): void;
-    getConfig(): ICurveOptions;
-    getAnchor(): Vector3;
-    setAnchor(anchor: Vector3): void;
-    resetAnchor(): void;
-    setPlacement(placement: CurvePlacementUpdate): void;
-    setTransform(translation: Vector3, rotation: Vector3, scale: Vector3): void;
-    setTranslation(translation: Vector3): void;
-    setRotation(rotation: Vector3): void;
-    setScale(scale: Vector3): void;
-    getPlacement(): import("../editor.js").ParametricPlacement;
-    getEditCapabilities(): import("../editor.js").ParametricEditCapabilities;
-    canConvertToFreeform(): boolean;
-    toFreeform(id?: string): import("../freeform.js").FreeformGeometry;
-    private generateGeometry;
-    getOffset(distance: number, acuteThresholdDegrees?: number, bevel?: boolean): ICurveOffsetResult;
-    private writePositionsToGeometry;
-}

package/src/primitives/elliptical_arc.d.ts

@@ -1,38 +0,0 @@
-import * as THREE from "three";
-import { Vector3 } from "../../opengeometry/pkg/opengeometry.js";
-import { AnalyticCurve, type AnalyticCurveStats } from "./analytic-curve.js";
-import type { AnalyticAccuracy } from "../shapes/analytic-solid.js";
-export interface IEllipticalArcOptions {
-    ogid?: string;
-    center?: Vector3;
-    majorRadius?: number;
-    minorRadius?: number;
-    startAngle?: number;
-    sweepAngle?: number;
-    deflection?: number;
-    accuracy?: AnalyticAccuracy;
-    color?: THREE.ColorRepresentation;
-}
-export type EllipticalArcConfigUpdate = Partial<Omit<IEllipticalArcOptions, "ogid">>;
-interface NormalizedEllipticalArcOptions {
-    ogid?: string;
-    center: Vector3;
-    majorRadius: number;
-    minorRadius: number;
-    startAngle: number;
-    sweepAngle: number;
-    deflection: number;
-    accuracy?: AnalyticAccuracy;
-    color: THREE.ColorRepresentation;
-}
-/** Authoritative elliptical edge with transient deflection tessellation. */
-export declare class EllipticalArc extends AnalyticCurve {
-    options: Readonly<NormalizedEllipticalArcOptions>;
-    constructor(options?: IEllipticalArcOptions);
-    getAnchor(): Vector3;
-    getConfig(): Readonly<NormalizedEllipticalArcOptions>;
-    setConfig(update: EllipticalArcConfigUpdate): AnalyticCurveStats;
-    getBrep(): Record<string, unknown>;
-    retessellate(deflection: number): AnalyticCurveStats;
-}
-export {};

package/src/primitives/index.d.ts

@@ -1,9 +0,0 @@
-/**
- * 2D and path primitive wrappers backed by the OpenGeometry kernel.
- */
-export * from './line.js';
-export * from './polyline.js';
-export * from './arc.js';
-export * from './rectangle.js';
-export * from './curve.js';
-export * from "./elliptical_arc.js";

package/src/primitives/line.d.ts

@@ -1,77 +0,0 @@
-import { Vector3 } from "../../opengeometry/pkg/opengeometry.js";
-import * as THREE from "three";
-/**
- * Construction options for a line segment wrapper.
- */
-export interface ILineOptions {
-    ogid?: string;
-    start: Vector3;
-    end: Vector3;
-    color: number;
-    fatLines?: boolean;
-    width?: number;
-    translation?: Vector3;
-    rotation?: Vector3;
-    scale?: Vector3;
-}
-/**
- * Placement updates accepted by `Line`.
- */
-export interface LinePlacementOptions {
-    translation?: Vector3;
-    rotation?: Vector3;
-    scale?: Vector3;
-}
-/**
- * Partial config payload accepted by `Line.setConfig(...)`.
- */
-export type LineConfigUpdate = Partial<Omit<ILineOptions, "translation" | "rotation" | "scale">>;
-/**
- * Alias for `Line` placement updates.
- */
-export type LinePlacementUpdate = LinePlacementOptions;
-/**
- * Offset result returned by `Line.offset(...)`.
- */
-export interface ILineOffsetResult {
-    points: Vector3[];
-    beveledVertexIndices: number[];
-    isClosed: boolean;
-}
-/**
- * Simple Line defined by Two Points
- */
-export declare class Line extends THREE.Line {
-    ogid: string;
-    options: ILineOptions;
-    private line;
-    private fatLine;
-    set color(color: number);
-    constructor(options?: ILineOptions);
-    validateOptions(): void;
-    setConfig(options: LineConfigUpdate): void;
-    getConfig(): ILineOptions;
-    getAnchor(): Vector3;
-    setAnchor(anchor: Vector3): void;
-    resetAnchor(): void;
-    setPlacement(placement: LinePlacementUpdate): void;
-    setTransform(translation: Vector3, rotation: Vector3, scale: Vector3): void;
-    setTranslation(translation: Vector3): void;
-    setRotation(rotation: Vector3): void;
-    setScale(scale: Vector3): void;
-    getPlacement(): import("../editor.js").ParametricPlacement;
-    getEditCapabilities(): import("../editor.js").ParametricEditCapabilities;
-    canConvertToFreeform(): boolean;
-    toFreeform(id?: string): import("../freeform.js").FreeformGeometry;
-    /**
-     * Every time there are property changes, geometry needs to be discarded and regenerated.
-     * This is to ensure that the geometry is always up-to-date with the current state.
-     */
-    discardGeometry(): void;
-    private getCurrentPositions;
-    private updateRenderStyle;
-    private generateGeometry;
-    getDXF(): string;
-    getOffset(distance: number, acuteThresholdDegrees?: number, bevel?: boolean): ILineOffsetResult;
-    private writePositionsToGeometry;
-}

package/src/primitives/polyline.d.ts

@@ -1,78 +0,0 @@
-import * as THREE from 'three';
-import { Vector3 } from '../../opengeometry/pkg/opengeometry.js';
-/**
- * Construction options for an ordered polyline wrapper.
- */
-export interface IPolylineOptions {
-    ogid?: string;
-    color: number;
-    points: Vector3[];
-    fatLines?: boolean;
-    width?: number;
-    translation?: Vector3;
-    rotation?: Vector3;
-    scale?: Vector3;
-}
-/**
- * Placement updates accepted by `Polyline`.
- */
-export interface PolylinePlacementOptions {
-    translation?: Vector3;
-    rotation?: Vector3;
-    scale?: Vector3;
-}
-/**
- * Partial config payload accepted by `Polyline.setConfig(...)`.
- */
-export type PolylineConfigUpdate = Partial<Omit<IPolylineOptions, "translation" | "rotation" | "scale">>;
-/**
- * Alias for `Polyline` placement updates.
- */
-export type PolylinePlacementUpdate = PolylinePlacementOptions;
-/**
- * Offset result returned by `Polyline.offset(...)`.
- */
-export interface IOffsetResult {
-    points: Vector3[];
-    beveledVertexIndices: number[];
-    isClosed: boolean;
-}
-/**
- * Polyline wrapper backed by the kernel OGPolyline primitive.
- */
-export declare class Polyline extends THREE.Line {
-    ogid: string;
-    options: IPolylineOptions;
-    isClosed: boolean;
-    private polyline;
-    private fatLine;
-    transformationMatrix: THREE.Matrix4;
-    set color(color: number);
-    constructor(options?: IPolylineOptions);
-    validateOptions(): void;
-    setConfig(options: PolylineConfigUpdate): void;
-    getConfig(): IPolylineOptions;
-    getAnchor(): Vector3;
-    setAnchor(anchor: Vector3): void;
-    resetAnchor(): void;
-    setPlacement(placement: PolylinePlacementUpdate): void;
-    setTransform(translation: Vector3, rotation: Vector3, scale: Vector3): void;
-    setTranslation(translation: Vector3): void;
-    setRotation(rotation: Vector3): void;
-    setScale(scale: Vector3): void;
-    getPlacement(): import("../editor.js").ParametricPlacement;
-    getEditCapabilities(): import("../editor.js").ParametricEditCapabilities;
-    canConvertToFreeform(): boolean;
-    toFreeform(id?: string): import("../freeform.js").FreeformGeometry;
-    addPoint(point: Vector3): void;
-    /**
-     * Every time there are property changes, geometry needs to be discarded and regenerated.
-     * This is to ensure that the geometry is always up-to-date with the current state.
-     */
-    discardGeometry(): void;
-    private getCurrentPositions;
-    private updateRenderStyle;
-    private generateGeometry;
-    getOffset(distance: number, acuteThresholdDegrees?: number, bevel?: boolean): IOffsetResult;
-    private writePositionsToGeometry;
-}

package/src/primitives/rectangle.d.ts

@@ -1,72 +0,0 @@
-import { Vector3 } from "../../opengeometry/pkg/opengeometry.js";
-import * as THREE from "three";
-/**
- * Construction options for a rectangle profile wrapper.
- */
-export interface IRectangleOptions {
-    ogid?: string;
-    center: Vector3;
-    width: number;
-    breadth: number;
-    color: number;
-    fatLines?: boolean;
-    lineWidth?: number;
-    translation?: Vector3;
-    rotation?: Vector3;
-    scale?: Vector3;
-}
-/**
- * Placement updates accepted by `Rectangle`.
- */
-export interface RectanglePlacementOptions {
-    translation?: Vector3;
-    rotation?: Vector3;
-    scale?: Vector3;
-}
-/**
- * Partial config payload accepted by `Rectangle.setConfig(...)`.
- */
-export type RectangleConfigUpdate = Partial<Omit<IRectangleOptions, "translation" | "rotation" | "scale">>;
-/**
- * Alias for `Rectangle` placement updates.
- */
-export type RectanglePlacementUpdate = RectanglePlacementOptions;
-/**
- * Offset result returned by `Rectangle.offset(...)`.
- */
-export interface IRectangleOffsetResult {
-    points: Vector3[];
-    beveledVertexIndices: number[];
-    isClosed: boolean;
-}
-/**
- * Rectangle wrapper backed by the kernel OGRectangle primitive.
- */
-export declare class Rectangle extends THREE.Line {
-    ogid: string;
-    options: IRectangleOptions;
-    private polyLineRectangle;
-    private fatLine;
-    set color(color: number);
-    constructor(options?: IRectangleOptions);
-    validateOptions(): void;
-    setConfig(options: RectangleConfigUpdate): void;
-    getAnchor(): Vector3;
-    setPlacement(placement: RectanglePlacementUpdate): void;
-    setTransform(translation: Vector3, rotation: Vector3, scale: Vector3): void;
-    setTranslation(translation: Vector3): void;
-    setRotation(rotation: Vector3): void;
-    setScale(scale: Vector3): void;
-    getConfig(): IRectangleOptions;
-    getPlacement(): import("../editor.js").ParametricPlacement;
-    getEditCapabilities(): import("../editor.js").ParametricEditCapabilities;
-    canConvertToFreeform(): boolean;
-    toFreeform(id?: string): import("../freeform.js").FreeformGeometry;
-    private getCurrentPositions;
-    private updateRenderStyle;
-    private generateGeometry;
-    getBrep(): any;
-    getOffset(distance: number, acuteThresholdDegrees?: number, bevel?: boolean): IRectangleOffsetResult;
-    discardGeometry(): void;
-    private writePositionsToGeometry;
-}

package/src/rendering/analytic-lod.d.ts

@@ -1,32 +0,0 @@
-import * as THREE from "three";
-import type { AnalyticSolid, AnalyticTessellationStats } from "../shapes/analytic-solid.js";
-import { AnalyticTessellationWorker } from "./analytic-tessellation.js";
-export declare function deflectionBucket(target: number, previous?: number): number;
-export declare function worldUnitsPerPixel(camera: THREE.PerspectiveCamera | THREE.OrthographicCamera, depth: number, physicalHeight: number): number;
-export interface AnalyticLodOptions {
-    fixedDeflection?: number;
-    onUpdate?: (solid: AnalyticSolid, statistics: AnalyticTessellationStats) => void;
-    onError?: (solid: AnalyticSolid, error: Error) => void;
-}
-/** Register authored changes explicitly; camera meshes never refresh a scene's authored BRep snapshots. */
-export declare class AnalyticLodController {
-    private readonly worker;
-    private readonly options;
-    private readonly entries;
-    private readonly cameraState;
-    private lastMotion;
-    private lastSchedule;
-    private initialized;
-    private closed;
-    private refining;
-    private fixedDeflection?;
-    constructor(worker: AnalyticTessellationWorker, options?: AnalyticLodOptions);
-    setDeflection(deflection?: number): void;
-    register(solid: AnalyticSolid): Promise<void>;
-    unregister(solid: AnalyticSolid): Promise<void>;
-    update(camera: THREE.PerspectiveCamera | THREE.OrthographicCamera, physicalHeight: number, now?: number, motion?: boolean): void;
-    /** Explicit export refinement; a resource or precision failure rejects and retains each body's prior mesh. */
-    refine(deflection: number): Promise<void>;
-    dispose(): void;
-}
-export declare function uniformScale(matrix: THREE.Matrix4): number;

package/src/rendering/analytic-tessellation.d.ts

@@ -1,32 +0,0 @@
-export interface AnalyticTessellationData {
-    positions: Float64Array;
-    normals: Float32Array;
-    indices: Uint32Array;
-    triangleFaceIds: Uint32Array;
-    outlinePositions: Float64Array;
-    outlineEdgeIds: Uint32Array;
-    revision: bigint;
-    achievedDeflection: number;
-}
-export declare const GEOMETRY_DEFLECTION_SHARE = 0.75;
-export interface AnalyticWorkerOptions {
-    workerURL: string | URL;
-    kernelURL: string | URL;
-    wasmURL: string | URL;
-}
-export declare class AnalyticTessellationWorker {
-    private readonly worker;
-    private readonly pending;
-    private readonly generations;
-    private readonly ready;
-    private serial;
-    private closed;
-    constructor(options: AnalyticWorkerOptions);
-    setModel(handle: string, serialized: string): Promise<void>;
-    tessellate(handle: string, deflection: number): Promise<AnalyticTessellationData>;
-    cancel(handle: string): number;
-    removeModel(handle: string): Promise<void>;
-    dispose(): void;
-    private send;
-    private fail;
-}

package/src/shapes/analytic-pattern.d.ts

@@ -1,36 +0,0 @@
-import * as THREE from "three";
-import { AnalyticSolid } from "./analytic-solid.js";
-export interface AnalyticPatternInstance {
-    id?: string;
-    matrix: THREE.Matrix4;
-}
-export interface AnalyticPatternHit {
-    pattern: AnalyticPattern;
-    instanceIndex: number;
-    instanceId: string;
-    source: AnalyticSolid;
-    faceId?: number;
-}
-/**
- * Renders many rigid placements of one authoritative analytic body. The source
- * owns the BRep; instances own only identity and placement matrices.
- */
-export declare class AnalyticPattern extends THREE.Group {
-    readonly source: AnalyticSolid;
-    readonly surface: THREE.InstancedMesh<THREE.BufferGeometry, THREE.Material>;
-    readonly instanceIds: readonly string[];
-    private disposed;
-    constructor(source: AnalyticSolid, instances: readonly AnalyticPatternInstance[]);
-    get count(): number;
-    setInstanceMatrix(index: number, matrix: THREE.Matrix4): void;
-    resolveIntersection(intersection: THREE.Intersection): AnalyticPatternHit | undefined;
-    dispose(): void;
-    private checkActive;
-}
-export declare function linearPattern(source: AnalyticSolid, count: number, spacing: THREE.Vector3): AnalyticPattern;
-export declare function rectangularPattern(source: AnalyticSolid, counts: readonly [number, number], spacing: readonly [THREE.Vector3, THREE.Vector3]): AnalyticPattern;
-export declare function circularPattern(source: AnalyticSolid, count: number, radius: number, options?: {
-    startAngle?: number;
-    sweepAngle?: number;
-    rotateInstances?: boolean;
-}): AnalyticPattern;