@bubblydoo/uxp-toolkit 0.0.6 → 0.0.8

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,62 +170,15 @@ 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/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", "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([
@@ -734,12 +512,8 @@ export {
   batchPlayCommands,
   copyToClipboard,
   createCommand,
-  createGetBackgroundLayerCommand,
-  createGetDocumentCommand,
-  createGetDocumentHasBackgroundLayerCommand,
   createModifyingBatchPlayContext,
   createMultiGetDocumentCommand,
-  createRenameLayerCommand,
   executeAsModal,
   executeAsModalAndSuspendHistory,
   flattenTree,

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.6",
+  "version": "0.0.8",
   "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": {
@@ -40,7 +44,7 @@
     "vitest": "^4.0.18",
     "zod": "^4.3.6",
     "@bubblydoo/tsconfig": "0.0.3",
-    "@bubblydoo/uxp-test-framework": "0.0.6"
+    "@bubblydoo/uxp-test-framework": "0.0.8"
   },
   "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(),
+  });
+}

package/src/commands-library/expandFolder.ts

@@ -0,0 +1,21 @@
+import { z } from "zod";
+import { createCommand } from "../core/command";
+import type { PsLayerRef } from "../ut-tree/psLayerRef";
+
+export function createExpandFolderCommand(layerRef: PsLayerRef) {
+  return createCommand({
+    modifying: true,
+    descriptor: {
+      _obj: 'set',
+      _target: {
+        _ref: [
+          { _property: 'layerSectionExpanded' },
+          { _ref: 'layer', _id: layerRef.id },
+          { _ref: 'document', _id: layerRef.docId }
+        ],
+      },
+      to: true,
+    },
+    schema: z.unknown(),
+  });
+}

package/src/commands-library/exportLUTs.ts

@@ -0,0 +1,45 @@
+import { z } from "zod";
+import { createCommand } from "../core/command";
+
+export type LUTExportFormat = 'CUBE' | 'ICC' | '3DL' | 'CSP';
+
+export interface ExportLUTsOptions {
+  description?: string;
+  gridPoints?: number;
+  copyright?: string;
+  exportFormats?: LUTExportFormat[];
+  lowercaseExtension?: boolean;
+}
+
+export function createExportLUTsCommand(
+  path: string,
+  options: ExportLUTsOptions = {}
+) {
+  const {
+    description = 'Exported LUT',
+    gridPoints = 32,
+    copyright = 'Copyright',
+    exportFormats = ['CUBE', 'ICC', '3DL', 'CSP'] as LUTExportFormat[],
+    lowercaseExtension = false,
+  } = options;
+
+  return createCommand({
+    modifying: true,
+    descriptor: {
+      _obj: 'export',
+      using: {
+        _obj: '$lut ',
+        $fpth: path,
+        $dscr: description,
+        $gPts: gridPoints,
+        copyright: copyright,
+        $wICC: exportFormats.includes('ICC'),
+        $w3DL: exportFormats.includes('3DL'),
+        $wCUB: exportFormats.includes('CUBE'),
+        $wCSP: exportFormats.includes('CSP'),
+        $lcFE: lowercaseExtension,
+      },
+    },
+    schema: z.unknown(),
+  });
+}

package/src/commands-library/hasVectorMask.ts

@@ -0,0 +1,23 @@
+import { z } from "zod";
+import { createCommand } from "../core/command";
+
+export function createHasVectorMaskCommand(layerId: number) {
+  return createCommand({
+    modifying: false,
+    descriptor: {
+      _obj: 'get',
+      _target: [
+        {
+          _property: 'hasVectorMask',
+        },
+        {
+          _ref: 'layer',
+          _id: layerId,
+        },
+      ],
+    },
+    schema: z.object({
+      hasVectorMask: z.boolean(),
+    }),
+  });
+}

package/src/commands-library/index.ts

@@ -0,0 +1,29 @@
+// Layer selection and manipulation
+export * from './selectLayer';
+export * from './addLayerToSelection';
+export * from './expandFolder';
+
+// Layer operations
+export * from './getLayer';
+export * from './renameLayer';
+export * from './rasterizeLayerStyle';
+export * from './rasterizeVectorMask';
+
+// Layer mask operations
+export * from './applyLayerMask';
+export * from './removeLayerMask';
+export * from './loadLayerMaskAsSelection';
+export * from './hasVectorMask';
+
+// Document operations
+export * from './getDocument';
+export * from './multiGetDocument';
+export * from './convertMode';
+
+// Color and LUT operations
+export * from './createColorLookupAdjustmentLayer';
+export * from './set3DLUTColorLookup';
+export * from './exportLUTs';
+
+// Other
+export * from './renderGrid';