@bubblydoo/uxp-toolkit 0.0.2

package/src/ut-tree/photoshopLayerDescriptorsToUTLayers.ts

@@ -0,0 +1,182 @@
+import { type LayerDescriptor } from "./getFlattenedLayerDescriptorsList";
+import { executeAsModal } from "../core/executeAsModal";
+import { createGetLayerCommand } from "./getLayerEffects";
+
+type UTLayerKind = "pixel" | "adjustment-layer" | "text" | "curves" | "smartObject" | "video" | "group" | "threeD" | "gradientFill" | "pattern" | "solidColor" | "background";
+
+type UTBlendMode = "normal" | "dissolve" | "darken" | "multiply" | "colorBurn" | "linearBurn" | "darkerColor" | "lighten" | "screen" | "colorDodge" | "linearDodge" | "lighterColor" | "overlay" | "softLight" | "hardLight" | "vividLight" | "linearLight" | "pinLight" | "hardMix" | "difference" | "exclusion" | "blendSubtraction" | "blendDivide" | "hue" | "saturation" | "color" | "luminosity" | "passThrough";
+
+type UTLayerBuilder = {
+  name: string;
+  docId: number;
+  id: number;
+  visible: boolean;
+  kind: UTLayerKind;
+  blendMode: UTBlendMode;
+  effects: Record<string, boolean>;
+  isClippingMask: boolean;
+  layers?: UTLayerBuilder[];
+};
+
+export type UTLayer = Readonly<Omit<UTLayerBuilder, "layers">> & {
+  layers?: UTLayer[];
+};
+
+const layerKindMap = new Map<number, UTLayerKind>([
+  [1, "pixel"],
+  [2, "adjustment-layer"], // All adjustment layers
+  [3, "text"],
+  [4, "curves"],
+  [5, "smartObject"],
+  [6, "video"],
+  [7, "group"],
+  [8, "threeD"],
+  [9, "gradientFill"],
+  [10, "pattern"],
+  [11, "solidColor"],
+  [12, "background"], // according to the internet but the actual value is undefined
+]);
+
+const blendModes: string[] = [
+  "normal",
+  "dissolve",
+  "darken",
+  "multiply",
+  "colorBurn",
+  "linearBurn",
+  "darkerColor",
+  "lighten",
+  "screen",
+  "colorDodge",
+  "linearDodge",
+  "lighterColor",
+  "overlay",
+  "softLight",
+  "hardLight",
+  "vividLight",
+  "linearLight",
+  "pinLight",
+  "hardMix",
+  "difference",
+  "exclusion",
+  "blendSubtraction",
+  "blendDivide",
+  "hue",
+  "saturation",
+  "color",
+  "luminosity",
+  "passThrough",
+] satisfies UTBlendMode[];
+
+const getLayerSectionValue = (layer: LayerDescriptor): string | undefined => {
+  if (typeof layer.layerSection === "string") {
+    return layer.layerSection;
+  }
+  if (
+    layer.layerSection &&
+    typeof layer.layerSection === "object" &&
+    "_value" in layer.layerSection
+  ) {
+    return layer.layerSection._value;
+  }
+  return undefined;
+};
+
+const getLayerKind = (layer: LayerDescriptor): UTLayerKind => {
+  const kind = layerKindMap.get(layer.layerKind);
+  if (!kind) {
+    throw new Error(`Unknown layer kind: ${layer.layerKind}`);
+  }
+  return kind;
+};
+
+const getBlendMode = (layer: LayerDescriptor): UTBlendMode => {
+  const mode = layer.mode._value;
+  if (!blendModes.includes(mode)) {
+    throw new Error(`Unknown blend mode: ${mode}`);
+  }
+  return mode as UTBlendMode;
+};
+
+const determineLayerSection = (layer: LayerDescriptor): string => {
+  const section = getLayerSectionValue(layer);
+  const isGroupEnd =
+    layer.name === "</Layer group>" ||
+    layer.name === "</Layer set>" ||
+    section === "layerSectionEnd";
+
+  const isGroupStart = section === "layerSectionStart";
+  return isGroupStart ? "start" : isGroupEnd ? "end" : "normal";
+};
+
+// Generate a tree from a flat list of layer descriptors
+export const photoshopLayerDescriptorsToUTLayers = async (layers: LayerDescriptor[]): Promise<UTLayer[]> => {
+  const root: UTLayerBuilder[] = [];
+  const stack: {
+    layers: UTLayerBuilder[];
+  }[] = [{ layers: root }];
+
+  // 1. Prepare a single batch request for all layers
+  const commands = layers.map((layer) => createGetLayerCommand({ docId: layer.docId, id: layer.layerID }));
+
+  // 2. Execute one batch command instead of N commands
+  const batchResults = await executeAsModal("Get Layer Effects Data", async (ctx) => {
+    return await ctx.batchPlayCommands(commands);
+  });
+
+  // 3. Create a fast lookup map for the results
+  const effectsMap = new Map<number, UTLayerBuilder["effects"]>();
+  batchResults.forEach((result, index) => {
+    const layerId = layers[index]!.layerID;
+    const data = result.layerEffects;
+    const effects: UTLayerBuilder["effects"] = {};
+    if (data) {
+      for (const effect in data) {
+        effects[effect] = Array.isArray(data[effect]) ? data[effect].some((e) => e.enabled) : !!data[effect]?.enabled;
+      }
+    }
+    effectsMap.set(layerId, effects);
+  });
+
+  for (const layer of layers) {
+    // Determine if the layer is a group start or end
+    const sectionType = determineLayerSection(layer);
+
+    const isClippingMask = !!batchResults.find((res, index) => {
+      return layer.layerID === res.layerID;
+    })?.group;
+
+    // Handle group end
+    if (sectionType === "end") {
+      if (stack.length > 1) {
+        stack.pop();
+      }
+      continue;
+    }
+    // Create the node
+    const node: UTLayerBuilder = {
+      name: layer.name,
+      docId: layer.docId,
+      id: layer.layerID,
+      visible: layer.visible,
+      kind: getLayerKind(layer),
+      blendMode: getBlendMode(layer),
+      isClippingMask,
+      effects: effectsMap.get(layer.layerID) || {},
+    };
+
+    // Add the node to the current level
+    const current = stack[stack.length - 1];
+    current!.layers.push(node);
+
+    // Handle group start
+    if (sectionType === "start") {
+      node.layers = [];
+      // Push children array to stack to process content
+      stack.push({ layers: node.layers });
+    }
+  }
+
+  // Cast to the readonly Tree type
+  return root as UTLayer[];
+};

