@pooder/kit 5.4.0 → 6.0.0

package/src/services/ViewportSystem.ts

@@ -1,95 +1,95 @@
-import { Coordinate, Layout, Point, Size } from "../coordinate";
-
-export class ViewportSystem {
-  private _containerSize: Size = { width: 0, height: 0 };
-  private _physicalSize: Size = { width: 0, height: 0 };
-  private _padding: number = 0;
-  private _layout: Layout = {
-    scale: 1,
-    offsetX: 0,
-    offsetY: 0,
-    width: 0,
-    height: 0,
-  };
-
-  constructor(
-    containerSize: Size = { width: 0, height: 0 },
-    physicalSize: Size = { width: 0, height: 0 },
-    padding: number = 40,
-  ) {
-    this._containerSize = containerSize;
-    this._physicalSize = physicalSize;
-    this._padding = padding;
-    this.updateLayout();
-  }
-
-  get layout(): Layout {
-    return this._layout;
-  }
-
-  get scale(): number {
-    return this._layout.scale;
-  }
-
-  get offset(): Point {
-    return { x: this._layout.offsetX, y: this._layout.offsetY };
-  }
-
-  updateContainer(width: number, height: number) {
-    if (
-      this._containerSize.width === width &&
-      this._containerSize.height === height
-    )
-      return;
-    this._containerSize = { width, height };
-    this.updateLayout();
-  }
-
-  updatePhysical(width: number, height: number) {
-    if (
-      this._physicalSize.width === width &&
-      this._physicalSize.height === height
-    )
-      return;
-    this._physicalSize = { width, height };
-    this.updateLayout();
-  }
-
-  setPadding(padding: number) {
-    if (this._padding === padding) return;
-    this._padding = padding;
-    this.updateLayout();
-  }
-
-  private updateLayout() {
-    this._layout = Coordinate.calculateLayout(
-      this._containerSize,
-      this._physicalSize,
-      this._padding,
-    );
-  }
-
-  toPixel(value: number): number {
-    return value * this._layout.scale;
-  }
-
-  toPhysical(value: number): number {
-    return this._layout.scale === 0 ? 0 : value / this._layout.scale;
-  }
-
-  toPixelPoint(point: Point): Point {
-    return {
-      x: point.x * this._layout.scale + this._layout.offsetX,
-      y: point.y * this._layout.scale + this._layout.offsetY,
-    };
-  }
-
-  // Convert screen coordinate (e.g. mouse event) to physical coordinate (relative to content origin)
-  toPhysicalPoint(point: Point): Point {
-    if (this._layout.scale === 0) return { x: 0, y: 0 };
-    return {
-      x: (point.x - this._layout.offsetX) / this._layout.scale,
-      y: (point.y - this._layout.offsetY) / this._layout.scale,
-    };
-  }
-}
+import { Coordinate, Layout, Point, Size } from "../coordinate";
+
+export class ViewportSystem {
+  private _containerSize: Size = { width: 0, height: 0 };
+  private _physicalSize: Size = { width: 0, height: 0 };
+  private _padding: number = 0;
+  private _layout: Layout = {
+    scale: 1,
+    offsetX: 0,
+    offsetY: 0,
+    width: 0,
+    height: 0,
+  };
+
+  constructor(
+    containerSize: Size = { width: 0, height: 0 },
+    physicalSize: Size = { width: 0, height: 0 },
+    padding: number = 40,
+  ) {
+    this._containerSize = containerSize;
+    this._physicalSize = physicalSize;
+    this._padding = padding;
+    this.updateLayout();
+  }
+
+  get layout(): Layout {
+    return this._layout;
+  }
+
+  get scale(): number {
+    return this._layout.scale;
+  }
+
+  get offset(): Point {
+    return { x: this._layout.offsetX, y: this._layout.offsetY };
+  }
+
+  updateContainer(width: number, height: number) {
+    if (
+      this._containerSize.width === width &&
+      this._containerSize.height === height
+    )
+      return;
+    this._containerSize = { width, height };
+    this.updateLayout();
+  }
+
+  updatePhysical(width: number, height: number) {
+    if (
+      this._physicalSize.width === width &&
+      this._physicalSize.height === height
+    )
+      return;
+    this._physicalSize = { width, height };
+    this.updateLayout();
+  }
+
+  setPadding(padding: number) {
+    if (this._padding === padding) return;
+    this._padding = padding;
+    this.updateLayout();
+  }
+
+  private updateLayout() {
+    this._layout = Coordinate.calculateLayout(
+      this._containerSize,
+      this._physicalSize,
+      this._padding,
+    );
+  }
+
+  toPixel(value: number): number {
+    return value * this._layout.scale;
+  }
+
+  toPhysical(value: number): number {
+    return this._layout.scale === 0 ? 0 : value / this._layout.scale;
+  }
+
+  toPixelPoint(point: Point): Point {
+    return {
+      x: point.x * this._layout.scale + this._layout.offsetX,
+      y: point.y * this._layout.scale + this._layout.offsetY,
+    };
+  }
+
+  // Convert screen coordinate (e.g. mouse event) to physical coordinate (relative to content origin)
+  toPhysicalPoint(point: Point): Point {
+    if (this._layout.scale === 0) return { x: 0, y: 0 };
+    return {
+      x: (point.x - this._layout.offsetX) / this._layout.scale,
+      y: (point.y - this._layout.offsetY) / this._layout.scale,
+    };
+  }
+}

