@bubblydoo/uxp-toolkit 0.0.8 → 0.0.9

package/src/other/uxpEntrypoints.ts

@@ -1,4 +1,4 @@
-import { z } from "zod";
+import { z } from 'zod';
 
 export const uxpEntrypointsSchema = z.object({
   _pluginInfo: z.object({
@@ -6,4 +6,4 @@ export const uxpEntrypointsSchema = z.object({
     name: z.string(),
     version: z.string(),
   }),
-});
+});

package/src/ut-tree/getDocumentLayerDescriptors.ts

@@ -1,10 +1,10 @@
-import { batchPlayCommand, batchPlayCommands } from "../core/command";
-import { createMultiGetDocumentCommand } from "../commands-library/multiGetDocument";
-import { createGetDocumentHasBackgroundLayerCommand } from "../commands-library/getDocument";
-import { createGetBackgroundLayerCommand } from "../commands-library/getLayer";
+import { createGetDocumentHasBackgroundLayerCommand } from '../commands-library/getDocument';
+import { createGetBackgroundLayerCommand } from '../commands-library/getLayer';
+import { createMultiGetDocumentCommand } from '../commands-library/multiGetDocument';
+import { batchPlayCommand, batchPlayCommands } from '../core/command';
 
 // get layer properties like name and layerID for all layers in the document (by index)
-export const getDocumentLayerDescriptors = async (documentId: number) => {
+export async function getDocumentLayerDescriptors(documentId: number) {
   const [layersResult, documentHasBackgroundLayerResult] = await batchPlayCommands([
     createMultiGetDocumentCommand(documentId),
     createGetDocumentHasBackgroundLayerCommand(documentId),
@@ -24,6 +24,6 @@ export const getDocumentLayerDescriptors = async (documentId: number) => {
       docId: documentId,
     };
   });
-};
+}
 
 export type LayerDescriptor = Awaited<ReturnType<typeof getDocumentLayerDescriptors>>[number];

package/src/ut-tree/getLayerEffects.ts