package/src/ut-tree/photoshopLayerDescriptorsToUTLayers.uxp-test.ts

@@ -0,0 +1,52 @@
+import type { Test } from "@bubblydoo/uxp-test-framework";
+import { photoshopLayerDescriptorsToUTLayers } from "./photoshopLayerDescriptorsToUTLayers";
+import { openFileByPath } from "../filesystem/openFileByPath";
+import { getFlattenedLayerDescriptorsList } from "./getFlattenedLayerDescriptorsList";
+import { expect } from "chai";
+
+export const photoshopLayerDescriptorsToUTLayersTest: Test = {
+  name: "photoshopLayerDescriptorsToUTLayers",
+  description: "Test the photoshopLayerDescriptorsToUTLayers function",
+  run: async () => {
+    const doc = await openFileByPath("plugin:/fixtures/clipping-layers.psd");
+    const descriptors = await getFlattenedLayerDescriptorsList(doc.id);
+    const layers = await photoshopLayerDescriptorsToUTLayers(descriptors);
+    expect(layers).to.containSubset([
+      {
+        name: "circle",
+        visible: true,
+        kind: "pixel",
+        blendMode: "normal",
+        isClippingMask: true,
+        effects: {},
+      },
+      {
+        name: "group",
+        visible: true,
+        kind: "group",
+        blendMode: "passThrough",
+        isClippingMask: false,
+        effects: {},
+        layers: [
+          {
+            name: "green square",
+            visible: true,
+            kind: "pixel",
+            blendMode: "normal",
+            isClippingMask: true,
+            effects: {},
+          },
+          {
+            name: "red square",
+            id: 2,
+            visible: true,
+            kind: "pixel",
+            blendMode: "normal",
+            isClippingMask: false,
+            effects: {},
+          },
+        ],
+      },
+    ]);
+  },
+};

