@thi.ng/geom 7.0.1 → 8.0.1

package/api/polyline3.d.ts

@@ -0,0 +1,28 @@
+import type { Fn } from "@thi.ng/api";
+import type { ReadonlyVec, Vec } from "@thi.ng/vectors";
+import type { Attribs, IHiccupPathSegment, IHiccupShape3 } from "../api.js";
+import { APC } from "./apc.js";
+export declare class Polyline3 extends APC implements IHiccupShape3<Polyline3>, IHiccupPathSegment {
+    readonly type = "polyline3";
+    readonly dim = 3;
+    add(...points: Vec[]): void;
+    copy(): Polyline3;
+    copyTransformed(fn: Fn<ReadonlyVec[], Vec[]>): Polyline3;
+    withAttribs(attribs: Attribs): Polyline3;
+    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[];
+}
+//# sourceMappingURL=polyline3.d.ts.map

package/api/polyline3.js

@@ -0,0 +1,31 @@
+import { __copyShape } from "../internal/copy.js";
+import { APC } from "./apc.js";
+class Polyline3 extends APC {
+  type = "polyline3";
+  dim = 3;
+  add(...points) {
+    this.points.push(...points);
+  }
+  copy() {
+    return __copyShape(Polyline3, this);
+  }
+  copyTransformed(fn) {
+    return __copyShape(Polyline3, this, fn(this.points));
+  }
+  withAttribs(attribs) {
+    return new Polyline3(this.points, attribs);
+  }
+  toHiccup() {
+    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]]);
+    }
+    return res;
+  }
+}
+export {
+  Polyline3
+};

