@bubblydoo/uxp-toolkit 0.0.8 → 0.0.10

package/dist/index.js

@@ -7,9 +7,43 @@ import {
   createGetDocumentHasBackgroundLayerCommand,
   createGetLayerCommand,
   createModifyingBatchPlayContext,
-  createMultiGetDocumentCommand,
-  executeAsModal
-} from "./chunk-3CLJMC63.js";
+  createMultiGetDocumentCommand
+} from "./chunk-JBXCIUBZ.js";
+
+// src/core/executeAsModal.ts
+import { core } from "photoshop";
+async function executeAsModal(commandName, fn, opts) {
+  let error;
+  let result;
+  await core.executeAsModal(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/core/suspendHistory.ts
 async function suspendHistory(document, historyStateName, fn) {
@@ -21,15 +55,15 @@ async function suspendHistory(document, historyStateName, fn) {
 }
 
 // src/core-wrappers/executeAsModalAndSuspendHistory.ts
-var executeAsModalAndSuspendHistory = async (commandName, document, fn) => {
+async function executeAsModalAndSuspendHistory(commandName, document, fn) {
   return await executeAsModal(commandName, async (ctx) => {
     return await suspendHistory(document, commandName, (suspendHistoryContext) => fn(ctx, suspendHistoryContext));
   });
-};
+}
 
 // src/dom/getFlattenedDomLayersList.ts
 import { constants } from "photoshop";
-var getFlattenedDomLayersList = (layers) => {
+function getFlattenedDomLayersList(layers) {
   const allLayers = [];
   const stack = [];
   for (let i = layers.length - 1; i >= 0; i--) {
@@ -37,7 +71,8 @@ var getFlattenedDomLayersList = (layers) => {
   }
   while (stack.length > 0) {
     const layer = stack.pop();
-    if (!layer) continue;
+    if (!layer)
+      continue;
     allLayers.push(layer);
     if (layer.kind === constants.LayerKind.GROUP) {
       const children = layer.layers;
@@ -49,10 +84,10 @@ var getFlattenedDomLayersList = (layers) => {
     }
   }
   return allLayers;
-};
+}
 
 // src/dom/photoshopDomLayersToTree.ts
-var photoshopDomLayersToTree = (layers) => {
+function photoshopDomLayersToTree(layers) {
   const filteredLayers = layers.filter((layer) => layer.parent === null);
   const generateTree = (layers2) => {
     return layers2.map((layer) => ({
@@ -62,15 +97,132 @@ var photoshopDomLayersToTree = (layers) => {
     }));
   };
   return generateTree(filteredLayers);
+}
+
+// src/error-sourcemaps/sourcemaps.ts
+import ErrorStackParser from "error-stack-parser";
+import { SourceMapConsumer } from "source-map-js";
+import { storage } from "uxp";
+
+// src/errors/ut-error.ts
+var UTError = class extends Error {
+  constructor(message, opts = {}) {
+    super(message, opts);
+    this.name = "UTError";
+  }
+};
+
+// src/node-compat/path/resolvePath.ts
+import { resolve as nativeResolve } from "path";
+function pathResolve(...pathSegments) {
+  const urlOrString = nativeResolve(...pathSegments);
+  if (typeof urlOrString === "string") {
+    return urlOrString;
+  }
+  if (isUrl(urlOrString)) {
+    return urlOrString.toString();
+  }
+  throw new Error("Unexpected URL object");
+}
+function isUrl(urlOrString) {
+  return urlOrString instanceof URL;
+}
+
+// src/error-sourcemaps/sourcemaps.ts
+async function parseUxpErrorSourcemaps(error, opts = {}) {
+  const parsedError = parseErrorIntoBasicStackFrames(error);
+  const unsourcemappedHeaderLines = opts.unsourcemappedHeaderLines ?? 0;
+  const loadedFilesCache = {};
+  const fs = storage.localFileSystem;
+  const parsedMappedError = [];
+  for (const frame of parsedError) {
+    if (!frame.fileName || !frame.lineNumber || !frame.columnNumber) {
+      parsedMappedError.push(frame);
+      continue;
+    }
+    const entryPath = `plugin:${frame.fileName}`;
+    const file = loadedFilesCache[entryPath] ?? await fs.getEntryWithUrl(entryPath);
+    loadedFilesCache[entryPath] = file;
+    if (!file.isFile) {
+      parsedMappedError.push(frame);
+      continue;
+    }
+    const sourcemapFileEntryPath = `${entryPath}.map`;
+    const sourcemapFile = loadedFilesCache[sourcemapFileEntryPath] ?? await fs.getEntryWithUrl(sourcemapFileEntryPath);
+    loadedFilesCache[sourcemapFileEntryPath] = sourcemapFile;
+    if (!sourcemapFile.isFile) {
+      parsedMappedError.push(frame);
+      continue;
+    }
+    const sourcemapContents = await sourcemapFile.read({});
+    const sourcemap = JSON.parse(sourcemapContents);
+    const smc = new SourceMapConsumer(sourcemap);
+    const mappedFrame = smc.originalPositionFor({
+      line: frame.lineNumber - unsourcemappedHeaderLines,
+      column: frame.columnNumber
+    });
+    if (mappedFrame.source && mappedFrame.line && mappedFrame.column) {
+      parsedMappedError.push({
+        ...frame,
+        fileName: mappedFrame.source,
+        lineNumber: mappedFrame.line,
+        columnNumber: mappedFrame.column
+      });
+    } else {
+      parsedMappedError.push(frame);
+    }
+  }
+  return parsedMappedError;
+}
+function parseErrorIntoBasicStackFrames(error) {
+  try {
+    const frames = ErrorStackParser.parse(error);
+    return frames.map((frame) => {
+      return {
+        functionName: frame.functionName,
+        fileName: frame.fileName,
+        lineNumber: frame.lineNumber,
+        columnNumber: frame.columnNumber
+      };
+    });
+  } catch (e) {
+    throw new UTStacktraceParsingError("Failed to parse error stack trace", { cause: e });
+  }
+}
+async function getBasicStackFrameAbsoluteFilePath(frame) {
+  const pluginFolder = await storage.localFileSystem.getPluginFolder();
+  const absoluteFileName = pathResolve(
+    pluginFolder.nativePath,
+    "index.js",
+    frame.fileName
+  ).replace(/^plugin:/, "");
+  return `${absoluteFileName}:${frame.lineNumber}:${frame.columnNumber}`;
+}
+var UTStacktraceParsingError = class extends UTError {
+  name = "UTStacktraceParsingError";
+  constructor(message, opts = {}) {
+    super(message, opts);
+  }
 };
 
+// src/filesystem/isFileOrFolder.ts
+function isFile(entry) {
+  return entry.isFile === true;
+}
+function isFolder(entry) {
+  return entry.isFolder === true;
+}
+
 // src/filesystem/openFileByPath.ts
 import { app } from "photoshop";
-import { storage } from "uxp";
+import { storage as storage2 } from "uxp";
 async function openFileByPath(path) {
-  const fs = storage.localFileSystem;
-  const file = await fs.getEntryWithUrl(path);
-  const doc = await executeAsModal("Open file", () => app.open(file));
+  const fs = storage2.localFileSystem;
+  const entry = await fs.getEntryWithUrl(path);
+  if (!isFile(entry)) {
+    throw new Error("Entry is not a file");
+  }
+  const doc = await executeAsModal("Open file", () => app.open(entry));
   return doc;
 }
 
@@ -110,9 +262,6 @@ function mapTreeRef(tree, mapFn) {
 
 // src/other/applicationInfo.ts
 import { z } from "zod";
-async function photoshopGetApplicationInfo() {
-  return await batchPlayCommand(photoshopApplicationInfoCommand);
-}
 var photoshopAppInfoSchema = z.object({
   active: z.boolean(),
   autoShowHomeScreen: z.boolean(),
@@ -157,6 +306,9 @@ var photoshopApplicationInfoCommand = createCommand({
   },
   schema: photoshopAppInfoSchema
 });
+async function photoshopGetApplicationInfo() {
+  return await batchPlayCommand(photoshopApplicationInfoCommand);
+}
 
 // src/other/clipboard.ts
 async function copyToClipboard(text) {
@@ -180,7 +332,7 @@ var uxpEntrypointsSchema = z2.object({
 });
 
 // src/ut-tree/getDocumentLayerDescriptors.ts
-var getDocumentLayerDescriptors = async (documentId) => {
+async function getDocumentLayerDescriptors(documentId) {
   const [layersResult, documentHasBackgroundLayerResult] = await batchPlayCommands([
     createMultiGetDocumentCommand(documentId),
     createGetDocumentHasBackgroundLayerCommand(documentId)
@@ -196,7 +348,7 @@ var getDocumentLayerDescriptors = async (documentId) => {
       docId: documentId
     };
   });
-};
+}
 
 // src/ut-tree/getLayerEffects.ts
 async function getLayerEffects(layerRef) {
@@ -204,7 +356,8 @@ async function getLayerEffects(layerRef) {
   const data = result.layerEffects || {};
   const effects = {};
   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;
 }
@@ -256,20 +409,20 @@ var blendModes = [
   "luminosity",
   "passThrough"
 ];
-var getLayerKind = (layer) => {
+function getLayerKind(layer) {
   const kind = layerKindMap.get(layer.layerKind);
   if (!kind) {
     throw new Error(`Unknown layer kind: ${layer.layerKind}`);
   }
   return kind;
-};
-var getBlendMode = (layer) => {
+}
+function getBlendMode(layer) {
   const mode = layer.mode._value;
   if (!blendModes.includes(mode)) {
     throw new Error(`Unknown blend mode: ${mode}`);
   }
   return mode;
-};
+}
 function photoshopLayerDescriptorsToUTLayers(layers) {
   const root = [];
   const stack = [{ layers: root }];
@@ -301,12 +454,12 @@ function photoshopLayerDescriptorsToUTLayers(layers) {
   }
   return root;
 }
-var determineLayerSection = (layer) => {
+function determineLayerSection(layer) {
   const section = layer.layerSection._value;
   const isGroupEnd = layer.name === "</Layer group>" || layer.name === "</Layer set>" || section === "layerSectionEnd";
   const isGroupStart = section === "layerSectionStart";
   return isGroupStart ? "start" : isGroupEnd ? "end" : "normal";
-};
+}
 function getEffects(layer) {
   const effects = {};
   if (layer.layerEffects) {
@@ -317,25 +470,6 @@ function getEffects(layer) {
   return effects;
 }
 
-// src/ut-tree/utLayersToTree.ts
-function utLayersToTree(layer) {
-  return layer.map((layer2) => ({
-    ref: {
-      name: layer2.name,
-      docId: layer2.docId,
-      id: layer2.id,
-      visible: layer2.visible,
-      kind: layer2.kind,
-      blendMode: layer2.blendMode,
-      isClippingMask: layer2.isClippingMask,
-      effects: layer2.effects,
-      background: layer2.background
-    },
-    name: layer2.name,
-    children: layer2.layers ? utLayersToTree(layer2.layers) : void 0
-  }));
-}
-
 // src/ut-tree/utLayersToText.ts
 var VISIBLE_ICON = "\u25EF";
 var INVISIBLE_ICON = "\u2298";
@@ -354,7 +488,8 @@ function utLayersToText(tree, depth = 0) {
     const visible = layer.visible ? VISIBLE_ICON : INVISIBLE_ICON;
     const line = [visible, prefix, clippingMask, group, name, effects, blend].filter(Boolean).join(" ");
     if (layer.layers) {
-      return line + "\n" + utLayersToText(layer.layers, depth + 1);
+      return `${line}
+${utLayersToText(layer.layers, depth + 1)}`;
     }
     return line;
   }).join("\n");
@@ -363,6 +498,25 @@ function isSpecialBlendMode(layer) {
   return layer.kind === "group" ? layer.blendMode !== "passThrough" : layer.blendMode !== "normal";
 }
 
+// src/ut-tree/utLayersToTree.ts
+function utLayersToTree(layer) {
+  return layer.map((layer2) => ({
+    ref: {
+      name: layer2.name,
+      docId: layer2.docId,
+      id: layer2.id,
+      visible: layer2.visible,
+      kind: layer2.kind,
+      blendMode: layer2.blendMode,
+      isClippingMask: layer2.isClippingMask,
+      effects: layer2.effects,
+      background: layer2.background
+    },
+    name: layer2.name,
+    children: layer2.layers ? utLayersToTree(layer2.layers) : void 0
+  }));
+}
+
 // src/util/utLayerToLayer.ts
 import { app as app2 } from "photoshop";
 function utLayerToDomLayer(layer) {
@@ -380,7 +534,8 @@ function utLayerToDomLayer(layer) {
   return domLayer;
 }
 function utLayersToDomLayers(layers) {
-  if (layers.length === 0) return [];
+  if (layers.length === 0)
+    return [];
   const docId = layers[0].docId;
   if (!layers.every((l) => l.docId === docId)) {
     throw new Error("All layers must be from the same document.");
@@ -400,112 +555,6 @@ function utLayersToDomLayers(layers) {
     return domLayer;
   });
 }
-
-// src/error-sourcemaps/sourcemaps.ts
-import ErrorStackParser from "error-stack-parser";
-import { SourceMapConsumer } from "source-map-js";
-import { storage as storage2 } from "uxp";
-
-// src/node-compat/path/resolvePath.ts
-import { resolve as nativeResolve } from "path";
-function pathResolve(...pathSegments) {
-  const urlOrString = nativeResolve(...pathSegments);
-  if (typeof urlOrString === "string") {
-    return urlOrString;
-  }
-  if (isUrl(urlOrString)) {
-    return urlOrString.toString();
-  }
-  throw new Error("Unexpected URL object");
-}
-function isUrl(urlOrString) {
-  return urlOrString instanceof URL;
-}
-
-// src/errors/ut-error.ts
-var UTError = class extends Error {
-  constructor(message, opts = {}) {
-    super(message, opts);
-    this.name = "UTError";
-  }
-};
-
-// src/error-sourcemaps/sourcemaps.ts
-async function parseUxpErrorSourcemaps(error, opts = {}) {
-  const parsedError = parseErrorIntoBasicStackFrames(error);
-  const unsourcemappedHeaderLines = opts.unsourcemappedHeaderLines ?? 0;
-  const loadedFilesCache = {};
-  const fs = storage2.localFileSystem;
-  const parsedMappedError = [];
-  for (const frame of parsedError) {
-    if (!frame.fileName || !frame.lineNumber || !frame.columnNumber) {
-      parsedMappedError.push(frame);
-      continue;
-    }
-    const entryPath = "plugin:" + frame.fileName;
-    const file = loadedFilesCache[entryPath] ?? await fs.getEntryWithUrl(entryPath);
-    loadedFilesCache[entryPath] = file;
-    if (!file.isFile) {
-      parsedMappedError.push(frame);
-      continue;
-    }
-    const sourcemapFileEntryPath = entryPath + ".map";
-    const sourcemapFile = loadedFilesCache[sourcemapFileEntryPath] ?? await fs.getEntryWithUrl(sourcemapFileEntryPath);
-    loadedFilesCache[sourcemapFileEntryPath] = sourcemapFile;
-    if (!sourcemapFile.isFile) {
-      parsedMappedError.push(frame);
-      continue;
-    }
-    const sourcemapContents = await sourcemapFile.read({});
-    const sourcemap = JSON.parse(sourcemapContents);
-    const smc = new SourceMapConsumer(sourcemap);
-    const mappedFrame = smc.originalPositionFor({
-      line: frame.lineNumber - unsourcemappedHeaderLines,
-      column: frame.columnNumber
-    });
-    if (mappedFrame.source && mappedFrame.line && mappedFrame.column) {
-      parsedMappedError.push({
-        ...frame,
-        fileName: mappedFrame.source,
-        lineNumber: mappedFrame.line,
-        columnNumber: mappedFrame.column
-      });
-    } else {
-      parsedMappedError.push(frame);
-    }
-  }
-  return parsedMappedError;
-}
-function parseErrorIntoBasicStackFrames(error) {
-  try {
-    const frames = ErrorStackParser.parse(error);
-    return frames.map((frame) => {
-      return {
-        functionName: frame.functionName,
-        fileName: frame.fileName,
-        lineNumber: frame.lineNumber,
-        columnNumber: frame.columnNumber
-      };
-    });
-  } catch (e) {
-    throw new UTStacktraceParsingError("Failed to parse error stack trace", { cause: e });
-  }
-}
-async function getBasicStackFrameAbsoluteFilePath(frame) {
-  const pluginFolder = await storage2.localFileSystem.getPluginFolder();
-  const absoluteFileName = pathResolve(
-    pluginFolder.nativePath,
-    "index.js",
-    frame.fileName
-  ).replace(/^plugin:/, "");
-  return `${absoluteFileName}:${frame.lineNumber}:${frame.columnNumber}`;
-}
-var UTStacktraceParsingError = class extends UTError {
-  name = "UTStacktraceParsingError";
-  constructor(message, opts = {}) {
-    super(message, opts);
-  }
-};
 export {
   batchPlay,
   batchPlayCommand,
@@ -521,6 +570,8 @@ export {
   getDocumentLayerDescriptors,
   getFlattenedDomLayersList,
   getLayerEffects,
+  isFile,
+  isFolder,
   mapTree,
   mapTreeRef,
   openFileByPath,

package/dist/{psLayerRef-OY3h7srv.d.ts → psLayerRef-CGbTO4a5.d.ts}

@@ -1,70 +1,69 @@
-import * as photoshop_dom_CoreModules from 'photoshop/dom/CoreModules';
-import { ActionDescriptor } from 'photoshop/dom/CoreModules';
+import * as photoshop from 'photoshop';
+import { action, ActionDescriptor } from 'photoshop';
 import { z } from 'zod';
-import { action } from 'photoshop';
+
+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;
+    }[];
+}>;
 
 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[]>;
+declare function batchPlay(actions: P[0], options?: CorrectBatchPlayOptions): Promise<photoshop.ActionDescriptor[]>;
 
-interface UTCommandBase<T extends any> {
+interface UTCommandBase<T> {
     descriptor: ActionDescriptor;
     schema: z.ZodSchema<T>;
 }
-interface UTCommandModifying<T extends any> extends UTCommandBase<T> {
+interface UTCommandModifying<T> extends UTCommandBase<T> {
     modifying: true;
 }
-interface UTCommandNonModifying<T extends any> extends UTCommandBase<T> {
+interface UTCommandNonModifying<T> extends UTCommandBase<T> {
     modifying: false;
 }
-declare function createCommand<TReturn extends any, TModifying extends boolean>(obj: {
+declare function createCommand<TReturn, 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 batchPlayCommandBase<T>(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 batchPlayCommand<T>(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;
 };
 
-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;
-    }[];
-}>;
-
-type PsLayerRef = {
+interface PsLayerRef {
     id: number;
     docId: number;
-};
+}
 
 export { type CorrectBatchPlayOptions as C, type PsLayerRef as P, type UTCommandBase as U, type UTCommandModifying as a, type UTCommandNonModifying as b, createModifyingBatchPlayContext as c, type UTCommandResult as d, batchPlay as e, batchPlayCommand as f, batchPlayCommands as g, createCommand as h, createMultiGetDocumentCommand as i };

package/package.json

@@ -1,14 +1,14 @@
 {
   "name": "@bubblydoo/uxp-toolkit",
-  "version": "0.0.8",
-  "license": "MIT",
   "type": "module",
+  "version": "0.0.10",
   "author": "Hans Otto Wirtz <hansottowirtz@gmail.com>",
+  "license": "MIT",
+  "homepage": "https://github.com/bubblydoo/uxp-toolkit/tree/main/packages/uxp-toolkit",
   "repository": {
     "type": "git",
     "url": "https://github.com/bubblydoo/uxp-toolkit.git"
   },
-  "homepage": "https://github.com/bubblydoo/uxp-toolkit/tree/main/packages/uxp-toolkit",
   "exports": {
     ".": {
       "types": "./dist/index.d.ts",
@@ -32,10 +32,8 @@
     "xmlbuilder2": "^4.0.3"
   },
   "devDependencies": {
-    "@adobe-uxp-types/uxp": "^0.0.9",
     "@types/chai": "^5.2.3",
     "@types/node": "^20.8.7",
-    "@types/photoshop": "^25.0.2",
     "chai": "^6.2.2",
     "dedent": "^1.7.1",
     "rollup": "^4.57.0",
@@ -43,13 +41,17 @@
     "typescript": "^5.8.3",
     "vitest": "^4.0.18",
     "zod": "^4.3.6",
+    "@adobe-uxp-types/photoshop": "0.1.1",
+    "@adobe-uxp-types/uxp": "0.1.1",
     "@bubblydoo/tsconfig": "0.0.3",
-    "@bubblydoo/uxp-test-framework": "0.0.8"
+    "@bubblydoo/uxp-test-framework": "0.0.10"
   },
   "scripts": {
     "build": "tsup",
     "test": "vitest run",
     "uxp-test:build": "uxp-test build",
-    "uxp-test:dev": "uxp-test dev"
+    "uxp-test:dev": "uxp-test dev",
+    "typecheck": "tsc --noEmit",
+    "docs-json": "typedoc --json docs.json"
   }
 }

package/src/commands-library/addLayerToSelection.ts

@@ -1,10 +1,10 @@
-import { z } from "zod";
-import { createCommand } from "../core/command";
-import type { PsLayerRef } from "../ut-tree/psLayerRef";
+import type { PsLayerRef } from '../ut-tree/psLayerRef';
+import { z } from 'zod';
+import { createCommand } from '../core/command';
 
 export function createAddLayerToSelectionCommand(
   layerRef: PsLayerRef,
-  previousLayerRef: PsLayerRef
+  previousLayerRef: PsLayerRef,
 ) {
   return createCommand({
     modifying: true,

package/src/commands-library/applyLayerMask.ts

@@ -1,5 +1,5 @@
-import { z } from "zod";
-import { createCommand } from "../core/command";
+import { z } from 'zod';
+import { createCommand } from '../core/command';
 
 export function createSelectLayerMaskCommand(layerId: number) {
   return createCommand({

package/src/commands-library/convertMode.ts

@@ -1,5 +1,5 @@
-import { z } from "zod";
-import { createCommand } from "../core/command";
+import { z } from 'zod';
+import { createCommand } from '../core/command';
 
 export function createConvertModeCommand(depth: 8 | 16) {
   return createCommand({