@bubblydoo/uxp-toolkit 0.0.3 → 0.0.5

package/dist/index.js

@@ -100,44 +100,105 @@ var executeAsModalAndSuspendHistory = async (commandName, document, fn) => {
   });
 };
 
-// src/commands-library/getLayerProperties.ts
+// src/commands-library/renameLayer.ts
 import { z as z2 } from "zod";
-var getLayerProperties = async (document) => {
-  const command = createCommand({
+function createRenameLayerCommand(layerRef, newName) {
+  return createCommand({
+    modifying: true,
+    descriptor: {
+      _obj: "set",
+      _target: [{ _ref: "layer", _id: layerRef.id }, { _ref: "document", _id: layerRef.docId }],
+      to: { _obj: "layer", name: newName }
+    },
+    schema: z2.unknown()
+  });
+}
+
+// src/commands-library/getDocument.ts
+import z3 from "zod";
+function createGetDocumentCommand(documentId) {
+  return createCommand({
     modifying: false,
     descriptor: {
-      _obj: "multiGet",
-      _target: { _ref: [{ _ref: "document", _id: document.id }] },
-      extendedReference: [
-        ["name", "layerID", "visible"],
-        { _obj: "layer", index: 1, count: -1 }
-      ]
+      _obj: "get",
+      _target: { _ref: [{ _ref: "document", _id: documentId }] }
     },
-    schema: z2.object({
-      list: z2.array(
-        z2.object({
-          name: z2.string(),
-          layerID: z2.number(),
-          visible: z2.boolean().optional()
-        })
-      )
+    schema: z3.object({
+      title: z3.string(),
+      documentID: z3.number(),
+      visible: z3.boolean(),
+      hasBackgroundLayer: z3.boolean()
     })
   });
-  const result = await batchPlayCommand(command);
-  return [...result.list].reverse();
-};
+}
+function createGetDocumentHasBackgroundLayerCommand(documentId) {
+  return createCommand({
+    modifying: false,
+    descriptor: {
+      _obj: "get",
+      _target: {
+        _ref: [
+          { _property: "hasBackgroundLayer" },
+          { _ref: "document", _id: documentId }
+        ]
+      }
+    },
+    schema: z3.object({
+      hasBackgroundLayer: z3.boolean()
+    })
+  });
+}
 
-// src/commands-library/renameLayer.ts
-import { z as z3 } from "zod";
-function createRenameLayerCommand(layerRef, newName) {
+// src/commands-library/getLayer.ts
+import z4 from "zod";
+var layerSchema = z4.object({
+  name: z4.string(),
+  visible: z4.boolean(),
+  group: z4.boolean(),
+  layerSection: z4.object({
+    _value: z4.enum([
+      "layerSectionStart",
+      "layerSectionEnd",
+      "layerSectionContent"
+    ]),
+    _enum: z4.literal("layerSectionType")
+  }),
+  layerKind: z4.number(),
+  itemIndex: z4.number(),
+  background: z4.boolean(),
+  mode: z4.object({
+    _enum: z4.literal("blendMode"),
+    _value: z4.string()
+  }),
+  layerID: z4.number(),
+  layerEffects: z4.record(z4.string(), z4.object({
+    // "scale" does not have an "enabled" property, that's why it's optional
+    enabled: z4.boolean().optional()
+  }).or(z4.array(z4.object({
+    enabled: z4.boolean()
+  })))).optional()
+});
+function createGetLayerCommand(layerRef) {
   return createCommand({
-    modifying: true,
+    modifying: false,
     descriptor: {
-      _obj: "set",
-      _target: [{ _ref: "layer", _id: layerRef.id }, { _ref: "document", _id: layerRef.docId }],
-      to: { _obj: "layer", name: newName }
+      _obj: "get",
+      _target: [
+        { _ref: "layer", _id: layerRef.id },
+        { _ref: "document", _id: layerRef.docId }
+      ]
     },
-    schema: z3.unknown()
+    schema: layerSchema
+  });
+}
+function createGetBackgroundLayerCommand(docId) {
+  return createCommand({
+    modifying: false,
+    descriptor: {
+      _obj: "get",
+      _target: { _ref: [{ _ref: "layer", "_property": "background" }, { _ref: "document", _id: docId }] }
+    },
+    schema: layerSchema
   });
 }
 
@@ -223,37 +284,37 @@ function mapTreeRef(tree, mapFn) {
 }
 
 // src/other/applicationInfo.ts
-import { z as z4 } from "zod";
+import { z as z5 } from "zod";
 async function photoshopGetApplicationInfo() {
   return await batchPlayCommand(photoshopApplicationInfoCommand);
 }
-var photoshopAppInfoSchema = z4.object({
-  active: z4.boolean(),
-  autoShowHomeScreen: z4.boolean(),
-  available: z4.number(),
-  buildNumber: z4.string(),
-  documentArea: z4.object({
-    left: z4.number(),
-    top: z4.number(),
-    right: z4.number(),
-    bottom: z4.number()
+var photoshopAppInfoSchema = z5.object({
+  active: z5.boolean(),
+  autoShowHomeScreen: z5.boolean(),
+  available: z5.number(),
+  buildNumber: z5.string(),
+  documentArea: z5.object({
+    left: z5.number(),
+    top: z5.number(),
+    right: z5.number(),
+    bottom: z5.number()
   }),
-  hostName: z4.string(),
-  hostVersion: z4.object({
-    versionMajor: z4.number(),
-    versionMinor: z4.number(),
-    versionFix: z4.number()
+  hostName: z5.string(),
+  hostVersion: z5.object({
+    versionMajor: z5.number(),
+    versionMinor: z5.number(),
+    versionFix: z5.number()
   }),
-  localeInfo: z4.object({
-    decimalPoint: z4.string()
+  localeInfo: z5.object({
+    decimalPoint: z5.string()
   }),
-  osVersion: z4.string(),
-  panelList: z4.array(
-    z4.object({
-      ID: z4.string(),
-      name: z4.string(),
-      obscured: z4.boolean(),
-      visible: z4.boolean()
+  osVersion: z5.string(),
+  panelList: z5.array(
+    z5.object({
+      ID: z5.string(),
+      name: z5.string(),
+      obscured: z5.boolean(),
+      visible: z5.boolean()
     })
   )
 });
@@ -284,17 +345,17 @@ async function readFromClipboard() {
 }
 
 // src/other/uxpEntrypoints.ts
-import { z as z5 } from "zod";
-var uxpEntrypointsSchema = z5.object({
-  _pluginInfo: z5.object({
-    id: z5.string(),
-    name: z5.string(),
-    version: z5.string()
+import { z as z6 } from "zod";
+var uxpEntrypointsSchema = z6.object({
+  _pluginInfo: z6.object({
+    id: z6.string(),
+    name: z6.string(),
+    version: z6.string()
   })
 });
 
 // src/ut-tree/getLayerProperties.ts
-import { z as z6 } from "zod";
+import { z as z7 } from "zod";
 function createGetLayerPropertiesCommand(docId) {
   return createCommand({
     modifying: false,
@@ -302,105 +363,62 @@ function createGetLayerPropertiesCommand(docId) {
       _obj: "multiGet",
       _target: { _ref: [{ _ref: "document", _id: docId }] },
       extendedReference: [
-        ["name", "layerID", "visible"],
+        ["name", "layerID", "visible", "group", "layerSection", "layerKind", "itemIndex", "background", "mode", "layerEffects"],
         { _obj: "layer", index: 1, count: -1 }
       ]
     },
-    schema: z6.object({
-      list: z6.array(
-        z6.object({
-          name: z6.string(),
-          layerID: z6.number(),
-          visible: z6.boolean().optional()
+    schema: z7.object({
+      list: z7.array(
+        z7.object({
+          name: z7.string(),
+          layerID: z7.number(),
+          visible: z7.boolean(),
+          group: z7.boolean(),
+          layerSection: z7.object({
+            _value: z7.enum([
+              "layerSectionStart",
+              "layerSectionEnd",
+              "layerSectionContent"
+            ]),
+            _enum: z7.literal("layerSectionType")
+          }),
+          layerKind: z7.number(),
+          itemIndex: z7.number(),
+          background: z7.boolean(),
+          mode: z7.object({
+            _enum: z7.literal("blendMode"),
+            _value: z7.string()
+          }),
+          layerEffects: z7.record(z7.string(), z7.object({
+            // "scale" does not have an "enabled" property, that's why it's optional
+            enabled: z7.boolean().optional()
+          }).or(z7.array(z7.object({
+            enabled: z7.boolean()
+          })))).optional()
         })
       )
     })
   });
 }
-var getLayerProperties2 = async (documentId) => {
-  const command = createGetLayerPropertiesCommand(documentId);
-  const result = await batchPlayCommand(command);
-  return [...result.list].reverse();
-};
-
-// src/ut-tree/getFlattenedLayerDescriptorsList.ts
-import { z as z7 } from "zod";
-var layerDescriptorSchema = z7.object({
-  name: z7.string(),
-  // id: z.number(),
-  layerID: z7.number(),
-  // _docId: z.number(),
-  mode: z7.object({
-    _enum: z7.literal("blendMode"),
-    _value: z7.string()
-    // passThrough, normal, multiply, screen, overlay, etc.
-  }),
-  background: z7.boolean(),
-  itemIndex: z7.number(),
-  visible: z7.boolean(),
-  layerKind: z7.number(),
-  layerSection: z7.object({
-    _value: z7.enum([
-      "layerSectionStart",
-      "layerSectionEnd",
-      "layerSectionContent"
-    ]),
-    _enum: z7.literal("layerSectionType")
-  })
-});
-var getFlattenedLayerDescriptorsList = async (documentId) => {
-  const layerProperties = await getLayerProperties2(documentId);
-  const commands = layerProperties.map(
-    (layerProp) => createCommand({
-      modifying: false,
-      descriptor: {
-        _obj: "get",
-        _target: [
-          {
-            _ref: "layer",
-            _id: layerProp.layerID
-          }
-        ],
-        makeVisible: false,
-        layerID: [layerProp.layerID],
-        _isCommand: false
-      },
-      schema: layerDescriptorSchema
-    })
-  );
-  const layerDescriptors = await batchPlayCommands(commands);
-  return layerDescriptors.map((desc) => {
+var getDocumentLayerDescriptors = async (documentId) => {
+  const [layersResult, documentHasBackgroundLayerResult] = await batchPlayCommands([
+    createGetLayerPropertiesCommand(documentId),
+    createGetDocumentHasBackgroundLayerCommand(documentId)
+  ]);
+  const backgroundLayerResult = documentHasBackgroundLayerResult.hasBackgroundLayer ? await batchPlayCommand(createGetBackgroundLayerCommand(documentId)) : null;
+  const list = [...layersResult.list].reverse();
+  if (backgroundLayerResult) {
+    list.push(backgroundLayerResult);
+  }
+  return list.map((layerProp) => {
     return {
-      ...desc,
+      ...layerProp,
       docId: documentId
     };
   });
 };
 
 // src/ut-tree/getLayerEffects.ts
-import { z as z8 } from "zod";
-function createGetLayerCommand(layerRef) {
-  return createCommand({
-    modifying: false,
-    descriptor: {
-      _obj: "get",
-      _target: [
-        { _ref: "layer", _id: layerRef.id },
-        { _ref: "document", _id: layerRef.docId }
-      ]
-    },
-    schema: z8.object({
-      layerID: z8.number(),
-      group: z8.boolean().optional(),
-      layerEffects: z8.record(z8.string(), z8.object({
-        // "scale" does not have an "enabled" property, that's why it's optional
-        enabled: z8.boolean().optional()
-      }).or(z8.array(z8.object({
-        enabled: z8.boolean()
-      })))).optional()
-    })
-  });
-}
 async function getLayerEffects(layerRef) {
   const result = await batchPlayCommand(createGetLayerCommand(layerRef));
   const data = result.layerEffects || {};
@@ -411,132 +429,6 @@ async function getLayerEffects(layerRef) {
   return effects;
 }
 
-// src/ut-tree/photoshopLayerDescriptorsToUTLayers.ts
-var layerKindMap = /* @__PURE__ */ new Map([
-  [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
-]);
-var blendModes = [
-  "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"
-];
-var getLayerSectionValue = (layer) => {
-  if (typeof layer.layerSection === "string") {
-    return layer.layerSection;
-  }
-  if (layer.layerSection && typeof layer.layerSection === "object" && "_value" in layer.layerSection) {
-    return layer.layerSection._value;
-  }
-  return void 0;
-};
-var getLayerKind = (layer) => {
-  const kind = layerKindMap.get(layer.layerKind);
-  if (!kind) {
-    throw new Error(`Unknown layer kind: ${layer.layerKind}`);
-  }
-  return kind;
-};
-var getBlendMode = (layer) => {
-  const mode = layer.mode._value;
-  if (!blendModes.includes(mode)) {
-    throw new Error(`Unknown blend mode: ${mode}`);
-  }
-  return mode;
-};
-var determineLayerSection = (layer) => {
-  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";
-};
-var photoshopLayerDescriptorsToUTLayers = async (layers) => {
-  const root = [];
-  const stack = [{ layers: root }];
-  const commands = layers.map((layer) => createGetLayerCommand({ docId: layer.docId, id: layer.layerID }));
-  const batchResults = await executeAsModal("Get Layer Effects Data", async (ctx) => {
-    return await ctx.batchPlayCommands(commands);
-  });
-  const effectsMap = /* @__PURE__ */ new Map();
-  batchResults.forEach((result, index) => {
-    const layerId = layers[index].layerID;
-    const data = result.layerEffects;
-    const 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) {
-    const sectionType = determineLayerSection(layer);
-    const isClippingMask = !!batchResults.find((res, index) => {
-      return layer.layerID === res.layerID;
-    })?.group;
-    if (sectionType === "end") {
-      if (stack.length > 1) {
-        stack.pop();
-      }
-      continue;
-    }
-    const node = {
-      name: layer.name,
-      docId: layer.docId,
-      id: layer.layerID,
-      visible: layer.visible,
-      kind: getLayerKind(layer),
-      blendMode: getBlendMode(layer),
-      isClippingMask,
-      effects: effectsMap.get(layer.layerID) || {}
-    };
-    const current = stack[stack.length - 1];
-    current.layers.push(node);
-    if (sectionType === "start") {
-      node.layers = [];
-      stack.push({ layers: node.layers });
-    }
-  }
-  return root;
-};
-
 // src/ut-tree/utLayersToTree.ts
 function utLayersToTree(layer) {
   return layer.map((layer2) => ({
@@ -548,13 +440,41 @@ function utLayersToTree(layer) {
       kind: layer2.kind,
       blendMode: layer2.blendMode,
       isClippingMask: layer2.isClippingMask,
-      effects: layer2.effects
+      effects: layer2.effects,
+      background: layer2.background
     },
     name: layer2.name,
     children: layer2.layers ? utLayersToTree(layer2.layers) : void 0
   }));
 }
 
+// src/ut-tree/utLayersToText.ts
+var VISIBLE_ICON = "\u25EF";
+var INVISIBLE_ICON = "\u2298";
+var CLIPPING_MASK_ICON = "\u2B10";
+var GROUP_ICON = "\u25BE";
+var EFFECTS_ICON = "\u0192";
+var BLEND_ICON = "\u2055";
+function utLayersToText(tree, depth = 0) {
+  return tree.map((layer) => {
+    const prefix = " ".repeat(depth * 2);
+    const name = layer.name;
+    const effects = Object.keys(layer.effects).length > 0 ? EFFECTS_ICON : "";
+    const blend = isSpecialBlendMode(layer) ? BLEND_ICON : "";
+    const clippingMask = layer.isClippingMask ? CLIPPING_MASK_ICON : "";
+    const group = layer.kind === "group" ? GROUP_ICON : "";
+    const visible = layer.visible ? VISIBLE_ICON : INVISIBLE_ICON;
+    const line = [visible, prefix, clippingMask, group, name, effects, blend].filter(Boolean).join(" ");
+    if (layer.layers) {
+      return line + "\n" + utLayersToText(layer.layers, depth + 1);
+    }
+    return line;
+  }).join("\n");
+}
+function isSpecialBlendMode(layer) {
+  return layer.kind === "group" ? layer.blendMode !== "passThrough" : layer.blendMode !== "normal";
+}
+
 // src/util/utLayerToLayer.ts
 import { app as app2 } from "photoshop";
 function utLayerToDomLayer(layer) {
@@ -704,7 +624,9 @@ export {
   batchPlayCommands,
   copyToClipboard,
   createCommand,
-  createGetLayerCommand as createGetLayerEffectsCommand,
+  createGetBackgroundLayerCommand,
+  createGetDocumentCommand,
+  createGetDocumentHasBackgroundLayerCommand,
   createGetLayerPropertiesCommand,
   createModifyingBatchPlayContext,
   createRenameLayerCommand,
@@ -713,21 +635,19 @@ export {
   flattenTree,
   getBasicStackFrameAbsoluteFilePath,
   getFlattenedDomLayersList,
-  getFlattenedLayerDescriptorsList,
   getLayerEffects,
-  getLayerProperties,
-  getLayerProperties2 as getLayerPropertiesFromUtTree,
+  getDocumentLayerDescriptors as getLayerPropertiesFromUtTree,
   mapTree,
   mapTreeRef,
   openFileByPath,
   parseUxpErrorSourcemaps,
   photoshopDomLayersToTree,
   photoshopGetApplicationInfo,
-  photoshopLayerDescriptorsToUTLayers,
   readFromClipboard,
   suspendHistory,
   utLayerToDomLayer,
   utLayersToDomLayers,
   utLayersToTree,
+  utLayersToText as utTreeToText,
   uxpEntrypointsSchema
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bubblydoo/uxp-toolkit",
-  "version": "0.0.3",
+  "version": "0.0.5",
   "license": "MIT",
   "type": "module",
   "author": "Hans Otto Wirtz <hansottowirtz@gmail.com>",
@@ -33,15 +33,18 @@
     "@types/node": "^20.8.7",
     "@types/photoshop": "^25.0.2",
     "chai": "^6.2.2",
+    "dedent": "^1.7.1",
     "rollup": "^4.57.0",
     "tsup": "^8.5.1",
     "typescript": "^5.8.3",
+    "vitest": "^4.0.18",
     "zod": "^4.3.6",
-    "@bubblydoo/tsconfig": "0.0.2",
-    "@bubblydoo/uxp-test-framework": "0.0.3"
+    "@bubblydoo/uxp-test-framework": "0.0.5",
+    "@bubblydoo/tsconfig": "0.0.3"
   },
   "scripts": {
     "build": "tsup",
+    "test": "vitest run",
     "uxp-test:build": "uxp-test build",
     "uxp-test:dev": "uxp-test dev"
   }

package/src/commands-library/getDocument.ts

@@ -0,0 +1,36 @@
+import z from "zod";
+import { createCommand } from "../core/command";
+
+export function createGetDocumentCommand(documentId: number) {
+  return createCommand({
+    modifying: false,
+    descriptor: {
+      _obj: "get",
+      _target: { _ref: [{ _ref: "document", _id: documentId }] },
+    },
+    schema: z.object({
+      title: z.string(),
+      documentID: z.number(),
+      visible: z.boolean(),
+      hasBackgroundLayer: z.boolean(),
+    }),
+  });
+}
+
+export function createGetDocumentHasBackgroundLayerCommand(documentId: number) {
+  return createCommand({
+    modifying: false,
+    descriptor: {
+      _obj: "get",
+      _target: {
+        _ref: [
+          { _property: "hasBackgroundLayer" },
+          { _ref: "document", _id: documentId },
+        ],
+      },
+    },
+    schema: z.object({
+      hasBackgroundLayer: z.boolean(),
+    }),
+  });
+}