pantograph2d 0.1.0 → 0.2.0

package/dist/pantograph.d.ts

@@ -21,6 +21,7 @@ declare abstract class AbstractSegment<T extends AbstractSegment<T>> extends Tra
 
 declare abstract class AbstractStroke<T extends AbstractStroke<T>> extends Transformable<T> {
     readonly segments: Segment[];
+    abstract strokeType: string;
     get repr(): string;
     constructor(segments: Segment[], { ignoreChecks }?: {
         ignoreChecks?: boolean | undefined;
@@ -38,6 +39,42 @@ declare abstract class AbstractStroke<T extends AbstractStroke<T>> extends Trans
     abstract simplify(): T;
 }
 
+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;
+    });
+    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;
+    tangentAt(point: Vector): Vector;
+    get tangentAtFirstPoint(): Vector;
+    get tangentAtLastPoint(): Vector;
+    splitAt(points: Vector | Vector[]): Arc[];
+    transform(matrix: TransformationMatrix): Arc;
+}
+
 export declare class BoundingBox {
     readonly xMin: number;
     readonly yMin: number;
@@ -52,8 +89,12 @@ export declare class BoundingBox {
     merge(other: BoundingBox): BoundingBox;
 }
 
+export declare function cartesianToPolar([x, y]: Vector): [number, number];
+
 export declare function cut(first: Diagram | Figure | Loop, second: Diagram | Figure | Loop): Diagram;
 
+export declare const DEG2RAD: number;
+
 export declare class Diagram extends Transformable<Diagram> {
     figures: Figure[];
     constructor(figures?: Figure[], { ignoreChecks }?: {
@@ -89,10 +130,122 @@ declare class DrawingPen {
     polarLineTo([r, theta]: Vector): this;
     polarLine(distance: number, angle: number): this;
     tangentLine(distance: number): this;
+    threePointsArcTo(end: Vector, midPoint: Vector): this;
+    threePointsArc(xDist: number, yDist: number, viaXDist: number, viaYDist: number): this;
+    sagittaArcTo(end: Vector, sagitta: number): this;
+    sagittaArc(xDist: number, yDist: number, sagitta: number): this;
+    vSagittaArc(distance: number, sagitta: number): this;
+    hSagittaArc(distance: number, sagitta: number): this;
+    bulgeArcTo(end: Vector, bulge: number): this;
+    bulgeArc(xDist: number, yDist: number, bulge: number): this;
+    vBulgeArc(distance: number, bulge: number): this;
+    hBulgeArc(distance: number, bulge: number): this;
+    tangentArcTo(end: Vector): this;
+    tangentArc(xDist: number, yDist: number): this;
     close(): Diagram;
     closeWithMirror(): Diagram;
 }
 
+export declare function exportJSON(shape: Shape_2): {
+    type: string;
+    firstPoint: Vector;
+    lastPoint: Vector;
+    center?: undefined;
+    clockwise?: undefined;
+} | {
+    type: string;
+    firstPoint: Vector;
+    lastPoint: Vector;
+    center: Vector;
+    clockwise: boolean;
+} | {
+    type: string;
+    segments: ({
+        type: string;
+        firstPoint: Vector;
+        lastPoint: Vector;
+        center?: undefined;
+        clockwise?: undefined;
+    } | {
+        type: string;
+        firstPoint: Vector;
+        lastPoint: Vector;
+        center: Vector;
+        clockwise: boolean;
+    })[];
+} | {
+    type: string;
+    contour: {
+        type: string;
+        segments: ({
+            type: string;
+            firstPoint: Vector;
+            lastPoint: Vector;
+            center?: undefined;
+            clockwise?: undefined;
+        } | {
+            type: string;
+            firstPoint: Vector;
+            lastPoint: Vector;
+            center: Vector;
+            clockwise: boolean;
+        })[];
+    };
+    holes: {
+        type: string;
+        segments: ({
+            type: string;
+            firstPoint: Vector;
+            lastPoint: Vector;
+            center?: undefined;
+            clockwise?: undefined;
+        } | {
+            type: string;
+            firstPoint: Vector;
+            lastPoint: Vector;
+            center: Vector;
+            clockwise: boolean;
+        })[];
+    }[];
+} | {
+    type: string;
+    figures: {
+        type: string;
+        contour: {
+            type: string;
+            segments: ({
+                type: string;
+                firstPoint: Vector;
+                lastPoint: Vector;
+                center?: undefined;
+                clockwise?: undefined;
+            } | {
+                type: string;
+                firstPoint: Vector;
+                lastPoint: Vector;
+                center: Vector;
+                clockwise: boolean;
+            })[];
+        };
+        holes: {
+            type: string;
+            segments: ({
+                type: string;
+                firstPoint: Vector;
+                lastPoint: Vector;
+                center?: undefined;
+                clockwise?: undefined;
+            } | {
+                type: string;
+                firstPoint: Vector;
+                lastPoint: Vector;
+                center: Vector;
+                clockwise: boolean;
+            })[];
+        }[];
+    }[];
+};
+
 export declare function exportSVG(shape: Shape | Shape[], margin?: number): string;
 
 export declare class Figure extends Transformable<Figure> {
@@ -114,6 +267,8 @@ export declare function fuse(first: Diagram | Figure | Loop, second: Diagram | F
 
 export declare function fuseAll(shapes: (Diagram | Figure | Loop)[]): Diagram;
 
+export declare function importJSON(json: any): Line | Diagram | Figure | Loop | Arc;
+
 export declare function intersect(first: Diagram | Figure | Loop, second: Diagram | Figure | Loop): Diagram;
 
 export declare class Line extends AbstractSegment<Line> {
@@ -140,6 +295,7 @@ export declare class Line extends AbstractSegment<Line> {
 }
 
 export declare class Loop extends AbstractStroke<Loop> {
+    strokeType: string;
     constructor(segments: Segment[], { ignoreChecks }?: {
         ignoreChecks?: boolean | undefined;
     });
@@ -150,11 +306,18 @@ export declare class Loop extends AbstractStroke<Loop> {
     simplify(): Loop;
 }
 
+export declare function polarToCartesian(r: number, theta: number): Vector;
+
+export declare const RAD2DEG: number;
+
 export declare type Segment = AbstractSegment<any>;
 
-declare type Shape = Loop | Figure | Diagram;
+declare type Shape = Loop | Figure | Diagram | Arc | Line;
+
+declare type Shape_2 = Loop | Figure | Diagram | Arc | Line;
 
 export declare class Strand extends AbstractStroke<Strand> {
+    strokeType: string;
     reverse(): Strand;
     clone(): Strand;
     extend(strand: Strand): Strand;
@@ -189,8 +352,9 @@ export declare class TransformationMatrix {
     mirrorCenter(center?: Vector): TransformationMatrix;
     scale(scalar: number, center?: Vector): TransformationMatrix;
     transform(point: Vector): Vector;
+    keepsOrientation(): boolean;
 }
 
-declare type Vector = [number, number];
+export declare type Vector = [number, number];
 
 export { }

package/dist/pantograph.js

@@ -1,172 +1,286 @@
-import { L as g, s as L, T, a as P, D as s, F as a, b as f, p as l, c as m, f as x, d as $, i as y } from "./Diagram-8b41118e.js";
-function D(t) {
-  if (!t.length)
+import { s as v, L as c, t as x, p as D, a as M, b as k, d as b, c as F, e as I, T as R, D as a, F as h, f as g, g as p, h as m, i as G, j as B, k as C, A as l } from "./exportJSON-b3e1c256.js";
+import { l as rt } from "./exportJSON-b3e1c256.js";
+function U(n) {
+  if (!n.length)
     throw new Error("No segments to close");
-  const n = t[0], e = t.at(-1);
-  return P(n.firstPoint, e.lastPoint) ? t : [
-    ...t,
-    new g(e.lastPoint, n.firstPoint)
+  const t = n[0], r = n.at(-1);
+  return v(t.firstPoint, r.lastPoint) ? n : [
+    ...n,
+    new c(r.lastPoint, t.firstPoint)
   ];
 }
-function h(t) {
-  return new s([new a(new f(t))]);
+function w(n) {
+  return new a([new h(new g(n))]);
 }
-class k {
-  constructor(n = [0, 0]) {
-    this.pointer = n, this.firstPoint = n, this.pendingSegments = [];
+class N {
+  constructor(t = [0, 0]) {
+    this.pointer = t, this.firstPoint = t, this.pendingSegments = [];
   }
-  movePointerTo(n) {
+  movePointerTo(t) {
     if (this.pendingSegments.length)
       throw new Error(
         "You can only move the pointer if there is no segment defined"
       );
-    return this.pointer = n, this.firstPoint = n, this;
+    return this.pointer = t, this.firstPoint = t, this;
   }
-  saveSegment(n) {
-    return this.pendingSegments.push(n), this;
+  saveSegment(t) {
+    if (v(t.firstPoint, t.lastPoint))
+      throw new Error(`Segment has no length, ${t.repr}`);
+    return this.pendingSegments.push(t), this;
   }
-  lineTo(n) {
-    const e = new g(this.pointer, n);
-    return this.pointer = n, this.saveSegment(e);
+  lineTo(t) {
+    const r = new c(this.pointer, t);
+    return this.pointer = t, this.saveSegment(r);
   }
-  line(n, e) {
-    return this.lineTo([this.pointer[0] + n, this.pointer[1] + e]);
+  line(t, r) {
+    return this.lineTo([this.pointer[0] + t, this.pointer[1] + r]);
   }
-  vLine(n) {
-    return this.line(0, n);
+  vLine(t) {
+    return this.line(0, t);
   }
-  hLine(n) {
-    return this.line(n, 0);
+  hLine(t) {
+    return this.line(t, 0);
   }
-  vLineTo(n) {
-    return this.lineTo([this.pointer[0], n]);
+  vLineTo(t) {
+    return this.lineTo([this.pointer[0], t]);
   }
-  hLineTo(n) {
-    return this.lineTo([n, this.pointer[1]]);
+  hLineTo(t) {
+    return this.lineTo([t, this.pointer[1]]);
   }
-  polarLineTo([n, e]) {
-    const r = e * m, i = l(n, r);
+  polarLineTo([t, r]) {
+    const e = r * m, i = p(t, e);
     return this.lineTo(i);
   }
-  polarLine(n, e) {
-    const r = e * m, [i, u] = l(n, r);
-    return this.line(i, u);
+  polarLine(t, r) {
+    const e = r * m, [i, o] = p(t, e);
+    return this.line(i, o);
   }
-  tangentLine(n) {
-    const e = this.pendingSegments.at(-1);
-    if (!e)
+  tangentLine(t) {
+    const r = this.pendingSegments.at(-1);
+    if (!r)
       throw new Error("You need a previous segment to sketch a tangent line");
-    const [r, i] = e.tangentAtLastPoint;
-    return this.line(r * n, i * n);
+    const [e, i] = r.tangentAtLastPoint;
+    return this.line(e * t, i * t);
+  }
+  threePointsArcTo(t, r) {
+    return this.saveSegment(x(this.pointer, r, t)), this.pointer = t, this;
+  }
+  threePointsArc(t, r, e, i) {
+    const [o, s] = this.pointer;
+    return this.threePointsArcTo(
+      [o + t, s + r],
+      [o + e, s + i]
+    );
+  }
+  sagittaArcTo(t, r) {
+    if (!r)
+      return this.lineTo(t);
+    const e = new c(this.pointer, t), i = D(e.tangentAtFirstPoint), o = M(e.midPoint, k(i, r));
+    return this.threePointsArcTo(t, o);
+  }
+  sagittaArc(t, r, e) {
+    return this.sagittaArcTo(
+      [t + this.pointer[0], r + this.pointer[1]],
+      e
+    );
+  }
+  vSagittaArc(t, r) {
+    return this.sagittaArc(0, t, r);
+  }
+  hSagittaArc(t, r) {
+    return this.sagittaArc(t, 0, r);
+  }
+  bulgeArcTo(t, r) {
+    if (!r)
+      return this.lineTo(t);
+    const e = b(this.pointer, t) / 2, i = -r * e;
+    return this.sagittaArcTo(t, i);
+  }
+  bulgeArc(t, r, e) {
+    return this.bulgeArcTo(
+      [t + this.pointer[0], r + this.pointer[1]],
+      e
+    );
+  }
+  vBulgeArc(t, r) {
+    return this.bulgeArc(0, t, r);
+  }
+  hBulgeArc(t, r) {
+    return this.bulgeArc(t, 0, r);
+  }
+  tangentArcTo(t) {
+    const r = this.pendingSegments.at(-1);
+    if (!r)
+      throw new Error("You need a previous curve to sketch a tangent arc");
+    return this.saveSegment(
+      F(this.pointer, t, r.tangentAtLastPoint)
+    ), this.pointer = t, this;
+  }
+  tangentArc(t, r) {
+    const [e, i] = this.pointer;
+    return this.tangentArcTo([t + e, r + i]);
   }
   close() {
-    const n = D(this.pendingSegments);
-    return h(n);
+    const t = U(this.pendingSegments);
+    return w(t);
   }
   closeWithMirror() {
     if (!this.pendingSegments.length)
       throw new Error("No segments to close");
-    const n = this.pendingSegments[0], e = this.pendingSegments.at(-1), r = L(
-      e.lastPoint,
-      n.firstPoint
-    ), i = new T().mirrorLine(
-      r,
-      n.firstPoint
-    ), u = this.pendingSegments.map(
-      (o) => o.transform(i).reverse()
+    const t = this.pendingSegments[0], r = this.pendingSegments.at(-1), e = I(
+      r.lastPoint,
+      t.firstPoint
+    ), i = new R().mirrorLine(
+      e,
+      t.firstPoint
+    ), o = this.pendingSegments.map(
+      (s) => s.transform(i).reverse()
     );
-    return u.reverse(), h([
+    return o.reverse(), w([
       ...this.pendingSegments,
-      ...u
+      ...o
     ]);
   }
 }
-function A(t = [0, 0]) {
-  return new k(t);
+function X(n = [0, 0]) {
+  return new N(n);
 }
-function c(t) {
-  if (t instanceof a)
-    return [t];
-  if (t instanceof f)
-    return [new a(t)];
-  if (t instanceof s)
-    return t.figures;
+function u(n) {
+  if (n instanceof h)
+    return [n];
+  if (n instanceof g)
+    return [new h(n)];
+  if (n instanceof a)
+    return n.figures;
   throw new Error("Unknown shape");
 }
-function E(t, n) {
-  return new s(
-    x(c(t), c(n))
+function V(n, t) {
+  return new a(
+    G(u(n), u(t))
   );
 }
-function B(t) {
-  return t.reduce(
-    (n, e) => E(n, e),
-    new s()
+function Z(n) {
+  return n.reduce(
+    (t, r) => V(t, r),
+    new a()
   );
 }
-function M(t, n) {
-  return new s(
-    $(c(t), c(n))
+function z(n, t) {
+  return new a(
+    B(u(n), u(t))
   );
 }
-function G(t, n) {
-  return new s(
-    y(c(t), c(n))
+function H(n, t) {
+  return new a(
+    C(u(n), u(t))
   );
 }
-function F(t) {
-  if (t instanceof g)
-    return `L ${t.lastPoint.join(" ")}`;
+function S(n) {
+  if (n instanceof c)
+    return `L ${n.lastPoint.join(" ")}`;
+  if (n instanceof l)
+    return `A ${n.radius} ${n.radius} 0 ${n.angularLength > Math.PI ? "1" : "0"} ${n.clockwise ? "0" : "1"} ${n.lastPoint.join(" ")}`;
   throw new Error("Unknown segment type");
 }
-function d(t) {
-  const n = `M ${t.firstPoint.join(" ")}`, e = t.segments.map(F).join(" ");
-  return `${n} ${e} Z`;
+function T(n) {
+  const t = `M ${n.firstPoint.join(" ")}`, r = n.segments.map(S).join(" ");
+  return `${t} ${r} Z`;
 }
-function v(t) {
-  return `<path d="${t.allLoops.map(d).join(" ")}" />`;
+function L(n) {
+  return `<path d="${n.allLoops.map(T).join(" ")}" />`;
 }
-function b(t) {
+function O(n) {
   return `<g>
-  ${t.figures.map(v).join(`
+  ${n.figures.map(L).join(`
 `)}
 </g>`;
 }
-function j(t, n = 1) {
-  const e = t.xMin - n, r = t.yMin - n;
-  return `${e} ${r} ${t.width + 2 * n} ${t.height + 2 * n}`;
+function Y(n, t = 1) {
+  const r = n.xMin - t, e = n.yMin - t;
+  return `${r} ${e} ${n.width + 2 * t} ${n.height + 2 * t}`;
 }
-function w(t, n, e = 1) {
+function A(n, t, r = 1) {
   return `<?xml version="1.0" encoding="UTF-8" standalone="no"?>
-<svg version="1.1" xmlns="http://www.w3.org/2000/svg" viewBox="${j(n, e)}" fill="none" stroke="black" stroke-width="0.2%" vector-effect="non-scaling-stroke">
-    ${t}
+<svg version="1.1" xmlns="http://www.w3.org/2000/svg" viewBox="${Y(t, r)}" fill="none" stroke="black" stroke-width="0.2%" vector-effect="non-scaling-stroke">
+    ${n}
 </svg>`;
 }
-function p(t) {
-  if (t instanceof s)
-    return b(t);
-  if (t instanceof a)
-    return v(t);
-  if (t instanceof f)
-    return `<path d="${d(t)}" />`;
+function d(n) {
+  if (n instanceof a)
+    return O(n);
+  if (n instanceof h)
+    return L(n);
+  if (n instanceof g)
+    return `<path d="${T(n)}" />`;
+  if (n instanceof l || n instanceof c)
+    return `<path d="${`M ${n.firstPoint.join(" ")}`} ${S(
+      n
+    )}" />`;
   throw new Error("Unknown shape type");
 }
-function U(t, n = 1) {
-  if (Array.isArray(t)) {
-    const r = t.map((o) => o.mirror()), i = r.map((o) => p(o)).join(`
-`), u = r.slice(1).reduce((o, S) => o.merge(S.boundingBox), r[0].boundingBox);
-    return w(i, u);
+function K(n, t = 1) {
+  if (Array.isArray(n)) {
+    const e = n.map((s) => s.mirror()), i = e.map((s) => d(s)).join(`
+`), o = e.slice(1).reduce((s, E) => s.merge(E.boundingBox), e[0].boundingBox);
+    return A(i, o);
   }
-  const e = t.mirror();
-  return w(p(e), e.boundingBox, n);
+  const r = n.mirror();
+  return A(d(r), r.boundingBox, t);
+}
+const $ = (n) => {
+  if (n.type === "LINE")
+    return new c(n.firstPoint, n.lastPoint);
+  if (n.type === "ARC")
+    return new l(
+      n.firstPoint,
+      n.lastPoint,
+      n.center,
+      n.clockwise
+    );
+  throw new Error("Unknown segment type");
+}, f = (n) => {
+  const t = n.segments.map($);
+  return new g(t);
+}, y = (n) => {
+  const t = f(n.contour), r = n.holes.map(f);
+  return new h(t, r);
+}, J = (n) => {
+  const t = n.figures.map(y);
+  return new a(t);
+};
+function Q(n) {
+  if (n.type === "DIAGRAM")
+    return J(n);
+  if (n.type === "FIGURE")
+    return y(n);
+  if (n.type === "LOOP")
+    return f(n);
+  if (n.type === "LINE" || n.type === "ARC")
+    return $(n);
+  throw new Error("Unknown shape type");
+}
+const P = Math.PI / 180, q = 180 / Math.PI;
+function _(n, t) {
+  const r = Math.cos(t * P) * n, e = Math.sin(t * P) * n;
+  return [r, e];
+}
+function j([n, t]) {
+  const r = Math.sqrt(n * n + t * t), e = Math.atan2(t, n) * q;
+  return [r, e];
 }
 export {
-  M as cut,
-  A as draw,
-  U as exportSVG,
-  E as fuse,
-  B as fuseAll,
-  G as intersect,
-  p as svgBody
+  P as DEG2RAD,
+  q as RAD2DEG,
+  j as cartesianToPolar,
+  z as cut,
+  X as draw,
+  rt as exportJSON,
+  K as exportSVG,
+  V as fuse,
+  Z as fuseAll,
+  Q as importJSON,
+  H as intersect,
+  _ as polarToCartesian,
+  d as svgBody
 };
 //# sourceMappingURL=pantograph.js.map