archiyou 0.7.0

package/dist/src/DocViewSVGManager.d.ts

@@ -0,0 +1,91 @@
+import { SVGtoPDFtransform, PageData, ContainerData, DocPDFExporter, DocPathStyle, PDFLinePath } from './internal';
+export declare class DocViewSVGManager {
+    PATH_BASE_STYLE: DocPathStyle;
+    DIMLINE_LINE_THICKNESS_MM: number;
+    DIMLINE_ARROW_SVG_WIDTH: number;
+    DIMLINE_ARROW_PDF_WIDTH_MM: number;
+    DIMLINE_IS_SMALL_FACTOR_TIMES_TEXT_WIDTH: number;
+    DIMLINE_TEXT_SIZE_MM: number;
+    DIMLINE_TEXT_MAX_WIDTH_MM: number;
+    DIMLINE_TEXT_BACKGROUND_COLOR: string;
+    DIMLINE_TEXT_SMALL_OFFSET_TIMES_TEXT_SIZE: number;
+    _svg: string;
+    _svgXML: any;
+    _svgToPDFTransform: SVGtoPDFtransform;
+    _docActivePage: PageData;
+    constructor(view?: ContainerData);
+    parse(view?: ContainerData): any;
+    _setCleanSvg(view?: ContainerData): string;
+    reset(): void;
+    /** Return changed SVG as string */
+    export(): string;
+    setViewBox(): void;
+    setNoStrokeScaling(): void;
+    /** Information that is needed to transform SVG shape content to PDF */
+    toPDFDocTransform(pdfExporter: DocPDFExporter, view: ContainerData, page: PageData): SVGtoPDFtransform;
+    /** Transform and scale SVG Shape data to PDF space coordinates (points)
+     *      This includes styling based on classes
+     *
+     *  NOTES:
+     *      - incoming SVG units are worldUnits (in <svg _worldUnits="..">) [ NOTE: after parsing XML nodes _ is removed!]
+     *      - bbox is in <svg _bbox="left top width height"
+    */
+    toPDFDocShapePaths(pdfExporter: DocPDFExporter, view: ContainerData, page: PageData): Array<PDFLinePath>;
+    /** Within SVG path (<path d="..">) we have multiple ways to set style
+     *      1. on object itself as attribute: stroke="#0000FF" (see Edge._getSvgPathAttributes )
+     *      2. by classes
+     *
+     *  Classes have priority over object styling because it allowes the user to quickly override
+     *  styling without going into the script
+     */
+    gatherPDFPathStyleFromSVG(svgPathNode: any): DocPathStyle;
+    _svgPathAttributesToPDFPathStyle(svgPathNode: any): DocPathStyle;
+    /** Translate the classes applied to svg path to a PDF style map
+     *
+     *   Settings are in constants.ts: CLASS_TO_STYLE
+     *
+     *   Currently these styles exists:
+     *   - line - the default line edge
+     *   - dashed - dashed line edge
+     *   - hidden - a line edge that is hidden behind other shapes used in elevations
+     *   - outline - a line edge that is the outline of a projection
+     *   - dimensionline - a dimension line (see: Annotator)
+     *
+     *  Classes are applied in order (last has priority)
+    */
+    _svgPathClassesToPDFPathStyle(svgPathNode: any): DocPathStyle | null;
+    /** jsPDF needs Line paths as [{op: m|l, c: [x,y] }] */
+    _pdfLinePathToJsPDFPathLines(pdfPath: PDFLinePath): Array<Record<string, any>>;
+    /** Get d attribute of a SVG path and convert to PDF line path, this includes transformation of the coordinates and styling */
+    _svgPathDToPDFPath(d: string, transform: SVGtoPDFtransform): string;
+    drawDimLinesToPDF(pdfExporter: DocPDFExporter): void;
+    /**
+     *  if a SVG Dimension is considered small
+     *  Utility used by Dimension Line drawing functions
+    */
+    _svgDimLineIsSmall(dimLineNode: any): boolean;
+    /** Parse SVG dimension node and return line coordines in PDF system  */
+    _svgDimLineParseLine(dimLineNode: any): [number, number, number, number] | null;
+    /** Get normalized offset vector from dimension line
+     *  TODO: This does not take into account the original offset direction!
+     *  NOTE: We can't use archiyou-core because we are probably in the main app!
+    */
+    _svgDimLineOffsetVec(dimLineNode: any, length?: number): [number, number] | null;
+    /** Rotate a Vector a given angle around the origin and give it a certain length */
+    _rotateVec(v: [number, number], angle: number, length?: number): [number, number];
+    /** Draw the line element of a dimLineNode to PDFdocument
+     *  Returns the coordinates of the line in PDF coordinates
+    */
+    _drawDimLineLine(dimLineNode: any, pdfExporter: DocPDFExporter): Array<number>;
+    /** Draw the line nodes of a dimeLineNode to PDFDocument
+     *  When dimension line is small, the arrows are flipped ( <--> to >--< )
+    */
+    _drawDimLineArrows(dimLineNode: any, pdfExporter: DocPDFExporter): void;
+    /** Draw text label of Dimension line */
+    _drawDimLineText(dimLineNode: any, pdfExporter: DocPDFExporter): void;
+    /** Draw a raw SVG path d datastring to PDF after transforming
+     *  TODO: styles for jsPDF
+    */
+    _drawSVGPathToPDF(d: string, pdfExporter: DocPDFExporter, localTransforms?: Record<string, any>, styles?: Record<string, any>): void;
+    _svgCoordToPDFcoord(transform: SVGtoPDFtransform, c: number | string, axis?: 'x' | 'y'): number;
+}

