@bubblydoo/uxp-toolkit 0.0.8 → 0.0.10

package/src/core/suspendHistory.uxp-test.ts

@@ -1,18 +1,18 @@
-import type { Test } from "@bubblydoo/uxp-test-framework";
-import { expect } from "chai";
-import { suspendHistory } from "./suspendHistory";
-import { app } from "photoshop";
+import type { Test } from '@bubblydoo/uxp-test-framework';
+import { expect } from 'chai';
+import { app } from 'photoshop';
+import { suspendHistory } from './suspendHistory';
 
 export const suspendHistoryTest: Test = {
-  name: "core/suspendHistory should return correctly",
+  name: 'core/suspendHistory should return correctly',
   async run() {
     const document = app.activeDocument;
     if (!document) {
-      throw new Error("No active document");
+      throw new Error('No active document');
     }
-    const result = await suspendHistory(document, "Test", async (context) => {
+    const result = await suspendHistory(document, 'Test', async (context) => {
       return 'test';
     });
     expect(result).to.equal('test');
   },
-};
+};

package/src/core-wrappers/executeAsModalAndSuspendHistory.ts

@@ -1,11 +1,13 @@
-import type { Document } from "photoshop/dom/Document";
-import { suspendHistory, type SuspendHistoryContext } from "../core/suspendHistory";
-import { executeAsModal, type ExtendedExecutionContext } from "../core/executeAsModal";
+import type { Document } from 'photoshop';
+import type { ExtendedExecutionContext } from '../core/executeAsModal';
+import type { SuspendHistoryContext } from '../core/suspendHistory';
+import { executeAsModal } from '../core/executeAsModal';
+import { suspendHistory } from '../core/suspendHistory';
 
 type CombinedFn<T> = (executionContext: ExtendedExecutionContext, suspendHistoryContext: SuspendHistoryContext) => Promise<T>;
 
-export const executeAsModalAndSuspendHistory = async <T>(commandName: string, document: Document, fn: CombinedFn<T>): Promise<T> => {
+export async function executeAsModalAndSuspendHistory<T>(commandName: string, document: Document, fn: CombinedFn<T>): Promise<T> {
   return await executeAsModal(commandName, async (ctx) => {
-    return await suspendHistory(document, commandName, (suspendHistoryContext) => fn(ctx, suspendHistoryContext));
+    return await suspendHistory(document, commandName, suspendHistoryContext => fn(ctx, suspendHistoryContext));
   });
-};
+}

package/src/dom/getFlattenedDomLayersList.ts

@@ -1,11 +1,9 @@
-import { constants } from "photoshop";
-import type { Layer as DomLayer } from "photoshop/dom/Layer";
+import type { Layer as DomLayer } from 'photoshop';
+import { constants } from 'photoshop';
 
 // get all layers (including nested in groups)
 // TODO: I would rename this to getAllDOMLayers to avoid confusion with UXPToolkitLayer
-export const getFlattenedDomLayersList = (
-  layers: DomLayer[],
-): DomLayer[] => {
+export function getFlattenedDomLayersList(layers: DomLayer[]): DomLayer[] {
   const allLayers: DomLayer[] = [];
 
   // Use a stack to avoid maximal call stack size (recursion) errors efficiently
@@ -20,7 +18,8 @@ export const getFlattenedDomLayersList = (
 
   while (stack.length > 0) {
     const layer = stack.pop();
-    if (!layer) continue;
+    if (!layer)
+      continue;
 
     allLayers.push(layer);
 
@@ -40,4 +39,4 @@ export const getFlattenedDomLayersList = (
   }
 
   return allLayers;
-};
+}

package/src/dom/photoshopDomLayersToTree.ts

@@ -1,10 +1,10 @@
-import type { Layer as DomLayer } from "photoshop/dom/Layer";
-import type { Tree } from "../general-tree/treeTypes";
+import type { Layer as DomLayer } from 'photoshop';
+import type { Tree } from '../general-tree/treeTypes';
 
 // get layers recursively
-export const photoshopDomLayersToTree = (layers: DomLayer[]): Tree<DomLayer> => {
+export function photoshopDomLayersToTree(layers: DomLayer[]): Tree<DomLayer> {
   // Get top-level layers
-  const filteredLayers = layers.filter((layer) => layer.parent === null);
+  const filteredLayers = layers.filter(layer => layer.parent === null);
 
   const generateTree = (layers: DomLayer[]): Tree<DomLayer> => {
     return layers.map((layer: DomLayer) => ({
@@ -15,4 +15,4 @@ export const photoshopDomLayersToTree = (layers: DomLayer[]): Tree<DomLayer> =>
   };
 
   return generateTree(filteredLayers);
-};
+}

package/src/error-sourcemaps/sourcemaps.ts

@@ -1,12 +1,13 @@
-import ErrorStackParser from "error-stack-parser";
-import { SourceMapConsumer } from "source-map-js";
-import { storage } from "uxp";
-import { pathResolve } from "../node-compat/path/resolvePath";
-import { UTError } from "../errors/ut-error";
+import type { File } from 'uxp';
+import ErrorStackParser from 'error-stack-parser';
+import { SourceMapConsumer } from 'source-map-js';
+import { storage } from 'uxp';
+import { UTError } from '../errors/ut-error';
+import { pathResolve } from '../node-compat/path/resolvePath';
 
 export type BasicStackFrame = Pick<
   ErrorStackParser.StackFrame,
-  "functionName" | "fileName" | "lineNumber" | "columnNumber"
+  'functionName' | 'fileName' | 'lineNumber' | 'columnNumber'
 >;
 
 export async function parseUxpErrorSourcemaps(error: Error, opts: { unsourcemappedHeaderLines?: number } = {}) {
@@ -14,28 +15,28 @@ export async function parseUxpErrorSourcemaps(error: Error, opts: { unsourcemapp
 
   const unsourcemappedHeaderLines = opts.unsourcemappedHeaderLines ?? 0;
 
-  const loadedFilesCache: Record<string, storage.File> = {};
+  const loadedFilesCache: Record<string, File> = {};
 
-  const fs = (storage as any).localFileSystem;
+  const fs = storage.localFileSystem;
   const parsedMappedError: BasicStackFrame[] = [];
   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)) as storage.File);
+    const entryPath = `plugin:${frame.fileName}`;
+    const file
+      = loadedFilesCache[entryPath]
+        ?? ((await fs.getEntryWithUrl(entryPath)) as File);
     loadedFilesCache[entryPath] = file;
     if (!file.isFile) {
       parsedMappedError.push(frame);
       continue;
     }
-    const sourcemapFileEntryPath = entryPath + ".map";
-    const sourcemapFile =
-      loadedFilesCache[sourcemapFileEntryPath] ??
-      ((await fs.getEntryWithUrl(sourcemapFileEntryPath)) as storage.File);
+    const sourcemapFileEntryPath = `${entryPath}.map`;
+    const sourcemapFile
+      = loadedFilesCache[sourcemapFileEntryPath]
+        ?? ((await fs.getEntryWithUrl(sourcemapFileEntryPath)) as File);
     loadedFilesCache[sourcemapFileEntryPath] = sourcemapFile;
     if (!sourcemapFile.isFile) {
       parsedMappedError.push(frame);
@@ -55,7 +56,8 @@ export async function parseUxpErrorSourcemaps(error: Error, opts: { unsourcemapp
         lineNumber: mappedFrame.line,
         columnNumber: mappedFrame.column,
       } as ErrorStackParser.StackFrame);
-    } else {
+    }
+    else {
       parsedMappedError.push(frame);
     }
   }
@@ -74,27 +76,26 @@ function parseErrorIntoBasicStackFrames(error: Error): BasicStackFrame[] {
         columnNumber: frame.columnNumber,
       };
     });
-  } catch (e) {
-    throw new UTStacktraceParsingError("Failed to parse error stack trace", { cause: e });
+  }
+  catch (e) {
+    throw new UTStacktraceParsingError('Failed to parse error stack trace', { cause: e });
   }
 }
 
 export async function getBasicStackFrameAbsoluteFilePath(frame: BasicStackFrame): Promise<string> {
-  const pluginFolder = await (
-    storage as any
-  ).localFileSystem.getPluginFolder();
+  const pluginFolder = await storage.localFileSystem.getPluginFolder();
   const absoluteFileName = pathResolve(
     pluginFolder.nativePath,
-    "index.js",
+    'index.js',
     frame.fileName!,
-  ).replace(/^plugin:/, "");
+  ).replace(/^plugin:/, '');
   return `${absoluteFileName}:${frame.lineNumber}:${frame.columnNumber}`;
 }
 
 export class UTStacktraceParsingError extends UTError {
-  public override readonly name = "UTStacktraceParsingError";
+  public override readonly name = 'UTStacktraceParsingError';
 
   constructor(message: string, opts: ErrorOptions = {}) {
     super(message, opts);
   }
-}
+}

