@bubblydoo/uxp-toolkit 0.0.4 → 0.0.6

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,123 +345,82 @@ 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";
-function createGetLayerPropertiesCommand(docId) {
+// src/commands-library/multiGetDocument.ts
+import { z as z7 } from "zod";
+function createMultiGetDocumentCommand(docId) {
   return createCommand({
     modifying: false,
     descriptor: {
       _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) => {
+// src/ut-tree/getDocumentLayerDescriptors.ts
+var getDocumentLayerDescriptors = async (documentId) => {
+  const [layersResult, documentHasBackgroundLayerResult] = await batchPlayCommands([
+    createMultiGetDocumentCommand(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 || {};
@@ -458,15 +478,6 @@ var blendModes = [
   "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) {
@@ -481,36 +492,11 @@ var getBlendMode = (layer) => {
   }
   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) => {
+function photoshopLayerDescriptorsToUTLayers(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();
@@ -524,8 +510,9 @@ var photoshopLayerDescriptorsToUTLayers = async (layers) => {
       visible: layer.visible,
       kind: getLayerKind(layer),
       blendMode: getBlendMode(layer),
-      isClippingMask,
-      effects: effectsMap.get(layer.layerID) || {}
+      isClippingMask: layer.group,
+      effects: getEffects(layer),
+      background: layer.background
     };
     const current = stack[stack.length - 1];
     current.layers.push(node);
@@ -535,7 +522,22 @@ var photoshopLayerDescriptorsToUTLayers = async (layers) => {
     }
   }
   return root;
+}
+var determineLayerSection = (layer) => {
+  const section = layer.layerSection._value;
+  const isGroupEnd = layer.name === "</Layer group>" || layer.name === "</Layer set>" || section === "layerSectionEnd";
+  const isGroupStart = section === "layerSectionStart";
+  return isGroupStart ? "start" : isGroupEnd ? "end" : "normal";
 };
+function getEffects(layer) {
+  const effects = {};
+  if (layer.layerEffects) {
+    for (const effect in layer.layerEffects) {
+      effects[effect] = Array.isArray(layer.layerEffects[effect]) ? layer.layerEffects[effect].some((e) => e.enabled) : !!layer.layerEffects[effect]?.enabled;
+    }
+  }
+  return effects;
+}
 
 // src/ut-tree/utLayersToTree.ts
 function utLayersToTree(layer) {
@@ -548,13 +550,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,19 +734,19 @@ export {
   batchPlayCommands,
   copyToClipboard,
   createCommand,
-  createGetLayerCommand as createGetLayerEffectsCommand,
-  createGetLayerPropertiesCommand,
+  createGetBackgroundLayerCommand,
+  createGetDocumentCommand,
+  createGetDocumentHasBackgroundLayerCommand,
   createModifyingBatchPlayContext,
+  createMultiGetDocumentCommand,
   createRenameLayerCommand,
   executeAsModal,
   executeAsModalAndSuspendHistory,
   flattenTree,
   getBasicStackFrameAbsoluteFilePath,
+  getDocumentLayerDescriptors,
   getFlattenedDomLayersList,
-  getFlattenedLayerDescriptorsList,
   getLayerEffects,
-  getLayerProperties,
-  getLayerProperties2 as getLayerPropertiesFromUtTree,
   mapTree,
   mapTreeRef,
   openFileByPath,
@@ -729,5 +759,6 @@ export {
   utLayerToDomLayer,
   utLayersToDomLayers,
   utLayersToTree,
+  utLayersToText as utTreeToText,
   uxpEntrypointsSchema
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bubblydoo/uxp-toolkit",
-  "version": "0.0.4",
+  "version": "0.0.6",
   "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.3",
-    "@bubblydoo/uxp-test-framework": "0.0.4"
+    "@bubblydoo/uxp-test-framework": "0.0.6"
   },
   "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(),
+    }),
+  });
+}

package/src/commands-library/getDocument.txt

@@ -0,0 +1,62 @@
+// Object
+// EXIF: "EXIF tag 100274 Normal\rEXIF tag 100282 72.0\rEXIF tag 100283 72.0\rEXIF tag 100296 Inches\rEXIF tag 100305 Adobe Photoshop 27.3 (20251221.m.3348 0256c3c)  (Macintosh)\rEXIF tag 100306 2026:01:30 11:20:57\rEXIF tag 140961 Uncalibrated\rEXIF tag 140962 100\rEXIF tag 140963 100\r"
+// XMPMetadataAsUTF8: "<?xpacket begin=\"\" id=\"W5M0MpCehiHzreSzNTczkc
+// backgroundSaveInfo: {isPendingNormalSave: false}
+// bigNudgeH: 655360
+// bigNudgeV: 655360
+// center: {_obj: "paint", horizontal: {…}, vertical: {…}}
+// clippingPathInfo: {_obj: "clippingInfo", clippingPathIndex: -1, clippingPathFlatness: 0}
+// contentCredentialsEnabled: false
+// copyright: false
+// count: 3
+// depth: 8
+// documentID: 101
+// duotoneInk: 0
+// extension: (3) ["PSD", "PDD", "PSDT"]
+// fileInfo: {_obj: "fileInfo"}
+// fileReference: {_path: "/Users/otto/Code/projects/bubbly/uxp-toolkit/packa…t/uxp-tests-plugin/fixtures/one-layer-with-bg.psd", _kind: "local"}
+// format: "Photoshop"
+// genTechModelsUsed: []
+// generatorSettings: {_obj: "generatorSettings"}
+// guidesVisibility: true
+// hasBackgroundLayer: true
+// height: {_unit: "distanceUnit", _value: 100}
+// histogram: (256) [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1698, 19, 5, 10, 3, 11, 6, 7, 4, 1, 2, 2, 4, 2, 3, 0, 2, 4, 2, 0, 4, 1, 4, 1, 3, 4, 0, …]
+// isCloudDoc: false
+// isDirty: false
+// isUsingGenTech: false
+// itemIndex: 2
+// manage: {_enum: "manage", _value: "none"}
+// measurementScale: {_obj: "measurementScale", _target: Array(2), to: {…}}
+// mimeType: "application/vnd.adobe.photoshop"
+// mode: {_enum: "colorSpace", _value: "RGBColor"}
+// numberOfChannels: 3
+// numberOfLayers: 1
+// numberOfPaths: 0
+// patternPreviewMode: false
+// pixelScaleFactor: {_unit: "noneUnit", _value: 1}
+// printColorHandling: {_enum: "printColorHandling", _value: "printerManaged"}
+// printCopies: 1
+// printCurrentPrinter: "EPSON ET-8500 Series"
+// printOutput: {_obj: "printOutput", postScriptColor: true, intent: {…}, printSixteenBit: false, printerName: "", …}
+// printOutputOptions: {_obj: "printOutputOptions", caption: false, calibrationBars: false, registrationMarks: false, cornerCropMarks: false, …}
+// printerList: ["Brother MFC-L3750CDW series"]
+// quickMask: false
+// resolution: {_unit: "densityUnit", _value: 72}
+// rulerOriginH: 0
+// rulerOriginV: 0
+// rulersVisibility: true
+// selectionEdgesVisible: false
+// slices: {bounds: {…}, slices: Array(1)}
+// smartGuidesVisibility: true
+// targetLayers: [{…}]
+// targetLayersIDs: [{…}]
+// targetLayersIndexes: [{…}]
+// targetPathIndex: -1
+// targetPathVisibility: true
+// title: "one-layer-with-bg.psd"
+// visible: true
+// watermark: false
+// width: {_unit: "distanceUnit", _value: 100}
+// workPathIndex: -1
+// zoom: {_unit: "percentUnit", _value: 30.830188679245282}