@thi.ng/geom 7.0.1 → 8.0.0

package/api/group3.js

@@ -0,0 +1,48 @@
+import { ensureArray } from "@thi.ng/arrays/ensure-array";
+import { equiv } from "@thi.ng/equiv";
+import { __copyAttribs } from "../internal/copy.js";
+class Group3 {
+  constructor(attribs, children) {
+    this.attribs = attribs;
+    this.children = children ? ensureArray(children) : [];
+  }
+  type = "group3";
+  dim = 3;
+  children;
+  *[Symbol.iterator]() {
+    yield* this.children;
+  }
+  /**
+   * Appends given `shapes` to this {@link Group.children} array.
+   *
+   * @param shapes
+   */
+  add(...shapes) {
+    this.children.push(...shapes);
+    return this;
+  }
+  /**
+   * Removes all children from the group.
+   */
+  clear() {
+    this.children.length = 0;
+  }
+  copy() {
+    return this.copyTransformed((c) => c.copy());
+  }
+  copyTransformed(fn) {
+    return new Group3(__copyAttribs(this.attribs), this.children.map(fn));
+  }
+  withAttribs(attribs) {
+    return new Group3(attribs, this.children);
+  }
+  equiv(o) {
+    return o instanceof Group3 && equiv(this.attribs, o.attribs) && equiv(this.children, o.children);
+  }
+  toHiccup() {
+    return ["g", this.attribs, ...this.children.map((x) => x.toHiccup())];
+  }
+}
+export {
+  Group3
+};

package/api/line.d.ts

@@ -1,12 +1,15 @@
-import type { Attribs, IHiccupPathSegment, IHiccupShape } from "@thi.ng/geom-api";
-import type { Vec } from "@thi.ng/vectors";
+import type { Fn } from "@thi.ng/api";
+import type { ReadonlyVec, Vec } from "@thi.ng/vectors";
+import type { Attribs, IHiccupPathSegment, IHiccupShape2 } from "../api.js";
 import { APC } from "./apc.js";
