Fixed some errors, fixed publish script

Author: w8r

.github/workflows/publish.yml

@@ -1,3 +1,5 @@
+name: Publish to npm
+
 on:
   push:
     tags:
@@ -6,15 +8,21 @@ on:
 jobs:
   publish:
     runs-on: ubuntu-latest
+    permissions:
+      contents: read
+      id-token: write
 
     steps:
-      - uses: actions/checkout@v1
-      - uses: actions/setup-node@v1
+      - uses: actions/checkout@v4
+      - uses: actions/setup-node@v4
         with:
           node-version: 20
+          registry-url: 'https://registry.npmjs.org'
       - run: npm ci
+      - run: npm run lint
+      - run: npm run typecheck
+      - run: npm run test:run
       - run: npm run build
-      - run: npm test
-      - uses: JS-DevTools/npm-publish@v1
-        with:
-          token: ${{ secrets.NPM_TOKEN }}
+      - run: npm publish --provenance --access public
+        env:
+          NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}

src/debug_utils.ts

@@ -9,42 +9,46 @@ export function renderPoints(possiblePoints: any[], prop: string): void {
   possiblePoints.forEach(function (e) {
     var point = L.circleMarker([e.point[1], e.point[0]], {
       radius: Math.floor(5 + Math.random() * 10),
-      color:  e[prop] ? 'green' : 'gray',
+      color: e[prop] ? "green" : "gray",
       opacity: e[prop] ? 0.5 : 0.1,
-      weight: 1
+      weight: 1,
     }).addTo(points);
   });
-};
+}
 
 export function renderSweepLine(sweepLine: any[], pos: any, event: any): void {
   var map = window.map;
   if (!map) return;
-  if (window.sws) window.sws.forEach(function (p) {
-    map.removeLayer(p);
-  });
+  if (window.sws)
+    window.sws.forEach(function (p) {
+      map.removeLayer(p);
+    });
   window.sws = [];
   sweepLine.forEach(function (e) {
-    var poly = L.polyline([
-      e.key.point.slice().reverse(),
-      e.key.otherEvent.point.slice().reverse()
-    ], {color: 'green'}).addTo(map);
+    var poly = L.polyline(
+      [e.key.point.slice().reverse(), e.key.otherEvent.point.slice().reverse()],
+      { color: "green" }
+    ).addTo(map);
     window.sws.push(poly);
   });
 
   if (window.vt) map.removeLayer(window.vt);
   var v = pos.slice();
   var b = map.getBounds();
-  window.vt = L.polyline([
-    [b.getNorth(), v[0]],
-    [b.getSouth(), v[0]]
-  ], {color: 'green', weight: 1}).addTo(map);
+  window.vt = L.polyline(
+    [
+      [b.getNorth(), v[0]],
+      [b.getSouth(), v[0]],
+    ],
+    { color: "green", weight: 1 }
+  ).addTo(map);
 
   if (window.ps) map.removeLayer(window.ps);
-  window.ps = L.polyline([
-    event.point.slice().reverse(),
-    event.otherEvent.point.slice().reverse()
-  ], {color: 'black', weight: 9, opacity: 0.4}).addTo(map);
+  window.ps = L.polyline(
+    [event.point.slice().reverse(), event.otherEvent.point.slice().reverse()],
+    { color: "black", weight: 9, opacity: 0.4 }
+  ).addTo(map);
   debugger;
-};
+}
 
 /* eslint-enable */

test/compare_events.test.ts

@@ -2,12 +2,13 @@ import { describe, it, expect } from "vitest";
 import Queue from "tinyqueue";
 import sweepEventsComp from "../src/compare_events";
 import SweepEvent from "../src/sweep_event";
