@bubblydoo/uxp-toolkit 0.0.5 → 0.0.7

package/dist/index.js

@@ -1,88 +1,15 @@
-// src/core/batchPlay.ts
-import { action } from "photoshop";
-async function batchPlay(actions, options) {
-  return action.batchPlay(actions, {
-    ...options,
-    modalBehavior: "execute",
-    dialogOptions: "silent",
-    synchronousExecution: false
-  });
-}
-
-// src/core/command.ts
-import "zod";
-
-// src/core/executeAsModal.ts
-import { core } from "photoshop";
-var originalExecuteAsModal = core.executeAsModal;
-async function executeAsModal(commandName, fn, opts) {
-  let error;
-  let result;
-  await originalExecuteAsModal(async (executionContext) => {
-    const abortController = new AbortController();
-    executionContext.onCancel = () => {
-      abortController.abort();
-    };
-    const extendedExecutionContext = {
-      isCancelled: executionContext.isCancelled,
-      reportProgress: executionContext.reportProgress,
-      hostControl: executionContext.hostControl,
-      signal: abortController.signal,
-      ...createModifyingBatchPlayContext()
-    };
-    try {
-      result = await fn(extendedExecutionContext);
-    } catch (e) {
-      console.error("error in executeAsModal");
-      console.error(e);
-      error = e;
-    }
-  }, {
-    commandName,
-    ...opts
-  });
-  if (error) {
-    throw error;
-  } else {
-    return result;
-  }
-}
-
-// src/core/command.ts
-import "photoshop";
-function createCommand(obj) {
-  return {
-    modifying: obj.modifying,
-    descriptor: obj.descriptor,
-    schema: obj.schema
-  };
-}
-async function batchPlayCommandBase(command, options) {
-  const [result] = await batchPlay([command.descriptor], options);
-  if (result?._obj === "error") {
-    throw new Error("Batch play command failed", { cause: result });
-  }
-  return command.schema.parse(result);
-}
-async function batchPlayCommandsBase(commands, options) {
-  const results = await batchPlay(commands.map((command) => command.descriptor), options);
-  if (results[0]?._obj === "error") {
-    throw new Error("Batch play command failed", { cause: results[0] });
-  }
-  return commands.map((command, index) => command.schema.parse(results[index]));
-}
-function batchPlayCommand(command, options) {
-  return batchPlayCommandBase(command, options);
-}
-function batchPlayCommands(commands, options) {
-  return batchPlayCommandsBase(commands, options);
-}
-function createModifyingBatchPlayContext() {
-  return {
-    batchPlayCommand: batchPlayCommandBase,
-    batchPlayCommands: batchPlayCommandsBase
-  };
-}
+import {
+  batchPlay,
+  batchPlayCommand,
+  batchPlayCommands,
+  createCommand,
+  createGetBackgroundLayerCommand,
+  createGetDocumentHasBackgroundLayerCommand,
+  createGetLayerCommand,
+  createModifyingBatchPlayContext,
+  createMultiGetDocumentCommand,
+  executeAsModal
+} from "./chunk-3CLJMC63.js";
 
 // src/core/suspendHistory.ts
 async function suspendHistory(document, historyStateName, fn) {
@@ -100,108 +27,6 @@ var executeAsModalAndSuspendHistory = async (commandName, document, fn) => {
   });
 };
 
