@bubblydoo/uxp-toolkit 0.0.7 → 0.0.9

package/dist/commands-library/index.js

@@ -5,11 +5,11 @@ import {
   createGetDocumentHasBackgroundLayerCommand,
   createGetLayerCommand,
   createMultiGetDocumentCommand
-} from "../chunk-3CLJMC63.js";
+} from "../chunk-JBXCIUBZ.js";
 
-// src/commands-library/selectLayer.ts
+// src/commands-library/addLayerToSelection.ts
 import { z } from "zod";
-function createSelectLayerCommand(layerRef) {
+function createAddLayerToSelectionCommand(layerRef, previousLayerRef) {
   return createCommand({
     modifying: true,
     descriptor: {
@@ -24,176 +24,172 @@ function createSelectLayerCommand(layerRef) {
           _id: layerRef.docId
         }
       ],
+      selectionModifier: {
+        _enum: "selectionModifierType",
+        _value: "addToSelection"
+      },
       makeVisible: false,
-      layerID: [layerRef.id],
-      _isCommand: false
+      layerID: [layerRef.id, previousLayerRef.id],
+      _isCommand: true
     },
     schema: z.unknown()
   });
 }
 
-// src/commands-library/addLayerToSelection.ts
+// src/commands-library/applyLayerMask.ts
 import { z as z2 } from "zod";