package/src/services/index.ts

@@ -1,3 +1,4 @@
-export { default as CanvasService } from "./CanvasService";
-export * from "./renderSpec";
-export * from "./ViewportSystem";
+export { default as CanvasService } from "./CanvasService";
+export * from "./renderSpec";
+export * from "./visibility";
+export * from "./ViewportSystem";

package/src/services/renderSpec.ts

@@ -1,53 +1,83 @@
-export type RenderObjectType = "rect" | "image" | "path" | "text";
-
-export type RenderProps = Record<string, any>;
-export type RenderCoordinateSpace = "scene" | "screen";
-export type RenderLayoutLength = number | string;
-export type RenderLayoutAlign = "start" | "center" | "end";
-export type RenderLayoutReference =
-  | "sceneViewport"
-  | "screenViewport"
-  | "custom";
-
-export interface RenderLayoutInsets {
-  top?: RenderLayoutLength;
-  right?: RenderLayoutLength;
-  bottom?: RenderLayoutLength;
-  left?: RenderLayoutLength;
-}
-
-export interface RenderLayoutRect {
-  left: number;
-  top: number;
-  width: number;
-  height: number;
-  space?: RenderCoordinateSpace;
-}
-
-export interface RenderObjectLayoutSpec {
-  reference?: RenderLayoutReference;
-  referenceRect?: RenderLayoutRect;
-  inset?: RenderLayoutLength | RenderLayoutInsets;
-  alignX?: RenderLayoutAlign;
-  alignY?: RenderLayoutAlign;
-  offsetX?: RenderLayoutLength;
-  offsetY?: RenderLayoutLength;
-  width?: RenderLayoutLength;
-  height?: RenderLayoutLength;
-}
-
-export interface RenderObjectSpec {
-  id: string;
-  type: RenderObjectType;
-  props: RenderProps;
-  data?: Record<string, any>;
-  src?: string;
-  space?: RenderCoordinateSpace;
-  layout?: RenderObjectLayoutSpec;
-}
-
-export interface RenderLayerSpec {
-  id: string;
-  objects: RenderObjectSpec[];
-  props?: RenderProps;
-}
+export type RenderObjectType = "rect" | "image" | "path" | "text";
+
+export type RenderProps = Record<string, any>;
+export type RenderCoordinateSpace = "scene" | "screen";
+export type RenderLayoutLength = number | string;
+export type RenderLayoutAlign = "start" | "center" | "end";
+export type RenderLayoutReference =
+  | "sceneViewport"
+  | "screenViewport"
+  | "custom";
+
+export interface RenderLayoutInsets {
+  top?: RenderLayoutLength;
+  right?: RenderLayoutLength;
+  bottom?: RenderLayoutLength;
+  left?: RenderLayoutLength;
+}
+
+export interface RenderLayoutRect {
+  left: number;
+  top: number;
+  width: number;
+  height: number;
+  space?: RenderCoordinateSpace;
+}
+
+export interface RenderObjectLayoutSpec {
+  reference?: RenderLayoutReference;
+  referenceRect?: RenderLayoutRect;
+  inset?: RenderLayoutLength | RenderLayoutInsets;
+  alignX?: RenderLayoutAlign;
+  alignY?: RenderLayoutAlign;
+  offsetX?: RenderLayoutLength;
+  offsetY?: RenderLayoutLength;
+  width?: RenderLayoutLength;
+  height?: RenderLayoutLength;
+}
+
+export interface RenderObjectSpec {
+  id: string;
+  type: RenderObjectType;
+  props: RenderProps;
+  data?: Record<string, any>;
+  src?: string;
+  space?: RenderCoordinateSpace;
+  layout?: RenderObjectLayoutSpec;
+}
+
+export type LayerObjectCountComparator = ">" | ">=" | "==" | "<" | "<=";
+
+export type VisibilityExpr =
+  | { op: "const"; value: boolean }
+  | { op: "activeToolIn"; ids: string[] }
+  | { op: "sessionActive"; toolId: string }
+  | { op: "layerExists"; layerId: string }
+  | {
+      op: "layerObjectCount";
+      layerId: string;
+      cmp: LayerObjectCountComparator;
+      value: number;
+    }
+  | { op: "not"; expr: VisibilityExpr }
+  | { op: "all"; exprs: VisibilityExpr[] }
+  | { op: "any"; exprs: VisibilityExpr[] };
+
+export interface RenderClipPathEffectSpec {
+  type: "clipPath";
+  id?: string;
+  source: RenderObjectSpec;
+  targetPassIds: string[];
+}
+
+export type RenderEffectSpec = RenderClipPathEffectSpec;
+
+export interface RenderPassSpec {
+  id: string;
+  stack?: number;
+  order?: number;
+  replace?: boolean;
+  visibility?: VisibilityExpr;
+  effects?: RenderEffectSpec[];
+  objects: RenderObjectSpec[];
+}

