@pooder/kit 5.4.0 → 6.0.1

package/tests/run.ts

@@ -1,118 +1,258 @@
-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();
+import {
+  pickExitIndex,
+  scoreOutsideAbove,
+} from "../src/extensions/bridgeSelection";
+import {
+  sampleWrappedOffsets,
+  wrappedDistance,
+} from "../src/extensions/wrappedOffsets";
+import {
+  circularMorphology,
+  createMask,
+  fillHoles,
+  findMinimalConnectRadius,
+  isMaskConnected8,
+} from "../src/extensions/maskOps";
+import { computeDetectEdgeSize } from "../src/extensions/edgeScale";
+import { evaluateVisibilityExpr } from "../src/services/visibility";
+
+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 testVisibilityDsl() {
+  const layers = new Map([
+    ["ruler-overlay", { exists: true, objectCount: 2 }],
+    ["feature-overlay", { exists: true, objectCount: 0 }],
+  ]);
+
+  const context = {
+    activeToolId: "pooder.kit.image",
+    isSessionActive: (toolId: string) => toolId === "pooder.kit.feature",
+    hasAnyActiveSession: () => true,
+    layers,
+  };
+
+  assert(
+    evaluateVisibilityExpr({ op: "const", value: true }, context) === true,
+    "const true failed",
+  );
+  assert(
+    evaluateVisibilityExpr({ op: "const", value: false }, context) === false,
+    "const false failed",
+  );
+  assert(
+    evaluateVisibilityExpr(
+      { op: "activeToolIn", ids: ["pooder.kit.image"] },
+      context,
+    ) === true,
+    "activeToolIn true failed",
+  );
+  assert(
+    evaluateVisibilityExpr(
+      { op: "activeToolIn", ids: ["pooder.kit.white-ink"] },
+      context,
+    ) === false,
+    "activeToolIn false failed",
+  );
+  assert(
+    evaluateVisibilityExpr(
+      { op: "sessionActive", toolId: "pooder.kit.feature" },
+      context,
+    ) === true,
+    "sessionActive true failed",
+  );
+  assert(
+    evaluateVisibilityExpr(
+      { op: "sessionActive", toolId: "pooder.kit.ruler" },
+      context,
+    ) === false,
+    "sessionActive false failed",
+  );
+  assert(
+    evaluateVisibilityExpr({ op: "anySessionActive" }, context) === true,
+    "anySessionActive true failed",
+  );
+  assert(
+    evaluateVisibilityExpr(
+      { op: "layerExists", layerId: "ruler-overlay" },
+      context,
+    ) === true,
+    "layerExists true failed",
+  );
+  assert(
+    evaluateVisibilityExpr(
+      { op: "layerExists", layerId: "missing-layer" },
+      context,
+    ) === false,
+    "layerExists false failed",
+  );
+
+  const comparisons: Array<{
+    cmp: ">" | ">=" | "==" | "<" | "<=";
+    value: number;
+    expected: boolean;
+  }> = [
+    { cmp: ">", value: 1, expected: true },
+    { cmp: ">=", value: 2, expected: true },
+    { cmp: "==", value: 2, expected: true },
+    { cmp: "<", value: 2, expected: false },
+    { cmp: "<=", value: 1, expected: false },
+  ];
+  comparisons.forEach((entry) => {
+    assert(
+      evaluateVisibilityExpr(
+        {
+          op: "layerObjectCount",
+          layerId: "ruler-overlay",
+          cmp: entry.cmp,
+          value: entry.value,
+        },
+        context,
+      ) === entry.expected,
+      `layerObjectCount ${entry.cmp} failed`,
+    );
+  });
+
+  assert(
+    evaluateVisibilityExpr(
+      {
+        op: "not",
+        expr: { op: "activeToolIn", ids: ["pooder.kit.white-ink"] },
+      },
+      context,
+    ) === true,
+    "not failed",
+  );
+  assert(
+    evaluateVisibilityExpr(
+      {
+        op: "all",
+        exprs: [
+          { op: "layerExists", layerId: "ruler-overlay" },
+          { op: "sessionActive", toolId: "pooder.kit.feature" },
+        ],
+      },
+      context,
+    ) === true,
+    "all failed",
+  );
+  assert(
+    evaluateVisibilityExpr(
+      {
+        op: "any",
+        exprs: [
+          { op: "layerExists", layerId: "missing-layer" },
+          { op: "activeToolIn", ids: ["pooder.kit.image"] },
+        ],
+      },
+      context,
+    ) === true,
+    "any failed",
+  );
+}
+
+function main() {
+  testWrappedOffsets();
+  testBridgeSelection();
+  testMaskOps();
+  testEdgeScale();
+  testVisibilityDsl();
+  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"]
+}
+

package/src/extensions/sceneVisibility.ts

@@ -1,64 +0,0 @@
-import { Service, ServiceContext, WORKBENCH_SERVICE } from "@pooder/core";
-import { CanvasService } from "../services";
-
-const CANVAS_SERVICE_ID = "CanvasService";
-const HIDDEN_DIELINE_TOOLS = new Set(["pooder.kit.image", "pooder.kit.white-ink"]);
-const HIDDEN_RULER_TOOLS = new Set(["pooder.kit.white-ink"]);
-
-export class SceneVisibilityService implements Service {
-  private context?: ServiceContext;
-  private activeToolId: string | null = null;
-  private canvasService?: CanvasService;
-
-  init(context: ServiceContext) {
-    if (this.context) {
-      this.dispose(this.context);
-    }
-
-    const canvasService =
-      context.get<CanvasService>(CANVAS_SERVICE_ID);
-    if (!canvasService) {
-      throw new Error("[SceneVisibilityService] CanvasService is required.");
-    }
-
-    this.context = context;
-    this.canvasService = canvasService;
-    this.activeToolId = context.get(WORKBENCH_SERVICE)?.activeToolId ?? null;
-    context.eventBus.on("tool:activated", this.onToolActivated);
-    context.eventBus.on("object:added", this.onObjectAdded);
-    this.apply();
-  }
-
-  dispose(context: ServiceContext) {
-    const activeContext = this.context ?? context;
-    activeContext.eventBus.off("tool:activated", this.onToolActivated);
-    activeContext.eventBus.off("object:added", this.onObjectAdded);
-    this.context = undefined;
-    this.activeToolId = null;
-    this.canvasService = undefined;
-  }
-
-  private onToolActivated = (e: { id: string | null }) => {
-    this.activeToolId = e.id;
-    this.apply();
-  };
-
-  private onObjectAdded = () => {
-    this.apply();
-  };
-
-  private apply() {
-    if (!this.canvasService) return;
-
-    const dielineLayer = this.canvasService.getLayer("dieline-overlay");
-    if (dielineLayer) {
-      const visible = !HIDDEN_DIELINE_TOOLS.has(this.activeToolId || "");
-      this.canvasService.setLayerVisibility("dieline-overlay", visible);
-    }
-
-    const rulerVisible = !HIDDEN_RULER_TOOLS.has(this.activeToolId || "");
-    this.canvasService.setLayerVisibility("ruler-overlay", rulerVisible);
-
-    this.canvasService.requestRenderAll();
-  }
-}