archiyou 0.7.0

package/dist/src/LibraryConnector.d.ts

@@ -0,0 +1,56 @@
+import { Script } from './internal';
+export declare class LibraryConnector {
+    DEFAULT_LIBRARY_URL: string;
+    LIBRARY_ENDPOINTS: {
+        v1: {
+            all: string;
+        };
+        v2: {
+            all: string;
+        };
+    };
+    domain: string;
+    version: 'v1' | 'v2';
+    constructor(domain?: string);
+    /**
+     * Detect if a string is a domain (with or without protocol). Returns the origin string or false.
+     * Accepts:
+     *  - example.com
+     *  - https://example.com
+     *  - http://example.com:8080
+     *  - sub.domain.example.com/
+     *
+     * Rejects strings that contain path segments beyond an optional trailing slash:
+     *  - https://example.com/path -> false
+     */
+    _validateDomain(value: string): string | false;
+    /** Just request base url and see if we get some results */
+    connect(): Promise<boolean>;
+    _getLibraryVersion(info?: Record<string, any>): 'v1' | 'v2' | null;
+    /** Get all script versions */
+    getAllScripts(): Promise<Array<Script>>;
+    /** Get only the latest script versions */
+    getLatestScripts(): Promise<Array<Script>>;
+    /** Get specific script */
+    getScript(author: string, name: string, version?: string): Promise<Script | null>;
+    getLatestScript(author: string, name: string): Promise<Script | null>;
+    getScriptVersions(author: string, name: string): Promise<Array<string>>;
+    /** Readout basic info on Library */
+    printLibraryOverview(): Promise<void>;
+    /** Get script from a URL
+     *
+     *  If no https://domain is given, default library URL is used
+     *  Otherwise a new instance of LibraryConnector is created for that domain
+     *
+     *  @param path - path to fetch the script from
+     *
+     *     examples:
+     *         - https://pub.archiyou.com/archiyou/simplestep
+     *         - https://pubv2.archiyou.com/archiyou/simplestep/0.9.1 or https://pub.archiyou.com/archiyou/simplestep:0.9.1
+     *         - archiyou/simplestep (default library)
+     *
+     
+     *  @returns Promise<Script> - The script object with code and params
+     */
+    getScriptFromUrl(url: string): Promise<Script>;
+}

package/dist/src/Make.d.ts