package/src/error-sourcemaps/sourcemaps.uxp-test.ts

@@ -1,24 +1,25 @@
-import type { Test } from "@bubblydoo/uxp-test-framework";
-import { parseUxpErrorSourcemaps } from "./sourcemaps";
-import { expect } from "chai";
+import type { Test } from '@bubblydoo/uxp-test-framework';
+import { expect } from 'chai';
+import { parseUxpErrorSourcemaps } from './sourcemaps';
 
 function throwError() {
-  throw new Error("Uncaught error"); // this error should stay exactly here in the source code, see below
+  throw new Error('Uncaught error'); // this error should stay exactly here in the source code, see below
 }
 
 export const sourcemapsTest: Test = {
-  name: "sourcemaps: should parse error sourcemaps",
+  name: 'sourcemaps: should parse error sourcemaps',
   async run() {
     let error: Error;
     try {
       throwError();
-    } catch (e) {
+    }
+    catch (e) {
       error = e as Error;
     }
     const parsedError = await parseUxpErrorSourcemaps(error!);
     console.log(parsedError);
-    expect(parsedError[0]!.fileName).to.include("sourcemaps.uxp-test.ts");
+    expect(parsedError[0]!.fileName).to.include('sourcemaps.uxp-test.ts');
     expect(parsedError[0]!.lineNumber).to.eq(6);
     expect(parsedError[0]!.columnNumber).to.eq(8);
   },
-};
+};

