@bubblydoo/uxp-toolkit 0.0.4 → 0.0.6

package/src/commands-library/getLayer.ts

@@ -0,0 +1,56 @@
+import z from "zod";
+import { createCommand } from "../core/command";
+import type { PsLayerRef } from "../ut-tree/psLayerRef";
+
+const layerSchema = z.object({
+  name: z.string(),
+  visible: z.boolean(),
+  group: z.boolean(),
+  layerSection: z.object({
+    _value: z.enum([
+      "layerSectionStart",
+      "layerSectionEnd",
+      "layerSectionContent",
+    ]),
+    _enum: z.literal("layerSectionType"),
+  }),
+  layerKind: z.number(),
+  itemIndex: z.number(),
+  background: z.boolean(),
+  mode: z.object({
+    _enum: z.literal("blendMode"),
+    _value: z.string(),
+  }),
+  layerID: z.number(),
+  layerEffects: z.record(z.string(), z.object({
+    // "scale" does not have an "enabled" property, that's why it's optional
+    enabled: z.boolean().optional(),
+  }).or(z.array(z.object({
+    enabled: z.boolean(),
+  })))).optional(),
+});
+
+export function createGetLayerCommand(layerRef: PsLayerRef) {
+  return createCommand({
+    modifying: false,
+    descriptor: {
+      _obj: "get",
+      _target: [
+        { _ref: "layer", _id: layerRef.id },
+        { _ref: "document", _id: layerRef.docId },
+      ],
+    },
+    schema: layerSchema,
+  });
+}
+
+export function createGetBackgroundLayerCommand(docId: number) {
+  return createCommand({
+    modifying: false,
+    descriptor: {
+      _obj: "get",
+      _target: { _ref: [{ _ref: "layer", "_property": "background" }, { _ref: "document", _id: docId }] },
+    },
+    schema: layerSchema,
+  });
+}

package/src/commands-library/getLayer.txt

