archiyou 0.7.0

package/dist/src/Solid.d.ts

@@ -0,0 +1,54 @@
+import { AnyShapeOrCollection, PointLike, ThickenDirection, MakeSolidInput, AnyShapeOrCollectionOrSelectionString, Vector, Point, Shape, Shell } from './internal';
+export declare class Solid extends Shape {
+    constructor(o?: any, ...args: any[]);
+    fromAll(shells: MakeSolidInput, ...args: any[]): Solid;
+    /** Created an solid out of closed Shell */
+    fromShell(shell: Shell): Solid;
+    /** Create Solid by sewing multiple Shells */
+    fromShells(shells: AnyShapeOrCollection): Solid;
+    _fromOcSolid(ocSolid: any, fix?: boolean): Solid;
+    _setToOc(): void;
+    ocGeom(): any;
+    /** Creates a box of size given by width, depth and height and position */
+    makeBox(width?: number, depth?: number, height?: number, position?: PointLike): Solid;
+    /** Creates a Box by giving two extreme points ( not the same, and not on the same axis ) */
+    makeBoxBetween(from: PointLike, to: PointLike): Solid;
+    /** Creates a Sphere Solid */
+    makeSphere(radius?: number, position?: PointLike, angle?: number): Solid;
+    /** Creates a Cone Solid */
+    makeCone(bottomRadius?: number, topRadius?: number, height?: number, position?: PointLike, angle?: number): Solid;
+    /** Creates a Cylinder with a given radius, height and position */
+    makeCylinder(radius?: number, height?: number, position?: PointLike, angle?: number): Solid;
+    /** Determine if Solid is a primitive type */
+    solidType(): string;
+    /** Get center of mass of Solid */
+    center(): Point;
+    /** Is 2D and on XY plane */
+    is2DXY(): boolean;
+    _fix(): Solid;
+    _fixReversedFaces(): Solid;
+    /** Give the Solid rounded corners at its Edges with a given radius */
+    fillet(radius?: number, at?: null | AnyShapeOrCollectionOrSelectionString): this;
+    /** Alias for filleted but with making copy  */
+    filleted(radius?: number, edges?: AnyShapeOrCollectionOrSelectionString): Solid;
+    /** Chamfer Solid at given Edges with given size */
+    chamfer(distance?: number, edges?: AnyShapeOrCollectionOrSelectionString): this;
+    /** Same of chamfer but with a copied Shape */
+    chamfered(distance?: number, edges?: AnyShapeOrCollectionOrSelectionString): Solid;
+    /** Alias for chamfer */
+    bevel(distance?: number, edges?: AnyShapeOrCollection): Solid;
+    /** Alias for chamfered */
+    beveled(distance?: number, edges?: AnyShapeOrCollection): Solid;
+    /** Alias for shelled with same API as thicken in Wire/Edge and Shell */
+    thickened(amount?: number, direction?: ThickenDirection, excludeFaces?: AnyShapeOrCollectionOrSelectionString): Solid;
+    thicken(amount: number, direction?: ThickenDirection, excludeFaces?: AnyShapeOrCollectionOrSelectionString): Solid;
+    normalAt(point: Point): Vector;
+    /** Even for Volume we try to calculate length
+     *  For now just the largest size of the bbox
+     *  Works well for boxes, but not more complex
+     */
+    length(): number;
+    area(): number;
+    /** Export entity and minimal data as string (used for outputting on console and hashing ) */
+    toString(): string;
+}

package/dist/src/Vector.d.ts

