@pixi-board/board-plugin-canvas 0.1.0

package/package.json

@@ -0,0 +1,27 @@
+{
+  "name": "@pixi-board/board-plugin-canvas",
+  "version": "0.1.0",
+  "private": false,
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./src/index.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "src",
+    "package.json"
+  ],
+  "devDependencies": {
+    "@types/node": "^24.10.1",
+    "tsup": "^8.5.0",
+    "typescript": "^5.9.3",
+    "@canvas/board-domain": "0.1.0",
+    "@canvas/board-plugin-sdk": "0.1.0"
+  },
+  "scripts": {
+    "build": "tsup src/index.ts --format esm --platform node --target node20 --out-dir dist --clean"
+  }
+}

package/src/dto.ts

@@ -0,0 +1,151 @@
+import {
+  displayNodeName,
+  nodeBounds,
+  type Asset,
+  type BoardNode,
+  type BoardSnapshot,
+  type ProjectInfo,
+} from "@canvas/board-domain";
+import path from "node:path";
+
+export type CanvasNodeDto = {
+  id: string;
+  type: BoardNode["type"];
+  name?: string;
+  displayName: string;
+  x: number;
+  y: number;
+  width: number;
+  height: number;
+  rotation: number;
+  zIndex: number;
+  locked: boolean;
+  bounds: {
+    minX: number;
+    minY: number;
+    maxX: number;
+    maxY: number;
+  };
+  assetId: string;
+  options?: Record<string, unknown>;
+};
+
+export type CanvasAssetDto = {
+  id: string;
+  kind: Asset["kind"];
+  fileName?: string;
+  mimeType?: string;
+  size?: number;
+  original?: {
+    localPath: string;
+    absolutePath: string;
+    sourceUrl?: string;
+    webLink?: string;
+  };
+  derivatives: Array<{
+    variant: string;
+    localPath: string;
+    absolutePath: string;
+    extension: string;
+    updatedAt: number;
+  }>;
+  metadata: {
+    width?: number;
+    height?: number;
+    duration?: number;
+    format?: string;
+    hash?: string;
+    metadata?: Record<string, unknown>;
+    createdAt: number;
+    updatedAt: number;
+  };
+};
+
+export function toNodeDto(node: BoardNode): CanvasNodeDto {
+  const bounds = nodeBounds(node);
+  return {
+    id: node.id,
+    type: node.type,
+    name: node.name,
+    displayName: displayNodeName(node.name),
+    x: node.x,
+    y: node.y,
+    width: node.width,
+    height: node.height,
+    rotation: node.rotation,
+    zIndex: node.zIndex,
+    locked: node.locked ?? false,
+    assetId: node.assetId,
+    options: node.options,
+    bounds: {
+      minX: bounds.minX,
+      minY: bounds.minY,
+      maxX: bounds.maxX,
+      maxY: bounds.maxY,
+    },
+  };
+}
+
+export function toAssetDto(projectRoot: string, asset: Asset): CanvasAssetDto {
+  return {
+    id: asset.id,
+    kind: asset.kind,
+    fileName: asset.fileName,
+    mimeType: asset.mimeType,
+    size: asset.size,
+    original: asset.localPath
+      ? {
+          localPath: asset.localPath,
+          absolutePath: path.resolve(projectRoot, asset.localPath),
+          sourceUrl: asset.sourceUrl,
+          webLink: asset.webLink,
+        }
+      : undefined,
+    derivatives: Object.entries(asset.derivatives ?? {}).map(([variant, derivative]) => ({
+      variant,
+      localPath: derivative.localPath,
+      absolutePath: path.resolve(projectRoot, derivative.localPath),
+      extension: derivative.extension,
+      updatedAt: derivative.updatedAt,
+    })),
+    metadata: {
+      width: asset.width,
+      height: asset.height,
+      duration: asset.duration,
+      format: asset.format,
+      hash: asset.hash,
+      metadata: asset.metadata,
+      createdAt: asset.createdAt,
+      updatedAt: asset.updatedAt,
+    },
+  };
+}
+
+export function toProjectInfo(projectRoot: string): ProjectInfo {
+  return {
+    name: path.basename(projectRoot),
+    rootPath: projectRoot,
+    boardPath: path.join(projectRoot, "board.json"),
+    assetsPath: path.join(projectRoot, "assets.json"),
+  };
+}
+
+export function toSnapshotDto(projectRoot: string, snapshot: BoardSnapshot) {
+  return {
+    project: toProjectInfo(projectRoot),
+    viewport: snapshot.viewport ?? null,
+    nodes: snapshot.nodes.map(toNodeDto),
+    assets: snapshot.assets.map((asset) => ({
+      id: asset.id,
+      kind: asset.kind,
+      fileName: asset.fileName,
+      mimeType: asset.mimeType,
+      size: asset.size,
+      metadata: asset.metadata,
+      width: asset.width,
+      height: asset.height,
+      duration: asset.duration,
+      updatedAt: asset.updatedAt,
+    })),
+  };
+}