package/src/errors/ut-error.ts

@@ -1,6 +1,6 @@
 export class UTError extends Error {
   constructor(message: string, opts: ErrorOptions = {}) {
     super(message, opts);
-    this.name = "UTError";
+    this.name = 'UTError';
   }
-}
+}

package/src/filesystem/isFileOrFolder.ts

@@ -0,0 +1,9 @@
+import type { Entry, File, Folder } from 'uxp';
+
+export function isFile(entry: Entry): entry is File {
+  return entry.isFile === true;
+}
+
+export function isFolder(entry: Entry): entry is Folder {
+  return entry.isFolder === true;
+}

package/src/filesystem/openFileByPath.ts

@@ -1,10 +1,14 @@
-import { app } from "photoshop";
-import { storage } from "uxp";
-import { executeAsModal } from "../core/executeAsModal";
+import { app } from 'photoshop';
+import { storage } from 'uxp';
+import { executeAsModal } from '../core/executeAsModal';
+import { isFile } from './isFileOrFolder';
 
 export async function openFileByPath(path: string) {
-  const fs = (storage as any).localFileSystem;
-  const file = (await fs.getEntryWithUrl(path)) as storage.File;
-  const doc = await executeAsModal("Open file", () => app.open(file as any));
+  const fs = storage.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;
 }

package/src/general-tree/flattenTree.ts