@@ -0,0 +1,167 @@
+import { MainAxis, PointLike, Point, Vertex } from './internal';
+export declare class Vector extends Point {
+    _ocVector: any;
+    constructor(p?: PointLike, ...args: any[]);
+    _clearOcVector(): void;
+    static isVector(obj: any): boolean;
+    /** Overload from Point */
+    fromPointLike(p?: PointLike, ...args: any[]): Vector;
+    /** Class method */
+    static fromPointLike(v: any, ...args: any[]): Vector;
+    /** Sets OC Vector from x,y,z coordinates  */
+    _updateOcVector(): Vector;
+    /** Update properties from _ocVector */
+    _updateFromOcVector(): Vector;
+    _toOcLocation(): any;
+    /** Try to convert anything to a Vector
+        mostly here for backwards compatibiliy
+        TODO: slowly move this out since the constructor does the same */
+    fromAll(v: any, ...args: any[]): Vector;
+    /** Set internal properties x,y,z from a given or already wrapped OC gp_Vec instance */
+    _fromOcVec(ocVec?: any): Vector;
+    /** Copy OC Vector from given Vector */
+    _copyOcFromVec(vector: Vector): void;
+    /** Create Vector from OC Point instance */
+    _fromOcPoint(ocPoint: any): Vector;
+    /** Create Vector from OC Direction instance */
+    _fromOcDir(ocDir: any): Vector;
+    /** Random Vector in a circle of given radius */
+    random(radius?: number): Vector;
+    toVector(): Vector;
+    toPoint(): Point;
+    toVertex(): Vertex;
+    toArray(): [number, number, number];
+    _ocGeom(): any;
+    /** Sets x,y,z components of Vector  */
+    set(vector: PointLike, ...args: any[]): Vector;
+    /** Sets x component of Vector  */
+    setX(x: number): Vector;
+    /** Sets y component of Vector  */
+    setY(y: number): Vector;
+    /** Sets z component of Vector  */
+    setZ(z: number): Vector;
+    setComponent(a: MainAxis, v: number): any;
+    /** Return the magnitude/length of this Vector */
+    magnitude(): any;
+    /** Return the magnitude/length of this Vector */
+    length(): any;
+    /** Return the squared magnitude/length of this Vector */
+    squareMagnitude(): any;
+    /** Check if this Vector is normal to the another: abs(<me>.Angle(Other) - PI/2.) <= AngularToleranc */
+    isNormalTo(other: PointLike, ...args: any[]): boolean;
+    /** Return the angles around the different axis
+     *     !!!! Some of these values can be null - for example for [100,0,0] => rotation around X axis = null  !!!!
+     */
+    angles(): Array<number>;
+    /** Returns the angles of rotation (intrinsic YZX Euler angles) around each axis that transform the given normalized Vector to the normalized other
+     *  Important: When rotation around axis apply in order YZX
+     *  docs:
+     *      - https://dev.opencascade.org/content/get-euler-angles-gptrsf-gpquaterniongeteulerangles
+     *      - https://dev.opencascade.org/content/gpquaternion-changes-regarding-euler-angles-700
+     *      - https://en.wikipedia.org/wiki/Euler_angles
+     *      - https://www.mathworks.com/matlabcentral/answers/407489-rotate-vectors-onto-each-other-and-euler-angles
+     *      - http://www.euclideanspace.com/maths/geometry/rotations/conversions/quaternionToEuler/index.htm
+    */
+    /** Return a new Vector with all its coordinates positive */
+    abs(): Vector;
+    /** Move the Vector - mainly for consistency for example Vertex */
+    move(p: PointLike, ...args: any[]): Vector;
+    /** Copy Vector and return a new one */
+    copy(): Vector;
+    /** Add a PointLike to this Vector */
+    add(vector: PointLike, ...args: any[]): Vector;
+    /** Add PointLike to this one and return a new Vector  */
+    added(vector: PointLike, ...args: any[]): Vector;
+    /** Subtract a PointLike from current Vector */
+    subtract(vector: PointLike, ...args: any[]): this;
+    /** Subtract a PointLike from this one and return a new Vector  */
+    subtracted(vector: PointLike, ...args: any[]): Vector;
+    /** Multiple Vector with scalar (1D,2D,3D) and return current Vector
+     *  We can multiple with one number or by axis with Array [x,y,z]
+    */
+    multiply(scalar: number | PointLike, ...args: any[]): Vector;
+    /** Multiply Vector with scalar and return a copy of Vector */
+    multiplied(scalar: number | PointLike, ...args: any[]): Vector;
+    /** Scale is an alias for multiply */
+    scale(scalar: number | PointLike, ...args: any[]): Vector;
+    /** Scaled is an alias for multiplied */
+    scaled(scalar: number | PointLike, ...args: any[]): Vector;
+    /** Divide Vector by scalar and return current Vector */
+    divide(scalar: number | PointLike, ...args: any[]): Vector;
+    /** Divide Vector by this one and return a new Vector  */
+    divided(scalar: PointLike, ...args: any[]): Vector;
+    /** Calculate Cross Vector with this and other vector and return a new Vector */
+    crossed(other: PointLike, ...args: any[]): Vector;
+    /** Calculate Dot / Inner product with this and other Vector */
+    dot(other: PointLike, ...args: any[]): number;
+    /** Normalize current Vector and return */
+    normalize(): Vector;
+    /** Normalize current Vector and return a copy */
+    normalized(): Vector;
+    /** Reverse current Vector and return current Vector */
+    reverse(): this;
+    /** Reverse current Vector and return a copy */
+    reversed(): Vector;
+    /** Mirror current Vector
+        @param position position of mirror axis
+        @param direction direction of mirror axis - default is the Y axis
+    */
+    mirror(position?: PointLike, direction?: PointLike): Vector;
+    /** Mirror current Vector and return a copy */
+    mirrored(position?: PointLike, direction?: PointLike): Vector;
+    /**
+     *   Rotates current Vector along a axis defined by position and direction
+     *   @param angle in degrees
+     */
+    rotate(angle: number, position?: PointLike, direction?: PointLike): this;
+    /**
+     *   Same as rotate() but returns a copy
+     *   @param angle in degrees
+     */
+    rotated(angle: number, position?: PointLike, direction?: PointLike): Vector;
+    rotateX(angle: number): this;
+    rotateY(angle: number): this;
+    rotateZ(angle: number): this;
+    /** Swap x,y coordinates for some 2D applications */
+    swappedXY(): Vector;
+    /** Get largest component along any (negative) axis */
+    largestAxis(): MainAxis;
+    isOrtho(): boolean;
+    /** Check if this Vector is the opposite of another Vector */
+    isOpposite(other: PointLike, ...args: any[]): boolean;
+    /** Check if this Vector is parallel to another Vector */
+    isParallel(other: PointLike, ...args: any[]): boolean;
+    /** Get the axis that this Vector could represent, if not null */
+    isWhatAxis(): string;
+    /** Return the smallest angle between this and another Vector in degrees */
+    angle(other: PointLike, ...args: any[]): number;
+    /** Angle [0-360] on XY plane
+     *  alias backwards compat
+    */
+    angle2D(): number;
+    /** Angle [0-360] on XY plane */
+    angleXY(): number;
+    /** Angle on XY (top) plane */
+    angleXZ(): number;
+    /** Angle around Y-axis, alias of angleXZ */
+    angleY(): number;
+    /** Angle on YZ (right) plane */
+    angleYZ(): number;
+    /** Angle around X-axis, alias of angleYZ */
+    angleX(): number;
+    /** Return the angle between one Vector and another where ref defines the positive sense of rotation */
+    angleRef(other: PointLike, ref: PointLike): number;
+    projectedToPlane(normal: PointLike): Vector;
+    /** Get smallest angle with another Vector around a axis direction */
+    angleAround(other: PointLike, axis: PointLike): number;
+    /** Check if this Vector is the same as another */
+    equals(other: PointLike, ...args: any[]): boolean;
+    /** Returns distance between current Vector with another */
+    distance(other: PointLike, ...args: any[]): number;
+    /** Returns the X/Y/Z Plane that Vectors share */
+    sharedPlanes(other: PointLike, ...args: any[]): Array<string>;
+    round(): Vector;
+    rounded(): Vector;
+    /** Export entity and minimal data as string (used for outputting on console and hashing ) */
+    toString(): string;
+}