@@ -0,0 +1,85 @@
+import { ConsoleMessage, ArchiyouApp, Point, Face, ShapeCollection, Table } from './internal';
+export type Alignment2D = 'topleft' | 'topright' | 'bottomleft' | 'bottomright';
+/** Statistics on last make operation, including error messages and important metrics
+ *  stats can be accessed after the operation at make.stats
+ *  this mechanism avoids any complex return values
+*/
+export interface MakeStats {
+    messages: Array<ConsoleMessage>;
+    efficiency: number;
+    wastedArea: number;
+    wastedVolume: number;
+    numStock: number;
+    full?: ShapeCollection;
+    cut?: ShapeCollection;
+    fitted?: ShapeCollection;
+    extra?: ShapeCollection;
+    waste?: ShapeCollection;
+}
+export interface Layout2DOptions {
+    start: Alignment2D;
+    direction: 'horizontal' | 'vertical';
+    width: number;
+    height: number;
+    stockWidth?: number;
+    stockHeight?: number;
+    grid?: number;
+    gridOffset?: number;
+    secondaryGrid?: number;
+    secondaryGridOffset?: number;
+    seamsStartOffset?: number;
+    leftover?: boolean;
+    cutMargin?: number;
+    stats?: boolean;
+}
+export declare function Layout2DOptions(o: any): o is Layout2DOptions;
+export interface PartListOptions {
+    sortBy: 'part' | 'section' | 'length' | 'quantity';
+}
+export interface WallOpening {
+    left: number;
+    sill: number;
+    width: number;
+    height: number;
+}
+export declare class Make {
+    LAYOUT2D_BOX_DEFAULT_FITTING_MARGIN_SIZE: number;
+    _ay: ArchiyouApp;
+    stats: MakeStats;
+    constructor(ay?: ArchiyouApp);
+    setArchiyou(ay: ArchiyouApp): void;
+    resetStats(): MakeStats;
+    _alignment2DToPoint(a: Alignment2D, width: number, height: number): Point;
+    _checkLayoutOptions(o: Layout2DOptions): Layout2DOptions;
+    _layout2DBoxesNewBox(cursor: Point, o: Layout2DOptions, leftOverSize?: number): Face;
+    _layout2DBoxes(o?: Layout2DOptions): ShapeCollection;
+    /** Calculate stats of layout2DBoxes operation */
+    _layout2DBoxesStats(o?: Layout2DOptions): MakeStats;
+    /** Public method to generate rectangular boarding on rectangle plane on XY plane
+     *  Generates statistics on waste, cuts etc at make.stats
+    */
+    boarding(o?: Layout2DOptions): ShapeCollection;
+    _boarding(o?: Layout2DOptions): ShapeCollection;
+    /** Find a 2D strut length and angle that exactly fits diagonally in given space
+     *   NOTE: It's easy to see how it works if you consider the special circumstances
+     *   of width=spaceWidth, width=spaceHeight and angle(spaceWidth,spaceHeight) = 45 deg
+    */
+    fitRectStrut(width: number, space: Array<number | number>, withSpace?: boolean): Face | ShapeCollection;
+    /** Make simple rectangular frame of width, height, depth and thickness at origin position
+     *  prio sets what members have priority (default: horizontal)
+     *  Frame is parallel to the front side
+    */
+    rectFrame(width: number, height: number, depth: number, thickness: number, prio?: 'horizontal' | 'vertical'): ShapeCollection;
+    /** Make an advanced wood frame for a wall
+     *  starting from origin with centerline along x-axis
+     *  returns ShapeCollection and puts messages inside console
+    */
+    wallFrame(width: number, height: number, depth: number, studThickness: number, grid: number, openings?: Array<WallOpening>): ShapeCollection;
+    /** Generate part list Calc table from ShapeCollection for beam-like shapes
+     *  For optimal information gathering:
+     *   - Beam-like shapes only
+     *   - group shapes into groups (will be used for part names)
+     *   - name individual shapes (will be used as subpart name)
+    */
+    partList(shapes: ShapeCollection, name?: string): Table;
+}

package/dist/src/MakeOperations.d.ts

@@ -0,0 +1,32 @@
+import { Make, Point, Vector, Face, AnyShape } from './internal';
+type OperationShapeType = 'beam' | 'board' | null;
+type OperationRefPlane = {
+    origin: Point;
+    xDir: Vector;
+    yDir: Vector;
+    zDir: Vector;
+    face: Face;
+};
+export declare class MakeOperations {
+    _make: Make;
+    constructor(make: Make);
+    /** Operation: Cut
+     *  Cross cut with cutting plane center at (x,y,z) on shape reference plane
+     *  and plane rotation
+    */
+    cut(shape: AnyShape, params: {
+        x: number;
+        y: number;
+        z: number;
+        angle?: number;
+        secondaryAngle?: number;
+    }): AnyShape | null;
+    /** Calculate the base information for a operation
+     *  What the ShapeType is and the local reference plane
+     */
+    _setOperationBase(shape: AnyShape): {
+        type: OperationShapeType;
+        ref: OperationRefPlane;
+    };
+}
+export {};

package/dist/src/OBbox.d.ts

