@bubblydoo/uxp-toolkit 0.0.8 → 0.0.9

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,5 +1,5 @@
-import { core } from "photoshop";
-import { createModifyingBatchPlayContext } from "./command";
+import { core } from 'photoshop';
+import { createModifyingBatchPlayContext } from './command';
 
 // copied from devtools:
 // hostControl: {suspendHistory: ƒ, resumeHistory: ƒ, registerAutoCloseDocument: ƒ, unregisterAutoCloseDocument: ƒ}
@@ -12,7 +12,7 @@ import { createModifyingBatchPlayContext } from "./command";
 // reportProgress: ƒ ()
 // resolve: ƒ ()
 
-export type CorrectExecutionContext = {
+export interface CorrectExecutionContext {
   /**
    * True if user has cancelled the modal interaction.
    *
@@ -38,8 +38,8 @@ export type CorrectExecutionContext = {
      * Call to suspend history on a target document, returns the suspension ID which can be used for resumeHistory
      */
     suspendHistory: (info: {
-      documentID: number,
-      name: string,
+      documentID: number;
+      name: string;
     }) => Promise<number>;
     /**
      * Call to resume history on a target document
@@ -52,19 +52,19 @@ export type CorrectExecutionContext = {
   };
 }
 
-export type CorrectExecuteAsModalOptions = {
+export interface CorrectExecuteAsModalOptions {
   commandName: string;
   interactive?: boolean;
   timeOut?: number;
 }
 
-export type ExtendedExecutionContext = Omit<CorrectExecutionContext, "onCancel"> & ReturnType<typeof createModifyingBatchPlayContext> & {
+export type ExtendedExecutionContext = Omit<CorrectExecutionContext, '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<CorrectExecuteAsModalOptions, 'commandName'>;
 
 export async function executeAsModal<T>(commandName: string, fn: (executionContext: ExtendedExecutionContext) => Promise<T>, opts?: OptionsWithoutCommandName): Promise<T> {
   let error: unknown;
@@ -84,8 +84,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 +96,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) => {

package/src/core/suspendHistory.uxp-test.ts

@@ -1,18 +1,18 @@
-import type { Test } from "@bubblydoo/uxp-test-framework";
-import { expect } from "chai";
-import { suspendHistory } from "./suspendHistory";
-import { app } from "photoshop";
+import type { Test } from '@bubblydoo/uxp-test-framework';
+import { expect } from 'chai';
+import { app } from 'photoshop';
+import { suspendHistory } from './suspendHistory';
 
 export const suspendHistoryTest: Test = {
-  name: "core/suspendHistory should return correctly",
+  name: 'core/suspendHistory should return correctly',
   async run() {
     const document = app.activeDocument;
     if (!document) {
-      throw new Error("No active document");
+      throw new Error('No active document');
     }
-    const result = await suspendHistory(document, "Test", async (context) => {
+    const result = await suspendHistory(document, 'Test', async (context) => {
       return 'test';
     });
     expect(result).to.equal('test');
   },
-};
+};