package/dist/src/Vertex.d.ts

@@ -0,0 +1,57 @@
+import { PointLike, Point, Vector, Shape, Edge } from './internal';
+type IEdge = Edge;
+export declare class Vertex extends Shape {
+    _x: number;
+    _y: number;
+    _z: number;
+    constructor(p?: PointLike, ...args: any[]);
+    /** Create Vertex from PointLike input */
+    fromPointLike(p?: PointLike, ...args: any[]): Vertex;
+    /** Class method */
+    static fromPointLike(p: any, ...args: any[]): Vertex;
+    /** For backwards compatibility
+        TODO: Up for removal
+    */
+    fromAll(v?: PointLike, ...args: any[]): Vertex;
+    /**
+     *   Create Vertex from given ocVertex
+     *      We take some effort to round the Vertex because OC native rounding with Shape.round() does not work for Vertices?
+     */
+    _fromOcVertex(ocVertex?: any, round?: boolean): Vertex;
+    /** Set OC Shape from given [x,y,z] or if not present the existing [x,y,z] */
+    _updateOcShape(x?: number, y?: number, z?: number): Vertex;
+    /** Updates properties from this._ocShape */
+    _updateFromOcShape(): Vertex;
+    /** For backward compatibility: Better to use constructor */
+    fromVector(v: Vector): Vertex;
+    /** For backward compatibility: could just use constructor */
+    fromPoint(p: Point): this;
+    _fromOcPoint(ocPoint: any): Vertex;
+    get x(): number;
+    get y(): number;
+    get z(): number;
+    set x(x: number);
+    set y(y: number);
+    set z(z: number);
+    setX(x: number): Vertex;
+    /** Sets y component of Vector  */
+    setY(y: number): Vertex;
+    /** Sets z component of Vector  */
+    setZ(z: number): Vertex;
+    toVector(): Vector;
+    toArray(): Array<number>;
+    toPoint(): Point;
+    _toOcPoint(): any;
+    /** The position of the Vertex. Method is for consistency with other Shapes */
+    center(): any;
+    /** Extrudes the Vertex to create a Edge with certain length along a Direction Vector: default direction: Z-axis */
+    extrude(amount: number, direction?: PointLike): IEdge;
+    /** Extrude a copy of Vertex to create a Edge with certain length along a Direction Vector: default direction: Z-axis */
+    extruded(amount: number, direction?: PointLike): IEdge;
+    /** Rounds this Vertex (avoids very small values like 2.0e-15 */
+    rounded(): Vertex;
+    toData(): Array<number>;
+    /** Export entity and minimal data as string (used for outputting on console and hashing ) */
+    toString(): string;
+}
+export {};

