@bubblydoo/uxp-toolkit 0.0.8 → 0.0.10

package/src/commands-library/createColorLookupAdjustmentLayer.ts

@@ -1,5 +1,5 @@
-import { z } from "zod";
-import { createCommand } from "../core/command";
+import { z } from 'zod';
+import { createCommand } from '../core/command';
 
 export function createColorLookupAdjustmentLayerCommand() {
   return createCommand({

package/src/commands-library/expandFolder.ts

@@ -1,6 +1,6 @@
-import { z } from "zod";
-import { createCommand } from "../core/command";
-import type { PsLayerRef } from "../ut-tree/psLayerRef";
+import type { PsLayerRef } from '../ut-tree/psLayerRef';
+import { z } from 'zod';
+import { createCommand } from '../core/command';
 
 export function createExpandFolderCommand(layerRef: PsLayerRef) {
   return createCommand({
@@ -11,7 +11,7 @@ export function createExpandFolderCommand(layerRef: PsLayerRef) {
         _ref: [
           { _property: 'layerSectionExpanded' },
           { _ref: 'layer', _id: layerRef.id },
-          { _ref: 'document', _id: layerRef.docId }
+          { _ref: 'document', _id: layerRef.docId },
         ],
       },
       to: true,

package/src/commands-library/exportLUTs.ts

@@ -1,5 +1,5 @@
-import { z } from "zod";
-import { createCommand } from "../core/command";
+import { z } from 'zod';
+import { createCommand } from '../core/command';
 
 export type LUTExportFormat = 'CUBE' | 'ICC' | '3DL' | 'CSP';
 
@@ -13,7 +13,7 @@ export interface ExportLUTsOptions {
 
 export function createExportLUTsCommand(
   path: string,
-  options: ExportLUTsOptions = {}
+  options: ExportLUTsOptions = {},
 ) {
   const {
     description = 'Exported LUT',
@@ -32,7 +32,7 @@ export function createExportLUTsCommand(
         $fpth: path,
         $dscr: description,
         $gPts: gridPoints,
-        copyright: copyright,
+        copyright,
         $wICC: exportFormats.includes('ICC'),
         $w3DL: exportFormats.includes('3DL'),
         $wCUB: exportFormats.includes('CUBE'),

package/src/commands-library/getDocument.ts

@@ -1,12 +1,12 @@
-import z from "zod";
-import { createCommand } from "../core/command";
+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 }] },
+      _obj: 'get',
+      _target: { _ref: [{ _ref: 'document', _id: documentId }] },
     },
     schema: z.object({
       title: z.string(),
@@ -21,11 +21,11 @@ export function createGetDocumentHasBackgroundLayerCommand(documentId: number) {
   return createCommand({
     modifying: false,
     descriptor: {
-      _obj: "get",
+      _obj: 'get',
       _target: {
         _ref: [
-          { _property: "hasBackgroundLayer" },
-          { _ref: "document", _id: documentId },
+          { _property: 'hasBackgroundLayer' },
+          { _ref: 'document', _id: documentId },
         ],
       },
     },

package/src/commands-library/getLayer.ts

@@ -1,6 +1,6 @@
-import z from "zod";
-import { createCommand } from "../core/command";
-import type { PsLayerRef } from "../ut-tree/psLayerRef";
+import type { PsLayerRef } from '../ut-tree/psLayerRef';
+import z from 'zod';
+import { createCommand } from '../core/command';
 
 const layerSchema = z.object({
   name: z.string(),
@@ -8,17 +8,17 @@ const layerSchema = z.object({
   group: z.boolean(),
   layerSection: z.object({
     _value: z.enum([
-      "layerSectionStart",
-      "layerSectionEnd",
-      "layerSectionContent",
+      'layerSectionStart',
+      'layerSectionEnd',
+      'layerSectionContent',
     ]),
-    _enum: z.literal("layerSectionType"),
+    _enum: z.literal('layerSectionType'),
   }),
   layerKind: z.number(),
   itemIndex: z.number(),
   background: z.boolean(),
   mode: z.object({
-    _enum: z.literal("blendMode"),
+    _enum: z.literal('blendMode'),
     _value: z.string(),
   }),
   layerID: z.number(),
@@ -34,10 +34,10 @@ export function createGetLayerCommand(layerRef: PsLayerRef) {
   return createCommand({
     modifying: false,
     descriptor: {
-      _obj: "get",
+      _obj: 'get',
       _target: [
-        { _ref: "layer", _id: layerRef.id },
-        { _ref: "document", _id: layerRef.docId },
+        { _ref: 'layer', _id: layerRef.id },
+        { _ref: 'document', _id: layerRef.docId },
       ],
     },
     schema: layerSchema,
@@ -48,8 +48,8 @@ export function createGetBackgroundLayerCommand(docId: number) {
   return createCommand({
     modifying: false,
     descriptor: {
-      _obj: "get",
-      _target: { _ref: [{ _ref: "layer", "_property": "background" }, { _ref: "document", _id: docId }] },
+      _obj: 'get',
+      _target: { _ref: [{ _ref: 'layer', _property: 'background' }, { _ref: 'document', _id: docId }] },
     },
     schema: layerSchema,
   });

package/src/commands-library/hasVectorMask.ts

@@ -1,5 +1,5 @@
-import { z } from "zod";
-import { createCommand } from "../core/command";
+import { z } from 'zod';
+import { createCommand } from '../core/command';
 
 export function createHasVectorMaskCommand(layerId: number) {
   return createCommand({

package/src/commands-library/index.ts

@@ -1,29 +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 './expandFolder';
 export * from './exportLUTs';
+// Document operations
+export * from './getDocument';
+
+// Layer operations
+export * from './getLayer';
+export * from './hasVectorMask';
+export * from './loadLayerMaskAsSelection';
+export * from './multiGetDocument';
 
+export * from './rasterizeLayerStyle';
+export * from './rasterizeVectorMask';
+export * from './removeLayerMask';
+
+export * from './renameLayer';
 // Other
 export * from './renderGrid';
+// Layer selection and manipulation
+export * from './selectLayer';
+
+export * from './set3DLUTColorLookup';

package/src/commands-library/loadLayerMaskAsSelection.ts

@@ -1,5 +1,5 @@
-import { z } from "zod";
-import { createCommand } from "../core/command";
+import { z } from 'zod';
+import { createCommand } from '../core/command';
 
 export function createLoadLayerMaskAsSelectionCommand(layerId: number) {
   return createCommand({

package/src/commands-library/multiGetDocument.ts

@@ -1,15 +1,15 @@
-import { z } from "zod";
-import { createCommand } from "../core/command";
+import { z } from 'zod';
+import { createCommand } from '../core/command';
 
 export function createMultiGetDocumentCommand(docId: number) {
   return createCommand({
     modifying: false,
     descriptor: {
-      _obj: "multiGet",
-      _target: { _ref: [{ _ref: "document", _id: docId }] },
+      _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 },
+        ['name', 'layerID', 'visible', 'group', 'layerSection', 'layerKind', 'itemIndex', 'background', 'mode', 'layerEffects'],
+        { _obj: 'layer', index: 1, count: -1 },
       ],
     },
     schema: z.object({
@@ -21,17 +21,17 @@ export function createMultiGetDocumentCommand(docId: number) {
           group: z.boolean(),
           layerSection: z.object({
             _value: z.enum([
-              "layerSectionStart",
-              "layerSectionEnd",
-              "layerSectionContent",
+              'layerSectionStart',
+              'layerSectionEnd',
+              'layerSectionContent',
             ]),
-            _enum: z.literal("layerSectionType"),
+            _enum: z.literal('layerSectionType'),
           }),
           layerKind: z.number(),
           itemIndex: z.number(),
           background: z.boolean(),
           mode: z.object({
-            _enum: z.literal("blendMode"),
+            _enum: z.literal('blendMode'),
             _value: z.string(),
           }),
           layerEffects: z.record(z.string(), z.object({
@@ -40,8 +40,8 @@ export function createMultiGetDocumentCommand(docId: number) {
           }).or(z.array(z.object({
             enabled: z.boolean(),
           })))).optional(),
-        })
-      )
-    })
+        }),
+      ),
+    }),
   });
 }

package/src/commands-library/rasterizeLayerStyle.ts

@@ -1,6 +1,6 @@
-import { z } from "zod";
-import { createCommand } from "../core/command";
-import type { PsLayerRef } from "../ut-tree/psLayerRef";
+import type { PsLayerRef } from '../ut-tree/psLayerRef';
+import { z } from 'zod';
+import { createCommand } from '../core/command';
 
 export function createRasterizeLayerStyleCommand(psLayerRef: PsLayerRef) {
   return createCommand({

package/src/commands-library/rasterizeVectorMask.ts

@@ -1,5 +1,5 @@
-import { z } from "zod";
-import { createCommand } from "../core/command";
+import { z } from 'zod';
+import { createCommand } from '../core/command';
 
 export function createRasterizeVectorMaskCommand() {
   return createCommand({

package/src/commands-library/removeLayerMask.ts

@@ -1,5 +1,5 @@
-import { z } from "zod";
-import { createCommand } from "../core/command";
+import { z } from 'zod';
+import { createCommand } from '../core/command';
 
 export function createDeleteChannelCommand() {
   return createCommand({

package/src/commands-library/renameLayer.ts

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

package/src/commands-library/renameLayer.uxp-test.ts

@@ -1,10 +1,10 @@
-import { executeAsModal } from "../core/executeAsModal";
-import { openFileByPath } from "../filesystem/openFileByPath";
-import { getDocumentLayerDescriptors } from "../ut-tree/getDocumentLayerDescriptors";
-import type { Test } from "@bubblydoo/uxp-test-framework";
-import { expect } from "chai";
-import { app } from "photoshop";
-import { createRenameLayerCommand } from "./renameLayer";
+import type { Test } from '@bubblydoo/uxp-test-framework';
+import { expect } from 'chai';
+import { app } from 'photoshop';
+import { executeAsModal } from '../core/executeAsModal';
+import { openFileByPath } from '../filesystem/openFileByPath';
+import { getDocumentLayerDescriptors } from '../ut-tree/getDocumentLayerDescriptors';
+import { createRenameLayerCommand } from './renameLayer';
 
 async function getFirstLayer() {
   const allLayers = await getDocumentLayerDescriptors(app.activeDocument.id);
@@ -18,15 +18,15 @@ async function getFirstLayer() {
 }
 
 export const renameLayerTest: Test = {
-  name: "Rename Layer",
+  name: 'Rename Layer',
   async run() {
-    await openFileByPath("plugin:/fixtures/one-layer.psd");
+    await openFileByPath('plugin:/fixtures/one-layer.psd');
     const layer = await getFirstLayer();
-    expect(layer.name).to.equal("Layer 1");
-    await executeAsModal("Rename Layer", async (ctx) => {
-      await ctx.batchPlayCommand(createRenameLayerCommand(layer.ref, "New Name"));
+    expect(layer.name).to.equal('Layer 1');
+    await executeAsModal('Rename Layer', async (ctx) => {
+      await ctx.batchPlayCommand(createRenameLayerCommand(layer.ref, 'New Name'));
     });
     const layer2 = await getFirstLayer();
-    expect(layer2.name).to.equal("New Name");
+    expect(layer2.name).to.equal('New Name');
   },
 };

package/src/commands-library/renderGrid.ts

@@ -1,5 +1,5 @@
-import { z } from "zod";
-import { createCommand } from "../core/command";
+import { z } from 'zod';
+import { createCommand } from '../core/command';
 
 export function createRenderGridCommand(gridPoints: number) {
   return createCommand({

package/src/commands-library/selectLayer.ts

@@ -1,6 +1,6 @@
-import { z } from "zod";
-import { createCommand } from "../core/command";
-import type { PsLayerRef } from "../ut-tree/psLayerRef";
+import type { PsLayerRef } from '../ut-tree/psLayerRef';
+import { z } from 'zod';
+import { createCommand } from '../core/command';
 
 export function createSelectLayerCommand(layerRef: PsLayerRef) {
   return createCommand({

package/src/commands-library/set3DLUTColorLookup.ts

@@ -1,5 +1,5 @@
-import { z } from "zod";
-import { createCommand } from "../core/command";
+import { z } from 'zod';
+import { createCommand } from '../core/command';
 
 export type LUTFormatType = 'LUTFormatCUBE' | 'LUTFormat3DL' | 'LUTFormatCSP';
 

package/src/core/batchPlay.ts

@@ -1,4 +1,4 @@
-import { action } from "photoshop";
+import { action } from 'photoshop';
 
 type P = Parameters<typeof action.batchPlay>;
 
@@ -9,8 +9,8 @@ export type CorrectBatchPlayOptions = P[1] & {
 export async function batchPlay(actions: P[0], options?: CorrectBatchPlayOptions) {
   return action.batchPlay(actions, {
     ...options,
-    modalBehavior: "execute",
-    dialogOptions: "silent",
+    modalBehavior: 'execute',
+    dialogOptions: 'silent',
     synchronousExecution: false,
   });
 }

package/src/core/command.test-d.ts

@@ -1,14 +1,16 @@
-import { describe, expectTypeOf, test } from "vitest";
-import { z } from "zod";
+/* eslint-disable unused-imports/no-unused-vars */
+import type { UTCommandResult } from './command';
+import { describe, expectTypeOf, test } from 'vitest';
+import { z } from 'zod';
 import {
   createCommand,
-  type UTCommandResult,
-} from "./command";
 
-describe("UTCommandResult type tests", () => {
-  test("extracts result type from non-modifying command", () => {
+} from './command';
+
+describe('UTCommandResult type tests', () => {
+  test('extracts result type from non-modifying command', () => {
     const command = createCommand({
-      descriptor: { _obj: "get" },
+      descriptor: { _obj: 'get' },
       schema: z.object({
         name: z.string(),
         count: z.number(),
@@ -22,4 +24,5 @@ describe("UTCommandResult type tests", () => {
       name: string;
       count: number;
     }>();
-  });});
+  });
+});

package/src/core/command.ts

@@ -1,29 +1,26 @@
-import type { ActionDescriptor } from "photoshop/dom/CoreModules";
-import { z } from "zod";
-import { batchPlay } from "./batchPlay";
-import { executeAsModal } from "./executeAsModal";
-import type { CorrectExecutionContext } from "./executeAsModal";
-import { action } from "photoshop";
-
-export interface UTCommandBase<T extends any> {
+import type { ActionDescriptor } from 'photoshop';
+import type { z } from 'zod';
+import { batchPlay } from './batchPlay';
+
+export interface UTCommandBase<T> {
   descriptor: ActionDescriptor;
   schema: z.ZodSchema<T>;
 }
 
-export interface UTCommandModifying<T extends any> extends UTCommandBase<T> {
+export interface UTCommandModifying<T> extends UTCommandBase<T> {
   modifying: true;
 }
 
-export interface UTCommandNonModifying<T extends any> extends UTCommandBase<T> {
+export interface UTCommandNonModifying<T> extends UTCommandBase<T> {
   modifying: false;
 }
 
-export function createCommand<TReturn extends any, TModifying extends boolean>(
+export function createCommand<TReturn, TModifying extends boolean>(
   obj: {
-    descriptor: ActionDescriptor,
-    schema: z.ZodSchema<TReturn>,
-    modifying: TModifying,
-  }
+    descriptor: ActionDescriptor;
+    schema: z.ZodSchema<TReturn>;
+    modifying: TModifying;
+  },
 ): TModifying extends true ? UTCommandModifying<TReturn> : UTCommandNonModifying<TReturn> {
   return {
     modifying: obj.modifying,
@@ -36,28 +33,28 @@ export type UTCommandResult<C> = C extends UTCommandBase<infer T> ? T : never;
 
 type BatchPlayOptions = Parameters<typeof batchPlay>[1];
 
-async function batchPlayCommandBase<T extends any>(command: UTCommandBase<T>, options?: BatchPlayOptions) {
+async function batchPlayCommandBase<T>(command: UTCommandBase<T>, options?: BatchPlayOptions) {
   const [result] = await batchPlay([command.descriptor], options);
-  if (result?._obj === "error") {
-    throw new Error("Batch play command failed", { cause: result });
+  if (result?._obj === 'error') {
+    throw new Error('Batch play command failed', { cause: result });
   }
   return command.schema.parse(result);
 }
 
 async function batchPlayCommandsBase<TCommands extends Array<UTCommandBase<any>>>(
   commands: readonly [...TCommands],
-  options?: BatchPlayOptions
+  options?: BatchPlayOptions,
 ): Promise<{
   [K in keyof TCommands]: UTCommandResult<TCommands[K]>;
 }> {
   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] });
+  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])) as any;
 }
 
-export function batchPlayCommand<T extends any>(command: UTCommandNonModifying<T>, options?: BatchPlayOptions) {
+export function batchPlayCommand<T>(command: UTCommandNonModifying<T>, options?: BatchPlayOptions) {
   return batchPlayCommandBase(command, options);
 }
 
@@ -69,7 +66,7 @@ export function createModifyingBatchPlayContext() {
   return {
     batchPlayCommand: batchPlayCommandBase,
     batchPlayCommands: batchPlayCommandsBase,
-  }
+  };
 }
 // some examples:
 

package/src/core/executeAsModal.ts

@@ -1,75 +1,17 @@
-import { core } from "photoshop";
-import { createModifyingBatchPlayContext } from "./command";
+import type { ExecuteAsModalOptions, ExecutionContext } from 'photoshop';
+import { core } from 'photoshop';
+import { createModifyingBatchPlayContext } from './command';
 
-// copied from devtools:
-// hostControl: {suspendHistory: ƒ, resumeHistory: ƒ, registerAutoCloseDocument: ƒ, unregisterAutoCloseDocument: ƒ}
-// mode: "action"
-// uiMode: "never"
-// finalizeArguments: ƒ ()
-// isCancelled: undefined
-// onCancel: undefined
-// reject: ƒ ()
-// reportProgress: ƒ ()
-// resolve: ƒ ()
-
-export type CorrectExecutionContext = {
-  /**
-   * True if user has cancelled the modal interaction.
-   *
-   * User can cancel by hitting the Escape key, or by pressing the "Cancel" button in the progress bar.
-   */
-  isCancelled: boolean;
-  /**
-   * If assigned a method, it will be called when user cancels the modal interaction.
-   */
-  onCancel: () => void;
-  /**
-   * Call this to customize the progress bar.
-   */
-  reportProgress: (info: {
-    value: number;
-    commandName?: string;
-  }) => void;
-  /**
-   * Use the methods in here to control Photoshop state
-   */
-  hostControl: {
-    /**
-     * Call to suspend history on a target document, returns the suspension ID which can be used for resumeHistory
-     */
-    suspendHistory: (info: {
-      documentID: number,
-      name: string,
-    }) => Promise<number>;
-    /**
-     * Call to resume history on a target document
-     */
-    resumeHistory: (suspensionID: number, commit: boolean) => Promise<void>;
-    /** Register a document to be closed when the modal scope exits. See below for details. */
-    registerAutoCloseDocument: (documentID: number) => Promise<void>;
-    /** Unregister a document from being closed when the modal scope exits */
-    unregisterAutoCloseDocument: (documentID: number) => Promise<void>;
-  };
-}
-
-export type CorrectExecuteAsModalOptions = {
-  commandName: string;
-  interactive?: boolean;
-  timeOut?: number;
-}
-
-export type ExtendedExecutionContext = Omit<CorrectExecutionContext, "onCancel"> & ReturnType<typeof createModifyingBatchPlayContext> & {
+export type ExtendedExecutionContext = Omit<ExecutionContext, 'onCancel'> & ReturnType<typeof createModifyingBatchPlayContext> & {
   signal: AbortSignal;
 };
 
-const originalExecuteAsModal: <T>(fn: (executionContext: CorrectExecutionContext) => Promise<void>, opts: CorrectExecuteAsModalOptions) => Promise<T> = core.executeAsModal as any;
-
-type OptionsWithoutCommandName = Omit<CorrectExecuteAsModalOptions, "commandName">;
+type OptionsWithoutCommandName = Omit<ExecuteAsModalOptions, 'commandName'>;
 
 export async function executeAsModal<T>(commandName: string, fn: (executionContext: ExtendedExecutionContext) => Promise<T>, opts?: OptionsWithoutCommandName): Promise<T> {
   let error: unknown;
   let result: T;
-  await originalExecuteAsModal(async (executionContext) => {
+  await core.executeAsModal(async (executionContext) => {
     const abortController = new AbortController();
     executionContext.onCancel = () => {
       abortController.abort();
@@ -84,8 +26,9 @@ export async function executeAsModal<T>(commandName: string, fn: (executionConte
     };
     try {
       result = await fn(extendedExecutionContext);
-    } catch (e) {
-      console.error("error in executeAsModal");
+    }
+    catch (e) {
+      console.error('error in executeAsModal');
       console.error(e);
       error = e;
     }
@@ -95,7 +38,8 @@ export async function executeAsModal<T>(commandName: string, fn: (executionConte
   });
   if (error) {
     throw error;
-  } else {
+  }
+  else {
     return result!;
   }
 }

package/src/core/suspendHistory.ts

@@ -1,11 +1,11 @@
-import type { Document } from "photoshop/dom/Document";
+import type { Document } from 'photoshop';
 
 // The Adobe provided type is wrong
-export type SuspendHistoryContext = {};
+export interface SuspendHistoryContext {}
 export async function suspendHistory<T>(
   document: Document,
   historyStateName: string,
-  fn: (context: SuspendHistoryContext) => Promise<T>
+  fn: (context: SuspendHistoryContext) => Promise<T>,
 ): Promise<T> {
   let result: T | undefined;
   await document.suspendHistory(async (context) => {