package/dist/src/Edge.d.ts

@@ -0,0 +1,190 @@
+import { DxfBlock } from '@tarikjabiri/dxf';
+import { ThickenDirection, PointLike, Cursor, AnyShape, AnyShapeOrCollection, LinearShape, LinearShapeTail, PointLikeSequence, DimensionOptions, Vector, Point, Shape, Vertex, Wire, Face, Shell, Solid, ShapeCollection, VertexCollection, DimensionLine } from './internal';
+type IWire = Wire;
+type IFace = Face;
+type IShell = Shell;
+type IDimensionLine = DimensionLine;
+export declare class Edge extends Shape {
+    TO_SVG_DASH_SIZE_DEFAULT: number;
+    TO_SVG_LINE_WIDTH_DEFAULT: number;
+    TO_SVG_LINE_COLOR_DEFAULT: string;
+    TO_SVG_OPACTIY_DEFAULT: number;
+    /** Creates a simple Line Edge, use new Edge().makeCicle etc for others */
+    constructor(start?: any, end?: any);
+    _fromOcEdge(ocEdge: any): this;
+    /**
+     * Create Edge from given OC Curve
+     * @param ocCurve Geom_Curve
+     * @param ocStartPnt gp_Pnt
+     * @param ocEndPnt gp_Pnt
+     */
+    _fromOcCurve(ocCurve: any): Edge;
+    _ocGeom(): Edge;
+    /** Convert Edge to one Vector */
+    toVector(): Vector;
+    _toWire(): IWire;
+    /** Convert to Wire and add to Scene */
+    toWire(): IWire;
+    _toOcCurve(): any;
+    _toOcCurveHandle(): any;
+    getCursor(): Cursor;
+    makeLine(start: PointLike, end: PointLike): Edge;
+    /** Create a Circle Edge with given radius (default:50) and center (default: [0,0,0]) */
+    makeCircle(radius?: number, center?: PointLike): Edge;
+    /** Make Spline that goes through Vectors provided in list of points (PointLike) */
+    makeSpline(points: PointLikeSequence, ...args: any[]): Edge;
+    /** Make Arc line
+     *  @param type threepoint or tangent
+     */
+    makeArc(start: PointLike, mid: PointLike, end: PointLike, type?: string): Edge;
+    /** Make Bezier curve from given points. One control point for Quadratic. Two for Cubic */
+    makeBezier(points: PointLikeSequence, ...args: any[]): Edge;
+    /** Make weighted Bezier Curve by supplying (control)points and weights */
+    /** Get first Vertex of Edge */
+    start(): Vertex;
+    /** Get last Vertex of Edge */
+    end(): Vertex;
+    _firstVertex(): Vertex;
+    _lastVertex(): Vertex;
+    /** Get Edge Type: Line, Circle, Ellipse, Hyperbola, Parabola, BezierCurve, BSplineCurve, OffsetCurve, OtherCurve
+     *  IMPORTANT: Because it generates a lot of confusion we add here the distinction Circle/Arc that is not in OpenCascade
+    */
+    edgeType(): string;
+    is2DXY(): boolean;
+    /** TODO: Make this more robust? */
+    isCircular(): boolean;
+    /** Get length of Edge */
+    length(): number;
+    /** Calculate the center of this Edge and return a Point */
+    center(): Point;
+    /** Return middle of Edge */
+    middle(): Point;
+    /** Calculate the normal of the straight line Edge
+     *  Force that normal always faces flipTo (otherwise the side is determined by direction)
+    */
+    normal(orientTo?: PointLike, ...args: any[]): Vector;
+    /** Calculate workplane normal if 2D (not a 1D Line) */
+    workPlaneNormal(): Vector;
+    _reverseOcEdge(ocEdge: any): any;
+    /** Reverse Edge in place */
+    reverse(): Edge;
+    /** Create a new Edge by reversing current one */
+    reversed(): Edge;
+    /** Get direction Vector of Line Edge from start to end */
+    direction(normalize?: boolean): Vector;
+    /** Alias for direction. Always returns normalized Vector */
+    dir(): Vector;
+    /** Get tangent (= direction ) at certain point on the Edge */
+    tangent(): Vector;
+    /** Get direction = tangent at certain point on the Edge */
+    directionAt(point: PointLike, ...args: any[]): Vector;
+    /** Get direction Vector at start Vertex */
+    directionAtStart(): Vector;
+    /** Get direction Vector at end Vertex */
+    directionAtEnd(): Vector;
+    /** Get direction Vector at percentage of length */
+    directionAtPerc(perc: any): Vector;
+    /** Get tangent Vector (=direction) at certain point on the Edge */
+    tangentAt(point: PointLike, ...args: any[]): Vector;
+    /** Close a non-Line Edge to create a Wire **/
+    close(): IWire;
+    /** Thicken Edge to create a Face (private: without adding result to Scene) */
+    _thickened(amount?: number, direction?: ThickenDirection, onPlaneNormal?: PointLike): IFace;
+    /** Thicken Edge to create a Face */
+    thickened(amount?: number, direction?: string, onPlaneNormal?: PointLike): IFace;
+    thicken(amount: number, direction?: ThickenDirection, onPlaneNormal?: PointLike): IFace;
+    /** Thicken the Edge along the normal to create a Face */
+    thickenOffsetted(amount?: number, v?: PointLike, flip?: boolean): IFace;
+    /** Offset Edge a given amount into normal direction or reversed with '-amount' and return new Edge (private without adding to Scene)
+     *  NOTE: param type does nothing but is for consistency
+    */
+    _offsetted(amount?: number, type?: string, onPlaneNormal?: PointLike): Edge | Wire;
+    /** Offset Edge a given amount into normal direction or reversed with '-amount' and return new Edge */
+    offsetted(amount?: number, type?: string, onPlaneNormal?: PointLike): Edge | Wire;
+    /** Offset Edge a given amount into normal direction or reversed with '-amount' */
+    offset(amount?: number, type?: string, onPlaneNormal?: PointLike): Edge | Wire;
+    /** Get start value of Edge parameter range */
+    paramStart(): number;
+    /** Get end value of Edge parameter range */
+    paramEnd(): number;
+    /**
+     * Generate a Point at specific percentage of this Edge
+     *  @param perc: number between 0 and 1
+     */
+    pointAt(perc: number): Point;
+    /** Get Point at specific param value */
+    pointAtParam(param: number): Point;
+    /** Check if Edge has a Vertex that equals the given Vertex */
+    isVertex(vertex: PointLike, ...args: any[]): Vertex;
+    /** Calculate the normal for a point on the Edge */
+    normalAt(point: PointLike, ...args: any[]): Vector;
+    /** Get normal of Edge at percentage of length */
+    normalAtPerc(perc: number): Vector;
+    /** Calculate the angle between two touching Edges at either ends */
+    angleTo(other: Edge): number;
+    /** Needed to fix some Edges, for example after projecting */
+    _buildCurves(): void;
+    /** Extend Edge into a given direction (start or end)
+     *  NOTE: Check quality of Edge - there are signs of resulting Edges not being consistent
+    */
+    extend(amount?: number, direction?: LinearShapeTail): Edge;
+    /** Extend Edge into a certain direction (start or end) and return a copy */
+    _extended(amount?: number, direction?: LinearShapeTail): Edge;
+    /** Extend Edge into a certain direction (start or end) and return a copy */
+    extended(amount?: number, direction?: LinearShapeTail): Edge;
+    /** Extend Edge to nearest point that is shared by other Shape (if any!)
+     *  @param other
+     *  @param direction Extend at start or end. If not given pick closest
+     */
+    extendTo(other: AnyShape, direction?: LinearShapeTail): this;
+    extendedTo(other: AnyShape, direction?: LinearShapeTail): Edge;
+    _maxCircularShape(): Edge | null;
+    /** Loft (forwarded to Wire) */
+    loft(sections: AnyShapeOrCollection, solid?: boolean): IShell | Solid;
+    lofted(sections: AnyShapeOrCollection, solid?: boolean): IShell | Solid;
+    alignTo(other: LinearShape, from?: LinearShapeTail, to?: LinearShapeTail): this;
+    /** Get parameter (U) on Edge for given Point. If not on Edge will pick closest */
+    getParamAt(point: PointLike): number | null;
+    /** Generate a Collection of a given number of Vertices equally spaced over this Edge including the start and end of the Edge */
+    populated(num?: number): VertexCollection;
+    /** Break a curved Edge up into a Wire consisting of Line Edges with given angle between segments */
+    segmentize(angle?: number, size?: number): LinearShape;
+    /** Get distributed points on Edge according to QuasiUniformDeflection method
+     *  See: https://dev.opencascade.org/doc/refman/html/class_g_c_pnts___quasi_uniform_deflection.html#details
+     *  Used in toSVG()
+    */
+    _segmentizeToPoints(angularDeflection?: number, force2D?: boolean): Array<Point>;
+    _intersectionsWithEdge(other: Edge): Vertex | Edge | ShapeCollection;
+    /** Test if an Edge shares a Vertex with another */
+    connected(other: Edge): boolean;
+    /** Check if this Edge is parallel to other given entity */
+    parallel(other?: PointLike | Edge, ...args: any[]): boolean;
+    dimension(options?: DimensionOptions): IDimensionLine;
+    /** Alias for dimension() */
+    dim(options?: DimensionOptions): IDimensionLine;
+    /** Minimal raw data of this Edge */
+    toData(): Array<Array<number>>;
+    /** Export entity and minimal data as string (used for outputting on console and hashing ) */
+    toString(): string;
+    /** Export (segmentized) Edge (only X,Y coords) to SVG string
+     *  <path d="M 10 10 L 100 200">
+     *  IMPORTANT: official SVG path (without comma!)
+     *  code inspired from CadQuery: https://github.com/CadQuery/cadquery/blob/917d918e34690c101a50a233a11026974b87574b/cadquery/occ_impl/exporters/svg.py#L84
+    */
+    toSVG(): string;
+    /** get SVG attributes from style properties of Shape */
+    _getSvgPathAttributes(): string;
+    /** Based on attributes or tests add classes to Svg that help us select and style these SVG elements later */
+    _getSvgClasses(): string;
+    /** Export Edge to DXF writer instance
+     *  Now only lines are supported
+     *  TODO: Introduce arcs and splines
+    */
+    toDXF(dxf: DxfBlock): this;
+    /** Getting U min and max of Curve
+     *  IMPORTANT: For Line Curves the parameters are the same as the length
+     *  For Arc Curves and Circles the U is the angle ( in radians ) - Half a circle: U = [0, PI] - Circle [0,PI*2]
+     */
+    getParamMinMax(): Array<number>;
+}
+export {};