package/dist/src/VertexCollection.d.ts

@@ -0,0 +1,11 @@
+import { MakeShapeCollectionInput, ShapeCollection } from './internal';
+/** A ShapeCollection with only Vertices */
+export declare class VertexCollection extends ShapeCollection {
+    constructor(entities?: MakeShapeCollectionInput, ...args: any[]);
+    /** Try to turn anything into a VertexCollection (based on ShapeCollection._addEntities) ) */
+    fromAll(entities?: MakeShapeCollectionInput, ...args: any[]): VertexCollection;
+    /** Class method */
+    static fromAll(v: any, ...args: any[]): VertexCollection;
+    /** Check and filter all shapes in ShapeCollection that are Vertices */
+    _check(): VertexCollection;
+}

package/dist/src/Wire.d.ts

@@ -0,0 +1,180 @@
+import { PointLike, Cursor, AnyShape, AnyShapeOrCollection, Alignment, LinearShape, PointLikeSequence, PointLikeOrVertexCollection, LinearShapeTail, AnyShapeSequence, ThickenDirection, MakeWireInput, DimensionOptions, Vector, Shape, Vertex, Point, Edge, Face, Shell, Solid, ShapeCollection, DimensionLine } from './internal';
+type IFace = Face;
+type IShell = Shell;
+type ISolid = Solid;
+export declare class Wire extends Shape {
+    constructor(entities?: MakeWireInput, ...args: any[]);
+    /** Copy a other Wire instance
+     *  NOTE: Is this still needed, as we have a copy method?
+    */
+    _fromWire(w: Wire): Wire;
+    _fromOcWire(ocWire: any, fix?: boolean): Wire;
+    /** Try to convert something into a Wire */
+    fromAll(o: MakeWireInput): Wire;
+    /** Class method */
+    static fromAll(o: any): Wire;
+    /** Sequentually build a Wire */
+    _addEntities(entities: MakeWireInput): this;
+    /** Process Shapes sequentially and combine them into a Wire */
+    _fromShapeCollection(shapes: ShapeCollection): Wire;
+    getCursor(): Cursor;
+    fromEdges(edges: AnyShapeSequence, ...args: any[]): Wire;
+    /** Create Wire with Line Edges from Vertices **/
+    fromVertices(vertices: PointLikeSequence, ...args: any[]): Wire;
+    /** Create Wire from Points (Vertices or an Array or coords) */
+    fromPoints(points: PointLikeSequence): Wire;
+    /** Create flat Rectangular Wire */
+    makeRect(width?: number, depth?: number, position?: PointLike): Wire;
+    /** Create a (righthand or lefthand) Helix with a radius, height and angle. Advanced coneSemiAngle (angle at top) for making a changing Helix radius (- for smaller to top) */
+    makeHelix(radius?: number, height?: number, angle?: number, pivot?: PointLike, direction?: PointLike, lefthand?: boolean, coneSemiAngle?: number): Wire;
+    /** Make 2D Spiral */
+    makeSpiral(firstRadius: number, secondRadius: number, angle: number, lefthand: boolean): Wire;
+    /** Return the first Edge (private)) */
+    _toEdge(): any;
+    /** Return the first Edge (comes in handy when using Wire methods on single Edge Wire) */
+    toEdge(): any;
+    /** For consistency */
+    _toWire(): this;
+    /** For consistency */
+    toWire(): this;
+    /** Try to convert Wire to Face (private) */
+    _toFace(): Face;
+    /** Try to convert Wire to Face */
+    toFace(): IFace;
+    /** This returns the most specified subclass of Shape */
+    _ocGeom(): any;
+    _toOcCurve(): any;
+    _toOcCurveHandle(): any;
+    /** Check if Wire is coplanar */
+    planar(): boolean;
+    /** Get subtype of Wire, used for selecting */
+    wireType(): string;
+    /** Check if a Wire is closed */
+    closed(): boolean;
+    /** Check if Wire is continuous */
+    checkConnections(): boolean;
+    selfIntersecting(): boolean;
+    /** Get the start Vertex of the Wire */
+    start(): Vertex;
+    /** Get the end Vertex of the Wire */
+    end(): Vertex;
+    is2DXY(): boolean;
+    /** Get Normal of the Wire at the start Vertex */
+    normalAtStart(): Vector;
+    /** Get Normal of the Wire at the end Vertex */
+    normalAtEnd(): Vector;
+    /** Get workplane normal if Wire is planar */
+    workPlaneNormal(): Vector;
+    /** Get Direction Vector of Wire at the start Vertex */
+    directionAtStart(): Vector;
+    /** Get Direction Vector of Wire at the end Vertex */
+    directionAtEnd(): Vector;
+    /** Get Edge that contains or is closest to Point */
+    edgeAtPoint(point: PointLike, ...args: any[]): Edge;
+    /** Get the normal on a Point on the Wire  */
+    normalAt(point: PointLike, ...args: any[]): Vector;
+    /** Get normal of Face bounded by Wire
+     *  NOTE: NormalAt gives on point on the Wire, normal that of the workplane
+    */
+    normal(): Vector;
+    directionAt(point: PointLike, ...args: any[]): Vector;
+    /** Get a Point at a certain percentage of the Wire */
+    pointAt(perc: number): Vector;
+    pointAtParam(param: number): Vector;
+    /** Generate a Collection of a given number of Vertices equally spaces over this Wire including the start and end
+     *  IMPORTANT: Parameters on a Wire are not homogenous with length units: We need a bit more advanced solution
+     */
+    populated(num?: number): ShapeCollection;
+    /** Get the length of this Wire */
+    length(): number;
+    /** Get center of Wire - This is not the middle Point! See middle() */
+    center(): Point;
+    /** Return middle of Wire */
+    middle(): Point;
+    /** Do checks and fix Wire
+     *  WARNING: This does more bad than good, so disabled in _fromOcWir
+     */
+    checkAndFix(): Wire;
+    /** Close this Wire by creating Edge from last Vertex to first */
+    close(): Wire;
+    /** Reverse order of Wire by reversing Edges */
+    reverse(): Wire;
+    /** Same as reverse but return a copy */
+    reversed(): Wire;
+    /** Connect two Wires together into new one: introducing new line Edges distance is less than radius */
+    combined(other: Wire, radius?: number): Wire;
+    /** Extra algorithm to combine Edges into Wire - The OC WireBuilder does this mostly too - but this is triggered as last resort */
+    combineEdges(edges: AnyShapeSequence, radius?: number): Wire;
+    /** We get unconnected Edges a lot ( because OC is somewhat loose with Edges in Wires )
+        This algorithm reconstructs a Collection of Array of Edges into a ordered (by number of Edges) Array of Wires */
+    _groupEdges(edges: AnyShapeSequence, radius?: number): Array<Array<Edge>>;
+    /** Make a Solid by lofting from one Wire through section Wires (private: without adding to Scene)  */
+    _lofted(sections: AnyShapeOrCollection, solid?: boolean): IShell | Solid;
+    /** Make a new Solid by lofting from a flat Shape through a number of sections */
+    lofted(sections: AnyShapeOrCollection, solid?: boolean): IShell | Solid;
+    /** Make a Solid by lofting a flat Shape through a number of sections  */
+    loft(sections: AnyShapeOrCollection, solid?: boolean): IShell | Solid;
+    /** Sweep a profile Wire or Face ( see Face.ts implementation: splitting inner and outerwires) along a path to create a Shell or Solid
+     *  TODO: holes in profile from Face
+    */
+    _sweeped(path: LinearShape, solid?: boolean, autoRotate?: boolean, alignToPath?: Alignment): IFace | Shell | Solid;
+    /** Sweep a profile Wire or Face ( see Face.ts implementation: splitting inner and outerwires) along a path to create a Shell or Solid  */
+    sweeped(path: LinearShape, solid?: boolean, autoRotate?: boolean, alignToPath?: Alignment): IFace | Shell | Solid;
+    /** Sweep a profile Wire or Face ( see Face.ts implementation: splitting inner and outerwires) along a path to create a Shell or Solid  */
+    sweep(path: LinearShape, solid?: boolean, autoRotate?: boolean, alignToPath?: Alignment): IFace | Shell | Solid;
+    /** Thicken (2D) Wire to create a thick Face (private: without adding to Scene)
+     *   Compared to offset thickening creates a higher order Shape while offset keeps original Shape type
+     *   @param amount The total thickness added
+     *   @param direction PointLike or Side (top,bottom,left,right,front,back)
+     *   @param onPlaneNormal Force the resulting Face to be on a specific plane given by its normal
+    */
+    _thickened(amount: number, direction?: ThickenDirection, onPlaneNormal?: PointLike): IFace;
+    thickened(amount: number, direction?: ThickenDirection, onPlaneNormal?: PointLike): IFace;
+    /** Thicken (2D) Wire to create a thick Face
+        @param direction PointLike or Side (top,bottom,left,right,front,back)
+    */
+    thicken(amount: number, direction?: ThickenDirection, onPlaneNormal?: PointLike): IFace;
+    /** Offset Wire to create a new parallel Wire at given distance (private)
+     *  IMPORTANT: minus amount means the Wire becomes smaller. We will check for that!
+     *  TODO: Offsetting a simple Wire can generate unordered Edges and problems later on. Need to introduce checks
+     *  ex: polyline([0,0,25],[50,0,50],[100,0,25]).offsetted(5)  => 2 vertices!
+    */
+    _offsetted(amount?: number, type?: string, onPlaneNormal?: PointLike): Wire;
+    /** Offset Wire to create a new parallel Wire at given distance */
+    offsetted(amount?: number, type?: string, onPlaneNormal?: PointLike): Wire;
+    /** Create a new version of current Wire that is parallel at a given distance */
+    offset(amount?: number, type?: string, onPlaneNormal?: PointLike): Wire;
+    /** Extrude a Wire while rotating around the center with a given angle (private: without adding to Scene) */
+    _twistExtruded(amount?: number, angle?: number, pivot?: PointLike, direction?: PointLike, lefthand?: boolean): ISolid;
+    twistExtruded(amount?: number, angle?: number, pivot?: PointLike, direction?: PointLike, lefthand?: boolean): ISolid;
+    twistExtrude(amount?: number, angle?: number, pivot?: PointLike, direction?: PointLike, lefthand?: boolean): ISolid;
+    /** Create a new Wire by projecting this Wire onto another Shape
+     *  either from one direction or concentric
+     *
+     *  Returns a ShapeCollection with front and back groups
+     *
+     *  TODO: When projecting on surface that has same dimensions as projecting Face results can wrong,
+     *          edges are added between front and back projection
+     *  NOTE: Converted from code by Roger Maitland for CadQuery: https://github.com/CadQuery/cadquery/issues/562
+     
+     */
+    _projectTo(other: AnyShape, direction: Vector, center?: Vector): ShapeCollection | null;
+    projectTo(other: AnyShape, direction: Vector, center: Vector): ShapeCollection | null;
+    /** Aligning linear Shapes to each other so they form a connected Line */
+    alignTo(other: LinearShape, pivot?: LinearShapeTail, alignment?: LinearShapeTail): this;
+    /** Fillet Wire at given Vertices or all */
+    fillet(radius?: number, at?: PointLikeOrVertexCollection): this;
+    /** Fillet Wire at given Vertices or all */
+    chamfer(distance?: number, angle?: number, vertices?: PointLikeOrVertexCollection): this;
+    _intersectionsWithWire(other: Wire | Edge): ShapeCollection;
+    /** Simply generate dimension lines for all visible Edges in this Face
+     *  TODO: make sure offsets are right, skip same edges in boxes
+    */
+    dimension(dim?: DimensionOptions): DimensionLine | Array<DimensionLine>;
+    /** Alias for dimension() */
+    dim(dim?: DimensionOptions): DimensionLine | Array<DimensionLine>;
+    _hasClosingEdges(): boolean;
+    /** Export entity and minimal data as string (used for outputting on console and hashing ) */
+    toString(): string;
+}
+export {};