@@ -1,7 +1,6 @@
-
-import { type PsLayerRef } from "./psLayerRef";
-import { batchPlayCommand } from "../core/command";
-import { createGetLayerCommand } from "../commands-library/getLayer";
+import type { PsLayerRef } from './psLayerRef';
+import { createGetLayerCommand } from '../commands-library/getLayer';
+import { batchPlayCommand } from '../core/command';
 
 export async function getLayerEffects(layerRef: PsLayerRef) {
   const result = await batchPlayCommand(createGetLayerCommand(layerRef));
@@ -11,7 +10,8 @@ export async function getLayerEffects(layerRef: PsLayerRef) {
   const effects: Record<string, boolean> = {};
 
   for (const effect in data) {
-    if (effect !== "scale") effects[effect] = Array.isArray(data[effect]) ? data[effect].some((e) => e.enabled) : !!data[effect]?.enabled;
+    if (effect !== 'scale')
+      effects[effect] = Array.isArray(data[effect]) ? data[effect].some(e => e.enabled) : !!data[effect]?.enabled;
   }
 
   return effects;

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

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

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

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

package/src/ut-tree/photoshopLayerDescriptorsToUTLayers.ts

@@ -1,10 +1,10 @@
-import type { LayerDescriptor } from "./getDocumentLayerDescriptors";
+import type { LayerDescriptor } from './getDocumentLayerDescriptors';
 
-type UTLayerKind = "pixel" | "adjustment-layer" | "text" | "curves" | "smartObject" | "video" | "group" | "threeD" | "gradientFill" | "pattern" | "solidColor" | "background";
+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 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 = {
+interface UTLayerBuilder {
   name: string;
   docId: number;
   id: number;
@@ -15,75 +15,75 @@ type UTLayerBuilder = {
   isClippingMask: boolean;
   background: boolean;
   layers?: UTLayerBuilder[];
-};
+}
 
-export type UTLayer = Readonly<Omit<UTLayerBuilder, "layers">> & {
+export type UTLayer = Readonly<Omit<UTLayerBuilder, 'layers'>> & {
   layers?: UTLayer[];
 };
 
-export type UTLayerMultiGetOnly = Omit<UTLayer, "effects">;
+export type UTLayerMultiGetOnly = Omit<UTLayer, 'effects'>;
 
 const layerKindMap = new Map<number, UTLayerKind>([
-  [1, "pixel"],
-  [2, "adjustment-layer"], // All adjustment layers
-  [3, "text"],
-  [4, "curves"],
-  [5, "smartObject"],
-  [6, "video"],
-  [7, "group"],
-  [8, "threeD"],
-  [9, "gradientFill"],
-  [10, "pattern"],
-  [11, "solidColor"],
-  [12, "background"], // according to the internet but the actual value is undefined
+  [1, 'pixel'],
+  [2, 'adjustment-layer'], // All adjustment layers
+  [3, 'text'],
+  [4, 'curves'],
+  [5, 'smartObject'],
+  [6, 'video'],
+  [7, 'group'],
+  [8, 'threeD'],
+  [9, 'gradientFill'],
+  [10, 'pattern'],
+  [11, 'solidColor'],
+  [12, 'background'], // according to the internet but the actual value is undefined
 ]);
 
 const blendModes: string[] = [
-  "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",
+  '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',
 ] satisfies UTBlendMode[];
 
-const getLayerKind = (layer: LayerDescriptor): UTLayerKind => {
+function getLayerKind(layer: LayerDescriptor): UTLayerKind {
   const kind = layerKindMap.get(layer.layerKind);
   if (!kind) {
     throw new Error(`Unknown layer kind: ${layer.layerKind}`);
   }
   return kind;
-};
+}
 
-const getBlendMode = (layer: LayerDescriptor): UTBlendMode => {
+function getBlendMode(layer: LayerDescriptor): UTBlendMode {
   const mode = layer.mode._value;
   if (!blendModes.includes(mode)) {
     throw new Error(`Unknown blend mode: ${mode}`);
   }
   return mode as UTBlendMode;
-};
+}
 
 export function photoshopLayerDescriptorsToUTLayers(layers: LayerDescriptor[]): UTLayer[] {
   const root: UTLayerBuilder[] = [];
@@ -96,7 +96,7 @@ export function photoshopLayerDescriptorsToUTLayers(layers: LayerDescriptor[]):
     const sectionType = determineLayerSection(layer);
 
     // Handle group end
-    if (sectionType === "end") {
+    if (sectionType === 'end') {
       if (stack.length > 1) {
         stack.pop();
       }
@@ -121,7 +121,7 @@ export function photoshopLayerDescriptorsToUTLayers(layers: LayerDescriptor[]):
     current!.layers.push(node);
 
     // Handle group start
-    if (sectionType === "start") {
+    if (sectionType === 'start') {
       node.layers = [];
       // Push children array to stack to process content
       stack.push({ layers: node.layers });
@@ -132,22 +132,22 @@ export function photoshopLayerDescriptorsToUTLayers(layers: LayerDescriptor[]):
   return root as UTLayer[];
 };
 
-const determineLayerSection = (layer: LayerDescriptor): "start" | "end" | "normal" => {
+function determineLayerSection(layer: LayerDescriptor): 'start' | 'end' | 'normal' {
   const section = layer.layerSection._value;
-  const isGroupEnd =
-    layer.name === "</Layer group>" ||
-    layer.name === "</Layer set>" ||
-    section === "layerSectionEnd";
+  const isGroupEnd
+    = layer.name === '</Layer group>'
+      || layer.name === '</Layer set>'
+      || section === 'layerSectionEnd';
 
-  const isGroupStart = section === "layerSectionStart";
-  return isGroupStart ? "start" : isGroupEnd ? "end" : "normal";
-};
+  const isGroupStart = section === 'layerSectionStart';
+  return isGroupStart ? 'start' : isGroupEnd ? 'end' : 'normal';
+}
 
 function getEffects(layer: LayerDescriptor): Record<string, boolean> {
   const effects: Record<string, boolean> = {};
   if (layer.layerEffects) {
     for (const effect in layer.layerEffects) {
-      effects[effect] = Array.isArray(layer.layerEffects[effect]) ? layer.layerEffects[effect].some((e) => e.enabled) : !!layer.layerEffects[effect]?.enabled;
+      effects[effect] = Array.isArray(layer.layerEffects[effect]) ? layer.layerEffects[effect].some(e => e.enabled) : !!layer.layerEffects[effect]?.enabled;
     }
   }
   return effects;

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

@@ -1,14 +1,14 @@
-import type { Test } from "@bubblydoo/uxp-test-framework";
-import { photoshopLayerDescriptorsToUTLayers } from "./photoshopLayerDescriptorsToUTLayers";
-import { openFileByPath } from "../filesystem/openFileByPath";
-import { expect } from "chai";
-import { getDocumentLayerDescriptors } from "./getDocumentLayerDescriptors";
+import type { Test } from '@bubblydoo/uxp-test-framework';
+import { expect } from 'chai';
+import { openFileByPath } from '../filesystem/openFileByPath';
+import { getDocumentLayerDescriptors } from './getDocumentLayerDescriptors';
+import { photoshopLayerDescriptorsToUTLayers } from './photoshopLayerDescriptorsToUTLayers';
 
 export const photoshopLayerDescriptorsToUTLayersTest: Test = {
-  name: "photoshopLayerDescriptorsToUTLayers",
-  description: "Test the photoshopLayerDescriptorsToUTLayers function",
+  name: 'photoshopLayerDescriptorsToUTLayers',
+  description: 'Test the photoshopLayerDescriptorsToUTLayers function',
   run: async () => {
-    const doc = await openFileByPath("plugin:/fixtures/clipping-layers.psd");
+    const doc = await openFileByPath('plugin:/fixtures/clipping-layers.psd');
     const descriptors = await getDocumentLayerDescriptors(doc.id);
 
     console.log(descriptors);
@@ -16,35 +16,35 @@ export const photoshopLayerDescriptorsToUTLayersTest: Test = {
     const layers = photoshopLayerDescriptorsToUTLayers(descriptors);
     expect(layers).to.containSubset([
       {
-        name: "circle",
+        name: 'circle',
         visible: true,
-        kind: "pixel",
-        blendMode: "normal",
+        kind: 'pixel',
+        blendMode: 'normal',
         isClippingMask: true,
         effects: {},
       },
       {
-        name: "group",
+        name: 'group',
         visible: true,
-        kind: "group",
-        blendMode: "passThrough",
+        kind: 'group',
+        blendMode: 'passThrough',
         isClippingMask: false,
         effects: {},
         layers: [
           {
-            name: "green square",
+            name: 'green square',
             visible: true,
-            kind: "pixel",
-            blendMode: "normal",
+            kind: 'pixel',
+            blendMode: 'normal',
             isClippingMask: true,
             effects: {},
           },
           {
-            name: "red square",
+            name: 'red square',
             id: 2,
             visible: true,
-            kind: "pixel",
-            blendMode: "normal",
+            kind: 'pixel',
+            blendMode: 'normal',
             isClippingMask: false,
             effects: {},
           },
@@ -55,28 +55,28 @@ export const photoshopLayerDescriptorsToUTLayersTest: Test = {
 };
 
 export const photoshopLayerDescriptorsToUTLayersTest2: Test = {
-  name: "photoshopLayerDescriptorsToUTLayers",
-  description: "Test the photoshopLayerDescriptorsToUTLayers function",
+  name: 'photoshopLayerDescriptorsToUTLayers',
+  description: 'Test the photoshopLayerDescriptorsToUTLayers function',
   run: async () => {
-    const doc = await openFileByPath("plugin:/fixtures/one-layer-with-bg.psd");
+    const doc = await openFileByPath('plugin:/fixtures/one-layer-with-bg.psd');
     const descriptors = await getDocumentLayerDescriptors(doc.id);
     console.log(descriptors);
     const layers = photoshopLayerDescriptorsToUTLayers(descriptors);
     console.log(layers);
     expect(layers).to.containSubset([
       {
-        name: "Layer 1",
+        name: 'Layer 1',
         visible: true,
-        kind: "pixel",
-        blendMode: "normal",
+        kind: 'pixel',
+        blendMode: 'normal',
         isClippingMask: false,
         effects: {},
       },
       {
-        name: "Background",
+        name: 'Background',
         visible: true,
-        kind: "background",
-        blendMode: "normal",
+        kind: 'background',
+        blendMode: 'normal',
         isClippingMask: false,
         effects: {},
       },

package/src/ut-tree/psLayerRef.ts

@@ -1,4 +1,4 @@
-export type PsLayerRef = {
+export interface PsLayerRef {
   id: number;
   docId: number;
-};
+}