@@ -0,0 +1,186 @@
+{
+    "layerID": 1,
+    "group": false,
+    "name": "Background",
+    "color": {
+        "_enum": "color",
+        "_value": "none"
+    },
+    "visible": true,
+    "mode": {
+        "_enum": "blendMode",
+        "_value": "normal"
+    },
+    "opacity": 255,
+    "itemIndex": 1,
+    "count": 2,
+    "preserveTransparency": true,
+    "layerFXVisible": false,
+    "globalAngle": 90,
+    "background": true,
+    "layerSection": {
+        "_enum": "layerSectionType",
+        "_value": "layerSectionContent"
+    },
+    "layerLocking": {
+        "_obj": "layerLocking",
+        "protectTransparency": true,
+        "protectComposite": false,
+        "protectPosition": true,
+        "protectArtboardAutonest": true,
+        "protectAll": false
+    },
+    "targetChannels": [
+        {
+            "_ref": "channel",
+            "_index": 1
+        },
+        {
+            "_ref": "channel",
+            "_index": 2
+        },
+        {
+            "_ref": "channel",
+            "_index": 3
+        }
+    ],
+    "visibleChannels": [
+        {
+            "_ref": "channel",
+            "_index": 1
+        },
+        {
+            "_ref": "channel",
+            "_index": 2
+        },
+        {
+            "_ref": "channel",
+            "_index": 3
+        }
+    ],
+    "channelRestrictions": [
+        {
+            "_enum": "channel",
+            "_value": "red"
+        },
+        {
+            "_enum": "channel",
+            "_value": "grain"
+        },
+        {
+            "_enum": "channel",
+            "_value": "blue"
+        }
+    ],
+    "fillOpacity": 255,
+    "hasUserMask": false,
+    "hasVectorMask": false,
+    "proportionalScaling": false,
+    "layerKind": 1,
+    "hasFilterMask": false,
+    "userMaskDensity": 255,
+    "userMaskFeather": 0,
+    "vectorMaskDensity": 255,
+    "vectorMaskFeather": 0,
+    "filterMaskDensity": 255,
+    "filterMaskFeather": 0,
+    "bounds": {
+        "_obj": "rectangle",
+        "top": {
+            "_unit": "pixelsUnit",
+            "_value": 0
+        },
+        "left": {
+            "_unit": "pixelsUnit",
+            "_value": 0
+        },
+        "bottom": {
+            "_unit": "pixelsUnit",
+            "_value": 100
+        },
+        "right": {
+            "_unit": "pixelsUnit",
+            "_value": 100
+        },
+        "width": {
+            "_unit": "pixelsUnit",
+            "_value": 100
+        },
+        "height": {
+            "_unit": "pixelsUnit",
+            "_value": 100
+        }
+    },
+    "boundsNoEffects": {
+        "_obj": "rectangle",
+        "top": {
+            "_unit": "pixelsUnit",
+            "_value": 0
+        },
+        "left": {
+            "_unit": "pixelsUnit",
+            "_value": 0
+        },
+        "bottom": {
+            "_unit": "pixelsUnit",
+            "_value": 100
+        },
+        "right": {
+            "_unit": "pixelsUnit",
+            "_value": 100
+        },
+        "width": {
+            "_unit": "pixelsUnit",
+            "_value": 100
+        },
+        "height": {
+            "_unit": "pixelsUnit",
+            "_value": 100
+        }
+    },
+    "boundsNoMask": {
+        "_obj": "rectangle",
+        "top": {
+            "_unit": "pixelsUnit",
+            "_value": 0
+        },
+        "left": {
+            "_unit": "pixelsUnit",
+            "_value": 0
+        },
+        "bottom": {
+            "_unit": "pixelsUnit",
+            "_value": 100
+        },
+        "right": {
+            "_unit": "pixelsUnit",
+            "_value": 100
+        },
+        "width": {
+            "_unit": "pixelsUnit",
+            "_value": 100
+        },
+        "height": {
+            "_unit": "pixelsUnit",
+            "_value": 100
+        }
+    },
+    "useAlignedRendering": false,
+    "generatorSettings": {
+        "_obj": "generatorSettings"
+    },
+    "keyOriginType": [],
+    "fillEnabled": false,
+    "animationProtection": {
+        "_obj": "animationProtection",
+        "animationUnifyPosition": false,
+        "animationUnifyEffects": false,
+        "animationUnifyVisibility": false,
+        "animationPropagate": true
+    },
+    "isSyntheticFill": false,
+    "artboardEnabled": false,
+    "vectorMaskEmpty": true,
+    "textWarningLevel": 0,
+    "parentLayerID": -1
+}

package/src/commands-library/multiGetDocument.ts

@@ -0,0 +1,47 @@
+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 }] },
+      extendedReference: [
+        ["name", "layerID", "visible", "group", "layerSection", "layerKind", "itemIndex", "background", "mode", "layerEffects"],
+        { _obj: "layer", index: 1, count: -1 },
+      ],
+    },
+    schema: z.object({
+      list: z.array(
+        z.object({
+          name: z.string(),
+          layerID: z.number(),
+          visible: z.boolean(),
+          group: z.boolean(),
+          layerSection: z.object({
+            _value: z.enum([
+              "layerSectionStart",
+              "layerSectionEnd",
+              "layerSectionContent",
+            ]),
+            _enum: z.literal("layerSectionType"),
+          }),
+          layerKind: z.number(),
+          itemIndex: z.number(),
+          background: z.boolean(),
+          mode: z.object({
+            _enum: z.literal("blendMode"),
+            _value: z.string(),
+          }),
+          layerEffects: z.record(z.string(), z.object({
+            // "scale" does not have an "enabled" property, that's why it's optional
+            enabled: z.boolean().optional(),
+          }).or(z.array(z.object({
+            enabled: z.boolean(),
+          })))).optional(),
+        })
+      )
+    })
+  });
+}

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

@@ -1,13 +1,13 @@
 import { executeAsModal } from "../core/executeAsModal";
 import { openFileByPath } from "../filesystem/openFileByPath";