package/dist/src/Exporter.d.ts

@@ -0,0 +1,100 @@
+import { ArchiyouApp, AnyShapeOrCollection, ExportGLTFOptions, MeshingQualitySettings, toSVGOptions, AnyShape, ShapeCollection } from './internal';
+type XmlNode = any;
+declare global {
+    interface Window {
+        showOpenFilePicker: any;
+        showSaveFilePicker: any;
+    }
+    interface globalThis {
+        showOpenFilePicker: any;
+        showSaveFilePicker: any;
+    }
+    interface Console {
+        geom: any;
+        user: any;
+    }
+}
+export declare class Exporter {
+    DEFAULT_MESH_QUALITY: {
+        linearDeflection: number;
+        angularDeflection: number;
+        tolerance: number;
+        edgeMinimalPoints: number;
+        edgeMinimalLength: number;
+    };
+    DEFAULT_GLTF_OPTIONS: ExportGLTFOptions;
+    _ay: ArchiyouApp;
+    constructor(ay?: ArchiyouApp);
+    setArchiyou(ay: ArchiyouApp): this;
+    /** Export given shapes or all shapes in Brep instance to STEP
+     *  Optionally supply a filename
+    */
+    exportToSTEP(shapes?: AnyShape | ShapeCollection, options?: Record<string, any>, filename?: string): string;
+    /** Open a window to save the file in browser */
+    exportToSTEPWindow(content?: string): Promise<void>;
+    /** Export given shapes or all shapes in Brep instance to STL
+     *  Optionally supply a filename
+    */
+    exportToSTL(shapes?: AnyShape | ShapeCollection, options?: Record<string, any>, filename?: string): Uint8Array;
+    /** Open a window to save the STL file in browser */
+    exportToSTLWindow(content?: ArrayBuffer): Promise<void>;
+    /** Export Scene to GLTF
+        
+        Export high-resolution GLTF with added loose Points and Lines. And optionally export seperate Vertices and Edges per Shape
+
+        OC docs:
+        - RWGltf_CafWriter: https://dev.opencascade.org/doc/refman/html/class_r_w_gltf___caf_writer.html
+        - XCAFDoc_DocumentTool: - https://dev.opencascade.org/doc/refman/html/class_x_c_a_f_doc___document_tool.html
+        - ShapeTool: https://dev.opencascade.org/doc/refman/html/class_x_c_a_f_doc___shape_tool.html
+        - TDF_Label: https://dev.opencascade.org/doc/refman/html/class_t_d_f___label.html
+        - TDataStd_Name: https://dev.opencascade.org/doc/refman/html/class_t_data_std___name.html
+        - VisMaterialTool: https://dev.opencascade.org/doc/refman/html/class_x_c_a_f_doc___vis_material_tool.html#aaa1fb4d64b9eb24ed86bbe6d368010ab
+        - XCAFDoc_VisMaterial - https://dev.opencascade.org/doc/refman/html/class_x_c_a_f_doc___vis_material.html
+        - VisMaterialPBR: https://dev.opencascade.org/doc/refman/html/struct_x_c_a_f_doc___vis_material_p_b_r.html
+
+    */
+    exportToGLTF(shapes?: AnyShapeOrCollection, options?: ExportGLTFOptions, filename?: string): Promise<ArrayBuffer | null>;
+    /** Needs to be called before before STL
+     *  Also with GLTF but keep it seperate for now
+     *  Return OcIncMesh instance to be able to delete them
+     */
+    _triangulateShapes(shapes: ShapeCollection, meshingQuality?: MeshingQualitySettings): Array<any>;
+    /** Export GLTF (binary or text) to the browser window */
+    exportToGLTFWindow(content?: Uint8Array | string): Promise<void>;
+    exportToGLTFAnimation(frameGLBs: Array<Uint8Array>): Promise<Uint8Array>;
+    exportToGLTFAnimationWindow(content: Uint8Array): Promise<void>;
+    /** Export entire (visual) model by creating a isometric 2D view
+     * TODO: seperate these functions into export3DtoSVG and export2DtoSVG
+    */
+    exportToSVG(shapes?: ShapeCollection, options?: toSVGOptions): string;
+    /** Shortcut function to export 3D shapes to SVG
+        Make a isometry first
+    */
+    _export3DToSVG(shapes: ShapeCollection, options?: toSVGOptions): string;
+    /** Export 2D shapes to SVG */
+    _export2DToSVG(shapes: ShapeCollection, options?: toSVGOptions): string;
+    /** Combine all SVG's into one with SMIL keyframe animations
+     *  We parse all SVGs and put all their content in seperate groups named "frame{{N}}"
+     *  At the same time apply special SLIM SVG keyframe animation tags
+     *  so the SVG animation can be viewed inside ordinary browsers
+     */
+    exportToSVGAnimation(svgs: Array<string>): string;
+    /** For some reason TXML does not offer a good node.toString() method */
+    _XmlNodeToString(n: any, wrapped?: string): string;
+    _getSvgBboxArea(svg: XmlNode): number;
+    /** Open browser file window to save svg */
+    exportToSVGWindow(content: string): Promise<void>;
+    exportToDXF(shapes?: AnyShape | ShapeCollection, options?: Record<string, any>): string | null;
+    /** Convenience method for exporting Shapes and save as file in browser and node */
+    save(filename: string, options?: any, shapes?: ShapeCollection): Promise<void>;
+    /** save raw data to file in browser of node */
+    _saveDataToFile(data: any, filename: string): Promise<void>;
+    /** Simplified function to output data to a file window */
+    saveDataToFileWindow(data: any, filename: string): Promise<void>;
+    /** Write data to local disk by opening a file picker in browser */
+    _exportToFileWindow(data: any, mime: string, ext: string, desc: string): Promise<void>;
+    _getFileName(): string;
+    _mimeFromFileName(fileName: string): string;
+    getNewFileHandle(desc: any, mime: any, ext: any, open?: boolean): Promise<any>;
+}
+export {};

