pantograph2d 0.5.0 → 0.6.0

package/dist/types/models/Stroke.d.ts

@@ -0,0 +1,29 @@
+import { BoundingBox } from "./BoundingBox.js";
+import { Vector } from "../definitions.js";
+import { Segment } from "./segments/Segment.js";
+import { TransformationMatrix } from "./TransformationMatrix.js";
+import { Transformable } from "./utils/Transformable.js";
+export type Stroke = AbstractStroke<any>;
+export declare abstract class AbstractStroke<T extends AbstractStroke<T>> extends Transformable<T> {
+    readonly segments: Segment[];
+    abstract strokeType: string;
+    get repr(): string;
+    get info(): string;
+    constructor(segments: Segment[], { ignoreChecks }?: {
+        ignoreChecks?: boolean | undefined;
+    });
+    get firstPoint(): Vector;
+    get lastPoint(): Vector;
+    get segmentsCount(): number;
+    onStroke(point: Vector): boolean;
+    intersects(other: Stroke): boolean;
+    overlappingSegments(other: Stroke): Segment[];
+    private _boundingBox;
+    get boundingBox(): BoundingBox;
+    abstract reverse(): T;
+    abstract clone(): T;
+    abstract transform(matrix: TransformationMatrix): T;
+    abstract simplify(): T;
+}
+export declare function checkSelfIntersections(segments: Segment[], type?: string): void;
+export declare function checkValidStroke(segments: Segment[], type?: string): void;

package/dist/types/models/TransformationMatrix.d.ts

@@ -0,0 +1,31 @@
+import { Vector } from "../definitions.js";
+type Matrix = [
+    number,
+    number,
+    number,
+    number,
+    number,
+    number,
+    number,
+    number,
+    number
+];
+export declare class TransformationMatrix {
+    private _matrix;
+    constructor(matrix?: Matrix);
+    clone(): TransformationMatrix;
+    transpose(): TransformationMatrix;
+    inverse(): TransformationMatrix;
+    translate(x: number, y: number): TransformationMatrix;
+    rotate(angle: number, center?: Vector): TransformationMatrix;
+    mirrorX(): TransformationMatrix;
+    mirrorY(): TransformationMatrix;
+    mirrorLine(normal: Vector, point?: Vector): TransformationMatrix;
+    mirrorCenter(center?: Vector): TransformationMatrix;
+    scale(scalar: number, center?: Vector): TransformationMatrix;
+    transform(point: Vector): Vector;
+    transformAngle(angle: number): number;
+    keepsOrientation(): boolean;
+    scaleFactor(): number;
+}
+export {};

package/dist/types/models/exports.d.ts

@@ -0,0 +1,11 @@
+export { Diagram } from "./Diagram.js";
+export { Figure } from "./Figure.js";
+export { Loop } from "./Loop.js";
+export { Strand } from "./Strand.js";
+export type { Stroke } from "./Stroke.js";
+export { BoundingBox } from "./BoundingBox.js";
+export { TransformationMatrix } from "./TransformationMatrix.js";
+export { Line } from "./segments/Line.js";
+export { Arc } from "./segments/Arc.js";
+export type { Segment } from "./segments/Segment.js";
+export { Transformable } from "./utils/Transformable.js";

package/dist/types/models/segments/Arc.d.ts

@@ -0,0 +1,52 @@
+import { BoundingBox } from "../BoundingBox.js";
+import { Vector } from "../../definitions.js";
+import { TransformationMatrix } from "../TransformationMatrix.js";
+import { Segment, AbstractSegment } from "./Segment.js";
+export declare class Arc extends AbstractSegment<Arc> {
+    segmentType: string;
+    readonly center: Vector;
+    readonly clockwise: boolean;
+    constructor(firstPoint: Vector, lastPoint: Vector, center: Vector, clockwise?: boolean, { ignoreChecks }?: {
+        ignoreChecks?: boolean | undefined;
+    });
+    get info(): string;
+    private _coefficients;
+    get coefficients(): {
+        x2: number;
+        xy: number;
+        y2: number;
+        x: number;
+        y: number;
+        c: number;
+    };
+    isValidParameter(t: number): boolean;
+    angleToParam(angle: number): number;
+    private _angularLength;
+    get angularLength(): number;
+    paramPoint(t: number): Vector;
+    pointToParam(point: Vector): number;
+    private _radius;
+    get radius(): number;
+    private _firstAngle;
+    get firstAngle(): number;
+    private _lastAngle;
+    get lastAngle(): number;
+    get length(): number;
+    get squareLength(): number;
+    get midPoint(): Vector;
+    isSame(other: Segment): boolean;
+    clone(): Arc;
+    reverse(): Arc;
+    private _boundingBox;
+    get boundingBox(): BoundingBox;
+    distanceFrom(point: Vector): number;
+    isOnSegment(point: Vector): boolean;
+    gradientAt(param: number): Vector;
+    tangentAt(point: Vector): Vector;
+    get tangentAtFirstPoint(): Vector;
+    get tangentAtLastPoint(): Vector;
+    splitAt(points: Vector | Vector[]): Arc[];
+    transform(matrix: TransformationMatrix): Arc;
+}
+export declare function threePointsArc(firstPoint: Vector, midPoint: Vector, lastPoint: Vector): Arc;
+export declare function tangentArc(firstPoint: Vector, lastPoint: Vector, tangentAtFirstPoint: Vector): Arc;