package/src/ut-tree/psLayerRef.ts

@@ -0,0 +1,4 @@
+export type PsLayerRef = {
+  id: number;
+  docId: number;
+};

package/src/ut-tree/utLayersToTree.ts

@@ -0,0 +1,21 @@
+import type { Tree } from "../general-tree/treeTypes";
+import type { UTLayer } from "./photoshopLayerDescriptorsToUTLayers";
+
+export type UTLayerWithoutChildren = Omit<UTLayer, "layers">;
+
+export function utLayersToTree(layer: UTLayer[]): Tree<UTLayerWithoutChildren> {
+  return layer.map((layer) => ({
+    ref: {
+      name: layer.name,
+      docId: layer.docId,
+      id: layer.id,
+      visible: layer.visible,
+      kind: layer.kind,
+      blendMode: layer.blendMode,
+      isClippingMask: layer.isClippingMask,
+      effects: layer.effects,
+    },
+    name: layer.name,
+    children: layer.layers ? utLayersToTree(layer.layers) : undefined,
+  }));
+}

package/src/util/utLayerToLayer.ts

@@ -0,0 +1,41 @@
+import type { Layer as DomLayer } from "photoshop/dom/Layer";
+import type { UTLayer } from "../ut-tree/photoshopLayerDescriptorsToUTLayers";
+import { app } from "photoshop";
+import { getFlattenedDomLayersList } from "../dom/getFlattenedDomLayersList";
+
+export function utLayerToDomLayer(layer: UTLayer): DomLayer {
+  const doc = app.documents.find((d) => d.id === layer.docId);
+  if (!doc) {
+    throw new Error(`Document with id ${layer.docId} not found.`);
+  }
+  const allLayers = getFlattenedDomLayersList(doc.layers);
+  const domLayer = allLayers.find((l) => l.id === layer.id);
+  if (!domLayer) {
+    throw new Error(
+      `Layer with id ${layer.id} not found in document ${layer.docId}.`
+    );
+  }
+  return domLayer;
+}
+
+export function utLayersToDomLayers(layers: UTLayer[]): DomLayer[] {
+  if (layers.length === 0) return [];
+  const docId = layers[0]!.docId;
+  if (!layers.every((l) => l.docId === docId)) {
+    throw new Error("All layers must be from the same document.");
+  }
+  const doc = app.documents.find((d) => d.id === docId);
+  if (!doc) {
+    throw new Error(`Document with id ${docId} not found.`);
+  }
+  const allLayers = getFlattenedDomLayersList(doc.layers);
+  return layers.map((l) => {
+    const domLayer = allLayers.find((dl) => dl.id === l.id);
+    if (!domLayer) {
+      throw new Error(
+        `Layer with id ${l.id} not found in document ${docId}.`
+      );
+    }
+    return domLayer;
+  });
+}

package/test/index.ts