@@ -0,0 +1,121 @@
+import { PointLike, MainAxis, Point, Vector, Shape, Edge, Face, Solid, AnyShape } from './internal';
+export declare class OBbox {
+    _oc: any;
+    _geom: any;
+    _ocOBbox: any;
+    position: Point;
+    /** Create 2D or 3D Bbox from a Shape */
+    constructor(shape: AnyShape);
+    create(shape: AnyShape): this;
+    /** Set public properties from _ocOBbox */
+    _setFromOcOBbox(): void;
+    /** Get center of Orientated Bounding Box */
+    center(): Point;
+    /** Get corner Points of Bbox in global coordinate system */
+    corners(): Array<Point>;
+    /** Return X axis normal of this OBbox, mostly along global x-axis */
+    xDir(): Vector;
+    /** Return Y axis normal of this OBbox */
+    yDir(): Vector;
+    /** Return Z axis normal of this OBbox */
+    zDir(): Vector;
+    width(): number;
+    depth(): number;
+    height(): number;
+    copy(): void;
+    /** Get Point of left, front, bottom corner in global coordinate system */
+    min(): Point;
+    minAtAxis(a: MainAxis): void;
+    maxAtAxis(a: MainAxis): void;
+    /** Get maximum point (right,top,back) */
+    max(): Point;
+    minX(): number;
+    maxX(): number;
+    minY(): number;
+    maxY(): number;
+    minZ(): number;
+    maxZ(): number;
+    /** Maximum size of Bbox */
+    maxSize(): number;
+    /** Maximum size of Bbox */
+    minSize(): number;
+    /** Get frontal Face (3D) or Edge (2D) */
+    front(): void;
+    /** Get back Face (3D) or Edge (2D) */
+    back(): void;
+    /** Get left Face (3D) or Edge (2D) */
+    left(): void;
+    /** Get left Face (3D) or Edge (2D) */
+    right(): void;
+    /** Get left Face (3D) or Edge (2D) */
+    top(): void;
+    /** Get left Face (3D) or Edge (2D) */
+    bottom(): void;
+    /** Get one of the 8 Vertices of the Bbox
+     *  @param - a string like 'leftfront', 'bottomright'
+     *  Order of sides does not matter
+    */
+    corner(where: string): void;
+    /** Get the diagonal of Orientated Bounding Box as Vertex (zero size Bbox) or Edge */
+    diagonal(): void;
+    /** Get position of Bbox based on percentages of x,y,z */
+    getPositionAtPerc(p: PointLike, ...args: any[]): void;
+    /** Enlarge by offsetting current Bbox in all direction a given amount. Returns a new Bbox. */
+    enlarged(amount: number): void;
+    /** Return a new Bbox by adding another */
+    added(other: OBbox): void;
+    /** Check if Orientated Bounding Box of zero size so a Point */
+    isPoint(): boolean;
+    /** Check if Orientated Bounding Box is 2D */
+    is2D(): boolean;
+    /** Check if Orientated Bounding Box is 3D */
+    is3D(): boolean;
+    /** Checks if sizes along axis are zero */
+    _sizesAreZero(): Array<boolean | boolean | boolean>;
+    /** Bbox has only one size dimension (the others are zero) */
+    is1D(): boolean;
+    /** The axis that is missing in 2D bbox */
+    axisMissingIn2D(): MainAxis | null;
+    /** Along what axis is this 1D Bbox */
+    sizeAxis1D(): MainAxis | null;
+    /** Axis on which the bbox has a size */
+    hasAxes(): Array<MainAxis>;
+    /** Get size of current Bbox along given axis */
+    sizeAlongAxis(axis: MainAxis): number;
+    /** Get Shape from this Orientated Bounding Box */
+    shape(): Edge | Face | Solid | null;
+    /** Alias for shape() */
+    toShape(): Edge | Face | Solid | null;
+    /** Make Line from 1D Bbox */
+    line(): Edge | null;
+    /** Create 2D Rectangle Face from Bbox */
+    rect(): Face;
+    /** returns a Box Shape for this Bbox if not 2D, otherwise null
+     *  NOTE: Don't automatically add to scene
+    */
+    box(): Solid | null;
+    /** Return flipped Bbox that is mirrored in x-axis. For certain 2D ops */
+    flippedY(): void;
+    /** Gets the Edge seperating width in two equal halves */
+    widthHalfLine(): Edge;
+    /** Gets the Edge seperating depth in two equal halves */
+    depthHalfLine(): Edge;
+    /** Get Sub Shapes associated with given sides
+        @param side - combinations of front|back|right|left|top|bottom
+        NOTE: we use _getSide for now - but we might refactor
+    */
+    getSidesShape(sidesString: string): void;
+    /** Get individual Bbox side shapes based on sidestring
+     *  @param sidesString any combination between front/back,left/right,top/bottom
+     */
+    _getIndividualSideShapes(sidesString: string): void;
+    /** Get area of bbox */
+    area(): number | null;
+    volume(): number | null;
+    contains(other: Shape): void;
+    _containsOBbox(other: OBbox): void;
+    toData(): Array<Array<number>>;
+    toString(): string;
+    /** Get side of OBbox - NOTE: Some sides can be zero length */
+    _getSide(side: string): void;
+}

package/dist/src/Obj.d.ts