package/api/quad.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 Quad extends APC implements IHiccupShape {
+export declare class Quad extends APC implements IHiccupShape2<Quad> {
+    readonly type = "quad";
+    readonly dim = 2;
     constructor(points: Iterable<Vec>, attribs?: Attribs);
-    get type(): string;
     copy(): Quad;
+    copyTransformed(fn: Fn<ReadonlyVec[], Vec[]>): Quad;
     withAttribs(attribs: Attribs): Quad;
     toHiccup(): (string | Vec[] | Attribs | undefined)[];
 }

package/api/quad.js

@@ -2,16 +2,18 @@ import { __copyShape } from "../internal/copy.js";
 import { __ensureNumVerts } from "../internal/pclike.js";
 import { APC } from "./apc.js";
 class Quad extends APC {
+  type = "quad";
+  dim = 2;
   constructor(points, attribs) {
     super(points, attribs);
     __ensureNumVerts(this.points.length, 4);
   }
-  get type() {
-    return "quad";
-  }
   copy() {
     return __copyShape(Quad, this);
   }
+  copyTransformed(fn) {
+    return __copyShape(Quad, this, fn(this.points));
+  }
   withAttribs(attribs) {
     return new Quad(this.points, attribs);
   }

package/api/quad3.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, IHiccupShape3 } from "../api.js";
 import { APC } from "./apc.js";
-export declare class Quad3 extends APC implements IHiccupShape {
+export declare class Quad3 extends APC implements IHiccupShape3<Quad3> {
+    readonly type = "quad3";
+    readonly dim = 3;
     constructor(points: Iterable<Vec>, attribs?: Attribs);
-    get type(): string;
     copy(): Quad3;
+    copyTransformed(fn: Fn<ReadonlyVec[], Vec[]>): Quad3;
     withAttribs(attribs: Attribs): Quad3;
     toHiccup(): (string | Vec[] | Attribs | undefined)[];
 }

package/api/quad3.js

@@ -2,21 +2,23 @@ import { __copyShape } from "../internal/copy.js";
 import { __ensureNumVerts } from "../internal/pclike.js";
 import { APC } from "./apc.js";
 class Quad3 extends APC {
+  type = "quad3";
+  dim = 3;
   constructor(points, attribs) {
     super(points, attribs);
     __ensureNumVerts(this.points.length, 4);
   }
-  get type() {
-    return "quad3";
-  }
   copy() {
     return __copyShape(Quad3, this);
   }
+  copyTransformed(fn) {
+    return __copyShape(Quad3, this, fn(this.points));
+  }
   withAttribs(attribs) {
     return new Quad3(this.points, attribs);
   }
   toHiccup() {
-    return ["polygon", this.attribs, this.points];
+    return ["polygon3", this.attribs, this.points];
   }
 }
 export {

package/api/quadratic.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, HiccupPathSegment, IHiccupPathSegment, IHiccupShape2 } from "../api.js";
 import { APC } from "./apc.js";
-export declare class Quadratic extends APC implements IHiccupShape, IHiccupPathSegment {
+export declare class Quadratic extends APC implements IHiccupShape2<Quadratic>, IHiccupPathSegment {
+    readonly type = "quadratic";
+    readonly dim = 2;
     constructor(points: Iterable<Vec>, attribs?: Attribs);
-    get type(): string;
     copy(): Quadratic;
+    copyTransformed(fn: Fn<ReadonlyVec[], Vec[]>): Quadratic;
     withAttribs(attribs: Attribs): Quadratic;
     toHiccup(): (string | Attribs | (string | Vec)[][] | undefined)[];
-    toHiccupPathSegments(): (string | Vec)[][];
+    toHiccupPathSegments(): HiccupPathSegment[];
 }
 //# sourceMappingURL=quadratic.d.ts.map

package/api/quadratic.js

@@ -2,29 +2,35 @@ import { __copyShape } from "../internal/copy.js";
 import { __ensureNumVerts } from "../internal/pclike.js";
 import { APC } from "./apc.js";
 class Quadratic extends APC {
+  type = "quadratic";
+  dim = 2;
   constructor(points, attribs) {
     super(points, attribs);
     __ensureNumVerts(this.points.length, 3);
   }
-  get type() {
-    return "quadratic";
-  }
   copy() {
     return __copyShape(Quadratic, this);
   }
+  copyTransformed(fn) {
+    return __copyShape(Quadratic, this, fn(this.points));
+  }
   withAttribs(attribs) {
     return new Quadratic(this.points, attribs);
   }
   toHiccup() {
+    const [a, b, c] = this.points;
     return [
       "path",
       this.attribs,
-      [["M", this.points[0]], ...this.toHiccupPathSegments()]
+      [
+        ["M", a],
+        ["Q", b, c]
+      ]
     ];
   }
   toHiccupPathSegments() {
-    const pts = this.points;
-    return [["Q", pts[1], pts[2]]];
+    const [_, b, c] = this.points;
+    return [["Q", b, c]];
   }
 }
 export {

package/api/quadratic3.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 Quadratic3 extends APC implements IHiccupShape3<Quadratic3>, IHiccupPathSegment {
+    readonly type = "quadratic3";
+    readonly dim = 3;
+    constructor(points: Iterable<Vec>, attribs?: Attribs);
+    copy(): Quadratic3;
+    copyTransformed(fn: Fn<ReadonlyVec[], Vec[]>): Quadratic3;
+    withAttribs(attribs: Attribs): Quadratic3;
+    toHiccup(): (string | Attribs | (string | Vec)[][] | undefined)[];
+    toHiccupPathSegments(): HiccupPathSegment[];
+}
+//# sourceMappingURL=quadratic3.d.ts.map

package/api/quadratic3.js

@@ -0,0 +1,38 @@
+import { __copyShape } from "../internal/copy.js";
+import { __ensureNumVerts } from "../internal/pclike.js";
+import { APC } from "./apc.js";
+class Quadratic3 extends APC {
+  type = "quadratic3";
+  dim = 3;
+  constructor(points, attribs) {
+    super(points, attribs);
+    __ensureNumVerts(this.points.length, 3);
+  }
+  copy() {
+    return __copyShape(Quadratic3, this);
+  }
+  copyTransformed(fn) {
+    return __copyShape(Quadratic3, this, fn(this.points));
+  }
+  withAttribs(attribs) {
+    return new Quadratic3(this.points, attribs);
+  }
+  toHiccup() {
+    const [a, b, c] = this.points;
+    return [
+      "path3",
+      this.attribs,
+      [
+        ["M", a],
+        ["Q", b, c]
+      ]
+    ];
+  }
+  toHiccupPathSegments() {
+    const [_, b, c] = this.points;
+    return [["Q", b, c]];
+  }
+}
+export {
+  Quadratic3
+};

package/api/ray.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 Ray implements IHiccupShape {
+import type { Attribs, IHiccupShape2 } from "../api.js";
+export declare class Ray implements IHiccupShape2<Ray> {
     pos: Vec;
     dir: Vec;
     attribs?: Attribs | undefined;
+    readonly type = "ray";
+    readonly dim = 2;
     constructor(pos: Vec, dir: Vec, attribs?: Attribs | undefined);
-    get type(): string;
     copy(): Ray;
     withAttribs(attribs: Attribs): Ray;
     toHiccup(): (string | Vec | Attribs | undefined)[];

package/api/ray.js

@@ -1,5 +1,5 @@
 import { maddN2 } from "@thi.ng/vectors/maddn";
-import { set } from "@thi.ng/vectors/set";
+import { set2 } from "@thi.ng/vectors/set";
 import { __copyAttribs } from "../internal/copy.js";
 class Ray {
   constructor(pos, dir, attribs) {
@@ -7,14 +7,13 @@ class Ray {
     this.dir = dir;
     this.attribs = attribs;
   }
-  get type() {
-    return "ray";
-  }
+  type = "ray";
+  dim = 2;
   copy() {
     return new Ray(
-      set([], this.pos),
-      set([], this.dir),
-      __copyAttribs(this)
+      set2([], this.pos),
+      set2([], this.dir),
+      __copyAttribs(this.attribs)
     );
   }
   withAttribs(attribs) {

package/api/ray3.d.ts

@@ -0,0 +1,14 @@
+import type { Vec } from "@thi.ng/vectors";
+import type { Attribs, IHiccupShape3 } from "../api.js";
+export declare class Ray3 implements IHiccupShape3<Ray3> {
+    pos: Vec;
+    dir: Vec;
+    attribs?: Attribs | undefined;
+    readonly type = "ray3";
+    readonly dim = 3;
+    constructor(pos: Vec, dir: Vec, attribs?: Attribs | undefined);
+    copy(): Ray3;
+    withAttribs(attribs: Attribs): Ray3;
+    toHiccup(): (string | Vec | Attribs | undefined)[];
+}
+//# sourceMappingURL=ray3.d.ts.map

package/api/ray3.js

@@ -0,0 +1,33 @@
+import { maddN3 } from "@thi.ng/vectors/maddn";
+import { set3 } from "@thi.ng/vectors/set";
+import { __copyAttribs } from "../internal/copy.js";
+class Ray3 {
+  constructor(pos, dir, attribs) {
+    this.pos = pos;
+    this.dir = dir;
+    this.attribs = attribs;
+  }
+  type = "ray3";
+  dim = 3;
+  copy() {
+    return new Ray3(
+      set3([], this.pos),
+      set3([], this.dir),
+      __copyAttribs(this.attribs)
+    );
+  }
+  withAttribs(attribs) {
+    return new Ray3(this.pos, this.dir, attribs);
+  }
+  toHiccup() {
+    return [
+      "line3",
+      this.attribs,
+      this.pos,
+      maddN3([], this.dir, 1e6, this.pos)
+    ];
+  }
+}
+export {
+  Ray3
+};

package/api/rect.d.ts

@@ -1,13 +1,15 @@
-import type { AABBLike, Attribs, IHiccupShape } from "@thi.ng/geom-api";
 import { type Vec } from "@thi.ng/vectors/api";
-export declare class Rect implements AABBLike, IHiccupShape {
+import type { AABBLike, Attribs, IHiccupShape2 } from "../api.js";
+export declare class Rect implements AABBLike, IHiccupShape2<Rect> {
     pos: Vec;
     attribs?: Attribs | undefined;
+    readonly type = "rect";
+    readonly dim = 2;
     size: Vec;
     constructor(pos?: Vec, size?: number | Vec, attribs?: Attribs | undefined);
-    get type(): string;
     copy(): Rect;
     withAttribs(attribs: Attribs): Rect;
+    min(): Vec;
     max(): Vec;
     offset(offset: number): this;
     toHiccup(): (string | number | Vec | Attribs | undefined)[];

package/api/rect.js

@@ -1,41 +1,44 @@
 import { add2 } from "@thi.ng/vectors/add";
 import { addN2 } from "@thi.ng/vectors/addn";
 import { ZERO2 } from "@thi.ng/vectors/api";
+import { maddN2 } from "@thi.ng/vectors/maddn";
 import { max2 } from "@thi.ng/vectors/max";
 import { set2 } from "@thi.ng/vectors/set";
-import { subN2 } from "@thi.ng/vectors/subn";
 import { __asVec } from "../internal/args.js";
 import { __copyAttribs } from "../internal/copy.js";
 class Rect {
   constructor(pos = [0, 0], size = 1, attribs) {
     this.pos = pos;
     this.attribs = attribs;
-    this.size = __asVec(size);
+    this.size = max2(null, __asVec(size), ZERO2);
   }
+  type = "rect";
+  dim = 2;
   size;
-  get type() {
-    return "rect";
-  }
   copy() {
     return new Rect(
       set2([], this.pos),
       set2([], this.size),
-      __copyAttribs(this)
+      __copyAttribs(this.attribs)
     );
   }
   withAttribs(attribs) {
     return new Rect(this.pos, this.size, attribs);
   }
+  min() {
+    return set2([], this.pos);
+  }
   max() {
     return add2([], this.pos, this.size);
   }
   offset(offset) {
-    subN2(null, this.pos, offset);
+    const c = maddN2([], this.size, 0.5, this.pos);
     max2(null, addN2(null, this.size, offset * 2), ZERO2);
+    maddN2(this.pos, this.size, -0.5, c);
     return this;
   }
   toHiccup() {
-    return ["rect", this.attribs, this.pos, this.size[0], this.size[1]];
+    return [this.type, this.attribs, this.pos, this.size[0], this.size[1]];
   }
 }
 export {

package/api/sphere.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 Sphere implements IHiccupShape {
+import type { Attribs, IHiccupShape3 } from "../api.js";
+export declare class Sphere implements IHiccupShape3<Sphere> {
     pos: Vec;
     r: number;
     attribs?: Attribs | undefined;
+    readonly type = "sphere";
+    readonly dim = 3;
     constructor(pos?: Vec, r?: number, attribs?: Attribs | undefined);
-    get type(): string;
     copy(): Sphere;
     withAttribs(attribs: Attribs): Sphere;
     toHiccup(): (string | number | Vec | Attribs | undefined)[];

package/api/sphere.js

@@ -6,17 +6,20 @@ class Sphere {
     this.r = r;
     this.attribs = attribs;
   }
-  get type() {
-    return "sphere";
-  }
+  type = "sphere";
+  dim = 3;
   copy() {
-    return new Sphere(set3([], this.pos), this.r, __copyAttribs(this));
+    return new Sphere(
+      set3([], this.pos),
+      this.r,
+      __copyAttribs(this.attribs)
+    );
   }
   withAttribs(attribs) {
     return new Sphere(this.pos, this.r, attribs);
   }
   toHiccup() {
-    return ["sphere", this.attribs, this.pos, this.r];
+    return [this.type, this.attribs, this.pos, this.r];
   }
 }
 export {

package/api/text.d.ts

@@ -1,5 +1,5 @@
-import type { Attribs, IHiccupShape } from "@thi.ng/geom-api";
 import type { Vec } from "@thi.ng/vectors";
+import type { Attribs, IHiccupShape2 } from "../api.js";
 /**
  * Basic stub for text elements. Currently, only a minimal set of geometry
  * operations are implemented for this type, however this type implements
@@ -7,12 +7,13 @@ import type { Vec } from "@thi.ng/vectors";
  * so is useful as wrapper for inclusion of text elements in {@link Group}s with
  * other shape types.
  */
-export declare class Text implements IHiccupShape {
+export declare class Text implements IHiccupShape2<Text> {
     pos: Vec;
     body: any;
     attribs?: Attribs | undefined;
+    readonly type = "text";
+    readonly dim = 2;
     constructor(pos: Vec, body: any, attribs?: Attribs | undefined);
-    get type(): string;
     copy(): Text;
     withAttribs(attribs: Attribs): Text;
     toHiccup(): any[];

package/api/text.js

@@ -6,17 +6,20 @@ class Text {
     this.body = body;
     this.attribs = attribs;
   }
-  get type() {
-    return "text";
-  }
+  type = "text";
+  dim = 2;
   copy() {
-    return new Text(set([], this.pos), this.body, __copyAttribs(this));
+    return new Text(
+      set([], this.pos),
+      this.body,
+      __copyAttribs(this.attribs)
+    );
   }
   withAttribs(attribs) {
     return new Text(this.pos, this.body, attribs);
   }
   toHiccup() {
-    return ["text", this.attribs, this.pos, this.body];
+    return [this.type, this.attribs, this.pos, this.body];
   }
 }
 export {

package/api/triangle.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 Triangle extends APC implements IHiccupShape {
+export declare class Triangle extends APC implements IHiccupShape2<Triangle> {
+    readonly type = "tri";
+    readonly dim = 2;
     constructor(points: Iterable<Vec>, attribs?: Attribs);
-    get type(): string;
     copy(): Triangle;
+    copyTransformed(fn: Fn<ReadonlyVec[], Vec[]>): Triangle;
     withAttribs(attribs: Attribs): Triangle;
     toHiccup(): (string | Vec[] | Attribs | undefined)[];
 }

package/api/triangle.js

@@ -2,16 +2,18 @@ import { __copyShape } from "../internal/copy.js";
 import { __ensureNumVerts } from "../internal/pclike.js";
 import { APC } from "./apc.js";
 class Triangle extends APC {
+  type = "tri";
+  dim = 2;
   constructor(points, attribs) {
     super(points, attribs);
     __ensureNumVerts(this.points.length, 3);
   }
-  get type() {
-    return "tri";
-  }
   copy() {
     return __copyShape(Triangle, this);
   }
+  copyTransformed(fn) {
+    return __copyShape(Triangle, this, fn(this.points));
+  }
   withAttribs(attribs) {
     return new Triangle(this.points, attribs);
   }

package/api/triangle3.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 Triangle3 extends APC implements IHiccupShape3<Triangle3> {
+    readonly type = "tri3";
+    readonly dim = 3;
+    constructor(points: Iterable<Vec>, attribs?: Attribs);
+    copy(): Triangle3;
+    copyTransformed(fn: Fn<ReadonlyVec[], Vec[]>): Triangle3;
+    withAttribs(attribs: Attribs): Triangle3;
+    toHiccup(): (string | Vec[] | Attribs | undefined)[];
+}
+//# sourceMappingURL=triangle3.d.ts.map

package/api/triangle3.js

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