package/dist/src/constants.d.ts

@@ -0,0 +1,112 @@
+import { DocPathStyle } from './internal';
+export declare const USE_GARBAGE_COLLECTION = false;
+export declare const SHAPE_CACHE_ENABLED = false;
+export declare const SCRIPT_OUTPUT_CATEGORIES: string[];
+export declare const SCRIPT_OUTPUT_MODEL_FORMATS: string[];
+export declare const SCRIPT_OUTPUT_METRIC_FORMATS: string[];
+export declare const SCRIPT_OUTPUT_TABLE_FORMATS: string[];
+export declare const SCRIPT_OUTPUT_DOC_FORMATS: string[];
+export declare const MESHING_MAX_DEVIATION = 0.1;
+export declare const MESHING_ANGULAR_DEFLECTION = 0.5;
+export declare const MESHING_MINIMUM_POINTS = 2;
+export declare const MESHING_TOLERANCE = 0.000001;
+export declare const MESHING_EDGE_MIN_LENGTH = 0.000001;
+export declare const DEFAULT_WORKPLANE: number[];
+export declare const SHAPE_ARRAY_DEFAULT_OFFSET = 100;
+export declare const SHAPE_EXTRUDE_DEFAULT_AMOUNT = 100;
+export declare const SHAPE_SWEEP_DEFAULT_SOLID = true;
+export declare const SHAPE_SWEEP_DEFAULT_AUTOROTATE = true;
+export declare const SHAPE_SWEEP_DEFAULT_ALIGNMENT_TO_PATH = "center";
+export declare const SHAPE_SCALE_DEFAULT_FACTOR = 2;
+export declare const SHAPE_ALIGNMENT_DEFAULT = "center";
+export declare const SHAPE_SHELL_AMOUNT = 5;
+export declare const EDGE_DEFAULT_START: number[];
+export declare const EDGE_DEFAULT_END: number[];
+export declare const EDGE_DEFAULT_CIRCLE_RADIUS = 50;
+export declare const EDGE_DEFAULT_OFFSET = 10;
+export declare const EDGE_DEFAULT_THICKEN = 50;
+export declare const EDGE_DEFAULT_POPULATE_NUM = 10;
+export declare const EDGE_DEFAULT_EXTEND_AMOUNT = 10;
+export declare const EDGE_DEFAULT_EXTEND_DIRECTION = "end";
+export declare const EDGE_DEFAULT_ALIGNTO_FROM = "start";
+export declare const EDGE_DEFAULT_ALIGNTO_TO = "end";
+export declare const EDGE_DEFAULT_SEGMENTS_ANGLE = 10;
+export declare const EDGE_DEFAULT_SEGMENTS_ANGLE_SVG = 2;
+export declare const EDGE_DEFAULT_SEGMENTS_SIZE = 100;
+export declare const WIRE_RECT_WIDTH = 100;
+export declare const WIRE_RECT_DEPTH = 100;
+export declare const WIRE_RECT_POSITION: number[];
+export declare const WIRE_POPULATE_NUM = 10;
+export declare const WIRE_COMBINE_RADIUS = 1;
+export declare const WIRE_LOFTED_SOLID = true;
+export declare const WIRE_SWEEPED_SOLID = true;
+export declare const WIRE_SWEEPED_AUTOROTATE = true;
+export declare const WIRE_SWEEPED_ALIGNTOPATH = "center";
+export declare const WIRE_THICKEN_AMOUNT = 10;
+export declare const WIRE_THICKEN_DIRECTION: any;
+export declare const WIRE_OFFSET_AMOUNT = 10;
+export declare const WIRE_OFFSET_TYPE = "tangent";
+export declare const WIRE_ALIGNTO_TAIL = "start";
+export declare const WIRE_FILLET_RADIUS = 10;
+export declare const WIRE_CHAMFER_DISTANCE = 10;
+export declare const WIRE_CHAMFER_ANGLE = 45;
+export declare const SOLID_MAKEBOX_SIZE = 50;
+export declare const SOLID_MAKESPHERE_RADIUS = 50;
+export declare const SOLID_MAKESPHERE_ANGLE = 360;
+export declare const SOLID_MAKECONE_BOTTOM_RADIUS = 50;
+export declare const SOLID_MAKECONE_TOP_RADIUS = 0;
+export declare const SOLID_MAKECONE_HEIGHT = 50;
+export declare const SOLID_CYLINDER_RADIUS = 50;
+export declare const SOLID_CYLINDER_HEIGHT = 50;
+export declare const SOLID_CYLINDER_ANGLE = 360;
+export declare const SOLID_FILLET_RADIUS = 5;
+export declare const SOLID_CHAMFER_DISTANCE = 5;
+export declare const SOLID_THICKEN_AMOUNT = 5;
+export declare const SOLID_THICKEN_DIRECTION = "center";
+export declare const FACE_PLANE_WIDTH = 50;
+export declare const FACE_PLANE_DEPTH = 50;
+export declare const FACE_PLANE_POSITION: number[];
+export declare const FACE_PLANE_NORMAL: number[];
+export declare const FACE_BASEPLANE_AXIS = "xy";
+export declare const FACE_BASEPLANE_SIZE = 1000;
+export declare const FACE_CIRCLE_RADIUS = 50;
+export declare const FACE_EXTRUDE_AMOUNT = 100;
+export declare const FACE_OFFSET_AMOUNT = 10;
+export declare const FACE_OFFSET_TYPE = "tangent";
+export declare const FACE_THICKEN_AMOUNT = 10;
+export declare const FACE_THICKEN_DIRECTION = "center";
+export declare const FACE_LOFT_SOLID = true;
+export declare const FACE_NORMAL_EDGE_SIZE = 10;
+export declare const FACE_FILLET_RADIUS = 5;
+export declare const FACE_CHAMFER_DISTANCE = 10;
+export declare const FACE_CHAMFER_ANGLE = 45;
+export declare const DOC_DIMENSION_LINES_TEXT_HEIGHT = 2.5;
+export declare const DOC_CONTAINER_TITLE_TEXT_HEIGHT = 6;
+export declare const DOC_CONTAINER_CAPTION_TEXT_HEIGHT = 3;
+export declare const DOC_CONTAINER_CAPTION_TEXT_PADDING_FACTOR = 2;
+export declare const CLASS_TO_STYLE: Record<string, DocPathStyle>;
+export declare const MESH_QUALITY_PRESETS: {
+    low: {
+        linearDeflection: number;
+        angularDeflection: number;
+        tolerance: number;
+        edgeMinimalPoints: number;
+        edgeMinimalLength: number;
+    };
+    medium: {
+        linearDeflection: number;
+        angularDeflection: number;
+        tolerance: number;
+        edgeMinimalPoints: number;
+        edgeMinimalLength: number;
+    };
+    high: {
+        linearDeflection: number;
+        angularDeflection: number;
+        tolerance: number;
+        edgeMinimalPoints: number;
+        edgeMinimalLength: number;
+    };
+};
+export declare const METRICS: string[];
+export declare const BREP_METHODS_INTO_GLOBAL: string[];