@@ -0,0 +1,104 @@
+import { ShapeCollection, Brep, PointLike, AnyShape, AnyShapeOrCollection, MeshShape, MeshShapeBuffer, SceneGraphNode, BaseStyle, ObjStyle, MeshingQualitySettings } from './internal';
+export declare class Obj {
+    DEFAULT_OBJ_STYLE: ObjStyle;
+    DEFAULT_BASE_STYLE: BaseStyle;
+    _oc: any;
+    _brep: Brep;
+    _id: string;
+    _name: string;
+    _shapeType: string;
+    _isLayer: boolean;
+    _visible: boolean;
+    _style: ObjStyle;
+    _shapes: ShapeCollection;
+    _parent: Obj;
+    _children: Array<Obj>;
+    constructor(shapes?: AnyShapeOrCollection);
+    /** Try to get as many properties for easy introspection */
+    _setProps(): void;
+    /** Set this Obj as a child of another */
+    setParent(parent: Obj): void;
+    /** Add Obj with its children to active layer */
+    addToScene(): void;
+    /** Get or set style
+     *  NOTE: We don't use get/setters because we want to be able to return Obj for setter
+     */
+    style(newStyle: BaseStyle | ObjStyle): Obj;
+    /** set Color for Obj/Layer. Shortcut of style */
+    color(newColor: string | number | Array<number>): Obj;
+    /** set Lines to dashed (keeps existing styling) */
+    dashed(): Obj;
+    /** set strokeWidth in mm while keeping the rest of existing styling */
+    lineWidth(n: number): Obj;
+    /** Get current Obj color or the one that is defined by one of the parents up the hierarchy */
+    getColor(): number;
+    /** Internal: get RGBA values of current color in  range [0-1] for RGB and A*/
+    _getColorRGBA(): [number, number, number, number];
+    /** Compile different parameters into a ObjStyle instance */
+    _compileStyle(newStyle?: ObjStyle | BaseStyle): ObjStyle;
+    /** Check and normalize ObjStyle values (mostly colors) in place */
+    _checkObjStyle(style: ObjStyle): ObjStyle;
+    move(v: PointLike): void;
+    rotate(t: any): void;
+    /** get/setter method for name property */
+    name(name?: string): string | Obj;
+    get id(): string;
+    hide(): any;
+    show(): any;
+    add(o: Obj): Obj;
+    /** Remove an object from children */
+    remove(o: Obj): void;
+    has(o: Obj): boolean;
+    /** Gets the direct children of this Obj  */
+    children(): Array<Obj>;
+    /** Alias for children() */
+    nodes(): Array<Obj>;
+    /** Recursively get all Objs in this Obj container */
+    descendants(): Array<Obj>;
+    /** Return shapes of this Obj
+        @param all (default:true) also those of descendant Objs
+    */
+    shapes(all?: boolean): ShapeCollection;
+    /** Get all shapes of this Obj including its descendant Obj's returned as grouped ShapeCollection
+     *  TODO: Do we need Shape.valid() - It's slow!
+    */
+    allShapesCollection(): ShapeCollection;
+    /** DEBUG:  Sometimes weird Objs are created */
+    isCircular(): boolean;
+    /** Get all Shapes within this Obj and its children Objs */
+    allShapes(): ShapeCollection;
+    getObjByName(name?: string): Obj;
+    /** Empty Obj container by releasing all OC Shapes and then removing JS references */
+    empty(): Obj;
+    /** Add a Shape to this object */
+    addShape(shape: AnyShape): Obj;
+    /** Remove all Shapes */
+    clearShapes(): Obj;
+    /** Delete Shapes
+     *  Mostly removing OC classes, JS objects are picked up by garbage collection
+     */
+    clearOcShapes(): this;
+    /** Get type of Shape(s) in this Object */
+    shapeType(): string;
+    /** Does this Obj contain multiple Shapes */
+    isLayer(): boolean;
+    /**
+     * Sometimes a Shape changes - it can then change its own reference inside a Obj container
+     *  @param newShape Can be both a Shape and ShapeCollection - that will be converted by ShapeCollection()
+     *
+     * */
+    _updateShapes(shapes: AnyShapeOrCollection): void;
+    /** Output all mesh data from Shape in this Obj and its children */
+    toMeshShapes(quality?: MeshingQualitySettings): Array<MeshShape>;
+    toMeshShapeBuffer(quality: MeshingQualitySettings): MeshShapeBuffer;
+    /** Turn Obj containing shape/shapeCollection of other Objs into a graph which we can use to show in a menu */
+    toGraph(): SceneGraphNode;
+    /** Output all properties of this Obj including that of its Shapes into a { key value } row */
+    toData(): Object;
+    toString(): string;
+    /**
+     *  Export Obj tree structure with raw shapes that will be recreated in other scope
+     *  NOTE: is this needed?
+     * */
+    toComponentGraph(component: string, parentNode?: Object): Object;
+}