@@ -1,4 +1,4 @@
-import type { Tree } from "./treeTypes";
+import type { Tree } from './treeTypes';
 
 export function flattenTree<T>(tree: Tree<T>): Tree<T>[0][] {
   const result: Tree<T>[0][] = [];

package/src/general-tree/layerRef.ts

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

package/src/general-tree/mapTree.ts

@@ -1,4 +1,4 @@
-import type { Tree } from "./treeTypes";
+import type { Tree } from './treeTypes';
 
 export function mapTree<TRef, TMappedRef>(tree: Tree<TRef>, mapFn: (node: TRef) => TMappedRef): Tree<TMappedRef> {
   return tree.map((node) => {

package/src/general-tree/mapTreeRef.ts

@@ -1,4 +1,4 @@
-import type { Tree } from "./treeTypes";
+import type { Tree } from './treeTypes';
 
 export function mapTreeRef<TRef, TMappedRef>(tree: Tree<TRef>, mapFn: (node: TRef) => TMappedRef): Tree<TMappedRef> {
   return tree.map((node) => {

package/src/general-tree/treeTypes.ts

@@ -3,5 +3,3 @@ export type Tree<TRef = unknown> = {
   name: string;
   children?: Tree<TRef>;
 }[];
-
-

package/src/index.ts

@@ -1,74 +1,73 @@
+// UT tree – layer descriptors & Photoshop tree
+export { createMultiGetDocumentCommand } from './commands-library/multiGetDocument';
+// Core wrappers
+export { executeAsModalAndSuspendHistory } from './core-wrappers/executeAsModalAndSuspendHistory';
+
 // Core – batchPlay & command building
-export { batchPlay, type CorrectBatchPlayOptions } from "./core/batchPlay";
+export { batchPlay, type CorrectBatchPlayOptions } from './core/batchPlay';
 export {
-  createCommand,
   batchPlayCommand,
   batchPlayCommands,
+  createCommand,
   createModifyingBatchPlayContext,
   type UTCommandBase,
   type UTCommandModifying,
   type UTCommandNonModifying,
   type UTCommandResult,
-} from "./core/command";
+} from './core/command';
 
 // Core – execution context
 export {
   executeAsModal,
-  type CorrectExecutionContext,
-  type CorrectExecuteAsModalOptions,
   type ExtendedExecutionContext,
-} from "./core/executeAsModal";
+} from './core/executeAsModal';
+
 export {
   suspendHistory,
   type SuspendHistoryContext,
-} from "./core/suspendHistory";
-
-// Core wrappers
-export { executeAsModalAndSuspendHistory } from "./core-wrappers/executeAsModalAndSuspendHistory";
-
+} from './core/suspendHistory';
 // DOM – layers
-export { getFlattenedDomLayersList } from "./dom/getFlattenedDomLayersList";
-export { photoshopDomLayersToTree } from "./dom/photoshopDomLayersToTree";
+export { getFlattenedDomLayersList } from './dom/getFlattenedDomLayersList';
 
-// Filesystem
-export { openFileByPath } from "./filesystem/openFileByPath";
+export { photoshopDomLayersToTree } from './dom/photoshopDomLayersToTree';
 
+// Error sourcemaps
+export {
+  type BasicStackFrame,
+  getBasicStackFrameAbsoluteFilePath,
+  parseUxpErrorSourcemaps,
+} from './error-sourcemaps/sourcemaps';
+// Filesystem
+export { isFile, isFolder } from './filesystem/isFileOrFolder';
+export { openFileByPath } from './filesystem/openFileByPath';
 // General tree
-export { flattenTree } from "./general-tree/flattenTree";
-export { mapTree } from "./general-tree/mapTree";
-export { mapTreeRef } from "./general-tree/mapTreeRef";
-export { type Tree } from "./general-tree/treeTypes";
-export { type LayerRef } from "./general-tree/layerRef";
+export { flattenTree } from './general-tree/flattenTree';
+export { type LayerRef } from './general-tree/layerRef';
+export { mapTree } from './general-tree/mapTree';
 
+export { mapTreeRef } from './general-tree/mapTreeRef';
+export { type Tree } from './general-tree/treeTypes';
 // Other
-export { photoshopGetApplicationInfo } from "./other/applicationInfo";
-export { copyToClipboard, readFromClipboard } from "./other/clipboard";
-export { uxpEntrypointsSchema } from "./other/uxpEntrypoints";
+export { photoshopGetApplicationInfo } from './other/applicationInfo';
 
-// UT tree – layer descriptors & Photoshop tree
-export { createMultiGetDocumentCommand } from "./commands-library/multiGetDocument";
-export { getDocumentLayerDescriptors, type LayerDescriptor } from "./ut-tree/getDocumentLayerDescriptors";
-export { getLayerEffects } from "./ut-tree/getLayerEffects";
+export { copyToClipboard, readFromClipboard } from './other/clipboard';
+export { uxpEntrypointsSchema } from './other/uxpEntrypoints';
+export { getDocumentLayerDescriptors, type LayerDescriptor } from './ut-tree/getDocumentLayerDescriptors';
+export { getLayerEffects } from './ut-tree/getLayerEffects';
 export {
-  type UTLayer,
   photoshopLayerDescriptorsToUTLayers,
-} from "./ut-tree/photoshopLayerDescriptorsToUTLayers";
-export { type PsLayerRef } from "./ut-tree/psLayerRef";
+  type UTLayer,
+} from './ut-tree/photoshopLayerDescriptorsToUTLayers';
+export { type PsLayerRef } from './ut-tree/psLayerRef';
+
+// UT tree – text
+export { utLayersToText as utTreeToText } from './ut-tree/utLayersToText';
+
 export {
   utLayersToTree,
   type UTLayerWithoutChildren,
-} from "./ut-tree/utLayersToTree";
-
-// UT tree – text
-export { utLayersToText as utTreeToText } from "./ut-tree/utLayersToText";
+} from './ut-tree/utLayersToTree';
+export { type UTLayerPickKeys } from './util/utLayerPickKeysType';
 
 // 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 { utLayersToDomLayers, utLayerToDomLayer } from './util/utLayerToLayer';

package/src/metadata-storage/metadataStorage.ts

@@ -1,61 +1,53 @@
-import { convert } from "xmlbuilder2";
-import type { Document } from "photoshop/dom/Document";
-import { batchPlayCommand, createCommand, executeAsModal } from "@bubblydoo/uxp-toolkit";
-import { z } from "zod";
+import type { Document } from 'photoshop';
+import { batchPlayCommand, createCommand, executeAsModal } from '@bubblydoo/uxp-toolkit';
+import { convert } from 'xmlbuilder2';
+import { z } from 'zod';
 
-export const readDocumentMetadata = async (document: Document, { key, prefix }: { key: string, prefix: string }) => {
-  const converted = await readAllDocumentMetadata(document);
-  const property =
-    converted["x:xmpmeta"]["rdf:RDF"]["rdf:Description"][`${prefix}:${key}`];
-
-  return property;
-};
-
-export const readAllDocumentMetadata = async (document: Document) => {
+export async function readAllDocumentMetadata(document: Document) {
   const metadata = await batchPlayCommand(
     createCommand({
       modifying: false,
       descriptor: {
-        _obj: "get",
+        _obj: 'get',
         _target: {
           _ref: [
-            { _property: "XMPMetadataAsUTF8" },
-            { _ref: "document", _id: document.id },
+            { _property: 'XMPMetadataAsUTF8' },
+            { _ref: 'document', _id: document.id },
           ],
         },
       },
       schema: z.object({
         XMPMetadataAsUTF8: z.any(),
-      })
-    })
+      }),
+    }),
   );
 
   return convert(metadata.XMPMetadataAsUTF8, {
-    format: "object",
+    format: 'object',
   }) as any;
