@bubblydoo/uxp-toolkit 0.0.6 → 0.0.7

package/.turbo/turbo-build.log

@@ -1,15 +1,19 @@
 
-> @bubblydoo/uxp-toolkit@0.0.6 build /home/runner/work/uxp-toolkit/uxp-toolkit/packages/uxp-toolkit
+> @bubblydoo/uxp-toolkit@0.0.7 build /home/runner/work/uxp-toolkit/uxp-toolkit/packages/uxp-toolkit
 > tsup
 
-CLI Building entry: src/index.ts
+CLI Building entry: src/index.ts, src/commands-library/index.ts
 CLI Using tsconfig: tsconfig.json
 CLI tsup v8.5.1
 CLI Using tsup config: /home/runner/work/uxp-toolkit/uxp-toolkit/packages/uxp-toolkit/tsup.config.ts
 CLI Target: es2022
 ESM Build start
-ESM dist/index.js 20.97 KB
-ESM ⚡️ Build success in 28ms
+ESM dist/chunk-3CLJMC63.js         6.20 KB
+ESM dist/index.js                  14.84 KB
+ESM dist/commands-library/index.js 8.76 KB
+ESM ⚡️ Build success in 32ms
 DTS Build start
-DTS ⚡️ Build success in 2406ms
-DTS dist/index.d.ts 11.62 KB
+DTS ⚡️ Build success in 3738ms
+DTS dist/index.d.ts                  8.05 KB
+DTS dist/commands-library/index.d.ts 4.46 KB
+DTS dist/psLayerRef-OY3h7srv.d.ts    3.02 KB

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # @bubblydoo/uxp-toolkit
 
+## 0.0.7
+
+### Patch Changes
+
+- ee02127: More queries, more commands
+
 ## 0.0.6
 
 ### Patch Changes

package/dist/chunk-3CLJMC63.js

@@ -0,0 +1,234 @@
+// 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/executeAsModal.ts
+import { core } from "photoshop";
+
+// src/core/command.ts
+import "zod";
+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
+  };
+}
+
+// src/core/executeAsModal.ts
+var originalExecuteAsModal = core.executeAsModal;
+async function executeAsModal2(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/commands-library/multiGetDocument.ts
+import { z as z2 } 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: z2.object({
+      list: z2.array(
+        z2.object({
+          name: z2.string(),
+          layerID: z2.number(),
+          visible: z2.boolean(),
+          group: z2.boolean(),
+          layerSection: z2.object({
+            _value: z2.enum([
+              "layerSectionStart",
+              "layerSectionEnd",
+              "layerSectionContent"
+            ]),
+            _enum: z2.literal("layerSectionType")
+          }),
+          layerKind: z2.number(),
+          itemIndex: z2.number(),
+          background: z2.boolean(),
+          mode: z2.object({
+            _enum: z2.literal("blendMode"),
+            _value: z2.string()
+          }),
+          layerEffects: z2.record(z2.string(), z2.object({
+            // "scale" does not have an "enabled" property, that's why it's optional
+            enabled: z2.boolean().optional()
+          }).or(z2.array(z2.object({
+            enabled: z2.boolean()
+          })))).optional()
+        })
+      )
+    })
+  });
+}
+
+// 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
+  });
+}
+
+export {
+  batchPlay,
+  executeAsModal2 as executeAsModal,
+  createCommand,
+  batchPlayCommand,
+  batchPlayCommands,
+  createModifyingBatchPlayContext,
+  createMultiGetDocumentCommand,
+  createGetDocumentCommand,
+  createGetDocumentHasBackgroundLayerCommand,
+  createGetLayerCommand,
+  createGetBackgroundLayerCommand
+};

package/dist/commands-library/index.d.ts