package/dist/src/decorators.d.ts

@@ -0,0 +1,27 @@
+/**
+ *  Decorators for Geom API
+ *
+ *      See TS docs: https://www.typescriptlang.org/docs/handbook/decorators.html
+ *      or https://blog.logrocket.com/a-practical-guide-to-typescript-decorators/
+ *
+ * */
+/**
+*   Decorator for caching the results of operations and getting them when needed
+*   !!!! This function does not work anymore !!!!
+*   TODO: Check TS version and see why this is not working: https://www.typescriptlang.org/docs/handbook/decorators.html
+*/
+export declare function cacheOperation(targetPrototype: any, propertyKey: string, descriptor: PropertyDescriptor): PropertyDescriptor;
+/** TODO */
+export declare function ocCheck(target: Object, method: string, descriptor: PropertyDescriptor): void;
+/** Main @checkInput decorator
+
+    @param inputChecks - Per input the desired checks. NOTE: we can only supply typeguard functions (not types) or Classes or a Array with check and default value
+    @param uniformizeToTypes - Per input supply a type (Class or typeguard function) to convert into
+ */
+export declare function checkInput(inputChecks: any | Array<any>, uniformizeToTypes: any | Array<any>): MethodDecorator;
+export declare function addResultShapesToScene(targetPrototype: any, propertyKey: string, descriptor: PropertyDescriptor): PropertyDescriptor;
+/**
+*   Decorator to catch errors in OC and give sane error messages
+*/
+export declare function protectOC(hints?: string | Array<string>): MethodDecorator;
+export declare function asSketch(targetPrototype: any, propertyKey: string, descriptor: PropertyDescriptor): PropertyDescriptor;

package/dist/src/garbageCollection.d.ts

@@ -0,0 +1,4 @@
+/** This is the main method to target one or more OC objects for deletion after main class is garbage collected */
+export declare function targetOcForGarbageCollection(obj: any, ocObj: any): void;
+/** Unregister with token (the Oc instance)  */
+export declare function removeOcTargetForGarbageCollection(ocObj: any): any;

package/dist/src/init.d.ts

@@ -0,0 +1,5 @@
+import { ArchiyouApp } from './internal';
+export declare let _ay: ArchiyouApp;
+export declare function getArchiyou(): ArchiyouApp;
+export declare function setArchiyou(ay: Partial<ArchiyouApp>): void;
+export declare function init(): Promise<ArchiyouApp>;