-// src/commands-library/renameLayer.ts
-import { z as z2 } from "zod";
-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: "get",
-      _target: { _ref: [{ _ref: "document", _id: documentId }] }
-    },
-    schema: z3.object({
-      title: z3.string(),
-      documentID: z3.number(),
-      visible: z3.boolean(),
-      hasBackgroundLayer: z3.boolean()
-    })
-  });
-}
-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/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: false,
-    descriptor: {
-      _obj: "get",
-      _target: [
-        { _ref: "layer", _id: layerRef.id },
-        { _ref: "document", _id: layerRef.docId }
-      ]
-    },
-    schema: layerSchema
-  });
-}
-function createGetBackgroundLayerCommand(docId) {
-  return createCommand({
-    modifying: false,
-    descriptor: {
-      _obj: "get",
-      _target: { _ref: [{ _ref: "layer", "_property": "background" }, { _ref: "document", _id: docId }] }
-    },
-    schema: layerSchema
-  });
-}
-
 // src/dom/getFlattenedDomLayersList.ts
 import { constants } from "photoshop";
 var getFlattenedDomLayersList = (layers) => {
@@ -284,37 +109,37 @@ function mapTreeRef(tree, mapFn) {
 }
 
 // src/other/applicationInfo.ts
-import { z as z5 } from "zod";
+import { z } from "zod";
 async function photoshopGetApplicationInfo() {
   return await batchPlayCommand(photoshopApplicationInfoCommand);
 }
-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()
+var photoshopAppInfoSchema = z.object({
+  active: z.boolean(),
+  autoShowHomeScreen: z.boolean(),
+  available: z.number(),
+  buildNumber: z.string(),
+  documentArea: z.object({
+    left: z.number(),
+    top: z.number(),
+    right: z.number(),
+    bottom: z.number()
   }),
-  hostName: z5.string(),
-  hostVersion: z5.object({
-    versionMajor: z5.number(),
-    versionMinor: z5.number(),
-    versionFix: z5.number()
+  hostName: z.string(),
+  hostVersion: z.object({
+    versionMajor: z.number(),
+    versionMinor: z.number(),
+    versionFix: z.number()
   }),
-  localeInfo: z5.object({
-    decimalPoint: z5.string()
+  localeInfo: z.object({
+    decimalPoint: z.string()
   }),
-  osVersion: z5.string(),
-  panelList: z5.array(
-    z5.object({
-      ID: z5.string(),
-      name: z5.string(),
-      obscured: z5.boolean(),
-      visible: z5.boolean()
+  osVersion: z.string(),
+  panelList: z.array(
+    z.object({
+      ID: z.string(),
+      name: z.string(),
+      obscured: z.boolean(),
+      visible: z.boolean()
     })
   )
 });
@@ -345,64 +170,19 @@ async function readFromClipboard() {
 }
 
 // src/other/uxpEntrypoints.ts
-import { z as z6 } from "zod";
-var uxpEntrypointsSchema = z6.object({
-  _pluginInfo: z6.object({
-    id: z6.string(),
-    name: z6.string(),
-    version: z6.string()
+import { z as z2 } from "zod";
+var uxpEntrypointsSchema = z2.object({
+  _pluginInfo: z2.object({
+    id: z2.string(),
+    name: z2.string(),
+    version: z2.string()
   })
 });
 
-// src/ut-tree/getLayerProperties.ts
-import { z as z7 } from "zod";
-function createGetLayerPropertiesCommand(docId) {
-  return createCommand({
-    modifying: false,
-    descriptor: {
-      _obj: "multiGet",
-      _target: { _ref: [{ _ref: "document", _id: docId }] },
-      extendedReference: [
-        ["name", "layerID", "visible", "group", "layerSection", "layerKind", "itemIndex", "background", "mode", "layerEffects"],
-        { _obj: "layer", index: 1, count: -1 }
-      ]
-    },
-    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()
-        })
-      )
-    })
-  });
-}
+// src/ut-tree/getDocumentLayerDescriptors.ts
 var getDocumentLayerDescriptors = async (documentId) => {
   const [layersResult, documentHasBackgroundLayerResult] = await batchPlayCommands([
-    createGetLayerPropertiesCommand(documentId),
+    createMultiGetDocumentCommand(documentId),
     createGetDocumentHasBackgroundLayerCommand(documentId)
   ]);
   const backgroundLayerResult = documentHasBackgroundLayerResult.hasBackgroundLayer ? await batchPlayCommand(createGetBackgroundLayerCommand(documentId)) : null;
@@ -429,6 +209,114 @@ 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 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;
+};
+function photoshopLayerDescriptorsToUTLayers(layers) {
+  const root = [];
+  const stack = [{ layers: root }];
+  for (const layer of layers) {
+    const sectionType = determineLayerSection(layer);
+    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: layer.group,
+      effects: getEffects(layer),
+      background: layer.background
+    };
+    const current = stack[stack.length - 1];
+    current.layers.push(node);
+    if (sectionType === "start") {
+      node.layers = [];
+      stack.push({ layers: node.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) {
   return layer.map((layer2) => ({
@@ -624,25 +512,22 @@ export {
   batchPlayCommands,
   copyToClipboard,
   createCommand,
-  createGetBackgroundLayerCommand,
-  createGetDocumentCommand,
-  createGetDocumentHasBackgroundLayerCommand,
-  createGetLayerPropertiesCommand,
   createModifyingBatchPlayContext,
-  createRenameLayerCommand,
+  createMultiGetDocumentCommand,
   executeAsModal,
   executeAsModalAndSuspendHistory,
   flattenTree,
   getBasicStackFrameAbsoluteFilePath,
+  getDocumentLayerDescriptors,
   getFlattenedDomLayersList,
   getLayerEffects,
-  getDocumentLayerDescriptors as getLayerPropertiesFromUtTree,
   mapTree,
   mapTreeRef,
   openFileByPath,
   parseUxpErrorSourcemaps,
   photoshopDomLayersToTree,
   photoshopGetApplicationInfo,
+  photoshopLayerDescriptorsToUTLayers,
   readFromClipboard,
   suspendHistory,
   utLayerToDomLayer,

package/dist/psLayerRef-OY3h7srv.d.ts

@@ -0,0 +1,70 @@
+import * as photoshop_dom_CoreModules from 'photoshop/dom/CoreModules';
+import { ActionDescriptor } from 'photoshop/dom/CoreModules';
+import { z } from 'zod';
+import { action } from 'photoshop';
+
+type P = Parameters<typeof action.batchPlay>;
+type CorrectBatchPlayOptions = P[1] & {
+    immediateRedraw?: boolean;
+};
+declare function batchPlay(actions: P[0], options?: CorrectBatchPlayOptions): Promise<photoshop_dom_CoreModules.ActionDescriptor[]>;
+
+interface UTCommandBase<T extends any> {
+    descriptor: ActionDescriptor;
+    schema: z.ZodSchema<T>;
+}
+interface UTCommandModifying<T extends any> extends UTCommandBase<T> {
+    modifying: true;
+}
+interface UTCommandNonModifying<T extends any> extends UTCommandBase<T> {
+    modifying: false;
+}
+declare function createCommand<TReturn extends any, TModifying extends boolean>(obj: {
+    descriptor: ActionDescriptor;
+    schema: z.ZodSchema<TReturn>;
+    modifying: TModifying;
+}): TModifying extends true ? UTCommandModifying<TReturn> : UTCommandNonModifying<TReturn>;
+type UTCommandResult<C> = C extends UTCommandBase<infer T> ? T : never;
+type BatchPlayOptions = Parameters<typeof batchPlay>[1];
+declare function batchPlayCommandBase<T extends any>(command: UTCommandBase<T>, options?: BatchPlayOptions): Promise<T>;
+declare function batchPlayCommandsBase<TCommands extends Array<UTCommandBase<any>>>(commands: readonly [...TCommands], options?: BatchPlayOptions): Promise<{
+    [K in keyof TCommands]: UTCommandResult<TCommands[K]>;
+}>;
+declare function batchPlayCommand<T extends any>(command: UTCommandNonModifying<T>, options?: BatchPlayOptions): Promise<T>;
+declare function batchPlayCommands<TCommands extends Array<UTCommandNonModifying<any>>>(commands: readonly [...TCommands], options?: BatchPlayOptions): Promise<{ [K in keyof TCommands]: UTCommandResult<TCommands[K]>; }>;
+declare function createModifyingBatchPlayContext(): {
+    batchPlayCommand: typeof batchPlayCommandBase;
+    batchPlayCommands: typeof batchPlayCommandsBase;
+};
+
+declare function createMultiGetDocumentCommand(docId: number): UTCommandNonModifying<{
+    list: {
+        name: string;
+        layerID: number;
+        visible: boolean;
+        group: boolean;
+        layerSection: {
+            _value: "layerSectionStart" | "layerSectionEnd" | "layerSectionContent";
+            _enum: "layerSectionType";
+        };
+        layerKind: number;
+        itemIndex: number;
+        background: boolean;
+        mode: {
+            _enum: "blendMode";
+            _value: string;
+        };
+        layerEffects?: Record<string, {
+            enabled?: boolean | undefined;
+        } | {
+            enabled: boolean;
+        }[]> | undefined;
+    }[];
+}>;
+
+type PsLayerRef = {
+    id: number;
+    docId: number;
+};
+
+export { type CorrectBatchPlayOptions as C, type PsLayerRef as P, type UTCommandBase as U, type UTCommandModifying as a, type UTCommandNonModifying as b, createModifyingBatchPlayContext as c, type UTCommandResult as d, batchPlay as e, batchPlayCommand as f, batchPlayCommands as g, createCommand as h, createMultiGetDocumentCommand as i };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bubblydoo/uxp-toolkit",
-  "version": "0.0.5",
+  "version": "0.0.7",
   "license": "MIT",
   "type": "module",
   "author": "Hans Otto Wirtz <hansottowirtz@gmail.com>",
@@ -14,6 +14,10 @@
       "types": "./dist/index.d.ts",
       "import": "./dist/index.js"
     },
+    "./commands": {
+      "types": "./dist/commands-library/index.d.ts",
+      "import": "./dist/commands-library/index.js"
+    },
     "./package.json": "./package.json"
   },
   "publishConfig": {
@@ -39,8 +43,8 @@
     "typescript": "^5.8.3",
     "vitest": "^4.0.18",
     "zod": "^4.3.6",
-    "@bubblydoo/uxp-test-framework": "0.0.5",
-    "@bubblydoo/tsconfig": "0.0.3"
+    "@bubblydoo/tsconfig": "0.0.3",
+    "@bubblydoo/uxp-test-framework": "0.0.7"
   },
   "scripts": {
     "build": "tsup",

package/src/commands-library/addLayerToSelection.ts

@@ -0,0 +1,33 @@
+import { z } from "zod";
+import { createCommand } from "../core/command";
+import type { PsLayerRef } from "../ut-tree/psLayerRef";
+
+export function createAddLayerToSelectionCommand(
+  layerRef: PsLayerRef,
+  previousLayerRef: PsLayerRef
+) {
+  return createCommand({
+    modifying: true,
+    descriptor: {
+      _obj: 'select',
+      _target: [
+        {
+          _ref: 'layer',
+          _id: layerRef.id,
+        },
+        {
+          _ref: 'document',
+          _id: layerRef.docId,
+        },
+      ],
+      selectionModifier: {
+        _enum: 'selectionModifierType',
+        _value: 'addToSelection',
+      },
+      makeVisible: false,
+      layerID: [layerRef.id, previousLayerRef.id],
+      _isCommand: true,
+    },
+    schema: z.unknown(),
+  });
+}

package/src/commands-library/applyLayerMask.ts

@@ -0,0 +1,42 @@
+import { z } from "zod";
+import { createCommand } from "../core/command";
+
+export function createSelectLayerMaskCommand(layerId: number) {
+  return createCommand({
+    modifying: true,
+    descriptor: {
+      _obj: 'select',
+      _target: [
+        {
+          _ref: 'channel',
+          _enum: 'channel',
+          _value: 'mask',
+        },
+        {
+          _ref: 'layer',
+          _id: layerId,
+        },
+      ],
+      makeVisible: false,
+    },
+    schema: z.unknown(),
+  });
+}
+
+export function createDeleteChannelAndApplyCommand() {
+  return createCommand({
+    modifying: true,
+    descriptor: {
+      _obj: 'delete',
+      _target: [
+        {
+          _ref: 'channel',
+          _enum: 'ordinal',
+          _value: 'targetEnum',
+        },
+      ],
+      apply: true,
+    },
+    schema: z.unknown(),
+  });
+}

package/src/commands-library/convertMode.ts

@@ -0,0 +1,13 @@
+import { z } from "zod";
+import { createCommand } from "../core/command";
+
+export function createConvertModeCommand(depth: 8 | 16) {
+  return createCommand({
+    modifying: true,
+    descriptor: {
+      _obj: 'convertMode',
+      depth,
+    },
+    schema: z.unknown(),
+  });
+}

package/src/commands-library/createColorLookupAdjustmentLayer.ts

@@ -0,0 +1,24 @@
+import { z } from "zod";
+import { createCommand } from "../core/command";
+
+export function createColorLookupAdjustmentLayerCommand() {
+  return createCommand({
+    modifying: true,
+    descriptor: {
+      _obj: 'make',
+      _target: [
+        {
+          _ref: 'adjustmentLayer',
+        },
+      ],
+      using: {
+        _obj: 'adjustmentLayer',
+        type: {
+          _class: 'colorLookup',
+        },
+      },
+      _isCommand: true,
+    },
+    schema: z.unknown(),
+  });
+}