@@ -0,0 +1,21 @@
+import { applicationInfoTest } from "../src/other/applicationInfo.uxp-test";
+import { renameLayerTest } from "../src/commands-library/renameLayer.uxp-test";
+import { suspendHistoryErrorTest } from "./meta-tests/suspendHistory.uxp-test";
+import { executeAsModalErrorTest } from "./meta-tests/executeAsModal.uxp-test";
+import { suspendHistoryTest } from "../src/core/suspendHistory.uxp-test";
+import { sourcemapsTest } from "../src/error-sourcemaps/sourcemaps.uxp-test";
+import { clipboardTest } from "../src/other/clipboard.uxp-test";
+import { photoshopLayerDescriptorsToUTLayersTest } from "../src/ut-tree/photoshopLayerDescriptorsToUTLayers.uxp-test";
+import { metadataStorageTest } from "../src/metadata-storage/metadataStorage.uxp-test";
+
+export const tests = [
+  applicationInfoTest,
+  renameLayerTest,
+  suspendHistoryErrorTest,
+  executeAsModalErrorTest,
+  suspendHistoryTest,
+  sourcemapsTest,
+  clipboardTest,
+  photoshopLayerDescriptorsToUTLayersTest,
+  metadataStorageTest,
+];

package/test/meta-tests/executeAsModal.uxp-test.ts

@@ -0,0 +1,38 @@
+import { core } from "photoshop";
+import type { Test } from "@bubblydoo/uxp-test-framework";
+import { expect } from "chai";
+
+export const executeAsModalErrorTest: Test = {
+  name: "meta: executeAsModal should throw correctly",
+  async run() {
+    let threw = false;
+    try {
+      await core.executeAsModal(
+        async () => {
+          throw new Error("Uncaught error");
+        },
+        {
+          commandName: "Test",
+        }
+      );
+    } catch (e) {
+      threw = true;
+    }
+    expect(threw).to.be.true;
+  },
+};
+
+export const executeAsModalReturnTest: Test = {
+  name: "meta: executeAsModal should return correctly",
+  async run() {
+    const result = await core.executeAsModal(
+      async () => {
+        return 'test'
+      },
+      {
+        commandName: "Test",
+      }
+    );
+    expect(result).to.equal('test');
+  },
+};

package/test/meta-tests/suspendHistory.uxp-test.ts

@@ -0,0 +1,27 @@
+import { app } from "photoshop";
+import type { Test } from "@bubblydoo/uxp-test-framework";
+import { expect } from "chai";
+
+export const suspendHistoryErrorTest: Test = {
+  name: "meta: suspendHistory should throw correctly",
+  async run() {
+    const document = app.activeDocument;
+    if (!document) {
+      throw new Error("No active document");
+    }
+
+    let threw = false;
+    try {
+      await document.suspendHistory(
+        async (context) => {
+          throw new Error("Uncaught error");
+        },
+        "Test"
+      );
+    } catch (e) {
+      threw = true;
+    }
+    expect(threw).to.be.true;
+  },
+};
+

package/tsconfig.json

@@ -0,0 +1,13 @@
+{
+  "extends": "@bubblydoo/tsconfig/tsconfig.base.json",
+  "compilerOptions": {
+    "allowJs": true,
+    "moduleDetection": "force",
+    "verbatimModuleSyntax": true,
+    "noUncheckedIndexedAccess": true,
+    "noImplicitOverride": true,
+    "rootDir": ".",
+    "typeRoots": ["./node_modules/@adobe-uxp-types", "./node_modules/@types"]
+  },
+  "include": ["src", "test"]
+}

package/tsup.config.ts

@@ -0,0 +1,9 @@
+import { defineConfig } from "tsup";
+
+export default defineConfig({
+  entry: ["src/index.ts"],
+  format: "esm",
+  dts: true,
+  external: ["photoshop", "uxp"],
+  outDir: "dist",
+});

package/uxp-tests.json

@@ -0,0 +1,13 @@
+{
+  "$schema": "./node_modules/@bubblydoo/uxp-test-framework/uxp-tests-json-schema.json",
+  "outDir": "uxp-tests-plugin",
+  "testsFile": "test/index.ts",
+  "testFixturesDir": "test/fixtures",
+  "plugin": {
+    "id": "co.bubblydoo.uxp-toolkit-test-plugin",
+    "name": "UXP Toolkit Tests"
+  },
+  "vite": {
+    "enableTsconfigPathsPlugin": true
+  }
+}