-import { getLayerProperties } from "../ut-tree/getLayerProperties";
+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";
 
 async function getFirstLayer() {
-  const allLayers = await getLayerProperties(app.activeDocument.id);
+  const allLayers = await getDocumentLayerDescriptors(app.activeDocument.id);
   return {
     ref: {
       id: allLayers[0]!.layerID,
@@ -15,7 +15,7 @@ async function getFirstLayer() {
     },
     name: allLayers[0]!.name,
   };
-} 
+}
 
 export const renameLayerTest: Test = {
   name: "Rename Layer",
@@ -29,4 +29,4 @@ export const renameLayerTest: Test = {
     const layer2 = await getFirstLayer();
     expect(layer2.name).to.equal("New Name");
   },
-};
+};

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

@@ -0,0 +1,25 @@
+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", () => {
+    const command = createCommand({
+      descriptor: { _obj: "get" },
+      schema: z.object({
+        name: z.string(),
+        count: z.number(),
+      }),
+      modifying: false,
+    });
+
+    type Result = UTCommandResult<typeof command>;
+
+    expectTypeOf<Result>().toEqualTypeOf<{
+      name: string;
+      count: number;
+    }>();
+  });});

package/src/index.ts

@@ -18,14 +18,21 @@ export {
   type CorrectExecuteAsModalOptions,
   type ExtendedExecutionContext,
 } from "./core/executeAsModal";
-export { suspendHistory, type SuspendHistoryContext } from "./core/suspendHistory";
+export {
+  suspendHistory,
+  type SuspendHistoryContext,
+} from "./core/suspendHistory";
 
 // Core wrappers
 export { executeAsModalAndSuspendHistory } from "./core-wrappers/executeAsModalAndSuspendHistory";
 
 // Commands library
-export { getLayerProperties } from "./commands-library/getLayerProperties";
 export { createRenameLayerCommand } from "./commands-library/renameLayer";
+export {
+  createGetDocumentCommand,
+  createGetDocumentHasBackgroundLayerCommand,
+} from "./commands-library/getDocument";
+export { createGetBackgroundLayerCommand } from "./commands-library/getLayer";
 
 // DOM – layers
 export { getFlattenedDomLayersList } from "./dom/getFlattenedDomLayersList";
@@ -47,27 +54,29 @@ export { copyToClipboard, readFromClipboard } from "./other/clipboard";
 export { uxpEntrypointsSchema } from "./other/uxpEntrypoints";
 
 // UT tree – layer descriptors & Photoshop tree
+export { createMultiGetDocumentCommand } from "./commands-library/multiGetDocument";
+export { getDocumentLayerDescriptors } from "./ut-tree/getDocumentLayerDescriptors";
+export { getLayerEffects } from "./ut-tree/getLayerEffects";
 export {
-  getFlattenedLayerDescriptorsList,
-  type LayerDescriptor,
-} from "./ut-tree/getFlattenedLayerDescriptorsList";
-export {
-  createGetLayerPropertiesCommand,
-  getLayerProperties as getLayerPropertiesFromUtTree,
-} from "./ut-tree/getLayerProperties";
-export {
-  createGetLayerCommand as createGetLayerEffectsCommand,
-  getLayerEffects,
-} from "./ut-tree/getLayerEffects";
-export {
-  photoshopLayerDescriptorsToUTLayers,
   type UTLayer,
+  photoshopLayerDescriptorsToUTLayers,
 } from "./ut-tree/photoshopLayerDescriptorsToUTLayers";
 export { type PsLayerRef } from "./ut-tree/psLayerRef";
-export { utLayersToTree, type UTLayerWithoutChildren } from "./ut-tree/utLayersToTree";
+export {
+  utLayersToTree,
+  type UTLayerWithoutChildren,
+} from "./ut-tree/utLayersToTree";
+
+// UT tree – text
+export { utLayersToText as utTreeToText } from "./ut-tree/utLayersToText";
 
 // Util
 export { utLayerToDomLayer, utLayersToDomLayers } from "./util/utLayerToLayer";
