@immugio/three-math-extensions 0.0.5 → 0.0.7

package/CHANGELOG.md

@@ -1,34 +1,39 @@
-# Changelog
-
-All notable changes to this project will be documented in this file.
-
-The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/)
-and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
-
-Generated by [`auto-changelog`](https://github.com/CookPete/auto-changelog).
-
-## 0.0.4 - 2022-11-21
-
-### Commits
-
-- Automatic publish with change log [`a70c99d`](https://github.com/Immugio/three-math-extensions/commit/a70c99d0d42e60411ce01bcdb8dd4f3f489bb949)
-- Switch to npm [`ed47a17`](https://github.com/Immugio/three-math-extensions/commit/ed47a1787522db3bde5a2112bfd02480fe2edc54)
-- Initial commit [`3d1bf9e`](https://github.com/Immugio/three-math-extensions/commit/3d1bf9ef015570830007c9be99140c8c8d760d7f)
-- Add Line2D [`9a1dd0f`](https://github.com/Immugio/three-math-extensions/commit/9a1dd0f58352b7b25828693c688aa4770e95c174)
-- Readme, npm info [`dda4a28`](https://github.com/Immugio/three-math-extensions/commit/dda4a282a71a00308dcae858ffe53d67d4185be8)
-- Run tests in CI on commit [`e3f77ca`](https://github.com/Immugio/three-math-extensions/commit/e3f77ca76e25f4d99eef0130e5779b5e7c5aec6b)
-- Remove babel.config.js [`c9a1e16`](https://github.com/Immugio/three-math-extensions/commit/c9a1e1607cffec8a3d74adcca644320a79ca4c43)
-- Initial changelog [`6c98aa6`](https://github.com/Immugio/three-math-extensions/commit/6c98aa6ad631cf5e73d32dd76276f99b3ba5089f)
-- Release 0.0.4 [`bdac840`](https://github.com/Immugio/three-math-extensions/commit/bdac840f33261a3f39ef33bc05c80772169cfe87)
-- Add test badge [`37c62e8`](https://github.com/Immugio/three-math-extensions/commit/37c62e809bdcdfc63f7fe135469fd131f190f950)
-- Edit publish script condition [`dc77d89`](https://github.com/Immugio/three-math-extensions/commit/dc77d8978d87daab8732d6429ad1b01ba0ca6f97)
-- CI to use node version 16 [`dc42650`](https://github.com/Immugio/three-math-extensions/commit/dc426508939de922cc0316b7652bbd09aeed4610)
-- Action rename [`26a1f01`](https://github.com/Immugio/three-math-extensions/commit/26a1f014827faab2c02d30ca8ed18dac8f9ff8af)
-- Release 0.0.4 - tag pattern 4 [`ab9ad4e`](https://github.com/Immugio/three-math-extensions/commit/ab9ad4e49477a991482ed6d4d3a3ca4687a70b44)
-- Release 0.0.4 - tag pattern 3 [`d7d4c8f`](https://github.com/Immugio/three-math-extensions/commit/d7d4c8f546e6550868ddd06a5213fdec6c68bcd2)
-- Release 0.0.4 - tag pattern 2 [`0dcf801`](https://github.com/Immugio/three-math-extensions/commit/0dcf80190bd67a3ca93d45131a403201ab39e00f)
-- Release 0.0.4 - tag pattern [`e7f2f76`](https://github.com/Immugio/three-math-extensions/commit/e7f2f76aa247e1c51f0522c300a7aaf07253039c)
-- Release 0.0.5 [`c80d6bd`](https://github.com/Immugio/three-math-extensions/commit/c80d6bd12c25ddad0f67610cdf5c804d5759f084)
-- Status badge update [`370843e`](https://github.com/Immugio/three-math-extensions/commit/370843ed0a28b024761555572b7d51ccbdb4b77d)
-- Run tests in CI on commit [`aee8c55`](https://github.com/Immugio/three-math-extensions/commit/aee8c556ae1cab9025dbe0984dd17278fe6275a1)
-- Add Line2D to index [`a5fb6bd`](https://github.com/Immugio/three-math-extensions/commit/a5fb6bdeee5d9f07f325bfffc31ef96f0ce167d1)
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/)
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+Generated by [`auto-changelog`](https://github.com/CookPete/auto-changelog).
+
+## 0.0.6
+
+### Commits
+
+- Automatic publish with change log [`a70c99d`](https://github.com/Immugio/three-math-extensions/commit/a70c99d0d42e60411ce01bcdb8dd4f3f489bb949)
+- Switch to npm [`ed47a17`](https://github.com/Immugio/three-math-extensions/commit/ed47a1787522db3bde5a2112bfd02480fe2edc54)
+- Initial commit [`3d1bf9e`](https://github.com/Immugio/three-math-extensions/commit/3d1bf9ef015570830007c9be99140c8c8d760d7f)
+- Add Line2D [`9a1dd0f`](https://github.com/Immugio/three-math-extensions/commit/9a1dd0f58352b7b25828693c688aa4770e95c174)
+- Improve API, minor bug fix, improve test coverage [`881a5f0`](https://github.com/Immugio/three-math-extensions/commit/881a5f096823f0d5fd90faa76cd602f076291bc5)
+- Readme, npm info [`dda4a28`](https://github.com/Immugio/three-math-extensions/commit/dda4a282a71a00308dcae858ffe53d67d4185be8)
+- Add .npmignore [`f58329a`](https://github.com/Immugio/three-math-extensions/commit/f58329a86b96589bb574d6ebed37d4cc4474663a)
+- Run tests in CI on commit [`e3f77ca`](https://github.com/Immugio/three-math-extensions/commit/e3f77ca76e25f4d99eef0130e5779b5e7c5aec6b)
+- Remove babel.config.js [`c9a1e16`](https://github.com/Immugio/three-math-extensions/commit/c9a1e1607cffec8a3d74adcca644320a79ca4c43)
+- Initial changelog [`6c98aa6`](https://github.com/Immugio/three-math-extensions/commit/6c98aa6ad631cf5e73d32dd76276f99b3ba5089f)
+- Release 0.0.4 [`bdac840`](https://github.com/Immugio/three-math-extensions/commit/bdac840f33261a3f39ef33bc05c80772169cfe87)
+- Add test badge [`37c62e8`](https://github.com/Immugio/three-math-extensions/commit/37c62e809bdcdfc63f7fe135469fd131f190f950)
+- Edit publish script condition [`dc77d89`](https://github.com/Immugio/three-math-extensions/commit/dc77d8978d87daab8732d6429ad1b01ba0ca6f97)
+- CI to use node version 16 [`dc42650`](https://github.com/Immugio/three-math-extensions/commit/dc426508939de922cc0316b7652bbd09aeed4610)
+- Action rename [`26a1f01`](https://github.com/Immugio/three-math-extensions/commit/26a1f014827faab2c02d30ca8ed18dac8f9ff8af)
+- Correct change log version [`c6244bf`](https://github.com/Immugio/three-math-extensions/commit/c6244bf1488ad21bcc5589d1dff62c41d8182d48)
+- Release 0.0.4 - tag pattern 6 [`c1c5454`](https://github.com/Immugio/three-math-extensions/commit/c1c54541ed400e1ad49bf42fe8926cd5293efefd)
+- Release 0.0.4 - tag pattern 5 [`5245eed`](https://github.com/Immugio/three-math-extensions/commit/5245eed60195103e989c0fadf9bd642f39ef4589)
+- Release 0.0.4 - tag pattern 4 [`ab9ad4e`](https://github.com/Immugio/three-math-extensions/commit/ab9ad4e49477a991482ed6d4d3a3ca4687a70b44)
+- Release 0.0.4 - tag pattern 3 [`d7d4c8f`](https://github.com/Immugio/three-math-extensions/commit/d7d4c8f546e6550868ddd06a5213fdec6c68bcd2)
+- Release 0.0.4 - tag pattern 2 [`0dcf801`](https://github.com/Immugio/three-math-extensions/commit/0dcf80190bd67a3ca93d45131a403201ab39e00f)
+- Release 0.0.4 - tag pattern [`e7f2f76`](https://github.com/Immugio/three-math-extensions/commit/e7f2f76aa247e1c51f0522c300a7aaf07253039c)
+- Release 0.0.5 [`c80d6bd`](https://github.com/Immugio/three-math-extensions/commit/c80d6bd12c25ddad0f67610cdf5c804d5759f084)
+- Status badge update [`370843e`](https://github.com/Immugio/three-math-extensions/commit/370843ed0a28b024761555572b7d51ccbdb4b77d)
+- Run tests in CI on commit [`aee8c55`](https://github.com/Immugio/three-math-extensions/commit/aee8c556ae1cab9025dbe0984dd17278fe6275a1)
+- Add Line2D to index [`a5fb6bd`](https://github.com/Immugio/three-math-extensions/commit/a5fb6bdeee5d9f07f325bfffc31ef96f0ce167d1)

package/cjs/Line2D.js

@@ -492,6 +492,28 @@ class Line2D {
             lineToExtend.end.copy(this.end);
         }
     }
+    /**
+     * If there is an intersection between this and other, this line is extended to the intersection point. Lines are assumed to be infinite.
+     * Modifies this line.
+     * @param other
+     * @param maxDistanceToIntersection
+     */
+    extendToOrTrimAtIntersection(other, maxDistanceToIntersection = Number.MAX_VALUE) {
+        const intersection = this.intersect(other);
+        if (intersection) {
+            const distanceToStart = this.start.distanceTo(intersection);
+            const distanceToEnd = this.end.distanceTo(intersection);
+            if (distanceToStart <= maxDistanceToIntersection || distanceToEnd <= maxDistanceToIntersection) {
+                if (distanceToStart < distanceToEnd) {
+                    this.start.copy(intersection);
+                }
+                else {
+                    this.end.copy(intersection);
+                }
+            }
+        }
+        return this;
+    }
     /**
      * Returns the intersection point of two lines. The lines are assumed to be infinite.
      */

package/cjs/Vec2.js

@@ -19,5 +19,11 @@ class Vec2 extends three_1.Vector2 {
     in3DSpace(z = 0) {
         return new Vec3_1.Vec3(this.x, z, this.y);
     }
+    isNear(v, maxDistance = undefined) {
+        if (!maxDistance) {
+            return this.equals(v);
+        }
+        return this.distanceTo(v) <= maxDistance;
+    }
 }
 exports.Vec2 = Vec2;

package/cjs/Vec3.js

@@ -50,6 +50,12 @@ class Vec3 extends three_1.Vector3 {
     horizontalDistanceTo(point) {
         return new three_1.Vector3(this.x, 0, this.z).distanceTo(new three_1.Vector3(point.x, 0, point.z));
     }
+    isNear(v, maxDistance = undefined) {
+        if (maxDistance === undefined) {
+            return this.equals(v);
+        }
+        return this.distanceTo(v) <= maxDistance;
+    }
     clone() {
         return super.clone();
     }

package/esm/Line2D.js

@@ -489,6 +489,28 @@ export class Line2D {
             lineToExtend.end.copy(this.end);
         }
     }
+    /**
+     * If there is an intersection between this and other, this line is extended to the intersection point. Lines are assumed to be infinite.
+     * Modifies this line.
+     * @param other
+     * @param maxDistanceToIntersection
+     */
+    extendToOrTrimAtIntersection(other, maxDistanceToIntersection = Number.MAX_VALUE) {
+        const intersection = this.intersect(other);
+        if (intersection) {
+            const distanceToStart = this.start.distanceTo(intersection);
+            const distanceToEnd = this.end.distanceTo(intersection);
+            if (distanceToStart <= maxDistanceToIntersection || distanceToEnd <= maxDistanceToIntersection) {
+                if (distanceToStart < distanceToEnd) {
+                    this.start.copy(intersection);
+                }
+                else {
+                    this.end.copy(intersection);
+                }
+            }
+        }
+        return this;
+    }
     /**
      * Returns the intersection point of two lines. The lines are assumed to be infinite.
      */

package/esm/Vec2.js

@@ -16,4 +16,10 @@ export class Vec2 extends Vector2 {
     in3DSpace(z = 0) {
         return new Vec3(this.x, z, this.y);
     }
+    isNear(v, maxDistance = undefined) {
+        if (!maxDistance) {
+            return this.equals(v);
+        }
+        return this.distanceTo(v) <= maxDistance;
+    }
 }

package/esm/Vec3.js

@@ -47,6 +47,12 @@ export class Vec3 extends Vector3 {
     horizontalDistanceTo(point) {
         return new Vector3(this.x, 0, this.z).distanceTo(new Vector3(point.x, 0, point.z));
     }
+    isNear(v, maxDistance = undefined) {
+        if (maxDistance === undefined) {
+            return this.equals(v);
+        }
+        return this.distanceTo(v) <= maxDistance;
+    }
     clone() {
         return super.clone();
     }

package/package.json

@@ -1,52 +1,52 @@
-{
-  "name": "@immugio/three-math-extensions",
-  "version": "0.0.5",
-  "description": "Set of utilities for 2d and 3d line math built on top of three.js",
-  "author": "Jan Mikeska <janmikeska@gmail.com>",
-  "license": "ISC",
-  "keywords": [
-    "threejs",
-    "three",
-    "math"
-  ],
-  "bugs": {
-    "url": "https://github.com/Immugio/three-math-extensions/issues"
-  },
-  "homepage": "https://github.com/Immugio/three-math-extensions#readme",
-  "sideEffects": false,
-  "source": "src/index.ts",
-  "main": "cjs/index.js",
-  "module": "esm/index.js",
-  "types": "types/index.d.ts",
-  "auto-changelog": {
-    "commitLimit": false,
-    "template": "keepachangelog"
-  },
-  "scripts": {
-    "test": "npx jest",
-    "build:esm": "tsc",
-    "build:cjs": "tsc -p tsconfig-cjs.json",
-    "clean": "rimraf types cjs esm",
-    "build": "npm run clean && npm run build:esm && npm run build:cjs",
-    "preversion": "npm run clean && npm run build && npm run test",
-    "version": "auto-changelog -p && git add CHANGELOG.md",
-    "postversion": "git push && git push --tags"
-  },
-  "devDependencies": {
-    "@types/jest": "^29.2.1",
-    "@types/offscreencanvas": "2019.7.0",
-    "@types/three": "0.130.1",
-    "auto-changelog": "^2.4.0",
-    "jest": "^29.2.2",
-    "rimraf": "^3.0.2",
-    "ts-jest": "^29.0.0",
-    "typescript": "4.7.4"
-  },
-  "peerDependencies": {
-    "three": "^0.130.1"
-  },
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/Immugio/three-math-extensions.git"
-  }
-}
+{
+  "name": "@immugio/three-math-extensions",
+  "version": "0.0.7",
+  "description": "Set of utilities for 2d and 3d line math built on top of three.js",
+  "author": "Jan Mikeska <janmikeska@gmail.com>",
+  "license": "ISC",
+  "keywords": [
+    "threejs",
+    "three",
+    "math"
+  ],
+  "bugs": {
+    "url": "https://github.com/Immugio/three-math-extensions/issues"
+  },
+  "homepage": "https://github.com/Immugio/three-math-extensions#readme",
+  "sideEffects": false,
+  "source": "src/index.ts",
+  "main": "cjs/index.js",
+  "module": "esm/index.js",
+  "types": "types/index.d.ts",
+  "auto-changelog": {
+    "commitLimit": false,
+    "template": "keepachangelog"
+  },
+  "scripts": {
+    "test": "npx jest",
+    "build:esm": "tsc",
+    "build:cjs": "tsc -p tsconfig-cjs.json",
+    "clean": "rimraf types cjs esm",
+    "build": "npm run clean && npm run build:esm && npm run build:cjs",
+    "preversion": "npm run clean && npm run build && npm run test",
+    "version": "auto-changelog -p && git add CHANGELOG.md",
+    "postversion": "git push && git push --tags"
+  },
+  "devDependencies": {
+    "@types/jest": "^29.2.1",
+    "@types/offscreencanvas": "2019.7.0",
+    "@types/three": "0.130.1",
+    "auto-changelog": "^2.4.0",
+    "jest": "^29.2.2",
+    "rimraf": "^3.0.2",
+    "ts-jest": "^29.0.0",
+    "typescript": "4.7.4"
+  },
+  "peerDependencies": {
+    "three": "^0.130.1"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Immugio/three-math-extensions.git"
+  }
+}

package/src/Line2D.ts

@@ -572,6 +572,32 @@ export class Line2D {
         }
     }
 
+    /**
+     * If there is an intersection between this and other, this line is extended to the intersection point. Lines are assumed to be infinite.
+     * Modifies this line.
+     * @param other
+     * @param maxDistanceToIntersection
+     */
+    public extendToOrTrimAtIntersection(other: Line2D, maxDistanceToIntersection: number = Number.MAX_VALUE): Line2D {
+        const intersection = this.intersect(other);
+
+        if (intersection) {
+            const distanceToStart = this.start.distanceTo(intersection);
+            const distanceToEnd = this.end.distanceTo(intersection);
+
+            if (distanceToStart <= maxDistanceToIntersection || distanceToEnd <= maxDistanceToIntersection) {
+                if (distanceToStart < distanceToEnd) {
+                    this.start.copy(intersection);
+
+                } else {
+                    this.end.copy(intersection);
+                }
+            }
+        }
+
+        return this;
+    }
+
     /**
      * Returns the intersection point of two lines. The lines are assumed to be infinite.
      */

package/src/Vec2.ts

@@ -21,4 +21,12 @@ export class Vec2 extends Vector2 {
     public in3DSpace(z: number = 0): Vec3 {
         return new Vec3(this.x, z, this.y);
     }
+
+    public isNear(v: Vector2, maxDistance: number = undefined): boolean {
+        if (!maxDistance) {
+            return this.equals(v);
+        }
+
+        return this.distanceTo(v) <= maxDistance;
+    }
 }

package/src/Vec3.ts

@@ -64,6 +64,14 @@ export class Vec3 extends Vector3 {
         return new Vector3(this.x, 0, this.z).distanceTo(new Vector3(point.x, 0, point.z));
     }
 
+    public isNear(v: Vector3, maxDistance: number = undefined): boolean {
+        if (maxDistance === undefined) {
+            return this.equals(v);
+        }
+
+        return this.distanceTo(v) <= maxDistance;
+    }
+
     public clone(): this {
         return super.clone();
     }

package/types/Line2D.d.ts

@@ -196,6 +196,13 @@ export declare class Line2D {
      * @param tolerance
      */
     extendToEnds(lineToExtend: Line2D, tolerance: number): void;
+    /**
+     * If there is an intersection between this and other, this line is extended to the intersection point. Lines are assumed to be infinite.
+     * Modifies this line.
+     * @param other
+     * @param maxDistanceToIntersection
+     */
+    extendToOrTrimAtIntersection(other: Line2D, maxDistanceToIntersection?: number): Line2D;
     /**
      * Returns the intersection point of two lines. The lines are assumed to be infinite.
      */

package/types/Vec2.d.ts

@@ -5,4 +5,5 @@ export declare class Vec2 extends Vector2 {
     static fromPoint(point: Point2): Vec2;
     roundIfCloseToInteger(max?: number): this;
     in3DSpace(z?: number): Vec3;
+    isNear(v: Vector2, maxDistance?: number): boolean;
 }

package/types/Vec3.d.ts

@@ -13,5 +13,6 @@ export declare class Vec3 extends Vector3 {
     toPointWithFlippedYZ(): Vec3;
     onPlan(): Vec2;
     horizontalDistanceTo(point: Vector3): number;
+    isNear(v: Vector3, maxDistance?: number): boolean;
     clone(): this;
 }

package/.eslintrc.json

@@ -1,32 +0,0 @@
-{
-    "env": {
-        "browser": true,
-        "es2020": true
-    },
-    "extends": [
-        "eslint:recommended",
-        "plugin:@typescript-eslint/recommended"
-    ],
-    "parser": "@typescript-eslint/parser",
-    "parserOptions": {
-        "ecmaVersion": 11,
-        "sourceType": "module"
-    },
-    "plugins": [
-        "@typescript-eslint"
-    ],
-    "rules": {
-        "linebreak-style": [
-            "error",
-            "windows"
-        ],
-        "quotes": [
-            "error",
-            "double"
-        ],
-        "semi": [
-            "error",
-            "always"
-        ]
-    }
-}

package/jest.config.js

@@ -1,6 +0,0 @@
-/** @type {import('ts-jest/dist/types').InitialOptionsTsJest} */
-// eslint-disable-next-line no-undef
-module.exports = {
-  preset: "ts-jest",
-  testEnvironment: "node",
-};

package/src/__tests__/Line2D.spec.ts

@@ -1,358 +0,0 @@
-import { Line2D } from "../Line2D";
-import { Vector2 } from "three";
-import { Vec2 } from "../Vec2";
-import { Point2 } from "../Point2";
-
-describe("Line2D", () => {
-    it("should be created", () => {
-        const start = new Vec2(1, 2);
-        const end = new Vec2(3, 4);
-        const line = new Line2D(start, end, 20);
-        expect(line).toEqual(new Line2D(start, end, 20));
-        expect(line.start).toBe(start);
-        expect(line.end).toBe(end);
-    });
-
-    it("should be created fromCoordinates", () => {
-        const line = Line2D.fromCoordinates(1, 2, 3, 4, 10);
-        expect(line.start.x).toEqual(1);
-        expect(line.start.y).toEqual(2);
-        expect(line.end.x).toEqual(3);
-        expect(line.end.y).toEqual(4);
-        expect(line.index).toEqual(10);
-    });
-
-    it("should be created fromPoints", () => {
-        const line = Line2D.fromPoints({ x: 1, y: 2 }, { x: 3, y: 4 }, 10);
-        expect(line).toEqual(new Line2D(new Vec2(1, 2), new Vec2(3, 4), 10));
-    });
-
-    it("should create a single line polygon from a 2 points polygon", () => {
-        const start = new Vec2(1, 2);
-        const end = new Vec2(3, 4);
-        const lines = Line2D.fromPolygon([start, end]);
-        expect(lines.length).toEqual(1);
-        expect(lines[0]).toEqual(new Line2D(start, end));
-    });
-
-    it("should create a 2 lines polygon from a 3 points polygon", () => {
-        const p1 = new Vec2(1, 2);
-        const p2 = new Vec2(3, 4);
-        const p3 = new Vec2(5, 2);
-        const lines = Line2D.fromPolygon([p1, p2, p3]);
-        expect(lines.length).toEqual(2);
-        expect(lines[0]).toEqual(new Line2D(p1, p2, 0));
-        expect(lines[1]).toEqual(new Line2D(p2, p3, 1));
-    });
-
-    it("should create a closed 3 lines polygon from a 3 points polygon", () => {
-        const p1 = new Vec2(1, 2);
-        const p2 = new Vec2(3, 4);
-        const p3 = new Vec2(5, 2);
-        const lines = Line2D.fromPolygon([p1, p2, p3], true);
-        expect(lines.length).toEqual(3);
-        expect(lines[0]).toEqual(new Line2D(p1, p2, 0));
-        expect(lines[1]).toEqual(new Line2D(p2, p3, 1));
-        expect(lines[2]).toEqual(new Line2D(p3, p1, 2));
-    });
-
-    test("center should return the center of the line", () => {
-        const line = Line2D.fromCoordinates(-2, -2, 2, 2);
-        expect(line.center.x).toEqual(0);
-        expect(line.center.y).toEqual(0);
-    });
-
-    test("resize should resize the line by the given length", () => {
-        const line = Line2D.fromCoordinates(-2, 1, 2, 1);
-        const originalCenter = line.center;
-        expect(line.length).toEqual(4);
-
-        const resizeDistance = 2;
-        line.resize(resizeDistance);
-
-        expect(line.length).toEqual(6);
-        expect(line.center).toEqual(originalCenter);
-        expect(line.start.x).toEqual(-3);
-        expect(line.end.x).toEqual(3);
-    });
-
-    test("moveStartPoint should move p1 on the line by the given amount", () => {
-        const line = Line2D.fromCoordinates(-2, 1, 2, 1);
-        expect(line.length).toEqual(4);
-
-        line.moveStartPoint(2);
-        expect(line.length).toEqual(6);
-        expect(line.start.x).toEqual(-4);
-    });
-
-    test("moveEndPoint should move p1 on the line by the given amount", () => {
-        const line = Line2D.fromCoordinates(-2, 1, 2, 1);
-        expect(line.length).toEqual(4);
-
-        line.moveEndPoint(2);
-        expect(line.length).toEqual(6);
-        expect(line.end.x).toEqual(4);
-    });
-
-    test("flip should swap the end points", () => {
-        const line = Line2D.fromCoordinates(-2, 1, 2, 1);
-        const original = line.clone();
-        line.flip();
-        expect(line.start.equals(original.end)).toBe(true);
-        expect(line.end.equals(original.start)).toBe(true);
-    });
-
-    test("rotate should rotate the endpoints around the line center", () => {
-        const line = Line2D.fromCoordinates(10, 0, 20, 0);
-        line.rotate(Math.PI / 2); // 90 degrees counterclockwise
-        expect(line.start.x).toEqual(15);
-        expect(line.start.y).toEqual(-5);
-        expect(line.end.x).toEqual(15);
-        expect(line.end.y).toEqual(5);
-    });
-
-    test("translate should rotate the endpoints around the line center", () => {
-        const line = Line2D.fromCoordinates(10, 0, 20, 0);
-        line.translate({ x: 10, y: 100 });
-        expect(line.start.x).toEqual(20);
-        expect(line.start.y).toEqual(100);
-        expect(line.end.x).toEqual(30);
-        expect(line.end.y).toEqual(100);
-    });
-
-    test.each([
-        [Line2D.fromCoordinates(5, 5, 15, 15), 5, 5, true],
-        [Line2D.fromCoordinates(5, 5, 15, 15), 10, 10, true],
-        [Line2D.fromCoordinates(5, 5, 15, 15), 15, 15, true],
-        [Line2D.fromCoordinates(5, 5, 15, 15), 16, 16, false],
-        [Line2D.fromCoordinates(5, 5, 15, 15), 10, 16, false],
-        [Line2D.fromCoordinates(5, 5, 15, 15), 10, 4, false],
-        [Line2D.fromCoordinates(5, 5, 15, 15), 4, 4, false],
-        [Line2D.fromCoordinates(5, 5, 15, 15), 15, 16, false],
-    ])("Line.isPointOnLineSection should return true if the point is on the line section", (line: Line2D, x, y, expected: boolean) => {
-        expect(line.isPointOnLineSection({x, y})).toBe(expected);
-    });
-
-    test.each([
-        [Line2D.fromCoordinates(5, 5, 15, 5), 10, 6, .9, false],
-        [Line2D.fromCoordinates(5, 5, 15, 5), 10, 6, 1, true],
-    ])("Line.isPointCloseToAndBesideLineSection should return true if the point is within expected distance of the line section", (line: Line2D, x, y, tolerance, expected: boolean) => {
-        expect(line.isPointCloseToAndBesideLineSection({x, y}, tolerance)).toBe(expected);
-    });
-
-    test.each([
-        [Line2D.fromCoordinates(5, 5, 15, 15), 5, 5, true],
-        [Line2D.fromCoordinates(5, 5, 15, 15), 10, 10, true],
-        [Line2D.fromCoordinates(5, 5, 15, 15), 15, 15, true],
-        [Line2D.fromCoordinates(5, 5, 15, 15), 16, 16, false],
-        [Line2D.fromCoordinates(5, 5, 15, 15), 10, 16, true],
-        [Line2D.fromCoordinates(5, 5, 15, 15), 10, 4, true],
-        [Line2D.fromCoordinates(5, 5, 15, 15), 4, 4, false],
-        [Line2D.fromCoordinates(5, 5, 15, 15), 15, 16, false],
-    ])("Line.isPointBesideLineSection should return true if the point is beside the line section", (line: Line2D, x, y, expected: boolean) => {
-        expect(line.isPointBesideLineSection({x, y})).toBe(expected);
-    });
-
-    test.each([
-        [Line2D.fromCoordinates(5, 5, 15, 15), 5, 5, 0],
-        [Line2D.fromCoordinates(5, 5, 15, 15), 10, 10, 0],
-        [Line2D.fromCoordinates(5, 5, 15, 15), 15, 15, 0],
-        [Line2D.fromCoordinates(5, 5, 15, 15), 16, 16, 0],
-        [Line2D.fromCoordinates(5, 5, 15, 15), 10, 16, 4.242640687119285],
-        [Line2D.fromCoordinates(5, 5, 15, 15), 10, 4, 4.242640687119285],
-        [Line2D.fromCoordinates(5, 5, 15, 15), 4, 4, 0],
-        [Line2D.fromCoordinates(5, 5, 15, 15), 10, 11, 0.7071067811865476],
-    ])("Line.distanceToPointOnInfiniteLine should return true if the point is beside the line section. Line: (%s, x: %s, y: %s) expected: %s", (line: Line2D, x, y, expected: number) => {
-        expect(line.distanceToPointOnInfiniteLine({x, y})).toBe(expected);
-    });
-
-    test.each([
-        [Line2D.fromCoordinates(5, 5, 15, 15), 5, 5, true],
-        [Line2D.fromCoordinates(5, 5, 15, 15), 10, 10, true],
-        [Line2D.fromCoordinates(5, 5, 15, 15), 15, 15, true],
-        [Line2D.fromCoordinates(5, 5, 15, 15), 16, 16, true],
-        [Line2D.fromCoordinates(5, 5, 15, 15), 4, 4, true],
-        [Line2D.fromCoordinates(5, 5, 15, 15), 15, 16, false],
-    ])("Line.isPointOnInfiniteLine should return true if the point is on the infinite line", (line: Line2D, x, y, expected: boolean) => {
-        expect(line.isPointOnInfiniteLine({x, y})).toBe(expected);
-    });
-
-    test.each([
-        [Line2D.fromCoordinates(10, 5, 15, 5), Line2D.fromCoordinates(15, 5, 20, 5), true], // Other on the right, touching
-        [Line2D.fromCoordinates(5, 5, 15, 15), Line2D.fromCoordinates(15, 15, 16, 16), true], // Other on the right, touching, angle
-        [Line2D.fromCoordinates(10, 5, 15, 5), Line2D.fromCoordinates(15, 5, 20, 6), false], // Other on the right, touching but lines are not collinear
-        [Line2D.fromCoordinates(10, 5, 15, 5), Line2D.fromCoordinates(14, 5, 20, 5), true], // Other on the right, overlapping
-        [Line2D.fromCoordinates(10, 5, 15, 5), Line2D.fromCoordinates(9, 5, 20, 5), true], // Other completely covers Line
-        [Line2D.fromCoordinates(10, 5, 15, 5), Line2D.fromCoordinates(16, 5, 20, 5), false], // Other on the left, with gap
-    ])("Line.canJoinLine should return true if the point is on the line %s, other: %s, expected: %s" , (line: Line2D, other: Line2D, expected: boolean) => {
-        expect(line.isCollinearWithTouchOrOverlap(other)).toBe(expected);
-    });
-
-    test.each([
-        [Line2D.fromCoordinates(10, 5, 15, 5), Line2D.fromCoordinates(15, 5, 20, 5), Line2D.fromCoordinates(10, 5, 20, 5)], // Other on the right, touching
-        [Line2D.fromCoordinates(5, 5, 15, 15), Line2D.fromCoordinates(15, 15, 16, 16), Line2D.fromCoordinates(5, 5, 16, 16)], // Other on the right, touching, angle
-        [Line2D.fromCoordinates(10, 5, 15, 5), Line2D.fromCoordinates(15, 5, 20, 6), null], // Other on the right, touching but lines are not collinear
-        [Line2D.fromCoordinates(10, 5, 15, 5), Line2D.fromCoordinates(14, 5, 20, 5), Line2D.fromCoordinates(10, 5, 20, 5)], // Other on the right, overlapping
-        [Line2D.fromCoordinates(10, 5, 15, 5), Line2D.fromCoordinates(9, 5, 20, 5), Line2D.fromCoordinates(9, 5, 20, 5)], // Other completely covers Line
-        [Line2D.fromCoordinates(10, 5, 15, 5), Line2D.fromCoordinates(16, 5, 20, 5), null], // Other on the left, with gap
-    ])("Line.joinLine returns correctly joined lines", (line: Line2D, other: Line2D, expected: Line2D) => {
-        const result = Line2D.joinLine(line, other);
-        if (result === null) {
-            expect(result).toBe(null);
-        } else {
-            expect(result.start.x).toEqual(expected.start.x);
-            expect(result.start.y).toEqual(expected.start.y);
-            expect(result.end.x).toEqual(expected.end.x);
-            expect(result.end.y).toEqual(expected.end.y);
-        }
-    });
-
-    test("joinLines returns correctly joined lines", () => {
-        const gr1_Line1 = Line2D.fromCoordinates(15, 0, 20, 0);
-        const gr1_Line2 = Line2D.fromCoordinates(20, 0, 55, 0);
-
-        const gr2_Line1 = Line2D.fromCoordinates(915, 0, 920, 0);
-        const gr2_Line2 = Line2D.fromCoordinates(920, 0, 955, 0);
-
-        const result = Line2D.joinLines([gr1_Line1, gr1_Line2, gr2_Line1, gr2_Line2]);
-        expect(result.length).toEqual(2);
-
-        const gr1 = result.filter(l => l.start.equals(gr1_Line1.start) && l.end.equals(gr1_Line2.end));
-        expect(gr1.length).toEqual(1);
-
-        const gr2 = result.filter(l => l.start.equals(gr2_Line1.start) && l.end.equals(gr2_Line2.end));
-        expect(gr2.length).toEqual(1);
-    });
-
-    test("closestPointOnInfiniteLine returns the closes point to the infinite line", () => {
-        const line = Line2D.fromCoordinates(0, 0, 10, 0);
-        const point = new Vector2(11, 1);
-        const closest = line.closestPointOnInfiniteLine(point);
-        expect(closest.x).toEqual(11);
-        expect(closest.y).toEqual(0);
-    });
-
-    test("clipOverflow clip the overlapping sections from the other line", () => {
-        const line = Line2D.fromCoordinates(0, 0, 10, 0);
-        const other = Line2D.fromCoordinates(-5, 0, 15, 0);
-        line.trimExcess(other);
-        expect(other.start).toEqual(line.start);
-        expect(other.end).toEqual(line.end);
-    });
-
-    test("clipOverflow clip the overlapping sections from the other line", () => {
-        const line = Line2D.fromCoordinates(0, 0, 15, 0);
-        const other = Line2D.fromCoordinates(1, 0, 10, 0);
-        line.extendToEnds(other, 1);
-        expect(other.start).toEqual(line.start); // Only the first point is extended because it's within tolerance
-        expect(other.end.x).toEqual(10); // The second point is not extended because it's outside tolerance
-    });
-
-    test.each([
-        [new Vector2(15, 0), new Vector2(7.5, 7.5)],
-        [new Vector2(2, 2), new Vector2(2, 2)],
-        [new Vector2(-1, -5), new Vector2(0, 0)],
-        [new Vector2(20, 30), new Vector2(15, 15)],
-    ])("Line.closestPointOnLine should return a point laying directly on the line", (source: Vector2, expected: Vector2) => {
-        const line = Line2D.fromCoordinates(0, 0, 15, 15);
-        const closest = line.closestPointOnLine(source);
-        expect(closest).toEqual(expected);
-    });
-
-    test.each([
-        [Line2D.fromCoordinates(10, 0, 20, 0), Line2D.fromCoordinates(0, 0, 10, 0), "Touch from the left but not overlapping", false],
-        [Line2D.fromCoordinates(10, 0, 20, 0), Line2D.fromCoordinates(20, 0, 30, 0), "Touch from the right but not overlapping", false],
-        [Line2D.fromCoordinates(10, 0, 20, 0), Line2D.fromCoordinates(22, 0, 30, 0), "Not touch, no overlap", false],
-        [Line2D.fromCoordinates(10, 0, 20, 0), Line2D.fromCoordinates(0, 1, 11, 0), "Not a real overlap, lines are not collinear", false],
-        [Line2D.fromCoordinates(10, 0, 20, 0), Line2D.fromCoordinates(0, 0, 11, 0), "Overlap from the left", true],
-        [Line2D.fromCoordinates(10, 0, 20, 0), Line2D.fromCoordinates(19, 0, 30, 0), "Overlap from the right", true],
-        [Line2D.fromCoordinates(10, 0, 20, 0), Line2D.fromCoordinates(11, 0, 19, 0), "Line completely covers Other", true],
-        [Line2D.fromCoordinates(10, 0, 20, 0), Line2D.fromCoordinates(0, 0, 30, 0), "Line is completely covered by Other", true],
-    ])("Line.overlaps should return true if the lines overlap. Line: %s, other: %s, description: %s expected: %s", (line: Line2D, other: Line2D, description: string, expected: boolean) => {
-        expect(line.overlaps(other)).toBe(expected);
-    });
-
-    test.each([
-        [Line2D.fromCoordinates(10, 0, 20, 0), Line2D.fromCoordinates(0, 0, 10, 0), "Touch from the left but not overlapping", null],
-        [Line2D.fromCoordinates(10, 0, 20, 0), Line2D.fromCoordinates(20, 0, 30, 0), "Touch from the right but not overlapping", null],
-        [Line2D.fromCoordinates(10, 0, 20, 0), Line2D.fromCoordinates(22, 0, 30, 0), "Not touch, no overlap", null],
-        [Line2D.fromCoordinates(10, 0, 20, 0), Line2D.fromCoordinates(0, 1, 11, 0), "Not a real overlap, lines are not collinear", null],
-        [Line2D.fromCoordinates(10, 0, 20, 0), Line2D.fromCoordinates(0, 0, 11, 0), "Overlap from the left", Line2D.fromCoordinates(10, 0, 11, 0)],
-        [Line2D.fromCoordinates(10, 0, 20, 0), Line2D.fromCoordinates(19, 0, 30, 0), "Overlap from the right", Line2D.fromCoordinates(19, 0, 20, 0)],
-        [Line2D.fromCoordinates(10, 0, 20, 0), Line2D.fromCoordinates(11, 0, 19, 0), "Line completely covers Other", Line2D.fromCoordinates(11, 0, 19, 0)],
-        [Line2D.fromCoordinates(10, 0, 20, 0), Line2D.fromCoordinates(0, 0, 30, 0), "Line is completely covered by Other", Line2D.fromCoordinates(10, 0, 20, 0)],
-        [Line2D.fromCoordinates(3600, 1350, 3600, 2050), Line2D.fromCoordinates(3600, 1950, 3600, 2650), "Vertical Line is covered by Other on bottom", Line2D.fromCoordinates(3600, 1950, 3600, 2050)],
-    ])("Line.getOverlap should return overlap. Line: %s, other: %s, description: %s expected: %s", (line: Line2D, other: Line2D, description: string, expected: Line2D) => {
-        const result = line.getOverlap(other);
-        if (expected) {
-            expect(result.start.equals(expected.start)).toBe(true);
-            expect(result.end.equals(expected.end)).toBe(true);
-        } else {
-            expect(result).toBeNull();
-        }
-    });
-
-    test.each([
-        [
-            Line2D.fromCoordinates(3550, 2400, 150, 2400),
-            [Line2D.fromCoordinates(650, 2400, 150, 2400), Line2D.fromCoordinates(3550, 2400, 3050, 2400), Line2D.fromCoordinates(2404, 2400, 1604, 2400)],
-            "Horizontal line with 2 clips on on the ends and one middle",
-            [Line2D.fromCoordinates(3050, 2400, 2404, 2400), Line2D.fromCoordinates(1604, 2400, 650, 2400)],
-        ],
-        [
-            Line2D.fromCoordinates(3600, 150, 3600, 2450),
-            [Line2D.fromCoordinates(3600, 927, 3600, 1427)],
-            "Vertical line with 1 clip in the middle middle",
-            [Line2D.fromCoordinates(3600, 150, 3600, 927), Line2D.fromCoordinates(3600, 1427, 3600, 2450)],
-        ],
-        [
-            Line2D.fromCoordinates(6050, 3100, 3800, 3100),
-            [Line2D.fromCoordinates(6150, 3100, 3700, 3100)],
-            "Clip line overlaps the source line on both ends",
-            [],
-        ],
-    ])("Line.clipLines should return clipLines. Line: %s, others: %s, description: %s expected: %s", (line: Line2D, others: Line2D[], description: string, expected: Line2D[]) => {
-        const result = Line2D.clipLines(line, others);
-        expect(result.length).toEqual(expected.length);
-        expected.forEach((e, i) => {
-            expect(result[i].equals(e)).toBe(true);
-        });
-    });
-
-    test.each([
-        [
-            Line2D.fromCoordinates(0, 50, 100, 50),
-            Line2D.fromCoordinates(50, 0, 50, 100),
-            "Horizontal with vertical, intersected in the middle",
-            { x: 50, y: 50 }
-        ],
-        [
-            Line2D.fromCoordinates(0, 50, 100, 50),
-            Line2D.fromCoordinates(50, 0, 51, 100),
-            "Horizontal with vertical, intersected in the middle, but the angle in not 90 degrees",
-            null
-        ],
-        [
-            Line2D.fromCoordinates(0, 50, 100, 50),
-            Line2D.fromCoordinates(50, 0, 50, 49),
-            "Horizontal with vertical, 1 unit away from intersection",
-            null
-        ],
-    ])("Line.hasIntersectionWithAngle should return expected intersection. Line: %s, others: %s, description: %s expected: %s", (line: Line2D, other: Line2D, description: string, expected: Point2) => {
-        const result = line.hasIntersectionWithAngle(other, Math.PI / 2);
-        expect(result).toEqual(expected);
-    });
-
-    test("Line.chunk should split lines in to multiple with expected length", () => {
-        const size = 10;
-        const line = Line2D.fromCoordinates(0, 0, 88, 0);
-        const chunks = line.chunk(size);
-        expect(chunks.length).toEqual(9);
-
-        expect(chunks[0].length).toEqual(size);
-        expect(chunks[0].start.equals(line.start)).toBe(true);
-
-        expect(chunks[chunks.length - 1].length).toEqual(8);
-        expect(chunks[chunks.length - 1].end.equals(line.end)).toBe(true);
-    });
-});

package/src/__tests__/Line3D.join.spec.ts

@@ -1,28 +0,0 @@
-import { Line3D } from "../Line3D";
-import { Vec3 } from "../Vec3";
-
-describe("Line3d.jointLine", () => {
-    describe.each([
-        { message: "Same direction - Lines aren't parallel", a: new Line3D(new Vec3(0, 0, 0), new Vec3(10, 0, 0)), b: new Line3D(new Vec3(10, 0, 0), new Vec3(20, 0, 1)), expected: null },
-        { message: "Same direction - Lines don't overlap" ,a: new Line3D(new Vec3(0, 0, 0), new Vec3(5, 0, 0)), b: new Line3D(new Vec3(11, 0, 0), new Vec3(12, 0, 0)), expected: null},
-        { message: "Same direction - This line entirely covers the other line", a: new Line3D(new Vec3(0, 0, 0), new Vec3(10, 0, 0)), b: new Line3D(new Vec3(1, 0, 0), new Vec3(9, 0, 0)), expected: new Line3D(new Vec3(0, 0, 0), new Vec3(10, 0, 0)) },
-        { message: "Same direction - The other line entirely covers this line", a: new Line3D(new Vec3(1, 0, 0), new Vec3(9, 0, 0)), b: new Line3D(new Vec3(0, 0, 0), new Vec3(10, 0, 0)), expected: new Line3D(new Vec3(0, 0, 0), new Vec3(10, 0, 0)) },
-        { message: "Same direction - This line is overlapped by the start of the other line", a: new Line3D(new Vec3(0, 0, 0), new Vec3(10, 0, 0)), b: new Line3D(new Vec3(5, 0, 0), new Vec3(15, 0, 0)), expected: new Line3D(new Vec3(0, 0, 0), new Vec3(15, 0, 0)) },
-        { message: "Same direction - This line is overlapped by the end of the other line", a: new Line3D(new Vec3(0, 0, 0), new Vec3(10, 0, 0)), b: new Line3D(new Vec3(-5, 0, 0), new Vec3(5, 0, 0)), expected: new Line3D(new Vec3(-5, 0, 0), new Vec3(10, 0, 0)) },
-
-        { message: "Opposite direction - Lines aren't parallel", a: new Line3D(new Vec3(0, 0, 0), new Vec3(10, 0, 0)), b: new Line3D(new Vec3(20, 0, 0), new Vec3(10, 0, 1)), expected: null },
-        { message: "Opposite direction - Lines don't overlap", a: new Line3D(new Vec3(0, 0, 0), new Vec3(5, 0, 0)), b: new Line3D(new Vec3(12, 0, 0), new Vec3(11, 0, 0)), expected: null },
-        { message: "Opposite direction - This line entirely covers the other line", a: new Line3D(new Vec3(0, 0, 0), new Vec3(10, 0, 0)), b: new Line3D(new Vec3(9, 0, 0), new Vec3(1, 0, 0)), expected: new Line3D(new Vec3(0, 0, 0), new Vec3(10, 0, 0)) },
-        { message: "Opposite direction - The other line entirely covers this line", a: new Line3D(new Vec3(1, 0, 0), new Vec3(9, 0, 0)), b: new Line3D(new Vec3(10, 0, 0), new Vec3(0, 0, 0)), expected: new Line3D(new Vec3(0, 0, 0), new Vec3(10, 0, 0)) },
-        { message: "Opposite direction - This line is overlapped by the start of the other line", a: new Line3D(new Vec3(0, 0, 0), new Vec3(10, 0, 0)), b: new Line3D(new Vec3(15, 0, 0), new Vec3(5, 0, 0)), expected: new Line3D(new Vec3(0, 0, 0), new Vec3(15, 0, 0)) },
-        { message: "Opposite direction - This line is overlapped by the end of the other line", a: new Line3D(new Vec3(0, 0, 0), new Vec3(10, 0, 0)), b: new Line3D(new Vec3(5, 0, 0), new Vec3(-5, 0, 0)), expected: new Line3D(new Vec3(-5, 0, 0), new Vec3(10, 0, 0)) },
-
-        { message: "Angle - Lines aren't parallel", a: new Line3D(new Vec3(0, 0, 0), new Vec3(10, 9, 0)), b: new Line3D(new Vec3(5, 5, 0), new Vec3(15, 15, 0)), expected: null },
-        { message: "Angle - This line is overlapped by the start of the other line", a: new Line3D(new Vec3(0, 0, 0), new Vec3(10, 10, 0)), b: new Line3D(new Vec3(5, 5, 0), new Vec3(15, 15, 0)), expected: new Line3D(new Vec3(0, 0, 0), new Vec3(15, 15, 0)) },
-    ])("joint", ({message, a, b, expected }) => {
-        const result = a.joinLine(b);
-        test(`${message} - expected ${JSON.stringify(expected)}, received: ${JSON.stringify(result)}`, () => {
-            expect(result).toEqual(expected);
-        });
-    });
-});

package/src/__tests__/Line3D.joinLines.spec.ts

@@ -1,72 +0,0 @@
-import { Line3D } from "../Line3D";
-import { Vec3 } from "../Vec3";
-
-describe("Line3d.jointLines", () => {
-    describe.each([
-        {
-            message: "Single line",
-            source: [
-                new Line3D(new Vec3(0, 0, 0), new Vec3(10, 0, 0)),
-            ], expected: [
-                new Line3D(new Vec3(0, 0, 0), new Vec3(10, 0, 0)),
-            ]
-        },
-        {
-            message: "2 lines with gap",
-            source: [
-                new Line3D(new Vec3(0, 0, 0), new Vec3(10, 0, 0)),
-                new Line3D(new Vec3(11, 0, 0), new Vec3(20, 0, 0)),
-            ], expected: [
-                new Line3D(new Vec3(0, 0, 0), new Vec3(10, 0, 0)),
-                new Line3D(new Vec3(11, 0, 0), new Vec3(20, 0, 0)),
-            ]
-        },
-        {
-            message: "Three lines touching",
-            source: [
-                new Line3D(new Vec3(0, 0, 0), new Vec3(10, 0, 0)),
-                new Line3D(new Vec3(10, 0, 0), new Vec3(20, 0, 0)),
-                new Line3D(new Vec3(20, 0, 0), new Vec3(30, 0, 0)),
-            ], expected: [
-                new Line3D(new Vec3(0, 0, 0), new Vec3(30, 0, 0)),
-            ]
-        },
-        {
-            message: "Three lines touching, not ordered",
-            source: [
-                new Line3D(new Vec3(10, 0, 0), new Vec3(20, 0, 0)),
-                new Line3D(new Vec3(0, 0, 0), new Vec3(10, 0, 0)),
-                new Line3D(new Vec3(20, 0, 0), new Vec3(30, 0, 0)),
-            ], expected: [
-                new Line3D(new Vec3(0, 0, 0), new Vec3(30, 0, 0)),
-            ]
-        },
-        {
-            message: "Sources is composed of complex overlapping, covering and duplicated lines",
-            source: [
-                new Line3D(new Vec3(10, 0, 0), new Vec3(20, 0, 0)), // Group 1
-                new Line3D(new Vec3(0, 0, 0), new Vec3(10, 0, 0)),
-                new Line3D(new Vec3(20, 0, 0), new Vec3(30, 0, 0)),
-                new Line3D(new Vec3(10, 0, 0), new Vec3(20, 0, 0)),
-                new Line3D(new Vec3(-5, 0, 0), new Vec3(10, 0, 0)),
-                new Line3D(new Vec3(29, 0, 0), new Vec3(35, 0, 0)),
-
-                new Line3D(new Vec3(100 + 10, 0, 0), new Vec3(100 + 20, 0, 0)), // Group 2 - same axes but shifted by x: 100
-                new Line3D(new Vec3(100, 0, 0), new Vec3(100 + 10, 0, 0)),
-                new Line3D(new Vec3(100 + 20, 0, 0), new Vec3(100 + 30, 0, 0)),
-                new Line3D(new Vec3(100 + 10, 0, 0), new Vec3(100 + 20, 0, 0)),
-                new Line3D(new Vec3(100 + -5, 0, 0), new Vec3(100 + 10, 0, 0)),
-                new Line3D(new Vec3(100 + 29, 0, 0), new Vec3(100 + 35, 0, 0)),
-            ], expected: [
-                new Line3D(new Vec3(-5, 0, 0), new Vec3(35, 0, 0)),
-                new Line3D(new Vec3(100 + -5, 0, 0), new Vec3(100 + 35, 0, 0)),
-            ]
-        },
-    ])("jointLines", ({ message, source, expected }) => {
-        const result = Line3D.joinLines(source);
-        result.sort((a, b) => a.start.x - b.start.x); // Order of the result is not guaranteed
-        test(`${message} - expected ${JSON.stringify(expected)}, received: ${JSON.stringify(result)}`, () => {
-            expect(result).toEqual(expected);
-        });
-    });
-});

package/src/__tests__/Line3D.spec.ts

@@ -1,350 +0,0 @@
-import { Line3D } from "../Line3D";
-import { Vec3 } from "../Vec3";
-
-const defaultLine = () => new Line3D(new Vec3(-10, 0, 0), new Vec3(10, 0, 0));
-
-describe("Line3d", () => {
-    it("should create a line with expected values", () => {
-        const line = new Line3D(new Vec3(1, 2, 3), new Vec3(4, 5, 6));
-        expect(line.start).toEqual(new Vec3(1, 2, 3));
-        expect(line.end).toEqual(new Vec3(4, 5, 6));
-    });
-
-    it("should create a single line polygon from a 2 points polygon", () => {
-        const start = new Vec3(1, 2, 20);
-        const end = new Vec3(3, 4, 20);
-        const lines = Line3D.fromPolygon([start, end]);
-        expect(lines.length).toEqual(1);
-        expect(lines[0]).toEqual(new Line3D(start, end));
-    });
-
-    it("should create a 2 lines polygon from a 3 points polygon", () => {
-        const p1 = new Vec3(1, 2, 20);
-        const p2 = new Vec3(3, 4, 20);
-        const p3 = new Vec3(5, 2, 20);
-        const lines = Line3D.fromPolygon([p1, p2, p3]);
-        expect(lines.length).toEqual(2);
-        expect(lines[0]).toEqual(new Line3D(p1, p2));
-        expect(lines[1]).toEqual(new Line3D(p2, p3));
-    });
-
-    it("should create a closed 3 lines polygon from a 3 points polygon", () => {
-        const p1 = new Vec3(1, 2, 20);
-        const p2 = new Vec3(3, 4, 20);
-        const p3 = new Vec3(5, 2, 20);
-        const lines = Line3D.fromPolygon([p1, p2, p3], true);
-        expect(lines.length).toEqual(3);
-        expect(lines[0]).toEqual(new Line3D(p1, p2));
-        expect(lines[1]).toEqual(new Line3D(p2, p3));
-        expect(lines[2]).toEqual(new Line3D(p3, p1));
-    });
-
-    it("should return the expected center", () => {
-        const line = defaultLine();
-        expect(line.center).toEqual(new Vec3(0, 0, 0));
-    });
-
-    it("should resize should resize the line by the given length", () => {
-        const line = defaultLine();
-        const originalCenter = line.center;
-        expect(line.length).toEqual(20);
-
-        const resizeDistance = 2;
-        line.resize(resizeDistance);
-
-        expect(line.length).toEqual(22);
-        expect(line.center).toEqual(originalCenter);
-        expect(line.start.x).toEqual(-11);
-        expect(line.end.x).toEqual(11);
-    });
-
-    it("should setLength to required", () => {
-        const line = new Line3D(new Vec3(0, 0, 0), new Vec3(10, 0, 0));
-        const originalCenter = line.center;
-        expect(line.length).toEqual(10);
-
-        const newSize = 2;
-        line.setLength(newSize);
-
-        expect(line.length).toEqual(newSize);
-        expect(line.center).toEqual(originalCenter);
-        expect(line.start.x).toEqual(4);
-        expect(line.end.x).toEqual(6);
-    });
-
-    it("should project the line on another", () => {
-        // Arrange
-        const other = new Line3D(new Vec3(0, 0, 0), new Vec3(10, 0, 0));
-        const line = new Line3D(new Vec3(-1, 1, 0), new Vec3(10, 1, 0));
-
-        // Act
-        const projected = line.projectOn(other, false);
-
-        // Assert
-        expect(projected.start).toEqual(new Vec3(-1, 0, 0));
-        expect(projected.end).toEqual(new Vec3(10, 0, 0));
-    });
-
-    it("should project and clamp the line on another", () => {
-        // Arrange
-        const other = new Line3D(new Vec3(0, 0, 0), new Vec3(10, 0, 0));
-        const line = new Line3D(new Vec3(-1, 1, 0), new Vec3(10, 1, 0));
-
-        // Act
-        const projected = line.projectOn(other, true);
-
-        // Assert
-        expect(projected.start).toEqual(new Vec3(0, 0, 0));
-        expect(projected.end).toEqual(new Vec3(10, 0, 0));
-    });
-
-    it("should contain point", () => {
-        // Arrange
-        const line = new Line3D(new Vec3(0, 0, 0), new Vec3(10, 0, 0));
-
-        // Act
-        const contains = line.containsPoint(new Vec3(5, 0, 0));
-
-        // Assert
-        expect(contains).toBeTruthy();
-    });
-
-    it("should not contain point", () => {
-        // Arrange
-        const line = new Line3D(new Vec3(0, 0, 0), new Vec3(10, 0, 0));
-
-        // Act
-        const contains = line.containsPoint(new Vec3(5, 1, 0));
-
-        // Assert
-        expect(contains).toBeFalsy();
-    });
-
-    it.each([
-        ["lines are the same", new Line3D(new Vec3(0, 0, 0), new Vec3(10, 0, 0)), new Line3D(new Vec3(0, 0, 0), new Vec3(10, 0, 0)), true],
-        ["overlap from right", new Line3D(new Vec3(0, 0, 0), new Vec3(10, 0, 0)), new Line3D(new Vec3(5, 0, 0), new Vec3(11, 0, 0)), true],
-        ["overlap from left", new Line3D(new Vec3(0, 0, 0), new Vec3(10, 0, 0)), new Line3D(new Vec3(-5, 0, 0), new Vec3(5, 0, 0)), true],
-        ["second inside the first", new Line3D(new Vec3(0, 0, 0), new Vec3(10, 0, 0)), new Line3D(new Vec3(5, 0, 0), new Vec3(6, 0, 0)), true],
-        ["fist inside the second", new Line3D(new Vec3(5, 0, 0), new Vec3(6, 0, 0)), new Line3D(new Vec3(0, 0, 0), new Vec3(10, 0, 0)), true],
-        ["no overlap", new Line3D(new Vec3(0, 0, 0), new Vec3(10, 0, 0)), new Line3D(new Vec3(11, 0, 0), new Vec3(12, 0, 0)), false],
-        ["no overlap, but touching ends", new Line3D(new Vec3(0, 0, 0), new Vec3(10, 0, 0)), new Line3D(new Vec3(10, 0, 0), new Vec3(12, 0, 0)), false],
-        ["not parallel", new Line3D(new Vec3(0, 0, 0), new Vec3(10, 0, 0)), new Line3D(new Vec3(5, 0, 0), new Vec3(10, 1, 0)), false],
-    ])("should detect overlap of two lines - %s", (reason, line1, line2, expected) => {
-        // Act
-        const result = line1.overlaps(line2);
-
-        // Assert
-        expect(result).toEqual(expected);
-    });
-
-    it("should trim the line and return two offcuts, clip well within source", () => {
-        // Arrange
-        const source = new Line3D(new Vec3(0, 0, 0), new Vec3(10, 0, 0));
-        const clip = new Line3D(new Vec3(3, 0, 0), new Vec3(7, 0, 0));
-
-        // Act
-        const result = source.clipLine(clip);
-        const groupResult = source.clipLines([clip]);
-
-        // Assert
-        expect(result.length).toEqual(2);
-
-        expect(result[0].start).toEqual(new Vec3(0, 0, 0));
-        expect(result[0].end).toEqual(new Vec3(3, 0, 0));
-
-        expect(result[1].start).toEqual(new Vec3(7, 0, 0));
-        expect(result[1].end).toEqual(new Vec3(10, 0, 0));
-
-        expect(groupResult.sort((a, b) => a.start.x - b.start.x)).toEqual(result.sort((a, b) => a.start.x - b.start.x));
-    });
-
-    it("should trim the lines even if the clips are overlapping and return two offcuts", () => {
-        // Arrange
-        const source = new Line3D(new Vec3(0, 0, 0), new Vec3(10, 0, 0));
-        const clips = [
-            new Line3D(new Vec3(-3, 0, 0), new Vec3(2, 0, 0)),
-            new Line3D(new Vec3(3, 0, 0), new Vec3(6, 0, 0)),
-            new Line3D(new Vec3(4, 0, 0), new Vec3(7, 0, 0)),
-        ];
-
-        // Act
-        const result = source.clipLines(clips);
-
-        // Assert
-        result.sort((a, b) => a.start.x - b.start.x); // Order from the clipping is not guaranteed
-        expect(result).toEqual([
-            new Line3D(new Vec3(2, 0, 0), new Vec3(3, 0, 0)),
-            new Line3D(new Vec3(7, 0, 0), new Vec3(10, 0, 0)),
-        ]);
-    });
-
-    it.each([
-        { tolerance: 0 },
-        { tolerance: 1 },
-    ])("should trim the line and return two offcuts even if the source and trim run in opposite direction and are not perfectly parallel when sufficient tolerance is provided", ({ tolerance }) => {
-        // Arrange
-        const source = new Line3D(new Vec3(
-            1907.0952296605503,
-            0,
-            5258.129694575135
-        ), new Vec3(
-            1907.0952296605506,
-            0,
-            4302.1493774205865
-        ));
-        const clip = new Line3D(new Vec3(
-            1907.0952296605503,
-            0,
-            4762.083899346474
-        ), new Vec3(
-            1907.0952296605503,
-            0,
-            4954.083899346474
-        ));
-
-        // Act
-        const result = source.clipLine(clip, tolerance);
-
-        // Assert
-        if (tolerance === 0) {
-            expect(result).toEqual([source]);
-        } else {
-            expect(result).toEqual([
-                new Line3D(new Vec3(1907.0952296605503, 0, 5258.129694575135), new Vec3(1907.0952296605503, 0, 4954.083899346474)),
-                new Line3D(new Vec3(1907.0952296605503, 0, 4762.083899346474), new Vec3(1907.0952296605506, 0, 4302.1493774205865)),
-            ]);
-        }
-    });
-
-
-    it("should trim the line and return right side offcuts, clip is completely contained in source", () => {
-        // Arrange
-        const source = new Line3D(new Vec3(0, 0, 0), new Vec3(10, 0, 0));
-        const clip = new Line3D(new Vec3(0, 0, 0), new Vec3(7, 0, 0));
-
-        // Act
-        const result = source.clipLine(clip);
-        const groupResult = source.clipLines([clip]);
-
-        // Assert
-        expect(result.length).toEqual(1);
-        expect(result[0].start).toEqual(new Vec3(7, 0, 0));
-        expect(result[0].end).toEqual(new Vec3(10, 0, 0));
-        expect(result).toEqual(groupResult);
-    });
-
-    it("should trim the line and return right side offcuts, clip overlapping from left", () => {
-        // Arrange
-        const source = new Line3D(new Vec3(0, 0, 0), new Vec3(10, 0, 0));
-        const clip = new Line3D(new Vec3(-1, 0, 0), new Vec3(7, 0, 0));
-
-        // Act
-        const result = source.clipLine(clip);
-        const groupResult = source.clipLines([clip]);
-
-        // Assert
-        expect(result.length).toEqual(1);
-        expect(result[0].start).toEqual(new Vec3(7, 0, 0));
-        expect(result[0].end).toEqual(new Vec3(10, 0, 0));
-        expect(result).toEqual(groupResult);
-    });
-
-    it("should trim the line and return left side off-cut, clip is completely contained in source", () => {
-        // Arrange
-        const source = new Line3D(new Vec3(0, 0, 0), new Vec3(10, 0, 0));
-        const clip = new Line3D(new Vec3(5, 0, 0), new Vec3(10, 0, 0));
-
-        // Act
-        const result = source.clipLine(clip);
-        const groupResult = source.clipLines([clip]);
-
-        // Assert
-        expect(result.length).toEqual(1);
-        expect(result[0].start).toEqual(new Vec3(0, 0, 0));
-        expect(result[0].end).toEqual(new Vec3(5, 0, 0));
-        expect(result).toEqual(groupResult);
-    });
-
-    it("should trim the line and return left side off-cut, clip overlapping from right", () => {
-        // Arrange
-        const source = new Line3D(new Vec3(0, 0, 0), new Vec3(10, 0, 0));
-        const clip = new Line3D(new Vec3(5, 0, 0), new Vec3(15, 0, 0));
-
-        // Act
-        const result = source.clipLine(clip);
-        const groupResult = source.clipLines([clip]);
-
-        // Assert
-        expect(result.length).toEqual(1);
-        expect(result[0].start).toEqual(new Vec3(0, 0, 0));
-        expect(result[0].end).toEqual(new Vec3(5, 0, 0));
-        expect(result).toEqual(groupResult);
-    });
-
-    it("should trim the line and return no off-cut as it matches the source entirely", () => {
-        // Arrange
-        const source = new Line3D(new Vec3(0, 0, 0), new Vec3(10, 0, 0));
-        const clip = new Line3D(new Vec3(0, 0, 0), new Vec3(10, 0, 0));
-
-        // Act
-        const result = source.clipLine(clip);
-        const groupResult = source.clipLines([clip]);
-
-        // Assert
-        expect(result.length).toEqual(0);
-        expect(result).toEqual(groupResult);
-    });
-
-    it("should trim the line and return no off-cut as it overlaps the source", () => {
-        // Arrange
-        const source = new Line3D(new Vec3(0, 0, 0), new Vec3(10, 0, 0));
-        const clip = new Line3D(new Vec3(-1, 0, 0), new Vec3(11, 0, 0));
-
-        // Act
-        const result = source.clipLine(clip);
-        const groupResult = source.clipLines([clip]);
-
-        // Assert
-        expect(result.length).toEqual(0);
-        expect(result).toEqual(groupResult);
-    });
-
-    it("should trim the line with opposite direction", () => {
-        // Arrange
-        const source = new Line3D(new Vec3(6, 0, 0), new Vec3(10, 0, 0));
-        const clip = new Line3D(new Vec3(7, 0, 0), new Vec3(4, 0, 0));
-
-        // Act
-        const result = source.clipLine(clip);
-        const groupResult = source.clipLines([clip]);
-
-        // Assert
-        expect(result).toEqual([new Line3D(new Vec3(7, 0, 0), new Vec3(10, 0, 0))]);
-        expect(result).toEqual(groupResult);
-    });
-
-    it.each([
-        // Arrange
-        { a: new Line3D(new Vec3(0, 0, 0), new Vec3(10, 0, 0)), b: new Line3D(new Vec3(0, 0, 0), new Vec3(10, 0, 0)), expected: true },
-        { a: new Line3D(new Vec3(10, 0, 0), new Vec3(0, 0, 0)), b: new Line3D(new Vec3(0, 0, 0), new Vec3(10, 0, 0)), expected: true },
-        { a: new Line3D(new Vec3(0, 0, 0), new Vec3(10, 1, 0)), b: new Line3D(new Vec3(0, 0, 0), new Vec3(10, 0, 0)), expected: false },
-    ])("should determine if the lines are parallel %j", ({ a, b, expected }) => {
-        // Act
-        const areParallel = a.isParallelTo(b);
-        // Assert
-        expect(areParallel).toBe(expected);
-    });
-
-    it("chunk should split the line in to multiple with expected length", () => {
-        const size = 10;
-        const line = new Line3D(new Vec3(0, 0, 0), new Vec3(88, 0, 0));
-        const chunks = line.chunk(size);
-        expect(chunks.length).toEqual(9);
-
-        expect(chunks[0].length).toEqual(size);
-        expect(chunks[0].start.equals(line.start)).toBe(true);
-
-        expect(chunks[chunks.length - 1].length).toEqual(8);
-        expect(chunks[chunks.length - 1].end.equals(line.end)).toBe(true);
-    });
-});

package/tsconfig-cjs.json

@@ -1,9 +0,0 @@
-{
-    "extends": "./tsconfig.json",
-    "compilerOptions": {
-        "module": "commonjs",
-        "outDir": "./cjs",
-        "declaration": false,
-        "declarationDir": null
-    }
-}

package/tsconfig.json

@@ -1,13 +0,0 @@
-{
-  "compilerOptions": {
-    "outDir": "./esm",
-    "declaration": true,
-    "declarationDir": "./types",
-    "importHelpers": true,
-    "target": "ESNext",
-    "module": "ESNext",
-    "moduleResolution": "node",
-    "lib": [ "esnext", "dom" ]
-  },
-  "exclude": ["src/**/*.test.ts", "src/**/*.spec.ts"]
-}