package/dist/types/models/segments/EllipseArc.d.ts

@@ -0,0 +1,70 @@
+import { BoundingBox } from "../BoundingBox.js";
+import { Vector } from "../../definitions.js";
+import { TransformationMatrix } from "../TransformationMatrix.js";
+import { AbstractSegment } from "./Segment.js";
+import { Arc } from "./Arc.js";
+export declare class EllipseArc extends AbstractSegment<EllipseArc> {
+    segmentType: string;
+    precision: number;
+    readonly majorRadius: number;
+    readonly minorRadius: number;
+    readonly center: Vector;
+    readonly tiltAngle: number;
+    readonly clockwise: boolean;
+    constructor(firstPoint: Vector, lastPoint: Vector, center: Vector, r0: number, r1: number, tiltAngle: number, clockwise?: boolean, { ignoreChecks, angleUnits, }?: {
+        ignoreChecks?: boolean;
+        angleUnits?: "deg" | "rad";
+    });
+    private _coefficients;
+    get coefficients(): {
+        x2: number;
+        xy: number;
+        y2: number;
+        x: number;
+        y: number;
+        c: number;
+    };
+    get info(): string;
+    reverse(): EllipseArc;
+    clone(): EllipseArc;
+    private computeEllipseExtrema;
+    private _boundingBox;
+    get boundingBox(): BoundingBox;
+    private _linearExentricity?;
+    get linearExentricity(): number;
+    private _exentricity?;
+    get exentricity(): number;
+    private _focals?;
+    get focals(): [Vector, Vector];
+    get majorAxis(): Vector;
+    paramPoint(t: number): Vector;
+    pointToParam(point: Vector): number;
+    get midPoint(): Vector;
+    isValidParameter(t: number): boolean;
+    isSame(other: EllipseArc): boolean;
+    pointTheta(point: Vector): number;
+    thetaToParam(angle: number): number;
+    private isPointOnEllipse;
+    isOnSegment(point: Vector): boolean;
+    distanceFrom(point: Vector): number;
+    private _ellipseReferenceFrameTransform;
+    get ellipseReferenceFrameTransform(): TransformationMatrix;
+    private _reverseEllipseReferenceFrameTransform;
+    get reverseEllipseReferenceFrameTransform(): TransformationMatrix;
+    private _rotateFromEllipseReferenceFrame;
+    get rotateFromEllipseReferenceFrame(): TransformationMatrix;
+    private _firstAngle;
+    get firstAngle(): number;
+    private _lastAngle;
+    get lastAngle(): number;
+    private _deltaAngle;
+    get deltaAngle(): number;
+    normalAt(point: Vector): Vector;
+    gradientAt(param: number): Vector;
+    tangentAt(point: Vector): Vector;
+    get tangentAtFirstPoint(): Vector;
+    get tangentAtLastPoint(): Vector;
+    transform(matrix: TransformationMatrix): EllipseArc;
+    splitAt(points: Vector | Vector[]): EllipseArc[];
+}
+export declare function svgEllipse(firstPoint: Vector, lastPoint: Vector, r0: number, r1: number, phi: number, fA: boolean, fS: boolean): EllipseArc | Arc;

package/dist/types/models/segments/Line.d.ts

@@ -0,0 +1,32 @@
+import { BoundingBox } from "../BoundingBox.js";
+import { Vector } from "../../definitions.js";
+import { TransformationMatrix } from "../TransformationMatrix.js";
+import { Segment, AbstractSegment } from "./Segment.js";
+export declare class Line extends AbstractSegment<Line> {
+    segmentType: string;
+    isValidParameter(t: number): boolean;
+    paramPoint(t: number): Vector;
+    get length(): number;
+    get squareLength(): number;
+    private _V;
+    get V(): Vector;
+    private _slope;
+    get slope(): number;
+    private _yIntercept;
+    get yIntercept(): number;
+    get midPoint(): Vector;
+    isSame(other: Segment): boolean;
+    clone(): Line;
+    reverse(): Line;
+    private _boundingBox;
+    get boundingBox(): BoundingBox;
+    distanceFrom(point: Vector): number;
+    isOnSegment(point: Vector): boolean;
+    gradientAt(param: number): Vector;
+    tangentAt(point: Vector): Vector;
+    get normalVector(): Vector;
+    get tangentAtFirstPoint(): Vector;
+    get tangentAtLastPoint(): Vector;
+    splitAt(points: Vector | Vector[]): Line[];
+    transform(matrix: TransformationMatrix): Line;
+}