package/dist/src/Face.d.ts

@@ -0,0 +1,134 @@
+import { PointLike, Cursor, PointLikeSequence, MakeFaceInput, AnyShape, Axis, ThickenDirection, PointLikeOrAnyShape, PointLikeOrVertexCollection, AnyShapeSequence, AnyShapeOrCollection, PointLikeOrAnyShapeOrCollectionOrSelectionString, DimensionOptions, Vector, Point, Shape, Vertex, Edge, Wire, Shell, Solid, ShapeCollection, DimensionLine } from './internal';
+type IShell = Shell;
+type ISolid = Solid;
+export declare class Face extends Shape {
+    constructor(entities?: any, ...args: Array<any>);
+    /** Create Face from all kinds of inputs */
+    fromAll(o: MakeFaceInput, ...args: any[]): this;
+    /** Create Face from a Wire */
+    fromWire(wire: Wire): Face | Shell;
+    /** Create a Face from Vertices */
+    fromVertices(vertices: PointLikeSequence, ...args: any[]): Face;
+    fromEdges(shapes: AnyShapeSequence, ...args: any[]): Face;
+    /** Create a Face from a OC Face instance */
+    _fromOcFace(ocFace: any): Face;
+    /** Generate Cursor */
+    getCursor(): Cursor;
+    makePlane(width?: number, depth?: number, position?: PointLike, normal?: PointLike): Face;
+    /** Make Plane parallel to one of the baseplanes */
+    makePlaneBetween(from: PointLike, to: PointLike): Face;
+    /** Make the base planes of the coordinate system
+     *  @param axis can be 'z' for 'xy' plane, or directly 'xy'
+    */
+    makeBasePlane(axis?: Axis, size?: number): any;
+    /** Make a 2D plane from two coordinates. See makePlaneBetween for 3D */
+    makeRectBetween(from: PointLike, to: PointLike): Face;
+    makeCircle(radius: number, center: PointLike): Face;
+    /**
+     *  docs: https://dev.opencascade.org/doc/occt-7.5.0/refman/html/class_b_rep_offset_a_p_i___make_filling.html#a50e5b1deb08a18908eb8c8dde15dcefd
+     *  NOTE: Taken from code by Roger Maitland for CadQuery: https://github.com/CadQuery/cadquery/issues/562 */
+    makeNonPlanar(wireOrEdges: AnyShapeOrCollection, surfacePoints?: PointLikeSequence, holes?: AnyShapeOrCollection): this | AnyShapeOrCollection;
+    _setToOc(): void;
+    _toOcSurface(): any;
+    _ocGeom(): any;
+    /** Create Wire of Face without adding to scene */
+    _toWire(): Wire;
+    toWire(): Wire;
+    /** Create Shell with one Face */
+    toShell(): IShell;
+    _toShellWhenOcShell(): Face | Shell;
+    /** Center of this surface (not its center of mass!) - Override center() of Shape because it results in weird results */
+    center(): Point;
+    /** Check if this Face is planar */
+    isPlanar(): boolean;
+    is2DXY(): boolean;
+    /** Alias for isPlanar */
+    planar(): boolean;
+    /** Get subtype of Face - used in Selectors */
+    faceType(): string;
+    outerWire(): Wire;
+    innerWires(): ShapeCollection;
+    /** Get min U, max U, min V and max V parameters of current Face */
+    uvBounds(): number[];
+    /** Reverse Face */
+    reverse(): Face;
+    /** Get uv paramaters at center of Face */
+    uvCenter(): Array<number>;
+    /** Get center of this Face surface */
+    surfaceCenter(): Point;
+    /** Get normal of Plane Face - use normalAt for curved surfaces */
+    normal(): Vector;
+    /** Get the normal at a certain Point location on the Face */
+    normalAt(p: PointLike): Vector;
+    /** Get normal at given uv coordinates */
+    normalAtUv(u: number, v: number): Vector;
+    /** Create a Edge for Planar Face Normal */
+    normalEdge(size?: number): Edge;
+    /** Calculate the area of this Face */
+    area(): number;
+    /** Rotate this Face to its normal is parallel to the given Vector */
+    rotateTo(vector: PointLike, pivot?: PointLike): Face;
+    /** Extrude a Face a certain amount into a given direction. (private: not added to Scene)
+     *  This always creates a different type of Shape ( from Face to Solid ) to use extruded instead of extrude for now
+    */
+    _extruded(amount?: number, direction?: PointLike): ISolid;
+    /** Extrude a Face a certain amount into a given direction. (private: not added to Scene) */
+    extruded(amount?: number, direction?: PointLike): ISolid;
+    /** Same as extruded() but replaces old Shape with extruded one */
+    extrude(amount?: number, direction?: PointLike): ISolid;
+    /** For consistency: Refer shell() to extrude() on Faces */
+    shell(amount?: number): ISolid;
+    shelled(amount?: number): ISolid;
+    /** Make a bigger (+amount) or smaller (-amount) Face (private)
+     *  NOTE: onPlaneNormal is for consistency and does nothing
+    */
+    _offsetted(amount?: number, type?: string, onPlaneNormal?: PointLike): this;
+    /** Make a bigger (+amount) or smaller (-amount) Face (private) */
+    offsetted(amount?: number, type?: string, onPlaneNormal?: PointLike): this;
+    /** Make the Face bigger (+amount) or smaller (-amount) */
+    offset(amount?: number, type?: string, onPlaneNormal?: PointLike): this;
+    /** Thicken the Face a given amount and direction to create a Solid */
+    _thickened(amount?: number, direction?: ThickenDirection): ISolid;
+    thickened(amount?: number, direction?: ThickenDirection): ISolid;
+    /** Thicken current Face  */
+    thicken(amount?: number, direction?: ThickenDirection): ISolid;
+    /** Make a Shell or Solid by lofting outerWire of Face to other Wire Shapes  */
+    _lofted(sections: AnyShapeOrCollection, solid?: boolean): IShell | Solid;
+    lofted(sections: AnyShapeOrCollection, solid?: boolean): IShell | Solid;
+    /** Loft current Face */
+    loft(sections: AnyShapeOrCollection, solid?: boolean): IShell | Solid;
+    /** Extrude and twist a given amount of angles (private, without adding to scene ) */
+    _twistExtruded(amount?: number, angle?: number, pivot?: PointLike, direction?: PointLike, lefthand?: boolean): ISolid;
+    /** Extrude and twist a given amount of angles (public ) */
+    twistExtruded(amount?: number, angle?: number, pivot?: PointLike, direction?: PointLike, lefthand?: boolean): ISolid;
+    /** Extrude Face and rotate a given angle */
+    twistExtrude(amount?: number, angle?: number, pivot?: PointLike, direction?: PointLike, lefthand?: boolean): ISolid;
+    /** Round corners of Wire with given radius, at given Vertex (same or equals) or VertexCollection or all if given none */
+    fillet(radius?: number, at?: PointLikeOrAnyShapeOrCollectionOrSelectionString): this;
+    /** Chamfer two connected Edges at given Vertex and with and angle of given Edge */
+    chamfer(distance?: number, angle?: number, vertices?: PointLikeOrVertexCollection, edges?: ShapeCollection): this;
+    /** Create a new Face by projecting current onto another Face, Shell or Solid
+     *   NOTE: converted from code by Roger Maitland for CadQuery: https://github.com/CadQuery/cadquery/issues/562
+     *   TODO: FINISH
+    */
+    _projectTo(other: AnyShape, direction: Vector, center?: Vector): null | ShapeCollection;
+    _intersectionsWithFace(other: Face): Shape | Vertex | Edge | Vertex | Face | ShapeCollection;
+    _testUvToBounds(u: number, v: number): boolean;
+    /** Get position Vector at UV coords */
+    pointAtUv(u: number, v: number): Point;
+    /** Get UV coordinates of point on Face */
+    uvAt(point: PointLike): Array<number>;
+    /** Check if a given Point or Shape can be considered parallel to current Face */
+    parallel(other: PointLikeOrAnyShape): boolean;
+    /** Check if this Face is orthogonal (parallel with one of the base planes) */
+    orthogonal(): boolean;
+    /** 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>;
+    /** Export entity and minimal data as string (used for outputting on console and hashing ) */
+    toString(): string;
+}
+export {};