package/dist/src/OcLoader.d.ts

@@ -0,0 +1,39 @@
+/** IMPORTANT:
+ *
+ *  Statically importing WASM related modules gives errors while building archiyou as a module
+ *  Vite creates base64 versions of the archiyou-opencascade.js which is not what we want
+ *  Underneath are all dynamically imported modules
+*/
+export class OcLoader {
+    SHAPE_TOLERANCE: number;
+    RUN_TEST: boolean;
+    ocJsModulePath: string;
+    ocJsNodeModulePath: string;
+    ocWasmModulePath: string;
+    _oc: any;
+    loaded: boolean;
+    startLoadAt: any;
+    /** Load synchronous */
+    load(onLoaded: any): void;
+    /** Load async */
+    loadAsync(): Promise<any>;
+    _getContext(): "webworker" | "browser" | "node";
+    /** Load OpenCascade module synchronous and run function when loading is done
+     *  This still uses the standard OC.js method, because alternatives with dynamic imports
+     *  are not working well in browser
+    */
+    _loadOcBrowser(onLoaded: any): void;
+    /** Load OpenCascade module async
+     *  Uses static import for maximum compatibility
+     *  This can work in Webpack 4 and above, Vite and Node environments
+    */
+    _loadOcBrowserAsync(): Promise<any>;
+    /** Load OpenCascade in Node context */
+    _loadOcNodeAsync(): Promise<any>;
+    _loadOcNode(onLoaded: any): void;
+    /** When OC is loaded, we set a couple of things */
+    _onOcLoaded(oc: any, onLoaded: any): any;
+    _getAbsPath(filepath: any): Promise<any>;
+    runTest(): void;
+    searchMethod(s: any): string[];
+}

package/dist/src/ParamManager.d.ts

@@ -0,0 +1,57 @@
+import { ScriptParam, ScriptParamData, ParamOperation, ParamManagerOperator } from './internal';
+/** Main ParamManager
+ *  Maintains all ParamManagerOperators
+ */
+export declare class ParamManager {
+    PARAM_SIGNIFIER: string;
+    parent: any;
+    paramOperators: Array<ParamManagerOperator>;
+    /** Set up ParamManager with current params */
+    constructor(params?: Array<ScriptParam>);
+    setParent(scope: any): this;
+    /** Compare managedParams with original ones of ParamManager and update params array in place
+     *  If needed forcing reactivity by creating copies
+     *  returns new or changed params
+     */
+    static updateParamsWithManaged(currentParams: Array<ScriptParam>, managedParams?: Record<ParamOperation, Array<ScriptParam>>, forceReactivity?: boolean): Array<ScriptParam>;
+    /** Add or update Param and return what was done (update, new, null)  */
+    addParam(p: ScriptParam): ParamOperation | null;
+    deleteParam(name: string): this;
+    /** Update ParamEntryController if needed and return updated or not */
+    updateParam(p: ScriptParam): boolean;
+    _paramNameExists(p: ScriptParam): boolean;
+    /** Utility to easily get target Params */
+    getParams(): Array<ScriptParam>;
+    /** Utility to easily get target Params by name */
+    getParamsMap(): Record<string, ScriptParam>;
+    getParamController(name: string): ParamManagerOperator;
+    /** Programmatically define a param: from simple to advanced
+     *  This can be used to define complex Parameters that can't be defined by the menu
+     *
+     *  @example myParamManager.define({ name: 'testnum', type: 'number'})
+     *  @example myParamManager.define({ name: 'mylist', type: 'list', listElem:
+     *      {
+     *      type: 'object',
+     *      schema: { w: { type: 'number', default: 100 },
+     *                h: { type: 'number', default: 200, start: 50, end: 300 }
+     *   }})
+    */
+    define(p: ScriptParam): this;
+    /** Return Params that we operated upon */
+    getOperatedParamsByOperation(): Record<ParamOperation, Array<ScriptParamData>>;
+    /** If this ParamManager is in a worker scope */
+    inWorker(): boolean;
+    /** Set Param read and write as globals on worker scope (in this.parent)
+     *  NOTE: We can not really work with Proxies here because we can not really set a Param global (ie. $TEST)
+     *      on this scope that is not a Proxy. Proxies can only target Objects
+            Use $PARAMS.$TEST.set() to set a value
+    */
+    setParamGlobalsInScope(scope?: any): boolean;
+    /** Compare two params (either Param or ScriptParam) */
+    equalParams(param1: ScriptParam, param2: ScriptParam): boolean;
+    /** Set quick references from this instance to the values of params
+        This is used to control Params directly (through ParamManagerOperator)
+        The user can write values for example with $PARAMS.$TEST.set(50)
+    */
+    setParamControlRefs(): void;
+}

