@pooder/kit 4.3.1 → 5.0.1

package/src/wrappedOffsets.ts

@@ -0,0 +1,33 @@
+export function wrappedDistance(total: number, start: number, end: number): number {
+  if (!Number.isFinite(total) || total <= 0) return 0;
+  if (!Number.isFinite(start) || !Number.isFinite(end)) return 0;
+
+  const s = ((start % total) + total) % total;
+  const e = ((end % total) + total) % total;
+  return e >= s ? e - s : total - s + e;
+}
+
+export function sampleWrappedOffsets(
+  total: number,
+  start: number,
+  end: number,
+  count: number,
+): number[] {
+  if (!Number.isFinite(total) || total <= 0) return [];
+  if (!Number.isFinite(start) || !Number.isFinite(end)) return [];
+
+  const n = Math.max(0, Math.floor(count));
+  if (n <= 0) return [];
+
+  const dist = wrappedDistance(total, start, end);
+  if (n === 1) return [((start % total) + total) % total];
+
+  const step = dist / (n - 1);
+  const offsets: number[] = [];
+  for (let i = 0; i < n; i++) {
+    const raw = start + step * i;
+    const wrapped = ((raw % total) + total) % total;
+    offsets.push(wrapped);
+  }
+  return offsets;
+}

package/tests/run.ts

@@ -0,0 +1,118 @@
+import { pickExitIndex, scoreOutsideAbove } from "../src/bridgeSelection";
+import { sampleWrappedOffsets, wrappedDistance } from "../src/wrappedOffsets";
+import {
+  circularMorphology,
+  createMask,
+  fillHoles,
+  findMinimalConnectRadius,
+  isMaskConnected8,
+} from "../src/maskOps";
+import { computeDetectEdgeSize } from "../src/edgeScale";
+
+function assert(condition: unknown, message: string) {
+  if (!condition) throw new Error(message);
+}
+
+function testWrappedOffsets() {
+  assert(wrappedDistance(100, 10, 30) === 20, "distance 10->30 should be 20");
+  assert(wrappedDistance(100, 90, 10) === 20, "distance 90->10 should wrap to 20");
+
+  const a = sampleWrappedOffsets(100, 10, 30, 5);
+  assert(
+    JSON.stringify(a) === JSON.stringify([10, 15, 20, 25, 30]),
+    `unexpected sample: ${JSON.stringify(a)}`,
+  );
+
+  const b = sampleWrappedOffsets(100, 90, 10, 3);
+  assert(
+    JSON.stringify(b) === JSON.stringify([90, 0, 10]),
+    `unexpected wrap sample: ${JSON.stringify(b)}`,
+  );
+}
+
+function testBridgeSelection() {
+  const idx = pickExitIndex([
+    { insideAbove: true, insideBelow: true },
+    { insideAbove: false, insideBelow: true },
+    { insideAbove: false, insideBelow: false },
+  ]);
+  assert(idx === 1, `expected exit index 1, got ${idx}`);
+
+  const none = pickExitIndex([{ insideAbove: true, insideBelow: true }]);
+  assert(none === -1, `expected -1, got ${none}`);
+
+  const score = scoreOutsideAbove([
+    { outsideAbove: true },
+    { outsideAbove: false },
+    { outsideAbove: true },
+  ]);
+  assert(score === 2, `expected score 2, got ${score}`);
+}
+
+function testMaskOps() {
+  const width = 50;
+  const height = 50;
+  const mask = new Uint8Array(width * height);
+  mask[10 * width + 10] = 1;
+  mask[10 * width + 20] = 1;
+
+  const r = findMinimalConnectRadius(mask, width, height, 20);
+  const closed = circularMorphology(mask, width, height, r, "closing");
+  assert(isMaskConnected8(closed, width, height), `closed mask should be connected (r=${r})`);
+  if (r > 0) {
+    const closedPrev = circularMorphology(mask, width, height, r - 1, "closing");
+    assert(
+      !isMaskConnected8(closedPrev, width, height),
+      `r should be minimal (r=${r})`,
+    );
+  }
+
+  const donut = new Uint8Array(9 * 9);
+  for (let y = 1; y <= 7; y++) {
+    for (let x = 1; x <= 7; x++) donut[y * 9 + x] = 1;
+  }
+  for (let y = 3; y <= 5; y++) {
+    for (let x = 3; x <= 5; x++) donut[y * 9 + x] = 0;
+  }
+  const filled = fillHoles(donut, 9, 9);
+  assert(filled[4 * 9 + 4] === 1, "hole should be filled");
+
+  const imgW = 2;
+  const imgH = 1;
+  const rgba = new Uint8ClampedArray([
+    255, 255, 255, 255, 10, 10, 10, 254,
+  ]);
+  const imageData = { width: imgW, height: imgH, data: rgba } as unknown as ImageData;
+  const paddedWidth = imgW + 4;
+  const paddedHeight = imgH + 4;
+  const created = createMask(imageData, {
+    threshold: 10,
+    padding: 2,
+    paddedWidth,
+    paddedHeight,
+    maskMode: "auto",
+    alphaOpaqueCutoff: 250,
+  });
+  assert(created[2 * paddedWidth + 2] === 0, "white pixel should be background");
+  assert(created[2 * paddedWidth + 3] === 1, "non-white pixel should be foreground");
+}
+
+function testEdgeScale() {
+  const currentMax = 100;
+  const baseBounds = { width: 50, height: 20 };
+  const expandedBounds = { width: 70, height: 40 };
+  const { width, height, scale } = computeDetectEdgeSize(currentMax, baseBounds, expandedBounds);
+  assert(scale === 2, `expected scale 2, got ${scale}`);
+  assert(width === 140, `expected width 140, got ${width}`);
+  assert(height === 80, `expected height 80, got ${height}`);
+}
+
+function main() {
+  testWrappedOffsets();
+  testBridgeSelection();
+  testMaskOps();
+  testEdgeScale();
+  console.log("ok");
+}
+
+main();

package/tsconfig.test.json

@@ -1,15 +1,15 @@
-{
-  "compilerOptions": {
-    "target": "ES2020",
-    "module": "CommonJS",
-    "lib": ["ES2020", "DOM"],
-    "moduleResolution": "Node",
-    "esModuleInterop": true,
-    "skipLibCheck": true,
-    "strict": true,
-    "outDir": ".test-dist",
-    "rootDir": "."
-  },
-  "include": ["tests/**/*.ts", "src/**/*.ts"]
-}
-
+{
+  "compilerOptions": {
+    "target": "ES2020",
+    "module": "CommonJS",
+    "lib": ["ES2020", "DOM"],
+    "moduleResolution": "Node",
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "strict": true,
+    "outDir": ".test-dist",
+    "rootDir": "."
+  },
+  "include": ["tests/**/*.ts", "src/**/*.ts"]
+}
+