package/dist/src/GLTFBuilder.d.ts

@@ -0,0 +1,30 @@
+import { AnyShape, Vector, ShapeCollection, ArchiyouApp, MeshingQualitySettings, ArchiyouData, ArchiyouOutputSettings } from './internal';
+export declare class GLTFBuilder {
+    doc: any;
+    scene: any;
+    buffer: any;
+    SUBSHAPE_OUTPUT_NAME_SEPERATOR: string;
+    constructor();
+    /** To binary GLTF buffer */
+    toGLTFBuffer(): Promise<Uint8Array>;
+    /** build Animated GLTF */
+    createAnimation(frameGLBs: Array<Uint8Array>): Promise<void>;
+    /** Load GLB of frame into scene */
+    frameGLBToNode(GLBBuffer: Uint8Array, nodeName: string): Promise<void>;
+    loadFramesIntoScene(frameGLBs: Array<Uint8Array>): Promise<void>;
+    _quaternionFromAxisAngle(axis: Vector, angleDeg: number): Array<number>;
+    /** Apply Archiyou GLTF format data to raw GLTF content buffer */
+    addArchiyouData(gltfContent: ArrayBuffer | Uint8Array, ay: ArchiyouApp, settings?: ArchiyouOutputSettings): Promise<Uint8Array>;
+    /** Add all loose point and line Shapes (Vertex,Edge,Wire) to the GLTF buffer */
+    addPointsAndLines(gltfContent: ArrayBuffer | Uint8Array, shapes: ShapeCollection, quality: MeshingQualitySettings): Promise<Uint8Array>;
+    /** Add Vertices of Shape (including just one Vertex) as node to GLTF */
+    _addPoints(shape: AnyShape, gltfBuffer: ArrayBuffer | Uint8Array): void;
+    _addShapeLines(shape: AnyShape, gltfBuffer: ArrayBuffer | Uint8Array, quality: MeshingQualitySettings): void;
+    /** For visualization purposes it's handy output seperate point- and line buffer into the GLTF
+     *  So these can be seperately styled in a GLTF viewer
+     */
+    addSeperatePointsAndLinesForShapes(gltfContent: ArrayBuffer | Uint8Array, shapes: ShapeCollection, quality: MeshingQualitySettings): Promise<Uint8Array>;
+    /** Get ArchiyouData from GLTF binary */
+    readArchiyouData(gltf: ArrayBuffer | Uint8Array): Promise<ArchiyouData>;
+    _convertArrayBufferToUint8Array(buffer: ArrayBuffer | Uint8Array): Uint8Array;
+}