package/dist/types/models/segments/Segment.d.ts

@@ -0,0 +1,28 @@
+import type { Vector } from "../../definitions.js";
+import { BoundingBox } from "../BoundingBox.js";
+import type { TransformationMatrix } from "../TransformationMatrix.js";
+import { Transformable } from "../utils/Transformable.js";
+export type Segment = AbstractSegment<any>;
+export declare abstract class AbstractSegment<T extends AbstractSegment<T>> extends Transformable<T> {
+    firstPoint: Vector;
+    lastPoint: Vector;
+    constructor(firstPoint: Vector, lastPoint: Vector);
+    readonly precision: number;
+    abstract segmentType: string;
+    get repr(): string;
+    get info(): string;
+    abstract get midPoint(): Vector;
+    abstract get boundingBox(): BoundingBox;
+    abstract clone(): T;
+    abstract reverse(): T;
+    abstract isSame(other: AbstractSegment<any>): boolean;
+    abstract distanceFrom(element: Vector): number;
+    abstract isOnSegment(point: Vector): boolean;
+    abstract gradientAt(param: number): Vector;
+    abstract tangentAt(point: Vector): Vector;
+    abstract get tangentAtFirstPoint(): Vector;
+    abstract get tangentAtLastPoint(): Vector;
+    abstract splitAt(points: Vector[] | number[]): T[];
+    abstract transform(matrix: TransformationMatrix): T;
+    abstract paramPoint(t: number): Vector;
+}

package/dist/types/models/utils/Transformable.d.ts

@@ -0,0 +1,14 @@
+import { Vector } from "../../definitions.js";
+import { TransformationMatrix } from "../TransformationMatrix.js";
+export declare abstract class Transformable<T> {
+    abstract transform(matrix: TransformationMatrix): T;
+    translateX(x: number): T;
+    translateY(y: number): T;
+    translate(x: number, y: number): T;
+    translateTo([x, y]: Vector): T;
+    rotate(angle: number, center?: Vector): T;
+    scale(factor: number, center?: Vector): T;
+    mirrorCenter(center?: Vector): T;
+    mirror(axis?: "x" | "y"): T;
+    mirror(direction: Vector, center?: Vector): T;
+}

package/dist/types/offsetOperations.d.ts

@@ -0,0 +1,8 @@
+import { Strand } from "./models/Strand.js";
+import { Diagram } from "./models/Diagram.js";
+import { Figure } from "./models/Figure.js";
+import { Loop } from "./models/Loop.js";
+export declare function offset(shape: Diagram | Figure | Loop, offsetDistance: number): Diagram;
+export declare function outlineStroke(shape: Diagram | Figure | Loop | Strand, outlineDistance: number, { endCap }?: {
+    endCap?: "butt" | "round";
+}): Diagram;

package/dist/types/operations.d.ts

@@ -0,0 +1,2 @@
+export * from "./booleanOperations.js";
+export * from "./offsetOperations.js";

package/dist/types/utils/allCombinations.d.ts

@@ -0,0 +1,2 @@
+export declare function allCombinations(count: number): [number, number][];
+export declare function combineDifferentValues<T>(array: T[]): Generator<[T, T]>;

package/dist/types/utils/allPairs.d.ts

@@ -0,0 +1 @@
+export declare function allPairs<S, T>(list1: T[], list2: S[]): [T, S][];

package/dist/types/utils/angularDistance.d.ts

@@ -0,0 +1 @@
+export declare function angularDistance(angle1: number, angle2: number, clockwise: boolean, precision?: number): number;

package/dist/types/utils/listOfFigures.d.ts

@@ -0,0 +1,4 @@
+import { Diagram } from "../models/Diagram.js";
+import { Figure } from "../models/Figure.js";
+import { Loop } from "../models/Loop.js";
+export declare function listOfFigures(shape: Diagram | Figure | Loop): Figure[];

package/dist/types/utils/projectPointOnLine.d.ts

@@ -0,0 +1,3 @@
+import type { Vector } from "../definitions.js";
+import type { Line } from "../models/segments/Line.js";
+export declare function projectPointOnLine(line: Line, point: Vector): Vector;

package/dist/types/utils/range.d.ts

@@ -0,0 +1 @@
+export default function range(len: number): number[];

package/dist/types/utils/removeDuplicatePoints.d.ts

@@ -0,0 +1,2 @@
+import type { Vector } from "../definitions.js";
+export default function removeDuplicatePoints(points: Vector[], precision?: number): Vector[];