-};
+}
 
-export const writeDocumentMetadata = async (document: Document, newProperty: { key: string, value: string, prefix: string, prefixNamespace: string }) => {
+export async function writeDocumentMetadata(document: Document, newProperty: { key: string; value: string; prefix: string; prefixNamespace: string }) {
   const initialMetadata = await readAllDocumentMetadata(document);
-  const obj = convert(initialMetadata, { format: "object" }) as any;
-  obj["x:xmpmeta"]["rdf:RDF"]["rdf:Description"][
+  const obj = convert(initialMetadata, { format: 'object' }) as any;
+  obj['x:xmpmeta']['rdf:RDF']['rdf:Description'][
     `@xmlns:${newProperty.prefix}`
   ] = newProperty.prefixNamespace;
-  obj["x:xmpmeta"]["rdf:RDF"]["rdf:Description"][
+  obj['x:xmpmeta']['rdf:RDF']['rdf:Description'][
     `${newProperty.prefix}:${newProperty.key}`
   ] = newProperty.value;
-  const newXmpString = convert(obj, { format: "xml" });
-  await executeAsModal("Set Metadata", async (ctx) => {
+  const newXmpString = convert(obj, { format: 'xml' });
+  await executeAsModal('Set Metadata', async (ctx) => {
     const command = createCommand({
       modifying: true,
       descriptor: {
-        _obj: "set",
+        _obj: 'set',
         _target: [
-          { _ref: "property", _property: "XMPMetadataAsUTF8" },
-          { _ref: "document", _id: document.id },
+          { _ref: 'property', _property: 'XMPMetadataAsUTF8' },
+          { _ref: 'document', _id: document.id },
         ],
         to: {
-          _obj: "document",
+          _obj: 'document',
           XMPMetadataAsUTF8: newXmpString,
         },
       },
@@ -63,4 +55,12 @@ export const writeDocumentMetadata = async (document: Document, newProperty: { k
     });
     await ctx.batchPlayCommand(command, { synchronousExecution: true });
   });
-};
+}
+
+export async function readDocumentMetadata(document: Document, { key, prefix }: { key: string; prefix: string }) {
+  const converted = await readAllDocumentMetadata(document);
+  const property
+    = converted['x:xmpmeta']['rdf:RDF']['rdf:Description'][`${prefix}:${key}`];
+
+  return property;
+}

package/src/metadata-storage/metadataStorage.uxp-test.ts

@@ -1,21 +1,21 @@
-import { openFileByPath } from "../filesystem/openFileByPath";
-import type { Test } from "@bubblydoo/uxp-test-framework";
-import { expect } from "chai";
-import { app } from "photoshop";
+import type { Test } from '@bubblydoo/uxp-test-framework';
+import { expect } from 'chai';
+import { app } from 'photoshop';
+import { openFileByPath } from '../filesystem/openFileByPath';
 import {
   readDocumentMetadata,
   writeDocumentMetadata,
-} from "./metadataStorage";
+} from './metadataStorage';
 
-const TEST_PREFIX = "bubblytest";
-const TEST_PREFIX_NAMESPACE = "https://example.com/bubbly-test";
-const TEST_KEY = "testKey";
-const TEST_VALUE = "test-value-written-by-uxp-test";
+const TEST_PREFIX = 'bubblytest';
+const TEST_PREFIX_NAMESPACE = 'https://example.com/bubbly-test';
+const TEST_KEY = 'testKey';
+const TEST_VALUE = 'test-value-written-by-uxp-test';
 
 export const metadataStorageTest: Test = {
-  name: "Metadata Storage",
+  name: 'Metadata Storage',
   async run() {
-    await openFileByPath("plugin:/fixtures/one-layer.psd");
+    await openFileByPath('plugin:/fixtures/one-layer.psd');
     const document = app.activeDocument!;
 
     await writeDocumentMetadata(document, {

package/src/node-compat/path/resolvePath.ts

@@ -1,17 +1,19 @@
-import { resolve as nativeResolve } from "path";
+// eslint-disable-next-line unicorn/prefer-node-protocol
+import { resolve as nativeResolve } from 'path';
 
-/** for some reason native path.resolve in UXP returns a URL object
+/**
+ * for some reason native path.resolve in UXP returns a URL object
  * this function converts it to a string
  */
 export function pathResolve(...pathSegments: string[]): string {
   const urlOrString = nativeResolve(...pathSegments) as URL | string;
-  if (typeof urlOrString === "string") {
+  if (typeof urlOrString === 'string') {
     return urlOrString;
   }
   if (isUrl(urlOrString)) {
     return urlOrString.toString();
   }
-  throw new Error("Unexpected URL object");
+  throw new Error('Unexpected URL object');
 }
 
 function isUrl(urlOrString: any): urlOrString is URL {

package/src/other/applicationInfo.ts

@@ -1,9 +1,5 @@
-import { z } from "zod";
-import { batchPlayCommand, createCommand } from "../core/command";
-
-export async function photoshopGetApplicationInfo() {
-  return await batchPlayCommand(photoshopApplicationInfoCommand);
-}
+import { z } from 'zod';
+import { batchPlayCommand, createCommand } from '../core/command';
 
 const photoshopAppInfoSchema = z.object({
   active: z.boolean(),
@@ -32,25 +28,29 @@ const photoshopAppInfoSchema = z.object({
       name: z.string(),
       obscured: z.boolean(),
       visible: z.boolean(),
-    })
+    }),
   ),
 });
 
 const photoshopApplicationInfoCommand = createCommand({
   modifying: false,
   descriptor: {
-    _obj: "get",
+    _obj: 'get',
     _target: [
       {
-        _ref: "application",
-        _enum: "ordinal",
-        _value: "targetEnum",
+        _ref: 'application',
+        _enum: 'ordinal',
+        _value: 'targetEnum',
       },
     ],
   },
   schema: photoshopAppInfoSchema,
 });
 
+export async function photoshopGetApplicationInfo() {
+  return await batchPlayCommand(photoshopApplicationInfoCommand);
+}
+
 // $PnCK: {_enum: "cursorKind", _value: "brushSize"}
 // MRUColorList: (2) [{…}, {…}]
 // active: false