package/dist/src/IO.d.ts

@@ -0,0 +1,87 @@
+import { Brep, AnyShape, ShapeCollection } from './internal';
+interface Asset {
+    source: string;
+    valid: boolean;
+    locationType: 'url' | 'local';
+    url: string;
+    localId: string;
+    formatType: 'data' | 'geodata' | 'vector' | 'bitmap' | 'api';
+    format: string;
+    content?: any;
+    fetchError?: string;
+    imported?: any;
+}
+interface SvgTransform {
+    x: number;
+    y: number;
+}
+export declare class IO {
+    _oc: any;
+    _brep: Brep;
+    source: string;
+    asset: Asset;
+    cache: {
+        [key: string]: Asset;
+    };
+    FORMAT_TO_TYPE: {
+        svg: string;
+        json: string;
+        geojson: string;
+        jpg: string;
+        gif: string;
+        png: string;
+    };
+    constructor(brep: Brep);
+    load(source: string, forceFetch?: boolean, onlyCache?: boolean): Promise<any>;
+    /** Load directly from hot cache (no async) */
+    loadFromCache(source: string): AnyShape | ShapeCollection;
+    _parse(source: string): Asset;
+    _getAssetFromCache(source: string): Promise<any>;
+    _fetch(asset: Asset): Promise<{
+        content: any;
+        source: string;
+        valid: boolean;
+        locationType: "local" | "url";
+        url: string;
+        localId: string;
+        formatType: "data" | "geodata" | "vector" | "bitmap" | "api";
+        format: string;
+        fetchError?: string;
+        imported?: any;
+    }>;
+    _fetchAsset(asset: Asset): Promise<{
+        content: any;
+        source: string;
+        valid: boolean;
+        locationType: "local" | "url";
+        url: string;
+        localId: string;
+        formatType: "data" | "geodata" | "vector" | "bitmap" | "api";
+        format: string;
+        fetchError?: string;
+        imported?: any;
+    }>;
+    _handleFetchedAsset(asset: Asset, response: any): Promise<{
+        content: any;
+        source: string;
+        valid: boolean;
+        locationType: "local" | "url";
+        url: string;
+        localId: string;
+        formatType: "data" | "geodata" | "vector" | "bitmap" | "api";
+        format: string;
+        fetchError?: string;
+        imported?: any;
+    }>;
+    _handleFetchedAssetError(asset: Asset): void;
+    /** Convert and import fetched asset to Archiyou entity: either some Shape or raw data like a text or json data structure */
+    _importAsset(asset: Asset): any;
+    _importSVG(asset: Asset): ShapeCollection;
+    _getSvgNodesRecursive(svgTree: any, svgNodesWithTransform?: any[], parentTransform?: SvgTransform): any[];
+    _parseTransformString(t: string): {
+        x: number;
+        y: number;
+    };
+    _importSVGPath(pathData: string, transform?: SvgTransform): AnyShape | ShapeCollection;
+}
+export {};