+export { type UTLayerPickKeys } from "./util/utLayerPickKeysType";
 
 // Error sourcemaps
-export { parseUxpErrorSourcemaps, getBasicStackFrameAbsoluteFilePath, type BasicStackFrame } from "./error-sourcemaps/sourcemaps";
+export {
+  parseUxpErrorSourcemaps,
+  getBasicStackFrameAbsoluteFilePath,
+  type BasicStackFrame,
+} from "./error-sourcemaps/sourcemaps";

package/src/ut-tree/getDocumentLayerDescriptors.ts

@@ -0,0 +1,29 @@
+import { batchPlayCommand, batchPlayCommands } from "../core/command";
+import { createMultiGetDocumentCommand } from "../commands-library/multiGetDocument";
+import { createGetDocumentHasBackgroundLayerCommand } from "../commands-library/getDocument";
+import { createGetBackgroundLayerCommand } from "../commands-library/getLayer";
+
+// get layer properties like name and layerID for all layers in the document (by index)
+export const getDocumentLayerDescriptors = async (documentId: number) => {
+  const [layersResult, documentHasBackgroundLayerResult] = await batchPlayCommands([
+    createMultiGetDocumentCommand(documentId),
+    createGetDocumentHasBackgroundLayerCommand(documentId),
+  ]);
+
+  const backgroundLayerResult = documentHasBackgroundLayerResult.hasBackgroundLayer ? await batchPlayCommand(createGetBackgroundLayerCommand(documentId)) : null;
+
+  const list = [...layersResult.list].reverse();
+  if (backgroundLayerResult) {
+    list.push(backgroundLayerResult);
+  }
+
+  // Reverse to get bottom-up order
+  return list.map((layerProp) => {
+    return {
+      ...layerProp,
+      docId: documentId,
+    };
+  });
+};
+
+export type LayerDescriptor = Awaited<ReturnType<typeof getDocumentLayerDescriptors>>[number];

package/src/ut-tree/getLayerEffects.ts

@@ -1,36 +1,13 @@
 
 import { type PsLayerRef } from "./psLayerRef";
