@immugio/three-math-extensions 0.0.4 → 0.0.6

package/.github/workflows/build.yml

@@ -1,28 +0,0 @@
-name: Build
-
-on:
-  push:
-    branches: [ master ]
-  pull_request:
-    branches: [ master ]
-
-jobs:
-  build:
-
-    runs-on: ubuntu-latest
-
-    strategy:
-      matrix:
-        node-version: [16.x]
-
-    steps:
-      - uses: actions/checkout@v3
-
-      - name: Use Node.js ${{ matrix.node-version }}
-        uses: actions/setup-node@v3
-
-        with:
-          node-version: ${{ matrix.node-version }}
-      - run: npm ci
-      - run: npm run build --if-present
-      - run: npm test

package/.github/workflows/publish.yml

@@ -1,51 +0,0 @@
-name: Publish to NPM
-
-on:
-  push:
-    tags:
-      - '[0-9]+.[0-9]+.[0-9]+'
-jobs:
-  build:
-    runs-on: ubuntu-latest
-
-    strategy:
-      matrix:
-        node-version: [16.x]
-
-    steps:
-      - uses: actions/checkout@v2
-      - name: Use Node.js ${{ matrix.node-version }}
-        uses: actions/setup-node@v1
-        with:
-          node-version: ${{ matrix.node-version }}
-      - uses: actions/cache@v2
-        with:
-          path: node_modules
-          key: ${{ runner.os }}-node-${{ hashFiles('**/package-lock.json') }}
-          restore-keys: |
-            ${{ runner.os }}-node-
-
-      - name: Install Dependencies
-        run: npm install
-
-      - name: Building
-        run: npm run build
-
-      - name: Publish to NPM
-        run: |
-          npm config set //registry.npmjs.org/:_authToken=$NODE_AUTH_TOKEN
-          npm publish
-        env:
-          NODE_AUTH_TOKEN: ${{ secrets.NPM_AUTH_TOKEN }}
-      - name: Package lib
-        run: npm pack
-
-      - name: Release
-        uses: docker://antonyurchenko/git-release:v3
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-          ALLOW_EMPTY_CHANGELOG: "false"
-          ALLOW_TAG_PREFIX: "true"
-        with:
-          args: |
-            three-math-extensions-*.tgz

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);
-        });
-    });
-});