-function createAddLayerToSelectionCommand(layerRef, previousLayerRef) {
+function createSelectLayerMaskCommand(layerId) {
   return createCommand({
     modifying: true,
     descriptor: {
       _obj: "select",
       _target: [
         {
-          _ref: "layer",
-          _id: layerRef.id
+          _ref: "channel",
+          _enum: "channel",
+          _value: "mask"
         },
         {
-          _ref: "document",
-          _id: layerRef.docId
+          _ref: "layer",
+          _id: layerId
         }
       ],
-      selectionModifier: {
-        _enum: "selectionModifierType",
-        _value: "addToSelection"
-      },
-      makeVisible: false,
-      layerID: [layerRef.id, previousLayerRef.id],
-      _isCommand: true
+      makeVisible: false
+    },
+    schema: z2.unknown()
+  });
+}
+function createDeleteChannelAndApplyCommand() {
+  return createCommand({
+    modifying: true,
+    descriptor: {
+      _obj: "delete",
+      _target: [
+        {
+          _ref: "channel",
+          _enum: "ordinal",
+          _value: "targetEnum"
+        }
+      ],
+      apply: true
     },
     schema: z2.unknown()
   });
 }
 
-// src/commands-library/expandFolder.ts
+// src/commands-library/convertMode.ts
 import { z as z3 } from "zod";
-function createExpandFolderCommand(layerRef) {
+function createConvertModeCommand(depth) {
   return createCommand({
     modifying: true,
     descriptor: {
-      _obj: "set",
-      _target: {
-        _ref: [
-          { _property: "layerSectionExpanded" },
-          { _ref: "layer", _id: layerRef.id },
-          { _ref: "document", _id: layerRef.docId }
-        ]
-      },
-      to: true
+      _obj: "convertMode",
+      depth
     },
     schema: z3.unknown()
   });
 }
 
-// src/commands-library/renameLayer.ts
+// src/commands-library/createColorLookupAdjustmentLayer.ts
 import { z as z4 } from "zod";
-function createRenameLayerCommand(layerRef, newName) {
+function createColorLookupAdjustmentLayerCommand() {
   return createCommand({
     modifying: true,
     descriptor: {
-      _obj: "set",
-      _target: [{ _ref: "layer", _id: layerRef.id }, { _ref: "document", _id: layerRef.docId }],
-      to: { _obj: "layer", name: newName }
+      _obj: "make",
+      _target: [
+        {
+          _ref: "adjustmentLayer"
+        }
+      ],
+      using: {
+        _obj: "adjustmentLayer",
+        type: {
+          _class: "colorLookup"
+        }
+      },
+      _isCommand: true
     },
     schema: z4.unknown()
   });
 }
 
-// src/commands-library/rasterizeLayerStyle.ts
+// src/commands-library/expandFolder.ts
 import { z as z5 } from "zod";
-function createRasterizeLayerStyleCommand(psLayerRef) {
+function createExpandFolderCommand(layerRef) {
   return createCommand({
     modifying: true,
     descriptor: {
-      _obj: "rasterizeLayer",
-      _target: [{ _ref: "layer", _id: psLayerRef.id }, { _ref: "document", _id: psLayerRef.docId }],
-      what: { _enum: "rasterizeItem", _value: "layerStyle" }
+      _obj: "set",
+      _target: {
+        _ref: [
+          { _property: "layerSectionExpanded" },
+          { _ref: "layer", _id: layerRef.id },
+          { _ref: "document", _id: layerRef.docId }
+        ]
+      },
+      to: true
     },
     schema: z5.unknown()
   });
 }
 
-// src/commands-library/rasterizeVectorMask.ts
+// src/commands-library/exportLUTs.ts
 import { z as z6 } from "zod";
-function createRasterizeVectorMaskCommand() {
+function createExportLUTsCommand(path, options = {}) {
+  const {
+    description = "Exported LUT",
+    gridPoints = 32,
+    copyright = "Copyright",
+    exportFormats = ["CUBE", "ICC", "3DL", "CSP"],
+    lowercaseExtension = false
+  } = options;
   return createCommand({
     modifying: true,
     descriptor: {
-      _obj: "rasterizeLayer",
-      _target: [
-        {
-          _ref: "layer",
-          _enum: "ordinal",
-          _value: "targetEnum"
-        }
-      ],
-      what: {
-        _enum: "rasterizeItem",
-        _value: "vectorMask"
+      _obj: "export",
+      using: {
+        _obj: "$lut ",
+        $fpth: path,
+        $dscr: description,
+        $gPts: gridPoints,
+        copyright,
+        $wICC: exportFormats.includes("ICC"),
+        $w3DL: exportFormats.includes("3DL"),
+        $wCUB: exportFormats.includes("CUBE"),
+        $wCSP: exportFormats.includes("CSP"),
+        $lcFE: lowercaseExtension
       }
     },
     schema: z6.unknown()
   });
 }
 
-// src/commands-library/applyLayerMask.ts
+// src/commands-library/hasVectorMask.ts
 import { z as z7 } from "zod";
-function createSelectLayerMaskCommand(layerId) {
+function createHasVectorMaskCommand(layerId) {
   return createCommand({
-    modifying: true,
+    modifying: false,
     descriptor: {
-      _obj: "select",
+      _obj: "get",
       _target: [
         {
-          _ref: "channel",
-          _enum: "channel",
-          _value: "mask"
+          _property: "hasVectorMask"
         },
         {
           _ref: "layer",
           _id: layerId
         }
-      ],
-      makeVisible: false
-    },
-    schema: z7.unknown()
-  });
-}
-function createDeleteChannelAndApplyCommand() {
-  return createCommand({
-    modifying: true,
-    descriptor: {
-      _obj: "delete",
-      _target: [
-        {
-          _ref: "channel",
-          _enum: "ordinal",
-          _value: "targetEnum"
-        }
-      ],
-      apply: true
-    },
-    schema: z7.unknown()
-  });
-}
-
-// src/commands-library/removeLayerMask.ts
-import { z as z8 } from "zod";
-function createDeleteChannelCommand() {
-  return createCommand({
-    modifying: true,
-    descriptor: {
-      _obj: "delete",
-      _target: [
-        {
-          _ref: "channel",
-          _enum: "ordinal",
-          _value: "targetEnum"
-        }
       ]
     },
-    schema: z8.unknown()
+    schema: z7.object({
+      hasVectorMask: z7.boolean()
+    })
   });
 }
 
 // src/commands-library/loadLayerMaskAsSelection.ts
-import { z as z9 } from "zod";
+import { z as z8 } from "zod";
 function createLoadLayerMaskAsSelectionCommand(layerId) {
   return createCommand({
     modifying: true,
@@ -219,72 +215,120 @@ function createLoadLayerMaskAsSelectionCommand(layerId) {
         ]
       }
     },
+    schema: z8.unknown()
+  });
+}
+
+// src/commands-library/rasterizeLayerStyle.ts
+import { z as z9 } from "zod";
+function createRasterizeLayerStyleCommand(psLayerRef) {
+  return createCommand({
+    modifying: true,
+    descriptor: {
+      _obj: "rasterizeLayer",
+      _target: [{ _ref: "layer", _id: psLayerRef.id }, { _ref: "document", _id: psLayerRef.docId }],
+      what: { _enum: "rasterizeItem", _value: "layerStyle" }
+    },
     schema: z9.unknown()
   });
 }
 
-// src/commands-library/hasVectorMask.ts
+// src/commands-library/rasterizeVectorMask.ts
 import { z as z10 } from "zod";
-function createHasVectorMaskCommand(layerId) {
+function createRasterizeVectorMaskCommand() {
   return createCommand({
-    modifying: false,
+    modifying: true,
     descriptor: {
-      _obj: "get",
+      _obj: "rasterizeLayer",
       _target: [
-        {
-          _property: "hasVectorMask"
-        },
         {
           _ref: "layer",
-          _id: layerId
+          _enum: "ordinal",
+          _value: "targetEnum"
         }
-      ]
+      ],
+      what: {
+        _enum: "rasterizeItem",
+        _value: "vectorMask"
+      }
     },
-    schema: z10.object({
-      hasVectorMask: z10.boolean()
-    })
+    schema: z10.unknown()
   });
 }
 
-// src/commands-library/convertMode.ts
+// src/commands-library/removeLayerMask.ts
 import { z as z11 } from "zod";
-function createConvertModeCommand(depth) {
+function createDeleteChannelCommand() {
   return createCommand({
     modifying: true,
     descriptor: {
-      _obj: "convertMode",
-      depth
+      _obj: "delete",
+      _target: [
+        {
+          _ref: "channel",
+          _enum: "ordinal",
+          _value: "targetEnum"
+        }
+      ]
     },
     schema: z11.unknown()
   });
 }
 
-// src/commands-library/createColorLookupAdjustmentLayer.ts
+// src/commands-library/renameLayer.ts
 import { z as z12 } from "zod";
-function createColorLookupAdjustmentLayerCommand() {
+function createRenameLayerCommand(layerRef, newName) {
   return createCommand({
     modifying: true,
     descriptor: {
-      _obj: "make",
+      _obj: "set",
+      _target: [{ _ref: "layer", _id: layerRef.id }, { _ref: "document", _id: layerRef.docId }],
+      to: { _obj: "layer", name: newName }
+    },
+    schema: z12.unknown()
+  });
+}
+
+// src/commands-library/renderGrid.ts
+import { z as z13 } from "zod";
+function createRenderGridCommand(gridPoints) {
+  return createCommand({
+    modifying: true,
+    descriptor: {
+      _obj: "$3grd",
+      $grdP: gridPoints
+    },
+    schema: z13.unknown()
+  });
+}
+
+// src/commands-library/selectLayer.ts
+import { z as z14 } from "zod";
+function createSelectLayerCommand(layerRef) {
+  return createCommand({
+    modifying: true,
+    descriptor: {
+      _obj: "select",
       _target: [
         {
-          _ref: "adjustmentLayer"
+          _ref: "layer",
+          _id: layerRef.id
+        },
+        {
+          _ref: "document",
+          _id: layerRef.docId
         }
       ],
-      using: {
-        _obj: "adjustmentLayer",
-        type: {
-          _class: "colorLookup"
-        }
-      },
-      _isCommand: true
+      makeVisible: false,
+      layerID: [layerRef.id],
+      _isCommand: false
     },
-    schema: z12.unknown()
+    schema: z14.unknown()
   });
 }
 
 // src/commands-library/set3DLUTColorLookup.ts
-import { z as z13 } from "zod";
+import { z as z15 } from "zod";
 function createSet3DLUTColorLookupCommand(options) {
   const {
     lutPath,
@@ -330,50 +374,6 @@ function createSet3DLUTColorLookupCommand(options) {
       },
       _isCommand: true
     },
-    schema: z13.unknown()
-  });
-}
-
-// src/commands-library/exportLUTs.ts
-import { z as z14 } from "zod";
-function createExportLUTsCommand(path, options = {}) {
-  const {
-    description = "Exported LUT",
-    gridPoints = 32,
-    copyright = "Copyright",
-    exportFormats = ["CUBE", "ICC", "3DL", "CSP"],
-    lowercaseExtension = false
-  } = options;
-  return createCommand({
-    modifying: true,
-    descriptor: {
-      _obj: "export",
-      using: {
-        _obj: "$lut ",
-        $fpth: path,
-        $dscr: description,
-        $gPts: gridPoints,
-        copyright,
-        $wICC: exportFormats.includes("ICC"),
-        $w3DL: exportFormats.includes("3DL"),
-        $wCUB: exportFormats.includes("CUBE"),
-        $wCSP: exportFormats.includes("CSP"),
-        $lcFE: lowercaseExtension
-      }
-    },
-    schema: z14.unknown()
-  });
-}
-
-// src/commands-library/renderGrid.ts
-import { z as z15 } from "zod";
-function createRenderGridCommand(gridPoints) {
-  return createCommand({
-    modifying: true,
-    descriptor: {
-      _obj: "$3grd",
-      $grdP: gridPoints
-    },
     schema: z15.unknown()
   });
 }

package/dist/index.d.ts

@@ -1,14 +1,11 @@
-import { c as createModifyingBatchPlayContext, P as PsLayerRef } from './psLayerRef-OY3h7srv.js';
-export { C as CorrectBatchPlayOptions, U as UTCommandBase, a as UTCommandModifying, b as UTCommandNonModifying, d as UTCommandResult, e as batchPlay, f as batchPlayCommand, g as batchPlayCommands, h as createCommand, i as createMultiGetDocumentCommand } from './psLayerRef-OY3h7srv.js';
-import * as photoshop_dom_Document from 'photoshop/dom/Document';
-import { Document } from 'photoshop/dom/Document';
-import { Layer } from 'photoshop/dom/Layer';
-import { z } from 'zod';
+import { c as createModifyingBatchPlayContext, P as PsLayerRef } from './psLayerRef-CGbTO4a5.js';
+export { C as CorrectBatchPlayOptions, U as UTCommandBase, a as UTCommandModifying, b as UTCommandNonModifying, d as UTCommandResult, e as batchPlay, f as batchPlayCommand, g as batchPlayCommands, h as createCommand, i as createMultiGetDocumentCommand } from './psLayerRef-CGbTO4a5.js';
+import * as photoshop from 'photoshop';
+import { Document, Layer } from 'photoshop';
 import ErrorStackParser from 'error-stack-parser';
-import 'photoshop/dom/CoreModules';
-import 'photoshop';
+import { z } from 'zod';
 
-type CorrectExecutionContext = {
+interface CorrectExecutionContext {
     /**
      * True if user has cancelled the modal interaction.
      *
@@ -46,25 +43,26 @@ type CorrectExecutionContext = {
         /** Unregister a document from being closed when the modal scope exits */
         unregisterAutoCloseDocument: (documentID: number) => Promise<void>;
     };
-};
-type CorrectExecuteAsModalOptions = {
+}
+interface CorrectExecuteAsModalOptions {
     commandName: string;
     interactive?: boolean;
     timeOut?: number;
-};
-type ExtendedExecutionContext = Omit<CorrectExecutionContext, "onCancel"> & ReturnType<typeof createModifyingBatchPlayContext> & {
+}
+type ExtendedExecutionContext = Omit<CorrectExecutionContext, 'onCancel'> & ReturnType<typeof createModifyingBatchPlayContext> & {
     signal: AbortSignal;
 };
-type OptionsWithoutCommandName = Omit<CorrectExecuteAsModalOptions, "commandName">;
+type OptionsWithoutCommandName = Omit<CorrectExecuteAsModalOptions, 'commandName'>;
 declare function executeAsModal<T>(commandName: string, fn: (executionContext: ExtendedExecutionContext) => Promise<T>, opts?: OptionsWithoutCommandName): Promise<T>;
 
-type SuspendHistoryContext = {};
+interface SuspendHistoryContext {
+}
 declare function suspendHistory<T>(document: Document, historyStateName: string, fn: (context: SuspendHistoryContext) => Promise<T>): Promise<T>;
 
 type CombinedFn<T> = (executionContext: ExtendedExecutionContext, suspendHistoryContext: SuspendHistoryContext) => Promise<T>;
-declare const executeAsModalAndSuspendHistory: <T>(commandName: string, document: Document, fn: CombinedFn<T>) => Promise<T>;
+declare function executeAsModalAndSuspendHistory<T>(commandName: string, document: Document, fn: CombinedFn<T>): Promise<T>;
 
-declare const getFlattenedDomLayersList: (layers: Layer[]) => Layer[];
+declare function getFlattenedDomLayersList(layers: Layer[]): Layer[];
 
 type Tree<TRef = unknown> = {
     ref: TRef;
@@ -72,21 +70,27 @@ type Tree<TRef = unknown> = {
     children?: Tree<TRef>;
 }[];
 
-declare const photoshopDomLayersToTree: (layers: Layer[]) => Tree<Layer>;
+declare function photoshopDomLayersToTree(layers: Layer[]): Tree<Layer>;
 
-declare function openFileByPath(path: string): Promise<photoshop_dom_Document.Document>;
+type BasicStackFrame = Pick<ErrorStackParser.StackFrame, 'functionName' | 'fileName' | 'lineNumber' | 'columnNumber'>;
+declare function parseUxpErrorSourcemaps(error: Error, opts?: {
+    unsourcemappedHeaderLines?: number;
+}): Promise<BasicStackFrame[]>;
+declare function getBasicStackFrameAbsoluteFilePath(frame: BasicStackFrame): Promise<string>;
+
+declare function openFileByPath(path: string): Promise<photoshop.Document>;
 
 declare function flattenTree<T>(tree: Tree<T>): Tree<T>[0][];
 
+interface LayerRef {
+    id: number;
+    docId: number;
+}
+
 declare function mapTree<TRef, TMappedRef>(tree: Tree<TRef>, mapFn: (node: TRef) => TMappedRef): Tree<TMappedRef>;
 
 declare function mapTreeRef<TRef, TMappedRef>(tree: Tree<TRef>, mapFn: (node: TRef) => TMappedRef): Tree<TMappedRef>;
 
-type LayerRef = {
-    id: number;
-    docId: number;
-};
-
 declare function photoshopGetApplicationInfo(): Promise<{
     active: boolean;
     autoShowHomeScreen: boolean;
@@ -127,7 +131,7 @@ declare const uxpEntrypointsSchema: z.ZodObject<{
     }, z.core.$strip>;
 }, z.core.$strip>;
 
-declare const getDocumentLayerDescriptors: (documentId: number) => Promise<{
+declare function getDocumentLayerDescriptors(documentId: number): Promise<{
     docId: number;
     name: string;
     layerID: number;
@@ -154,9 +158,9 @@ type LayerDescriptor = Awaited<ReturnType<typeof getDocumentLayerDescriptors>>[n
 
 declare function getLayerEffects(layerRef: PsLayerRef): Promise<Record<string, boolean>>;
 
-type UTLayerKind = "pixel" | "adjustment-layer" | "text" | "curves" | "smartObject" | "video" | "group" | "threeD" | "gradientFill" | "pattern" | "solidColor" | "background";
-type UTBlendMode = "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";
-type UTLayerBuilder = {
+type UTLayerKind = 'pixel' | 'adjustment-layer' | 'text' | 'curves' | 'smartObject' | 'video' | 'group' | 'threeD' | 'gradientFill' | 'pattern' | 'solidColor' | 'background';
+type UTBlendMode = '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';
+interface UTLayerBuilder {
     name: string;
     docId: number;
     id: number;
@@ -167,29 +171,23 @@ type UTLayerBuilder = {
     isClippingMask: boolean;
     background: boolean;
     layers?: UTLayerBuilder[];
-};
-type UTLayer = Readonly<Omit<UTLayerBuilder, "layers">> & {
+}
+type UTLayer = Readonly<Omit<UTLayerBuilder, 'layers'>> & {
     layers?: UTLayer[];
 };
 declare function photoshopLayerDescriptorsToUTLayers(layers: LayerDescriptor[]): UTLayer[];
 
-type UTLayerWithoutChildren = Omit<UTLayer, "layers">;
-declare function utLayersToTree(layer: UTLayer[]): Tree<UTLayerWithoutChildren>;
-
-type UTLayerPickKeys<TKey extends keyof Omit<UTLayer, "layers">> = Pick<Omit<UTLayer, "layers">, TKey> & {
+type UTLayerPickKeys<TKey extends keyof Omit<UTLayer, 'layers'>> = Pick<Omit<UTLayer, 'layers'>, TKey> & {
     layers?: UTLayerPickKeys<TKey>[];
 };
 
-type MinimalUTLayer = UTLayerPickKeys<"effects" | "visible" | "isClippingMask" | "kind" | "blendMode" | "name">;
+type MinimalUTLayer = UTLayerPickKeys<'effects' | 'visible' | 'isClippingMask' | 'kind' | 'blendMode' | 'name'>;
 declare function utLayersToText(tree: MinimalUTLayer[], depth?: number): string;
 
+type UTLayerWithoutChildren = Omit<UTLayer, 'layers'>;
+declare function utLayersToTree(layer: UTLayer[]): Tree<UTLayerWithoutChildren>;
+
 declare function utLayerToDomLayer(layer: UTLayer): Layer;
 declare function utLayersToDomLayers(layers: UTLayer[]): Layer[];
 
-type BasicStackFrame = Pick<ErrorStackParser.StackFrame, "functionName" | "fileName" | "lineNumber" | "columnNumber">;
-declare function parseUxpErrorSourcemaps(error: Error, opts?: {
-    unsourcemappedHeaderLines?: number;
-}): Promise<BasicStackFrame[]>;
-declare function getBasicStackFrameAbsoluteFilePath(frame: BasicStackFrame): Promise<string>;
-
 export { type BasicStackFrame, type CorrectExecuteAsModalOptions, type CorrectExecutionContext, type ExtendedExecutionContext, type LayerDescriptor, type LayerRef, PsLayerRef, type SuspendHistoryContext, type Tree, type UTLayer, type UTLayerPickKeys, type UTLayerWithoutChildren, copyToClipboard, createModifyingBatchPlayContext, executeAsModal, executeAsModalAndSuspendHistory, flattenTree, getBasicStackFrameAbsoluteFilePath, getDocumentLayerDescriptors, getFlattenedDomLayersList, getLayerEffects, mapTree, mapTreeRef, openFileByPath, parseUxpErrorSourcemaps, photoshopDomLayersToTree, photoshopGetApplicationInfo, photoshopLayerDescriptorsToUTLayers, readFromClipboard, suspendHistory, utLayerToDomLayer, utLayersToDomLayers, utLayersToTree, utLayersToText as utTreeToText, uxpEntrypointsSchema };