package/dist/src/ParamManagerOperator.d.ts

@@ -0,0 +1,68 @@
+import { ParamManager, ParamOperation, ScriptParam, ScriptParamData } from './internal';
+export declare class ParamManagerOperator {
+    PARAM_TYPES: string[];
+    PARAM_TYPE_DEFAULT_LENGTH: number;
+    BASE_TYPE_PARAM_CHECKS: {
+        number: string;
+        boolean: string;
+        options: string;
+        list: string;
+        object: string;
+    };
+    name: string;
+    originalParam: ScriptParam;
+    targetParam: ScriptParam;
+    value: any;
+    manager: ParamManager;
+    operation: ParamOperation;
+    constructor(manager: ParamManager, p?: ScriptParam);
+    setOperation(op: ParamOperation): void;
+    /** Set value of Parameter */
+    set(v: any): any;
+    /** Insert a value into List Param */
+    push(v: any): any;
+    /** Directly make Param visible */
+    visible(): void;
+    /** Directly make Param invisible */
+    hide(): void;
+    /** Directly enable Param */
+    enable(): void;
+    /** Directly disable Param */
+    disable(): void;
+    /** Conditional visibility */
+    visibleIf(b: boolean): void;
+    /** Set behaviour that controls enable flag of this Param */
+    enableIf(b: boolean): void;
+    /** Set behaviour that controls value attribute of this Param */
+    valueOn(fn: (curParam: ScriptParam, params?: Record<string, ScriptParam>) => boolean): void;
+    /** Forward properties on this controller to target Param obj */
+    _setParamProps(): void;
+    /** Had this operator any operations */
+    paramOperated(): boolean;
+    /** Compare target Param with original one */
+    paramChanged(): boolean;
+    /** Evaluate behaviour and return changed param
+     *  @params a map for easy access: params.TEST.value
+    */
+    paramToData(param: ScriptParam): ScriptParamData;
+    /** Export to raw Param data for output
+     *  NOTE: We use ScriptParam here that is used for IO, but in App it is transformed back to Param
+    */
+    toData(): ScriptParamData;
+    /** Adding to lists create unending loops
+     *  We check if the last element is the same
+     *  TODO: Make a better solution
+    */
+    _checkIfListElemExistsLast(v: Record<string, any>): boolean;
+    /** Check Param input, if param is not set, the target Param is used */
+    _checkParamInput(v: any, p?: ScriptParam): boolean;
+    _checkNumParamInput(v: any, p?: ScriptParam): boolean;
+    _checkBoolParamInput(v: any, p?: ScriptParam): boolean;
+    _checkOptionsParamInput(v: any, p?: ScriptParam): boolean;
+    _checkListParamInput(v: any, p?: ScriptParam): boolean;
+    /** Check input against schema */
+    _checkObjParamInput(v: any, p?: ScriptParam): boolean;
+    _getObjValueByPath(path: string, obj: Object): any;
+    _checkParam(p: ScriptParam): ScriptParam;
+    getScope(): string;
+}

package/dist/src/Pipeline.d.ts

@@ -0,0 +1,20 @@
+import { ShapeCollection, Brep } from './internal';
+export declare class Pipeline {
+    _oc: any;
+    _brep: Brep;
+    name: string;
+    _shapes: ShapeCollection;
+    _function: () => ShapeCollection;
+    /** Create a Pipeline */
+    constructor(name?: string);
+    /** Things for the pipeline to do
+     *   NOTE: the given function is executed in the WebWorker global scope,
+     *   IMPORTANT: While previously defined variables from the main script scope are accessible,
+     *              it is STRONGLY ADVISED to only use variables defined within the pipeline function itself,
+     *              or passed as arguments to it. This avoids unexpected behavior due to variable scope issues.
+     *
+     */
+    do(fn: () => ShapeCollection): this;
+    /** Run pipeline and get a ShapeCollection back */
+    run(): ShapeCollection;
+}