package/src/services/visibility.ts

@@ -0,0 +1,78 @@
+import type { VisibilityExpr } from "./renderSpec";
+
+export interface VisibilityLayerState {
+  exists: boolean;
+  objectCount: number;
+}
+
+export interface VisibilityEvalContext {
+  activeToolId?: string | null;
+  isSessionActive?: (toolId: string) => boolean;
+  layers: Map<string, VisibilityLayerState>;
+}
+
+function compareLayerObjectCount(
+  actual: number,
+  cmp: ">" | ">=" | "==" | "<" | "<=",
+  expected: number,
+): boolean {
+  if (cmp === ">") return actual > expected;
+  if (cmp === ">=") return actual >= expected;
+  if (cmp === "<") return actual < expected;
+  if (cmp === "<=") return actual <= expected;
+  return actual === expected;
+}
+
+function layerState(
+  context: VisibilityEvalContext,
+  layerId: string,
+): VisibilityLayerState {
+  return context.layers.get(layerId) || { exists: false, objectCount: 0 };
+}
+
+export function evaluateVisibilityExpr(
+  expr: VisibilityExpr | undefined,
+  context: VisibilityEvalContext,
+): boolean {
+  if (!expr) return true;
+
+  if (expr.op === "const") {
+    return Boolean(expr.value);
+  }
+
+  if (expr.op === "activeToolIn") {
+    const activeToolId = context.activeToolId ?? null;
+    return !!activeToolId && expr.ids.includes(activeToolId);
+  }
+
+  if (expr.op === "sessionActive") {
+    const toolId = String(expr.toolId || "").trim();
+    if (!toolId) return false;
+    return context.isSessionActive ? context.isSessionActive(toolId) : false;
+  }
+
+  if (expr.op === "layerExists") {
+    return layerState(context, expr.layerId).exists === true;
+  }
+
+  if (expr.op === "layerObjectCount") {
+    const expected = Number(expr.value);
+    if (!Number.isFinite(expected)) return false;
+    const count = layerState(context, expr.layerId).objectCount;
+    return compareLayerObjectCount(count, expr.cmp, expected);
+  }
+
+  if (expr.op === "not") {
+    return !evaluateVisibilityExpr(expr.expr, context);
+  }
+
+  if (expr.op === "all") {
+    return expr.exprs.every((item) => evaluateVisibilityExpr(item, context));
+  }
+
+  if (expr.op === "any") {
+    return expr.exprs.some((item) => evaluateVisibilityExpr(item, context));
+  }
+
+  return true;
+}

package/src/units.ts

@@ -1,27 +1,27 @@
-import { Coordinate, Unit } from "./coordinate";
-
-export function parseLengthToMm(input: number | string, defaultUnit: Unit): number {
-  if (typeof input === "number") {
-    if (!Number.isFinite(input)) return 0;
-    return Coordinate.convertUnit(input, defaultUnit, "mm");
-  }
-
-  const raw = input.trim();
-  if (!raw) return 0;
-
-  const match = raw.match(/^([+-]?\d+(?:\.\d+)?)\s*(px|mm|cm|in)?$/i);
-  if (!match) return 0;
-
-  const value = Number(match[1]);
-  if (!Number.isFinite(value)) return 0;
-
-  const unit = (match[2]?.toLowerCase() as Unit | undefined) ?? defaultUnit;
-  return Coordinate.convertUnit(value, unit, "mm");
-}
-
-export function formatMm(valueMm: number, displayUnit: Unit, fractionDigits: number = 2): string {
-  if (!Number.isFinite(valueMm)) return "0";
-  const value = Coordinate.convertUnit(valueMm, "mm", displayUnit);
-  const rounded = Number(value.toFixed(fractionDigits));
-  return rounded.toString();
-}
+import { Coordinate, Unit } from "./coordinate";
+
+export function parseLengthToMm(input: number | string, defaultUnit: Unit): number {
+  if (typeof input === "number") {
+    if (!Number.isFinite(input)) return 0;
+    return Coordinate.convertUnit(input, defaultUnit, "mm");
+  }
+
+  const raw = input.trim();
+  if (!raw) return 0;
+
+  const match = raw.match(/^([+-]?\d+(?:\.\d+)?)\s*(px|mm|cm|in)?$/i);
+  if (!match) return 0;
+
+  const value = Number(match[1]);
+  if (!Number.isFinite(value)) return 0;
+
+  const unit = (match[2]?.toLowerCase() as Unit | undefined) ?? defaultUnit;
+  return Coordinate.convertUnit(value, unit, "mm");
+}
+
+export function formatMm(valueMm: number, displayUnit: Unit, fractionDigits: number = 2): string {
+  if (!Number.isFinite(valueMm)) return "0";
+  const value = Coordinate.convertUnit(valueMm, "mm", displayUnit);
+  const rounded = Number(value.toFixed(fractionDigits));
+  return rounded.toString();
+}