package/src/errors.ts

@@ -0,0 +1,11 @@
+export class BoardToolUserError extends Error {
+  constructor(message: string) {
+    super(message);
+    this.name = "BoardToolUserError";
+  }
+}
+
+export function errorMessage(error: unknown): string {
+  if (error instanceof Error) return error.message;
+  return String(error);
+}

package/src/filter.ts

@@ -0,0 +1,106 @@
+import { nodeBounds, type BoardNode } from "@canvas/board-domain";
+
+const NODE_TYPE_VALUES = ["image", "video", "audio", "model", "text", "markdown", "html", "importing", "generating"] as const;
+
+export type NodeFilter = {
+  type?: BoardNode["type"];
+  keyword?: string;
+  bounds?: {
+    x?: number;
+    y?: number;
+    width?: number;
+    height?: number;
+    minX?: number;
+    minY?: number;
+    maxX?: number;
+    maxY?: number;
+  };
+};
+
+type NormalizedBounds = {
+  minX: number;
+  minY: number;
+  maxX: number;
+  maxY: number;
+};
+
+export function filterNodes(nodes: BoardNode[], filter: unknown): BoardNode[] {
+  const parsed = parseFilter(filter);
+  return nodes.filter((node) => matchesType(node, parsed) && matchesKeyword(node, parsed) && matchesBounds(node, parsed));
+}
+
+function parseFilter(filter: unknown): NodeFilter {
+  if (!filter || typeof filter !== "object" || Array.isArray(filter)) {
+    return {};
+  }
+  const source = filter as Record<string, unknown>;
+  const parsed: NodeFilter = {};
+  if (typeof source.type === "string" && NODE_TYPE_VALUES.includes(source.type as BoardNode["type"])) {
+    parsed.type = source.type as BoardNode["type"];
+  }
+  if (typeof source.keyword === "string") {
+    parsed.keyword = source.keyword;
+  } else if (typeof source.name === "string") {
+    parsed.keyword = source.name;
+  } else if (typeof source.text === "string") {
+    parsed.keyword = source.text;
+  }
+  if (source.bounds && typeof source.bounds === "object" && !Array.isArray(source.bounds)) {
+    parsed.bounds = source.bounds as NodeFilter["bounds"];
+  }
+  return parsed;
+}
+
+function matchesType(node: BoardNode, filter: NodeFilter): boolean {
+  return !filter.type || node.type === filter.type;
+}
+
+function matchesKeyword(node: BoardNode, filter: NodeFilter): boolean {
+  const keyword = filter.keyword?.trim().toLowerCase();
+  if (!keyword) return true;
+  const haystack = [node.id, node.type, node.name ?? "", node.assetId].join("\n").toLowerCase();
+  return haystack.includes(keyword);
+}
+
+function matchesBounds(node: BoardNode, filter: NodeFilter): boolean {
+  if (!filter.bounds) return true;
+  const bounds = normalizeBounds(filter.bounds);
+  if (!bounds) return true;
+  const current = nodeBounds(node);
+  return (
+    current.maxX >= bounds.minX &&
+    current.minX <= bounds.maxX &&
+    current.maxY >= bounds.minY &&
+    current.minY <= bounds.maxY
+  );
+}
+
+function normalizeBounds(bounds: NonNullable<NodeFilter["bounds"]>): NormalizedBounds | null {
+  if (
+    typeof bounds.minX === "number" &&
+    typeof bounds.minY === "number" &&
+    typeof bounds.maxX === "number" &&
+    typeof bounds.maxY === "number"
+  ) {
+    return {
+      minX: bounds.minX,
+      minY: bounds.minY,
+      maxX: bounds.maxX,
+      maxY: bounds.maxY,
+    };
+  }
+  if (
+    typeof bounds.x === "number" &&
+    typeof bounds.y === "number" &&
+    typeof bounds.width === "number" &&
+    typeof bounds.height === "number"
+  ) {
+    return {
+      minX: bounds.x,
+      minY: bounds.y,
+      maxX: bounds.x + bounds.width,
+      maxY: bounds.y + bounds.height,
+    };
+  }
+  return null;
+}