-export declare class Line extends APC implements IHiccupShape, IHiccupPathSegment {
+export declare class Line extends APC implements IHiccupShape2<Line>, IHiccupPathSegment {
+    readonly type = "line";
+    readonly dim = 2;
     constructor(points: Iterable<Vec>, attribs?: Attribs);
-    get type(): string;
     copy(): Line;
+    copyTransformed(fn: Fn<ReadonlyVec[], Vec[]>): Line;
     withAttribs(attribs: Attribs): Line;
     toHiccup(): (string | Vec | Attribs | undefined)[];
-    toHiccupPathSegments(): ((string | Vec)[] | (string | number)[])[];
+    toHiccupPathSegments(): import("../api.js").HiccupPathSegment[];
 }
 //# sourceMappingURL=line.d.ts.map

package/api/line.js

@@ -1,28 +1,28 @@
 import { __copyShape } from "../internal/copy.js";
 import { __ensureNumVerts } from "../internal/pclike.js";
+import { __hiccupLineSegment } from "../internal/vertices.js";
 import { APC } from "./apc.js";
 class Line extends APC {
+  type = "line";
+  dim = 2;
   constructor(points, attribs) {
     super(points, attribs);
     __ensureNumVerts(this.points.length, 2);
   }
-  get type() {
-    return "line";
-  }
   copy() {
     return __copyShape(Line, this);
   }
+  copyTransformed(fn) {
+    return __copyShape(Line, this, fn(this.points));
+  }
   withAttribs(attribs) {
     return new Line(this.points, attribs);
   }
   toHiccup() {
-    return ["line", this.attribs, this.points[0], this.points[1]];
+    return [this.type, this.attribs, this.points[0], this.points[1]];
   }
   toHiccupPathSegments() {
-    const [a, b] = this.points;
-    return [
-      a[0] === b[0] ? ["V", b[1]] : a[1] === b[1] ? ["H", b[0]] : ["L", b]
-    ];
+    return [__hiccupLineSegment(this.points[0], this.points[1])];
   }
 }
 export {

package/api/line3.d.ts

@@ -0,0 +1,15 @@
+import type { Fn } from "@thi.ng/api";
+import type { ReadonlyVec, Vec } from "@thi.ng/vectors";
+import type { Attribs, HiccupPathSegment, IHiccupPathSegment, IHiccupShape3 } from "../api.js";
+import { APC } from "./apc.js";
+export declare class Line3 extends APC implements IHiccupShape3<Line3>, IHiccupPathSegment {
+    readonly type = "line3";
+    readonly dim = 3;
+    constructor(points: Iterable<Vec>, attribs?: Attribs);
+    copy(): Line3;
+    copyTransformed(fn: Fn<ReadonlyVec[], Vec[]>): Line3;
+    withAttribs(attribs: Attribs): Line3;
+    toHiccup(): (string | Vec | Attribs | undefined)[];
+    toHiccupPathSegments(): HiccupPathSegment[];
+}
+//# sourceMappingURL=line3.d.ts.map

package/api/line3.js

@@ -0,0 +1,29 @@
+import { __copyShape } from "../internal/copy.js";
+import { __ensureNumVerts } from "../internal/pclike.js";
+import { APC } from "./apc.js";
+class Line3 extends APC {
+  type = "line3";
+  dim = 3;
+  constructor(points, attribs) {
+    super(points, attribs);
+    __ensureNumVerts(this.points.length, 2);
+  }
+  copy() {
+    return __copyShape(Line3, this);
+  }
+  copyTransformed(fn) {
+    return __copyShape(Line3, this, fn(this.points));
+  }
+  withAttribs(attribs) {
+    return new Line3(this.points, attribs);
+  }
+  toHiccup() {
+    return [this.type, this.attribs, this.points[0], this.points[1]];
+  }
+  toHiccupPathSegments() {
+    return [["L", this.points[1]]];
+  }
+}
+export {
+  Line3
+};

package/api/path.d.ts

@@ -1,25 +1,28 @@
-import type { IClear } from "@thi.ng/api";
-import type { Attribs, IHiccupShape, PathSegment } from "@thi.ng/geom-api";
-export declare class Path implements IClear, IHiccupShape {
+import type { Fn, IClear, IEmpty } from "@thi.ng/api";
+import type { Attribs, IHiccupShape2, IPath, PathSegment2 } from "../api.js";
+export declare class Path implements IClear, IEmpty<Path>, IHiccupShape2<Path>, IPath<PathSegment2> {
     attribs?: Attribs | undefined;
-    segments: PathSegment[];
-    subPaths: PathSegment[][];
-    constructor(segments?: Iterable<PathSegment>, subPaths?: Iterable<PathSegment[]>, attribs?: Attribs | undefined);
-    get type(): string;
+    readonly type = "path";
+    readonly dim = 2;
+    segments: PathSegment2[];
+    subPaths: PathSegment2[][];
+    constructor(segments?: Iterable<PathSegment2>, subPaths?: Iterable<PathSegment2[]>, attribs?: Attribs | undefined);
     /**
      * Returns true, if the last main segment is a closing segment, e.g. if the
      * path represents a closed shape.
      */
     get closed(): boolean;
-    [Symbol.iterator](): Generator<PathSegment, void, undefined>;
+    [Symbol.iterator](): Generator<PathSegment2, void, undefined>;
     clear(): void;
+    empty(): Path;
     close(): this;
     copy(): Path;
+    copyTransformed(fn: Fn<PathSegment2[], PathSegment2[]>): Path;
     withAttribs(attribs: Attribs): Path;
     equiv(o: any): boolean;
-    isComplex(): number;
-    addSegments(...segments: PathSegment[]): this;
-    addSubPaths(...paths: PathSegment[][]): this;
+    isComplex(): boolean;
+    addSegments(...segments: PathSegment2[]): this;
+    addSubPaths(...paths: PathSegment2[][]): this;
     toHiccup(): (string | any[] | Attribs)[];
 }
 //# sourceMappingURL=path.d.ts.map

package/api/path.js

@@ -2,19 +2,18 @@ import { ensureArray } from "@thi.ng/arrays/ensure-array";
 import { peek } from "@thi.ng/arrays/peek";
 import { equiv } from "@thi.ng/equiv";
 import { illegalState } from "@thi.ng/errors/illegal-state";
+import { flatten1 } from "@thi.ng/transducers/flatten1";
 import { __copyAttribs, __copySegment } from "../internal/copy.js";
-const CLOSE = Object.freeze({ type: "z" });
 class Path {
   constructor(segments, subPaths, attribs) {
     this.attribs = attribs;
     this.segments = segments ? ensureArray(segments) : [];
     this.subPaths = subPaths ? ensureArray(subPaths) : [];
   }
+  type = "path";
+  dim = 2;
   segments;
   subPaths;
-  get type() {
-    return "path";
-  }
   /**
    * Returns true, if the last main segment is a closing segment, e.g. if the
    * path represents a closed shape.
@@ -24,30 +23,36 @@ class Path {
   }
   *[Symbol.iterator]() {
     yield* this.segments;
+    yield* flatten1(this.subPaths);
   }
   clear() {
     this.segments.length = 0;
   }
+  empty() {
+    return new Path();
+  }
   close() {
-    if (!this.closed) this.segments.push(CLOSE);
+    if (!this.closed) this.segments.push({ type: "z" });
     return this;
   }
   copy() {
-    const p = new Path(
-      this.segments.map(__copySegment),
-      this.subPaths.map((sub) => sub.map(__copySegment)),
-      __copyAttribs(this)
+    return this.copyTransformed((segments) => segments.map(__copySegment));
+  }
+  copyTransformed(fn) {
+    return new Path(
+      fn(this.segments),
+      this.subPaths.map(fn),
+      __copyAttribs(this.attribs)
     );
-    return p;
   }
   withAttribs(attribs) {
     return new Path(this.segments, this.subPaths, attribs);
   }
   equiv(o) {
-    return o instanceof Path && equiv(this.segments, o.segments);
+    return o instanceof Path && equiv(this.segments, o.segments) && equiv(this.subPaths, o.subPaths);
   }
   isComplex() {
-    return this.subPaths.length;
+    return !!this.subPaths.length;
   }
   addSegments(...segments) {
     for (let s of segments) {

package/api/path3.d.ts

@@ -0,0 +1,28 @@
+import type { Fn, IClear, IEmpty } from "@thi.ng/api";
+import type { Attribs, IHiccupShape3, IPath, PathSegment3 } from "../api.js";
+export declare class Path3 implements IClear, IEmpty<Path3>, IHiccupShape3<Path3>, IPath<PathSegment3> {
+    attribs?: Attribs | undefined;
+    readonly type = "path3";
+    readonly dim = 3;
+    segments: PathSegment3[];
+    subPaths: PathSegment3[][];
+    constructor(segments?: Iterable<PathSegment3>, subPaths?: Iterable<PathSegment3[]>, attribs?: Attribs | undefined);
+    /**
+     * Returns true, if the last main segment is a closing segment, e.g. if the
+     * path represents a closed shape.
+     */
+    get closed(): boolean;
+    [Symbol.iterator](): Generator<PathSegment3, void, undefined>;
+    clear(): void;
+    empty(): Path3;
+    close(): this;
+    copy(): Path3;
+    copyTransformed(fn: Fn<PathSegment3[], PathSegment3[]>): Path3;
+    withAttribs(attribs: Attribs): Path3;
+    equiv(o: any): boolean;
+    isComplex(): boolean;
+    addSegments(...segments: PathSegment3[]): this;
+    addSubPaths(...paths: PathSegment3[][]): this;
+    toHiccup(): (string | any[] | Attribs)[];
+}
+//# sourceMappingURL=path3.d.ts.map

package/api/path3.js

@@ -0,0 +1,91 @@
+import { ensureArray } from "@thi.ng/arrays/ensure-array";
+import { peek } from "@thi.ng/arrays/peek";
+import { equiv } from "@thi.ng/equiv";
+import { illegalState } from "@thi.ng/errors/illegal-state";
+import { flatten1 } from "@thi.ng/transducers/flatten1";
+import { __copyAttribs, __copySegment } from "../internal/copy.js";
+class Path3 {
+  constructor(segments, subPaths, attribs) {
+    this.attribs = attribs;
+    this.segments = segments ? ensureArray(segments) : [];
+    this.subPaths = subPaths ? ensureArray(subPaths) : [];
+  }
+  type = "path3";
+  dim = 3;
+  segments;
+  subPaths;
+  /**
+   * Returns true, if the last main segment is a closing segment, e.g. if the
+   * path represents a closed shape.
+   */
+  get closed() {
+    return peek(this.segments)?.type === "z";
+  }
+  *[Symbol.iterator]() {
+    yield* this.segments;
+    yield* flatten1(this.subPaths);
+  }
+  clear() {
+    this.segments.length = 0;
+  }
+  empty() {
+    return new Path3();
+  }
+  close() {
+    if (!this.closed) this.segments.push({ type: "z" });
+    return this;
+  }
+  copy() {
+    return this.copyTransformed((segments) => segments.map(__copySegment));
+  }
+  copyTransformed(fn) {
+    return new Path3(
+      fn(this.segments),
+      this.subPaths.map(fn),
+      __copyAttribs(this.attribs)
+    );
+  }
+  withAttribs(attribs) {
+    return new Path3(this.segments, this.subPaths, attribs);
+  }
+  equiv(o) {
+    return o instanceof Path3 && equiv(this.segments, o.segments) && equiv(this.subPaths, o.subPaths);
+  }
+  isComplex() {
+    return !!this.subPaths.length;
+  }
+  addSegments(...segments) {
+    for (let s of segments) {
+      this.closed && illegalState("path already closed");
+      this.segments.push(s);
+    }
+    return this;
+  }
+  addSubPaths(...paths) {
+    this.subPaths.push(...paths);
+    return this;
+  }
+  toHiccup() {
+    const acc = [];
+    const $hiccupSegments = (segments) => {
+      for (let i = 0, n = segments.length; i < n; i++) {
+        const s = segments[i];
+        if (s.geo) {
+          acc.push(...s.geo.toHiccupPathSegments());
+        } else if (s.point) {
+          acc.push(["M", s.point]);
+        } else {
+          acc.push([s.type]);
+        }
+      }
+    };
+    if (this.segments.length > 1) {
+      $hiccupSegments(this.segments);
+    }
+    for (let p of this.subPaths) $hiccupSegments(p);
+    return ["path3", this.attribs || {}, acc];
+  }
+}
+export {
+  Path3
+};

package/api/plane.d.ts

@@ -1,11 +1,12 @@
-import type { Attribs, IHiccupShape } from "@thi.ng/geom-api";
 import type { Vec } from "@thi.ng/vectors";
-export declare class Plane implements IHiccupShape {
+import type { Attribs, IHiccupShape3 } from "../api.js";
+export declare class Plane implements IHiccupShape3<Plane> {
     normal: Vec;
     w: number;
     attribs?: Attribs | undefined;
+    readonly type = "plane";
+    readonly dim = 3;
     constructor(normal?: Vec, w?: number, attribs?: Attribs | undefined);
-    get type(): string;
     copy(): Plane;
     withAttribs(attribs: Attribs): Plane;
     toHiccup(): (string | number | Vec | Attribs | undefined)[];

package/api/plane.js

@@ -6,11 +6,14 @@ class Plane {
     this.w = w;
     this.attribs = attribs;
   }
-  get type() {
-    return "plane";
-  }
+  type = "plane";
+  dim = 3;
   copy() {
-    return new Plane(set3([], this.normal), this.w, __copyAttribs(this));
+    return new Plane(
+      set3([], this.normal),
+      this.w,
+      __copyAttribs(this.attribs)
+    );
   }
   withAttribs(attribs) {
     return new Plane(this.normal, this.w, attribs);

package/api/points.d.ts

@@ -1,15 +1,13 @@
-import type { Attribs, IHiccupShape } from "@thi.ng/geom-api";
+import type { Fn } from "@thi.ng/api";
+import type { ReadonlyVec, Vec } from "@thi.ng/vectors";
+import type { Attribs, IHiccupShape2 } from "../api.js";
 import { APC } from "./apc.js";
-export declare class Points extends APC implements IHiccupShape {
-    get type(): string;
+export declare class Points extends APC implements IHiccupShape2<Points> {
+    readonly type = "points";
+    readonly dim = 2;
     copy(): Points;
+    copyTransformed(fn: Fn<ReadonlyVec[], Vec[]>): Points;
     withAttribs(attribs: Attribs): Points;
-    toHiccup(): (string | import("@thi.ng/vectors").Vec[] | Attribs | undefined)[];
-}
-export declare class Points3 extends APC implements IHiccupShape {
-    get type(): string;
-    copy(): Points3;
-    withAttribs(attribs: Attribs): Points3;
-    toHiccup(): (string | import("@thi.ng/vectors").Vec[] | Attribs | undefined)[];
+    toHiccup(): (string | Vec[] | Attribs | undefined)[];
 }
 //# sourceMappingURL=points.d.ts.map

package/api/points.js

@@ -1,34 +1,21 @@
 import { __copyShape } from "../internal/copy.js";
 import { APC } from "./apc.js";
 class Points extends APC {
-  get type() {
-    return "points";
-  }
+  type = "points";
+  dim = 2;
   copy() {
     return __copyShape(Points, this);
   }
-  withAttribs(attribs) {
-    return new Points(this.points, attribs);
-  }
-  toHiccup() {
-    return ["points", this.attribs, this.points];
-  }
-}
-class Points3 extends APC {
-  get type() {
-    return "points3";
-  }
-  copy() {
-    return __copyShape(Points3, this);
+  copyTransformed(fn) {
+    return __copyShape(Points, this, fn(this.points));
   }
   withAttribs(attribs) {
-    return new Points3(this.points, attribs);
+    return new Points(this.points, attribs);
   }
   toHiccup() {
-    return ["points3", this.attribs, this.points];
+    return [this.type, this.attribs, this.points];
   }
 }
 export {
-  Points,
-  Points3
+  Points
 };

package/api/points3.d.ts

@@ -0,0 +1,13 @@
+import type { Fn } from "@thi.ng/api";
+import type { ReadonlyVec, Vec } from "@thi.ng/vectors";
+import type { Attribs, IHiccupShape3 } from "../api.js";
+import { APC } from "./apc.js";
+export declare class Points3 extends APC implements IHiccupShape3<Points3> {
+    readonly type = "points3";
+    readonly dim = 3;
+    copy(): Points3;
+    copyTransformed(fn: Fn<ReadonlyVec[], Vec[]>): Points3;
+    withAttribs(attribs: Attribs): Points3;
+    toHiccup(): (string | Vec[] | Attribs | undefined)[];
+}
+//# sourceMappingURL=points3.d.ts.map

package/api/points3.js

@@ -0,0 +1,21 @@
+import { __copyShape } from "../internal/copy.js";
+import { APC } from "./apc.js";
+class Points3 extends APC {
+  type = "points3";
+  dim = 3;
+  copy() {
+    return __copyShape(Points3, this);
+  }
+  copyTransformed(fn) {
+    return __copyShape(Points3, this, fn(this.points));
+  }
+  withAttribs(attribs) {
+    return new Points3(this.points, attribs);
+  }
+  toHiccup() {
+    return [this.type, this.attribs, this.points];
+  }
+}
+export {
+  Points3
+};

package/api/polygon.d.ts

@@ -1,10 +1,13 @@
-import type { Attribs, IHiccupShape } from "@thi.ng/geom-api";
-import type { Vec } from "@thi.ng/vectors";
+import type { Fn } from "@thi.ng/api";
+import type { ReadonlyVec, Vec } from "@thi.ng/vectors";
+import type { Attribs, IHiccupShape2 } from "../api.js";
 import { APC } from "./apc.js";
-export declare class Polygon extends APC implements IHiccupShape {
-    get type(): string;
+export declare class Polygon extends APC implements IHiccupShape2<Polygon> {
+    readonly type = "poly";
+    readonly dim = 2;
     add(...points: Vec[]): void;
     copy(): Polygon;
+    copyTransformed(fn: Fn<ReadonlyVec[], Vec[]>): Polygon;
     withAttribs(attribs: Attribs): Polygon;
     toHiccup(): (string | Vec[] | Attribs | undefined)[];
 }

package/api/polygon.js

@@ -1,15 +1,17 @@
 import { __copyShape } from "../internal/copy.js";
 import { APC } from "./apc.js";
 class Polygon extends APC {
-  get type() {
-    return "poly";
-  }
+  type = "poly";
+  dim = 2;
   add(...points) {
     this.points.push(...points);
   }
   copy() {
     return __copyShape(Polygon, this);
   }
+  copyTransformed(fn) {
+    return __copyShape(Polygon, this, fn(this.points));
+  }
   withAttribs(attribs) {
     return new Polygon(this.points, attribs);
   }

package/api/polygon3.d.ts

@@ -0,0 +1,14 @@
+import type { Fn } from "@thi.ng/api";
+import type { ReadonlyVec, Vec } from "@thi.ng/vectors";
+import type { Attribs, IHiccupShape3 } from "../api.js";
+import { APC } from "./apc.js";
+export declare class Polygon3 extends APC implements IHiccupShape3<Polygon3> {
+    readonly type = "poly3";
+    readonly dim = 3;
+    add(...points: Vec[]): void;
+    copy(): Polygon3;
+    copyTransformed(fn: Fn<ReadonlyVec[], Vec[]>): Polygon3;
+    withAttribs(attribs: Attribs): Polygon3;
+    toHiccup(): (string | Vec[] | Attribs | undefined)[];
+}
+//# sourceMappingURL=polygon3.d.ts.map

package/api/polygon3.js

@@ -0,0 +1,24 @@
+import { __copyShape } from "../internal/copy.js";
+import { APC } from "./apc.js";
+class Polygon3 extends APC {
+  type = "poly3";
+  dim = 3;
+  add(...points) {
+    this.points.push(...points);
+  }
+  copy() {
+    return __copyShape(Polygon3, this);
+  }
+  copyTransformed(fn) {
+    return __copyShape(Polygon3, this, fn(this.points));
+  }
+  withAttribs(attribs) {
+    return new Polygon3(this.points, attribs);
+  }
+  toHiccup() {
+    return ["polygon3", this.attribs, this.points];
+  }
+}
+export {
+  Polygon3
+};

package/api/polyline.d.ts

@@ -1,13 +1,27 @@
-import type { Attribs, IHiccupPathSegment, IHiccupShape } from "@thi.ng/geom-api";
-import type { Vec } from "@thi.ng/vectors";
+import type { Fn } from "@thi.ng/api";
+import type { ReadonlyVec, Vec } from "@thi.ng/vectors";
+import type { Attribs, IHiccupPathSegment, IHiccupShape2 } from "../api.js";
 import { APC } from "./apc.js";
-export declare class Polyline extends APC implements IHiccupShape, IHiccupPathSegment {
-    get type(): string;
+export declare class Polyline extends APC implements IHiccupShape2<Polyline>, IHiccupPathSegment {
+    readonly type = "polyline";
+    readonly dim = 2;
     add(...points: Vec[]): void;
     copy(): Polyline;
+    copyTransformed(fn: Fn<ReadonlyVec[], Vec[]>): Polyline;
     withAttribs(attribs: Attribs): Polyline;
     toHiccup(): (string | Vec[] | {
         fill: string;
+        __samples?: Partial<import("../api.js").SamplingOpts> | number;
+        __prec?: number;
+        rotate?: number;
+        rotateX?: number;
+        rotateY?: number;
+        rotateZ?: number;
+        scale?: number | ReadonlyVec;
+        translate?: ReadonlyVec;
+        transform?: ReadonlyVec;
+        stroke?: any;
+        weight?: number;
     })[];
     toHiccupPathSegments(): any[];
 }

package/api/polyline.js

@@ -1,25 +1,28 @@
 import { __copyShape } from "../internal/copy.js";
+import { __hiccupLineSegment } from "../internal/vertices.js";
 import { APC } from "./apc.js";
 class Polyline extends APC {
-  get type() {
-    return "polyline";
-  }
+  type = "polyline";
+  dim = 2;
   add(...points) {
     this.points.push(...points);
   }
   copy() {
     return __copyShape(Polyline, this);
   }
+  copyTransformed(fn) {
+    return __copyShape(Polyline, this, fn(this.points));
+  }
   withAttribs(attribs) {
     return new Polyline(this.points, attribs);
   }
   toHiccup() {
-    return ["polyline", { ...this.attribs, fill: "none" }, this.points];
+    return [this.type, { ...this.attribs, fill: "none" }, this.points];
   }
   toHiccupPathSegments() {
     const res = [];
     for (let pts = this.points, n = pts.length, i = 1; i < n; i++) {
-      res.push(["L", pts[i]]);
+      res.push(__hiccupLineSegment(pts[i - 1], pts[i]));
     }
     return res;
   }