@bubblydoo/uxp-toolkit 0.0.2

package/dist/index.js

@@ -0,0 +1,733 @@
+// 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/command.ts
+import "zod";
+
+// src/core/executeAsModal.ts
+import { core } from "photoshop";
+var originalExecuteAsModal = core.executeAsModal;
+async function executeAsModal(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/core/command.ts
+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/suspendHistory.ts
+async function suspendHistory(document, historyStateName, fn) {
+  let result;
+  await document.suspendHistory(async (context) => {
+    result = await fn(context);
+  }, historyStateName);
+  return result;
+}
+
+// src/core-wrappers/executeAsModalAndSuspendHistory.ts
+var executeAsModalAndSuspendHistory = async (commandName, document, fn) => {
+  return await executeAsModal(commandName, async (ctx) => {
+    return await suspendHistory(document, commandName, (suspendHistoryContext) => fn(ctx, suspendHistoryContext));
+  });
+};
+
+// src/commands-library/getLayerProperties.ts
+import { z as z2 } from "zod";
+var getLayerProperties = async (document) => {
+  const command = createCommand({
+    modifying: false,
+    descriptor: {
+      _obj: "multiGet",
+      _target: { _ref: [{ _ref: "document", _id: document.id }] },
+      extendedReference: [
+        ["name", "layerID", "visible"],
+        { _obj: "layer", index: 1, count: -1 }
+      ]
+    },
+    schema: z2.object({
+      list: z2.array(
+        z2.object({
+          name: z2.string(),
+          layerID: z2.number(),
+          visible: z2.boolean().optional()
+        })
+      )
+    })
+  });
+  const result = await batchPlayCommand(command);
+  return [...result.list].reverse();
+};
+
+// src/commands-library/renameLayer.ts
+import { z as z3 } from "zod";
+function createRenameLayerCommand(layerRef, newName) {
+  return createCommand({
+    modifying: true,
+    descriptor: {
+      _obj: "set",
+      _target: [{ _ref: "layer", _id: layerRef.id }, { _ref: "document", _id: layerRef.docId }],
+      to: { _obj: "layer", name: newName }
+    },
+    schema: z3.unknown()
+  });
+}
+
+// src/dom/getFlattenedDomLayersList.ts
+import { constants } from "photoshop";
+var getFlattenedDomLayersList = (layers) => {
+  const allLayers = [];
+  const stack = [];
+  for (let i = layers.length - 1; i >= 0; i--) {
+    stack.push(layers[i]);
+  }
+  while (stack.length > 0) {
+    const layer = stack.pop();
+    if (!layer) continue;
+    allLayers.push(layer);
+    if (layer.kind === constants.LayerKind.GROUP) {
+      const children = layer.layers;
+      if (children && children.length > 0) {
+        for (let i = children.length - 1; i >= 0; i--) {
+          stack.push(children[i]);
+        }
+      }
+    }
+  }
+  return allLayers;
+};
+
+// src/dom/photoshopDomLayersToTree.ts
+var photoshopDomLayersToTree = (layers) => {
+  const filteredLayers = layers.filter((layer) => layer.parent === null);
+  const generateTree = (layers2) => {
+    return layers2.map((layer) => ({
+      ref: layer,
+      name: layer.name,
+      ...layer.layers && { children: generateTree(layer.layers) }
+    }));
+  };
+  return generateTree(filteredLayers);
+};
+
+// src/filesystem/openFileByPath.ts
+import { app } from "photoshop";
+import { storage } 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));
+  return doc;
+}
+
+// src/general-tree/flattenTree.ts
+function flattenTree(tree) {
+  const result = [];
+  for (const node of tree) {
+    result.push(node);
+    if (node.children) {
+      result.push(...flattenTree(node.children));
+    }
+  }
+  return result;
+}
+
+// src/general-tree/mapTree.ts
+function mapTree(tree, mapFn) {
+  return tree.map((node) => {
+    return {
+      ...node,
+      ref: mapFn(node.ref),
+      children: node.children ? mapTree(node.children, mapFn) : void 0
+    };
+  });
+}
+
+// src/general-tree/mapTreeRef.ts
+function mapTreeRef(tree, mapFn) {
+  return tree.map((node) => {
+    return {
+      ...node,
+      ref: mapFn(node.ref),
+      children: node.children ? mapTreeRef(node.children, mapFn) : void 0
+    };
+  });
+}
+
+// src/other/applicationInfo.ts
+import { z as z4 } from "zod";
+async function photoshopGetApplicationInfo() {
+  return await batchPlayCommand(photoshopApplicationInfoCommand);
+}
+var photoshopAppInfoSchema = z4.object({
+  active: z4.boolean(),
+  autoShowHomeScreen: z4.boolean(),
+  available: z4.number(),
+  buildNumber: z4.string(),
+  documentArea: z4.object({
+    left: z4.number(),
+    top: z4.number(),
+    right: z4.number(),
+    bottom: z4.number()
+  }),
+  hostName: z4.string(),
+  hostVersion: z4.object({
+    versionMajor: z4.number(),
+    versionMinor: z4.number(),
+    versionFix: z4.number()
+  }),
+  localeInfo: z4.object({
+    decimalPoint: z4.string()
+  }),
+  osVersion: z4.string(),
+  panelList: z4.array(
+    z4.object({
+      ID: z4.string(),
+      name: z4.string(),
+      obscured: z4.boolean(),
+      visible: z4.boolean()
+    })
+  )
+});
+var photoshopApplicationInfoCommand = createCommand({
+  modifying: false,
+  descriptor: {
+    _obj: "get",
+    _target: [
+      {
+        _ref: "application",
+        _enum: "ordinal",
+        _value: "targetEnum"
+      }
+    ]
+  },
+  schema: photoshopAppInfoSchema
+});
+
+// src/other/clipboard.ts
+async function copyToClipboard(text) {
+  await navigator.clipboard.writeText({
+    "text/plain": text
+  });
+}
+async function readFromClipboard() {
+  const clipboard = await navigator.clipboard.readText();
+  return clipboard["text/plain"];
+}
+
+// src/other/uxpEntrypoints.ts
+import { z as z5 } from "zod";
+var uxpEntrypointsSchema = z5.object({
+  _pluginInfo: z5.object({
+    id: z5.string(),
+    name: z5.string(),
+    version: z5.string()
+  })
+});
+
+// src/ut-tree/getLayerProperties.ts
+import { z as z6 } from "zod";
+function createGetLayerPropertiesCommand(docId) {
+  return createCommand({
+    modifying: false,
+    descriptor: {
+      _obj: "multiGet",
+      _target: { _ref: [{ _ref: "document", _id: docId }] },
+      extendedReference: [
+        ["name", "layerID", "visible"],
+        { _obj: "layer", index: 1, count: -1 }
+      ]
+    },
+    schema: z6.object({
+      list: z6.array(
+        z6.object({
+          name: z6.string(),
+          layerID: z6.number(),
+          visible: z6.boolean().optional()
+        })
+      )
+    })
+  });
+}
+var getLayerProperties2 = async (documentId) => {
+  const command = createGetLayerPropertiesCommand(documentId);
+  const result = await batchPlayCommand(command);
+  return [...result.list].reverse();
+};
+
+// src/ut-tree/getFlattenedLayerDescriptorsList.ts
+import { z as z7 } from "zod";
+var layerDescriptorSchema = z7.object({
+  name: z7.string(),
+  // id: z.number(),
+  layerID: z7.number(),
+  // _docId: z.number(),
+  mode: z7.object({
+    _enum: z7.literal("blendMode"),
+    _value: z7.string()
+    // passThrough, normal, multiply, screen, overlay, etc.
+  }),
+  background: z7.boolean(),
+  itemIndex: z7.number(),
+  visible: z7.boolean(),
+  layerKind: z7.number(),
+  layerSection: z7.object({
+    _value: z7.enum([
+      "layerSectionStart",
+      "layerSectionEnd",
+      "layerSectionContent"
+    ]),
+    _enum: z7.literal("layerSectionType")
+  })
+});
+var getFlattenedLayerDescriptorsList = async (documentId) => {
+  const layerProperties = await getLayerProperties2(documentId);
+  const commands = layerProperties.map(
+    (layerProp) => createCommand({
+      modifying: false,
+      descriptor: {
+        _obj: "get",
+        _target: [
+          {
+            _ref: "layer",
+            _id: layerProp.layerID
+          }
+        ],
+        makeVisible: false,
+        layerID: [layerProp.layerID],
+        _isCommand: false
+      },
+      schema: layerDescriptorSchema
+    })
+  );
+  const layerDescriptors = await batchPlayCommands(commands);
+  return layerDescriptors.map((desc) => {
+    return {
+      ...desc,
+      docId: documentId
+    };
+  });
+};
+
+// src/ut-tree/getLayerEffects.ts
+import { z as z8 } from "zod";
+function createGetLayerCommand(layerRef) {
+  return createCommand({
+    modifying: false,
+    descriptor: {
+      _obj: "get",
+      _target: [
+        { _ref: "layer", _id: layerRef.id },
+        { _ref: "document", _id: layerRef.docId }
+      ]
+    },
+    schema: z8.object({
+      layerID: z8.number(),
+      group: z8.boolean().optional(),
+      layerEffects: z8.record(z8.string(), z8.object({
+        // "scale" does not have an "enabled" property, that's why it's optional
+        enabled: z8.boolean().optional()
+      }).or(z8.array(z8.object({
+        enabled: z8.boolean()
+      })))).optional()
+    })
+  });
+}
+async function getLayerEffects(layerRef) {
+  const result = await batchPlayCommand(createGetLayerCommand(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;
+  }
+  return effects;
+}
+
+// src/ut-tree/photoshopLayerDescriptorsToUTLayers.ts
+var layerKindMap = /* @__PURE__ */ new Map([
+  [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
+]);
+var blendModes = [
+  "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"
+];
+var getLayerSectionValue = (layer) => {
+  if (typeof layer.layerSection === "string") {
+    return layer.layerSection;
+  }
+  if (layer.layerSection && typeof layer.layerSection === "object" && "_value" in layer.layerSection) {
+    return layer.layerSection._value;
+  }
+  return void 0;
+};
+var getLayerKind = (layer) => {
+  const kind = layerKindMap.get(layer.layerKind);
+  if (!kind) {
+    throw new Error(`Unknown layer kind: ${layer.layerKind}`);
+  }
+  return kind;
+};
+var getBlendMode = (layer) => {
+  const mode = layer.mode._value;
+  if (!blendModes.includes(mode)) {
+    throw new Error(`Unknown blend mode: ${mode}`);
+  }
+  return mode;
+};
+var determineLayerSection = (layer) => {
+  const section = getLayerSectionValue(layer);
+  const isGroupEnd = layer.name === "</Layer group>" || layer.name === "</Layer set>" || section === "layerSectionEnd";
+  const isGroupStart = section === "layerSectionStart";
+  return isGroupStart ? "start" : isGroupEnd ? "end" : "normal";
+};
+var photoshopLayerDescriptorsToUTLayers = async (layers) => {
+  const root = [];
+  const stack = [{ layers: root }];
+  const commands = layers.map((layer) => createGetLayerCommand({ docId: layer.docId, id: layer.layerID }));
+  const batchResults = await executeAsModal("Get Layer Effects Data", async (ctx) => {
+    return await ctx.batchPlayCommands(commands);
+  });
+  const effectsMap = /* @__PURE__ */ new Map();
+  batchResults.forEach((result, index) => {
+    const layerId = layers[index].layerID;
+    const data = result.layerEffects;
+    const effects = {};
+    if (data) {
+      for (const effect in data) {
+        effects[effect] = Array.isArray(data[effect]) ? data[effect].some((e) => e.enabled) : !!data[effect]?.enabled;
+      }
+    }
+    effectsMap.set(layerId, effects);
+  });
+  for (const layer of layers) {
+    const sectionType = determineLayerSection(layer);
+    const isClippingMask = !!batchResults.find((res, index) => {
+      return layer.layerID === res.layerID;
+    })?.group;
+    if (sectionType === "end") {
+      if (stack.length > 1) {
+        stack.pop();
+      }
+      continue;
+    }
+    const node = {
+      name: layer.name,
+      docId: layer.docId,
+      id: layer.layerID,
+      visible: layer.visible,
+      kind: getLayerKind(layer),
+      blendMode: getBlendMode(layer),
+      isClippingMask,
+      effects: effectsMap.get(layer.layerID) || {}
+    };
+    const current = stack[stack.length - 1];
+    current.layers.push(node);
+    if (sectionType === "start") {
+      node.layers = [];
+      stack.push({ layers: node.layers });
+    }
+  }
+  return root;
+};
+
+// 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
+    },
+    name: layer2.name,
+    children: layer2.layers ? utLayersToTree(layer2.layers) : void 0
+  }));
+}
+
+// src/util/utLayerToLayer.ts
+import { app as app2 } from "photoshop";
+function utLayerToDomLayer(layer) {
+  const doc = app2.documents.find((d) => d.id === layer.docId);
+  if (!doc) {
+    throw new Error(`Document with id ${layer.docId} not found.`);
+  }
+  const allLayers = getFlattenedDomLayersList(doc.layers);
+  const domLayer = allLayers.find((l) => l.id === layer.id);
+  if (!domLayer) {
+    throw new Error(
+      `Layer with id ${layer.id} not found in document ${layer.docId}.`
+    );
+  }
+  return domLayer;
+}
+function utLayersToDomLayers(layers) {
+  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.");
+  }
+  const doc = app2.documents.find((d) => d.id === docId);
+  if (!doc) {
+    throw new Error(`Document with id ${docId} not found.`);
+  }
+  const allLayers = getFlattenedDomLayersList(doc.layers);
+  return layers.map((l) => {
+    const domLayer = allLayers.find((dl) => dl.id === l.id);
+    if (!domLayer) {
+      throw new Error(
+        `Layer with id ${l.id} not found in document ${docId}.`
+      );
+    }
+    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,
+  batchPlayCommands,
+  copyToClipboard,
+  createCommand,
+  createGetLayerCommand as createGetLayerEffectsCommand,
+  createGetLayerPropertiesCommand,
+  createModifyingBatchPlayContext,
+  createRenameLayerCommand,
+  executeAsModal,
+  executeAsModalAndSuspendHistory,
+  flattenTree,
+  getBasicStackFrameAbsoluteFilePath,
+  getFlattenedDomLayersList,
+  getFlattenedLayerDescriptorsList,
+  getLayerEffects,
+  getLayerProperties,
+  getLayerProperties2 as getLayerPropertiesFromUtTree,
+  mapTree,
+  mapTreeRef,
+  openFileByPath,
+  parseUxpErrorSourcemaps,
+  photoshopDomLayersToTree,
+  photoshopGetApplicationInfo,
+  photoshopLayerDescriptorsToUTLayers,
+  readFromClipboard,
+  suspendHistory,
+  utLayerToDomLayer,
+  utLayersToDomLayers,
+  utLayersToTree,
+  uxpEntrypointsSchema
+};