-import { batchPlayCommand, createCommand } from "../core/command";
-import { z } from "zod";
-
-export function createGetLayerCommand(layerRef: PsLayerRef) {
-  return createCommand({
-    modifying: false,
-    descriptor: {
-      _obj: "get",
-      _target: [
-        { _ref: "layer", _id: layerRef.id },
-        { _ref: "document", _id: layerRef.docId },
-      ],
-    },
-    schema: z.object({
-      layerID: z.number(),
-      group: z.boolean().optional(),
-      layerEffects: z.record(z.string(), z.object({
-        // "scale" does not have an "enabled" property, that's why it's optional
-        enabled: z.boolean().optional(),
-      }).or(z.array(z.object({
-        enabled: z.boolean(),
-      })))).optional(),
-    }),
-  });
-}
+import { batchPlayCommand } from "../core/command";
+import { createGetLayerCommand } from "../commands-library/getLayer";
 
 export async function getLayerEffects(layerRef: PsLayerRef) {
   const result = await batchPlayCommand(createGetLayerCommand(layerRef));
 
   const data = result.layerEffects || {};
-  
+
   const effects: Record<string, boolean> = {};
 
   for (const effect in data) {

package/src/ut-tree/hasBackgroundLayer.uxp-test.ts

@@ -0,0 +1,42 @@
+import { app } from "photoshop";
+import { openFileByPath } from "../filesystem/openFileByPath";
+import { batchPlayCommand } from "../core/command";
+import { expect } from "chai";
+import { createGetDocumentHasBackgroundLayerCommand } from "../commands-library/getDocument";
+import type { Test } from "@bubblydoo/uxp-test-framework";
+import { createGetBackgroundLayerCommand } from "../commands-library/getLayer";
+import { executeAsModal } from "../core/executeAsModal";
+
+export const backgroundLayerTest: Test = {
+  name: "Has/Get Background Layer",
+  async run() {
+    const doc = await openFileByPath("plugin:/fixtures/one-layer-with-bg.psd");
+    const hasBackgroundLayer = await batchPlayCommand(
+      createGetDocumentHasBackgroundLayerCommand(doc.id)
+    )
+    expect(hasBackgroundLayer.hasBackgroundLayer).to.be.true;
+    const layer = await batchPlayCommand(
+      createGetBackgroundLayerCommand(app.activeDocument.id)
+    )
+    expect(layer.name).to.equal("Background");
+    await executeAsModal("Close Document", async () => await doc.close(0));
+
+    const doc2 = await openFileByPath("plugin:/fixtures/one-layer.psd");
+
+    const hasBackgroundLayer2 = await batchPlayCommand(
+      createGetDocumentHasBackgroundLayerCommand(doc2.id)
+    )
+    expect(hasBackgroundLayer2.hasBackgroundLayer).to.be.false;
+    let rejected = false;
+    try {
+      await batchPlayCommand(
+        createGetBackgroundLayerCommand(doc2.id)
+      )
+    } catch (e) {
+      rejected = true;
+    }
+    expect(rejected).to.be.true;
+
+    await executeAsModal("Close Document", async () => await doc2.close(0));
+  },
+};

package/src/ut-tree/photoshopLayerDescriptorsToUTLayers.test.ts

@@ -0,0 +1,114 @@
+import { expect, it } from "vitest";
+import { photoshopLayerDescriptorsToUTLayers } from "./photoshopLayerDescriptorsToUTLayers";
+import { utLayersToText } from "./utLayersToText";
+
+it("parses a flat list correctly", async () => {
+  expect(
+    utLayersToText(
+      photoshopLayerDescriptorsToUTLayers(
+        [
+          {
+            name: "circle",
+            layerID: 4,
+            mode: {
+              _enum: "blendMode",
+              _value: "normal",
+            },
+            background: false,
+            itemIndex: 5,
+            visible: true,
+            layerKind: 1,
+            layerSection: {
+              _value: "layerSectionContent",
+              _enum: "layerSectionType",
+            },
+            docId: 70,
+            layerEffects: {},
+            group: true,
+          },
+          {
+            name: "group",
+            layerID: 6,
+            mode: {
+              _enum: "blendMode",
+              _value: "passThrough",
+            },
+            background: false,
+            itemIndex: 4,
+            visible: true,
+            layerKind: 7,
+            layerSection: {
+              _value: "layerSectionStart",
+              _enum: "layerSectionType",
+            },
+            docId: 70,
+            layerEffects: {},
+            group: false,
+          },
+          {
+            name: "green square",
+            layerID: 3,
+            mode: {
+              _enum: "blendMode",
+              _value: "normal",
+            },
+            background: false,
+            itemIndex: 3,
+            visible: true,
+            layerKind: 1,
+            layerSection: {
+              _value: "layerSectionContent",
+              _enum: "layerSectionType",
+            },
+            docId: 70,
+            layerEffects: {},
+            group: true,
+          },
+          {
+            name: "red square",
+            layerID: 2,
+            mode: {
+              _enum: "blendMode",
+              _value: "normal",
+            },
+            background: false,
+            itemIndex: 2,
+            visible: true,
+            layerKind: 1,
+            layerSection: {
+              _value: "layerSectionContent",
+              _enum: "layerSectionType",
+            },
+            docId: 70,
+            layerEffects: {},
+            group: false,
+          },
+          {
+            name: "</Layer group>",
+            layerID: 7,
+            mode: {
+              _enum: "blendMode",
+              _value: "passThrough",
+            },
+            background: false,
+            itemIndex: 1,
+            visible: true,
+            layerKind: 13,
+            layerSection: {
+              _value: "layerSectionEnd",
+              _enum: "layerSectionType",
+            },
+            docId: 70,
+            layerEffects: {},
+            group: true,
+          },
+        ],
+      ),
+    ),
+  ).toMatchInlineSnapshot(`
+    "◯ ⬐ circle
+    ◯ ▾ group
+    ◯    ⬐ green square
+    ◯    red square"
+  `);
+});