package/dist/src/Point.d.ts

@@ -0,0 +1,88 @@
+import { MainAxis, PointLike, Cursor, AnyShapeOrCollection, Plane, Vector, Vertex } from './internal';
+import { gp_Pnt, gp_Vec } from './wasm/archiyou-opencascade';
+export declare class Point {
+    _x: number;
+    _y: number;
+    _z: number;
+    _oc: any;
+    _cursor: Cursor;
+    constructor(p?: PointLike, ...args: any[]);
+    static isPoint(obj: any): boolean;
+    /** Create a Point from a PointLike (see typings.ts) */
+    fromPointLike(p?: PointLike, ...args: any[]): Point | Vector;
+    /** Set cursor on this Point instance, so we can make relative coords */
+    cursor(cursor: Point | Cursor): Point;
+    /** Class method */
+    static fromPointLike(v: any, ...args: any[]): Point;
+    get x(): number;
+    get y(): number;
+    get z(): number;
+    set x(x: number);
+    set y(y: number);
+    set z(z: number);
+    /** Sets x,y,z components of Point  */
+    set(point: PointLike, ...args: any[]): Point;
+    /** Sets x component of Point  */
+    setX(x: number): Point;
+    /** Sets y component of Point  */
+    setY(y: number): Point;
+    /** Sets z component of Point  */
+    setZ(z: number): Point;
+    setComponent(a: MainAxis, v: number): Point;
+    isOrigin(): boolean;
+    _fromOcPoint(ocPoint: any): Vector | Point;
+    _fromOcXYZ(ocXYZ: any): Vector | Point;
+    _toOcPoint(): gp_Pnt;
+    _toOcVector(): gp_Vec;
+    _toOcDir(): any;
+    toArray(): [number, number, number];
+    toVector(): Vector;
+    /** Transform Point to new Vertex without adding to Scene */
+    _toVertex(): Vertex;
+    /** Transform Point to new Vertex and add to Scene */
+    toVertex(): Vertex;
+    copy(): Point;
+    /** Add a PointLike to this Vector */
+    add(v: PointLike, ...args: any[]): Point;
+    /** Add PointLike to this one and return a new Vector  */
+    added(v: PointLike, ...args: any[]): Point;
+    /** Move Point */
+    move(vec: PointLike, ...args: any[]): Point;
+    /** Move Point along x axis */
+    moveX(dx: number): Point;
+    /** Move Point along y axis */
+    moveY(dy: number): Point;
+    /** Move Point along y axis */
+    moveZ(dz: number): Point;
+    moved(vec: PointLike, ...args: any[]): Point;
+    /** Test if given entity has equivalent geometry as current Point */
+    equals(other: PointLike, ...args: any[]): boolean;
+    /** Test if given PointLike entity has equivalent geometry with a tolerance */
+    equalsTolerance(other: PointLike, tolerance: number): boolean;
+    distance(other: PointLike): number;
+    /** We got a Point array with relative coordinates: resolve into real numbers based on previous Point
+     *
+     *  2 Types:
+     *      - cartesian ['+10','-10']
+     *      - polar coordinates ['100<30'] or ['100<<20'] (relative angle)
+    */
+    _arrayResolveRelativeCoordinates(pointArr: Array<string | number>, cursor?: Cursor): Array<number>;
+    /** Calculate orthogonal projections from this Point to Edges/Wires of a given Shape or ShapeCollection
+        A projected Point from an original Point to a Curve is the point on a other Shape
+        where the line between the two points is perpendicular to the Curve at the projected Point
+    */
+    project(to: AnyShapeOrCollection): Array<Point>;
+    /** Flip x-coordinate */
+    flippedX(): Point;
+    /** Flip y-coordinate */
+    flippedY(): Point;
+    /** Flip z-coordinate */
+    flippedZ(): Point;
+    /** Does current Point share plane with the other */
+    sharedPlane(other: PointLike): Plane;
+    round(): Point;
+    rounded(): Point;
+    toData(): number[];
+    /** Export entity and minimal data as string (used for outputting on console and hashing ) */
+    toString(): string;
+}