+import { S } from "vitest/dist/reporters-w_64AS5f.js";
 
 describe("queue", () => {
   it("should process least(by x) sweep event first", () => {
     const queue = new Queue(undefined, sweepEventsComp);
-    const e1 = { point: [0.0, 0.0] };
-    const e2 = { point: [0.5, 0.5] };
+    const e1 = { point: [0.0, 0.0] } as SweepEvent;
+    const e2 = { point: [0.5, 0.5] } as SweepEvent;
 
     queue.push(e1);
     queue.push(e2);
@@ -18,8 +19,8 @@ describe("queue", () => {
 
   it("should process least(by y) sweep event first", () => {
     const queue = new Queue(undefined, sweepEventsComp);
-    const e1 = { point: [0.0, 0.0] };
-    const e2 = { point: [0.0, 0.5] };
+    const e1 = { point: [0.0, 0.0] } as SweepEvent;
+    const e2 = { point: [0.0, 0.5] } as SweepEvent;
 
     queue.push(e1);
     queue.push(e2);
@@ -30,8 +31,8 @@ describe("queue", () => {
 
   it("should pop least(by left prop) sweep event first", () => {
     const queue = new Queue(undefined, sweepEventsComp);
-    const e1 = { point: [0.0, 0.0], left: true };
-    const e2 = { point: [0.0, 0.0], left: false };
+    const e1 = { point: [0.0, 0.0], left: true } as SweepEvent;
+    const e2 = { point: [0.0, 0.0], left: false } as SweepEvent;
 
     queue.push(e1);
     queue.push(e2);
@@ -43,8 +44,8 @@ describe("queue", () => {
 
 describe("sweep event comparison x coordinates", () => {
   it("should compare x coordinates correctly", () => {
-    const e1 = { point: [0.0, 0.0] };
-    const e2 = { point: [0.5, 0.5] };
+    const e1 = { point: [0.0, 0.0] } as SweepEvent;
+    const e2 = { point: [0.5, 0.5] } as SweepEvent;
 
     expect(sweepEventsComp(e1, e2)).toBe(-1);
     expect(sweepEventsComp(e2, e1)).toBe(1);
@@ -53,8 +54,8 @@ describe("sweep event comparison x coordinates", () => {
 
 describe("sweep event comparison y coordinates", () => {
   it("should compare y coordinates correctly", () => {
-    const e1 = { point: [0.0, 0.0] };
-    const e2 = { point: [0.0, 0.5] };
+    const e1 = { point: [0.0, 0.0] } as SweepEvent;
+    const e2 = { point: [0.0, 0.5] } as SweepEvent;
 
     expect(sweepEventsComp(e1, e2)).toBe(-1);
     expect(sweepEventsComp(e2, e1)).toBe(1);
@@ -63,8 +64,8 @@ describe("sweep event comparison y coordinates", () => {
 
 describe("sweep event comparison not left first", () => {
   it("should process not left events first", () => {
-    const e1 = { point: [0.0, 0.0], left: true };
-    const e2 = { point: [0.0, 0.0], left: false };
+    const e1 = { point: [0.0, 0.0], left: true } as SweepEvent;
+    const e2 = { point: [0.0, 0.0], left: false } as SweepEvent;
 
     expect(sweepEventsComp(e1, e2)).toBe(1);
     expect(sweepEventsComp(e2, e1)).toBe(-1);

test/compare_segments.test.ts

@@ -1,17 +1,15 @@
-
-import { describe, it, expect } from 'vitest';
-import Tree            from 'splaytree';
-import compareSegments from '../src/compare_segments';
-import compareEvents   from '../src/compare_events';
-import SweepEvent      from '../src/sweep_event';
-
-describe('compare segments', () => {
-
-  describe('not collinear', () => {
-
-    it('should order by shared left point - right point first', () => {
+import { describe, it, expect } from "vitest";
+import Tree from "splaytree";
+import compareSegments from "../src/compare_segments";
+import compareEvents from "../src/compare_events";
+import SweepEvent from "../src/sweep_event";
+import { Position } from "../src/types";
+
+describe("compare segments", () => {
+  describe("not collinear", () => {
+    it("should order by shared left point - right point first", () => {
       const tree = new Tree(compareSegments);
-      const pt = [0.0, 0.0];
+      const pt: Position = [0.0, 0.0];
       const se1 = new SweepEvent(pt, true, new SweepEvent([1, 1], false));
       const se2 = new SweepEvent(pt, true, new SweepEvent([2, 3], false));
 
@@ -22,7 +20,7 @@ describe('compare segments', () => {
       expect(tree.minNode().key.otherEvent.point).toEqual([1, 1]);
     });
 
-    it('should sort by different left point - right point y coord', () => {
+    it("should sort by different left point - right point y coord", () => {
       const tree = new Tree(compareSegments);
       const se1 = new SweepEvent([0, 1], true, new SweepEvent([1, 1], false));
       const se2 = new SweepEvent([0, 2], true, new SweepEvent([2, 3], false));
@@ -34,8 +32,8 @@ describe('compare segments', () => {
       expect(tree.maxNode().key.otherEvent.point).toEqual([2, 3]);
     });
 
-    it('should maintain events order in sweep line', () => {
-      const se1 = new SweepEvent([0, 1],  true, new SweepEvent([2, 1], false));
+    it("should maintain events order in sweep line", () => {
+      const se1 = new SweepEvent([0, 1], true, new SweepEvent([2, 1], false));
       const se2 = new SweepEvent([-1, 0], true, new SweepEvent([2, 3], false));
 
       const se3 = new SweepEvent([0, 1], true, new SweepEvent([3, 4], false));
@@ -52,25 +50,35 @@ describe('compare segments', () => {
       expect(se4.isAbove(se3.point)).toBeFalsy();
     });
 
-    it('should handle when first point is below', () => {
-      const se2 = new SweepEvent([0, 1],  true, new SweepEvent([2, 1], false));
+    it("should handle when first point is below", () => {
+      const se2 = new SweepEvent([0, 1], true, new SweepEvent([2, 1], false));
       const se1 = new SweepEvent([-1, 0], true, new SweepEvent([2, 3], false));
 
       expect(se1.isBelow(se2.point)).toBeFalsy();
       expect(compareSegments(se1, se2)).toBe(1);
     });
   });
 
-  it('should handle collinear segments', () => {
-    const se1 = new SweepEvent([1, 1], true, new SweepEvent([5, 1], false), true);
-    const se2 = new SweepEvent([2, 1], true, new SweepEvent([3, 1], false), false);
+  it("should handle collinear segments", () => {
+    const se1 = new SweepEvent(
+      [1, 1],
+      true,
+      new SweepEvent([5, 1], false),
+      true
+    );
+    const se2 = new SweepEvent(
+      [2, 1],
+      true,
+      new SweepEvent([3, 1], false),
+      false
+    );
 
     expect(se1.isSubject).not.toBe(se2.isSubject);
     expect(compareSegments(se1, se2)).toBe(-1);
   });
 
-  it('should handle collinear shared left point', () => {
-    const pt = [0, 1];
+  it("should handle collinear shared left point", () => {
+    const pt = [0, 1] as Position;
 
     const se1 = new SweepEvent(pt, true, new SweepEvent([5, 1], false), false);
     const se2 = new SweepEvent(pt, true, new SweepEvent([3, 1], false), false);
@@ -89,13 +97,23 @@ describe('compare segments', () => {
     expect(compareSegments(se1, se2)).toBe(1);
   });
 
-  it('should handle collinear same polygon different left points', () => {
-    const se1 = new SweepEvent([1, 1], true, new SweepEvent([5, 1], false), true);
-    const se2 = new SweepEvent([2, 1], true, new SweepEvent([3, 1], false), true);
+  it("should handle collinear same polygon different left points", () => {
+    const se1 = new SweepEvent(
+      [1, 1],
+      true,
+      new SweepEvent([5, 1], false),
+      true
+    );
+    const se2 = new SweepEvent(
+      [2, 1],
+      true,
+      new SweepEvent([3, 1], false),
+      true
+    );
 
     expect(se1.isSubject).toBe(se2.isSubject);
     expect(se1.point).not.toBe(se2.point);
     expect(compareSegments(se1, se2)).toBe(-1);
     expect(compareSegments(se2, se1)).toBe(1);
   });
-});
+});

test/divide_segment.test.ts

@@ -13,6 +13,7 @@ import possibleIntersection from "../src/possible_intersection";
 import Tree from "splaytree";
 import compareSegments from "../src/compare_segments";
 import { INTERSECTION } from "../src/operation";
+import { Position } from "../src/types";
 
 // GeoJSON Data
 const shapes = JSON.parse(
@@ -106,9 +107,9 @@ describe("divide segments", () => {
       -Infinity,
     ];
     const q = fillQueue(s, c, bbox, bbox, INTERSECTION);
-    const p0 = [16, 282];
-    const p1 = [298, 359];
-    const p2 = [156, 203.5];
+    const p0 = [16, 282] as Position;
+    const p1 = [298, 359] as Position;
+    const p2 = [156, 203.5] as Position;
 
     const te = new SweepEvent(p0, true, null, true);
     const te2 = new SweepEvent(p1, false, te, false);