@@ -0,0 +1,110 @@
+import { P as PsLayerRef, a as UTCommandModifying, b as UTCommandNonModifying } from '../psLayerRef-OY3h7srv.js';
+export { i as createMultiGetDocumentCommand } from '../psLayerRef-OY3h7srv.js';
+import 'photoshop/dom/CoreModules';
+import 'zod';
+import 'photoshop';
+
+declare function createSelectLayerCommand(layerRef: PsLayerRef): UTCommandModifying<unknown>;
+
+declare function createAddLayerToSelectionCommand(layerRef: PsLayerRef, previousLayerRef: PsLayerRef): UTCommandModifying<unknown>;
+
+declare function createExpandFolderCommand(layerRef: PsLayerRef): UTCommandModifying<unknown>;
+
+declare function createGetLayerCommand(layerRef: PsLayerRef): 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 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 function createRenameLayerCommand(layerRef: PsLayerRef, newName: string): UTCommandModifying<unknown>;
+
+declare function createRasterizeLayerStyleCommand(psLayerRef: PsLayerRef): UTCommandModifying<unknown>;
+
+declare function createRasterizeVectorMaskCommand(): UTCommandModifying<unknown>;
+
+declare function createSelectLayerMaskCommand(layerId: number): UTCommandModifying<unknown>;
+declare function createDeleteChannelAndApplyCommand(): UTCommandModifying<unknown>;
+
+declare function createDeleteChannelCommand(): UTCommandModifying<unknown>;
+
+declare function createLoadLayerMaskAsSelectionCommand(layerId: number): UTCommandModifying<unknown>;
+
+declare function createHasVectorMaskCommand(layerId: number): UTCommandNonModifying<{
+    hasVectorMask: boolean;
+}>;
+
+declare function createGetDocumentCommand(documentId: number): UTCommandNonModifying<{
+    title: string;
+    documentID: number;
+    visible: boolean;
+    hasBackgroundLayer: boolean;
+}>;
+declare function createGetDocumentHasBackgroundLayerCommand(documentId: number): UTCommandNonModifying<{
+    hasBackgroundLayer: boolean;
+}>;
+
+declare function createConvertModeCommand(depth: 8 | 16): UTCommandModifying<unknown>;
+
+declare function createColorLookupAdjustmentLayerCommand(): UTCommandModifying<unknown>;
+
+type LUTFormatType = 'LUTFormatCUBE' | 'LUTFormat3DL' | 'LUTFormatCSP';
+interface Set3DLUTColorLookupOptions {
+    lutPath: string;
+    lutFormat?: LUTFormatType;
+    profileBase64?: string;
+    lutFileDataBase64?: string;
+}
+declare function createSet3DLUTColorLookupCommand(options: Set3DLUTColorLookupOptions): UTCommandModifying<unknown>;
+
+type LUTExportFormat = 'CUBE' | 'ICC' | '3DL' | 'CSP';
+interface ExportLUTsOptions {
+    description?: string;
+    gridPoints?: number;
+    copyright?: string;
+    exportFormats?: LUTExportFormat[];
+    lowercaseExtension?: boolean;
+}
+declare function createExportLUTsCommand(path: string, options?: ExportLUTsOptions): UTCommandModifying<unknown>;
+
+declare function createRenderGridCommand(gridPoints: number): UTCommandModifying<unknown>;
+
+export { type ExportLUTsOptions, type LUTExportFormat, type LUTFormatType, type Set3DLUTColorLookupOptions, createAddLayerToSelectionCommand, createColorLookupAdjustmentLayerCommand, createConvertModeCommand, createDeleteChannelAndApplyCommand, createDeleteChannelCommand, createExpandFolderCommand, createExportLUTsCommand, createGetBackgroundLayerCommand, createGetDocumentCommand, createGetDocumentHasBackgroundLayerCommand, createGetLayerCommand, createHasVectorMaskCommand, createLoadLayerMaskAsSelectionCommand, createRasterizeLayerStyleCommand, createRasterizeVectorMaskCommand, createRenameLayerCommand, createRenderGridCommand, createSelectLayerCommand, createSelectLayerMaskCommand, createSet3DLUTColorLookupCommand };