package/dist/types/utils/unitAngle.d.ts

@@ -0,0 +1 @@
+export declare function unitAngle(angle: number, precision?: number): number;

package/dist/types/utils/zip.d.ts

@@ -0,0 +1,3 @@
+export default function zip<T extends unknown[][]>(arrays: T): {
+    [K in keyof T]: T[K] extends (infer V)[] ? V : never;
+}[];

package/dist/types/vectorOperations.d.ts

@@ -0,0 +1,23 @@
+import type { Vector } from "./definitions.js";
+export declare const DEG2RAD: number;
+export declare const RAD2DEG: number;
+export declare const reprVector: (vector: Vector) => string;
+export declare const sameVector: ([x0, y0]: Vector, [x1, y1]: Vector, precision?: number) => boolean;
+export declare const add: ([x0, y0]: Vector, [x1, y1]: Vector) => Vector;
+export declare const subtract: ([x0, y0]: Vector, [x1, y1]: Vector) => Vector;
+export declare const squareLength: ([x, y]: Vector) => number;
+export declare const length: ([x, y]: Vector) => number;
+export declare const scalarMultiply: ([x0, y0]: Vector, scalar: number) => Vector;
+export declare const squareDistance: ([x0, y0]: Vector, [x1, y1]?: Vector) => number;
+export declare const distance: (p0: Vector, p1?: Vector) => number;
+export declare function crossProduct([x0, y0]: Vector, [x1, y1]: Vector): number;
+export declare function dotProduct([x0, y0]: Vector, [x1, y1]: Vector): number;
+export declare const angle: ([x0, y0]: Vector, [x1, y1]?: Vector) => number;
+export declare function normalize([x0, y0]: Vector): Vector;
+export declare function polarToCartesian(r: number, theta: number): Vector;
+export declare function polarAngle([x, y]: Vector): number;
+export declare function cartesianToPolar(v: Vector): [number, number];
+export declare function parallel(v1: Vector, v2: Vector, precision?: number): boolean;
+export declare function perpendicular(v: Vector): Vector;
+export declare function perpendicularClockwise(v: Vector): Vector;
+export declare function isOnAxis(point: Vector, direction: Vector, center: Vector): boolean;

package/package.json

@@ -1,26 +1,43 @@
 {
   "name": "pantograph2d",
-  "version": "0.5.0",
+  "version": "0.6.0",
   "description": "Pantograph, the pure JS 2D CAD library",
   "type": "module",
   "main": "./dist/pantograph.cjs",
   "module": "./dist/pantograph.js",
-  "types": "./dist/pantograph.d.ts",
   "files": [
     "dist"
   ],
+  "types": "./dist/types/main.d.ts",
   "exports": {
     ".": {
-      "import": "./dist/pantograph.js",
-      "require": "./dist/pantograph.cjs"
+      "import": {
+        "default": "./dist/pantograph.js",
+        "types": "./dist/types/main.d.ts"
+      },
+      "require": {
+        "default": "./dist/pantograph.cjs",
+        "types": "./dist/types/main.d.ts"
+      }
     },
     "./models": {
-      "import": "./dist/pantograph/models.js",
-      "require": "./dist/pantograph/models.cjs"
+      "import": {
+        "default": "./dist/pantograph/models.js",
+        "types": "./dist/types/api/models.d.ts"
+      },
+      "require": {
+        "default": "./dist/pantograph/models.cjs",
+        "types": "./dist/types/api/drawShape.d.ts"
+      }
     },
     "./drawShape": {
-      "import": "./dist/pantograph/drawShape.js",
-      "require": "./dist/pantograph/drawShape.cjs"
+      "import": {
+        "default": "./dist/pantograph/drawShape.js",
+        "types": "./dist/types/api/drawShape.d.ts"
+      },
+      "require": {
+        "default": "./dist/pantograph/drawShape.cjs"
+      }
     }
   },
   "scripts": {
@@ -37,6 +54,7 @@
   "author": "Steve Genoud",
   "license": "AGPL",
   "devDependencies": {
+    "@microsoft/api-extractor": "^7.35.1",
     "@types/node": "^18.15.5",
     "@typescript-eslint/eslint-plugin": "^5.55.0",
     "@typescript-eslint/parser": "^5.55.0",
@@ -48,10 +66,11 @@
     "vite-plugin-dts": "^2.2.0",
     "vitest": "^0.29.2"
   },
-  "gitHead": "f568ee50c44f14683baa3b60b0f95251145a9ba8",
+  "gitHead": "f5ef0d6e05b349cbdf28fb22d4dc62c9dded7396",
   "dependencies": {
     "-": "^0.0.1",
     "@types/flatbush": "^3.3.0",
-    "flatbush": "^4.1.0"
+    "flatbush": "^4.1.0",
+    "ml-matrix": "^6.10.4"
   }
 }