@bubblydoo/uxp-toolkit 0.0.6 → 0.0.8

package/dist/commands-library/index.js

@@ -0,0 +1,402 @@
+import {
+  createCommand,
+  createGetBackgroundLayerCommand,
+  createGetDocumentCommand,
+  createGetDocumentHasBackgroundLayerCommand,
+  createGetLayerCommand,
+  createMultiGetDocumentCommand
+} from "../chunk-3CLJMC63.js";
+
+// src/commands-library/selectLayer.ts
+import { z } from "zod";
+function createSelectLayerCommand(layerRef) {
+  return createCommand({
+    modifying: true,
+    descriptor: {
+      _obj: "select",
+      _target: [
+        {
+          _ref: "layer",
+          _id: layerRef.id
+        },
+        {
+          _ref: "document",
+          _id: layerRef.docId
+        }
+      ],
+      makeVisible: false,
+      layerID: [layerRef.id],
+      _isCommand: false
+    },
+    schema: z.unknown()
+  });
+}
+
+// src/commands-library/addLayerToSelection.ts
+import { z as z2 } from "zod";
+function createAddLayerToSelectionCommand(layerRef, previousLayerRef) {
+  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: z2.unknown()
+  });
+}
+
+// src/commands-library/expandFolder.ts
+import { z as z3 } from "zod";
+function createExpandFolderCommand(layerRef) {
+  return createCommand({
+    modifying: true,
+    descriptor: {
+      _obj: "set",
+      _target: {
+        _ref: [
+          { _property: "layerSectionExpanded" },
+          { _ref: "layer", _id: layerRef.id },
+          { _ref: "document", _id: layerRef.docId }
+        ]
+      },
+      to: true
+    },
+    schema: z3.unknown()
+  });
+}
+
+// src/commands-library/renameLayer.ts
+import { z as z4 } 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: z4.unknown()
+  });
+}
+
+// src/commands-library/rasterizeLayerStyle.ts
+import { z as z5 } 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: z5.unknown()
+  });
+}
+
+// src/commands-library/rasterizeVectorMask.ts
+import { z as z6 } from "zod";
+function createRasterizeVectorMaskCommand() {
+  return createCommand({
+    modifying: true,
+    descriptor: {
+      _obj: "rasterizeLayer",
+      _target: [
+        {
+          _ref: "layer",
+          _enum: "ordinal",
+          _value: "targetEnum"
+        }
+      ],
+      what: {
+        _enum: "rasterizeItem",
+        _value: "vectorMask"
+      }
+    },
+    schema: z6.unknown()
+  });
+}
+
+// src/commands-library/applyLayerMask.ts
+import { z as z7 } from "zod";
+function createSelectLayerMaskCommand(layerId) {
+  return createCommand({
+    modifying: true,
+    descriptor: {
+      _obj: "select",
+      _target: [
+        {
+          _ref: "channel",
+          _enum: "channel",
+          _value: "mask"
+        },
+        {
+          _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()
+  });
+}
+
+// src/commands-library/loadLayerMaskAsSelection.ts
+import { z as z9 } from "zod";
+function createLoadLayerMaskAsSelectionCommand(layerId) {
+  return createCommand({
+    modifying: true,
+    descriptor: {
+      _obj: "set",
+      _target: [
+        {
+          _ref: "channel",
+          _property: "selection"
+        }
+      ],
+      to: {
+        _ref: [
+          {
+            _ref: "channel",
+            _enum: "channel",
+            _value: "mask"
+          },
+          {
+            _ref: "layer",
+            _id: layerId
+          }
+        ]
+      }
+    },
+    schema: z9.unknown()
+  });
+}
+
+// src/commands-library/hasVectorMask.ts
+import { z as z10 } from "zod";
+function createHasVectorMaskCommand(layerId) {
+  return createCommand({
+    modifying: false,
+    descriptor: {
+      _obj: "get",
+      _target: [
+        {
+          _property: "hasVectorMask"
+        },
+        {
+          _ref: "layer",
+          _id: layerId
+        }
+      ]
+    },
+    schema: z10.object({
+      hasVectorMask: z10.boolean()
+    })
+  });
+}
+
+// src/commands-library/convertMode.ts
+import { z as z11 } from "zod";
+function createConvertModeCommand(depth) {
+  return createCommand({
+    modifying: true,
+    descriptor: {
+      _obj: "convertMode",
+      depth
+    },
+    schema: z11.unknown()
+  });
+}
+
+// src/commands-library/createColorLookupAdjustmentLayer.ts
+import { z as z12 } from "zod";
+function createColorLookupAdjustmentLayerCommand() {
+  return createCommand({
+    modifying: true,
+    descriptor: {
+      _obj: "make",
+      _target: [
+        {
+          _ref: "adjustmentLayer"
+        }
+      ],
+      using: {
+        _obj: "adjustmentLayer",
+        type: {
+          _class: "colorLookup"
+        }
+      },
+      _isCommand: true
+    },
+    schema: z12.unknown()
+  });
+}
+
+// src/commands-library/set3DLUTColorLookup.ts
+import { z as z13 } from "zod";
+function createSet3DLUTColorLookupCommand(options) {
+  const {
+    lutPath,
+    lutFormat = "LUTFormatCUBE",
+    profileBase64,
+    lutFileDataBase64
+  } = options;
+  return createCommand({
+    modifying: true,
+    descriptor: {
+      _obj: "set",
+      _target: [
+        {
+          _enum: "ordinal",
+          _ref: "adjustmentLayer",
+          _value: "targetEnum"
+        }
+      ],
+      to: {
+        _obj: "colorLookup",
+        lookupType: {
+          _enum: "colorLookupType",
+          _value: "3DLUT"
+        },
+        name: lutPath,
+        LUTFormat: {
+          _enum: "LUTFormatType",
+          _value: lutFormat
+        },
+        ...profileBase64 && {
+          profile: {
+            _data: profileBase64,
+            _rawData: "base64"
+          }
+        },
+        ...lutFileDataBase64 && {
+          LUT3DFileData: {
+            _data: lutFileDataBase64,
+            _rawData: "base64"
+          }
+        },
+        LUT3DFileName: lutPath
+      },
+      _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()
+  });
+}
+export {
+  createAddLayerToSelectionCommand,
+  createColorLookupAdjustmentLayerCommand,
+  createConvertModeCommand,
+  createDeleteChannelAndApplyCommand,
+  createDeleteChannelCommand,
+  createExpandFolderCommand,
+  createExportLUTsCommand,
+  createGetBackgroundLayerCommand,
+  createGetDocumentCommand,
+  createGetDocumentHasBackgroundLayerCommand,
+  createGetLayerCommand,
+  createHasVectorMaskCommand,
+  createLoadLayerMaskAsSelectionCommand,
+  createMultiGetDocumentCommand,
+  createRasterizeLayerStyleCommand,
+  createRasterizeVectorMaskCommand,
+  createRenameLayerCommand,
+  createRenderGridCommand,
+  createSelectLayerCommand,
+  createSelectLayerMaskCommand,
+  createSet3DLUTColorLookupCommand
+};

package/dist/index.d.ts

@@ -1,45 +1,12 @@
-import * as photoshop_dom_CoreModules from 'photoshop/dom/CoreModules';
-import { ActionDescriptor } from 'photoshop/dom/CoreModules';
-import { action } from 'photoshop';
-import { z } from 'zod';
+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 ErrorStackParser from 'error-stack-parser';
-
-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;
-};
+import 'photoshop/dom/CoreModules';
+import 'photoshop';
 
 type CorrectExecutionContext = {
     /**
@@ -97,46 +64,6 @@ declare function suspendHistory<T>(document: Document, historyStateName: string,
 type CombinedFn<T> = (executionContext: ExtendedExecutionContext, suspendHistoryContext: SuspendHistoryContext) => Promise<T>;
 declare const executeAsModalAndSuspendHistory: <T>(commandName: string, document: Document, fn: CombinedFn<T>) => Promise<T>;
 
-type PsLayerRef = {
-    id: number;
-    docId: number;
-};
-
-declare function createRenameLayerCommand(layerRef: PsLayerRef, newName: string): UTCommandModifying<unknown>;
-
-declare function createGetDocumentCommand(documentId: number): UTCommandNonModifying<{
-    title: string;
-    documentID: number;
-    visible: boolean;
-    hasBackgroundLayer: boolean;
-}>;
-declare function createGetDocumentHasBackgroundLayerCommand(documentId: number): UTCommandNonModifying<{
-    hasBackgroundLayer: boolean;
-}>;
-
-declare function createGetBackgroundLayerCommand(docId: number): UTCommandNonModifying<{
-    name: string;
-    visible: boolean;
-    group: boolean;
-    layerSection: {
-        _value: "layerSectionStart" | "layerSectionEnd" | "layerSectionContent";
-        _enum: "layerSectionType";
-    };
-    layerKind: number;
-    itemIndex: number;
-    background: boolean;
-    mode: {
-        _enum: "blendMode";
-        _value: string;
-    };
-    layerID: number;
-    layerEffects?: Record<string, {
-        enabled?: boolean | undefined;
-    } | {
-        enabled: boolean;
-    }[]> | undefined;
-}>;
-
 declare const getFlattenedDomLayersList: (layers: Layer[]) => Layer[];
 
 type Tree<TRef = unknown> = {
@@ -200,31 +127,6 @@ declare const uxpEntrypointsSchema: z.ZodObject<{
     }, z.core.$strip>;
 }, z.core.$strip>;
 
-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;
-    }[];
-}>;
-
 declare const getDocumentLayerDescriptors: (documentId: number) => Promise<{
     docId: number;
     name: string;
@@ -290,4 +192,4 @@ declare function parseUxpErrorSourcemaps(error: Error, opts?: {
 }): Promise<BasicStackFrame[]>;
 declare function getBasicStackFrameAbsoluteFilePath(frame: BasicStackFrame): Promise<string>;
 
-export { type BasicStackFrame, type CorrectBatchPlayOptions, type CorrectExecuteAsModalOptions, type CorrectExecutionContext, type ExtendedExecutionContext, type LayerRef, type PsLayerRef, type SuspendHistoryContext, type Tree, type UTCommandBase, type UTCommandModifying, type UTCommandNonModifying, type UTCommandResult, type UTLayer, type UTLayerPickKeys, type UTLayerWithoutChildren, batchPlay, batchPlayCommand, batchPlayCommands, copyToClipboard, createCommand, createGetBackgroundLayerCommand, createGetDocumentCommand, createGetDocumentHasBackgroundLayerCommand, createModifyingBatchPlayContext, createMultiGetDocumentCommand, createRenameLayerCommand, executeAsModal, executeAsModalAndSuspendHistory, flattenTree, getBasicStackFrameAbsoluteFilePath, getDocumentLayerDescriptors, getFlattenedDomLayersList, getLayerEffects, mapTree, mapTreeRef, openFileByPath, parseUxpErrorSourcemaps, photoshopDomLayersToTree, photoshopGetApplicationInfo, photoshopLayerDescriptorsToUTLayers, readFromClipboard, suspendHistory, utLayerToDomLayer, utLayersToDomLayers, utLayersToTree, utLayersToText as utTreeToText, uxpEntrypointsSchema };
+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 };