@bubblydoo/uxp-toolkit 0.0.2

package/.turbo/turbo-build.log

@@ -0,0 +1,15 @@
+
+> @bubblydoo/uxp-toolkit@0.0.2 build /home/runner/work/uxp-toolkit/uxp-toolkit/packages/uxp-toolkit
+> tsup
+
+CLI Building entry: src/index.ts
+CLI Using tsconfig: tsconfig.json
+CLI tsup v8.5.1
+CLI Using tsup config: /home/runner/work/uxp-toolkit/uxp-toolkit/packages/uxp-toolkit/tsup.config.ts
+CLI Target: es2022
+ESM Build start
+ESM dist/index.js 19.84 KB
+ESM ⚡️ Build success in 37ms
+DTS Build start
+DTS ⚡️ Build success in 2537ms
+DTS dist/index.d.ts 10.96 KB

package/CHANGELOG.md

@@ -0,0 +1,7 @@
+# @bubblydoo/uxp-toolkit
+
+## 0.0.2
+
+### Patch Changes
+
+- 3cafb8e: Initial setup

package/dist/index.d.ts

@@ -0,0 +1,271 @@
+import * as photoshop_dom_CoreModules from 'photoshop/dom/CoreModules';
+import { ActionDescriptor } from 'photoshop/dom/CoreModules';
+import { action } from 'photoshop';
+import { z } from 'zod';
+import * as photoshop_dom_Document from 'photoshop/dom/Document';
+import { Document } from 'photoshop/dom/Document';
+import { Layer } from 'photoshop/dom/Layer';
+import ErrorStackParser from 'error-stack-parser';
+
+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[]>;
+
+interface UTCommandBase<T extends any> {
+    descriptor: ActionDescriptor;
+    schema: z.ZodSchema<T>;
+}
+interface UTCommandModifying<T extends any> extends UTCommandBase<T> {
+    modifying: true;
+}
+interface UTCommandNonModifying<T extends any> extends UTCommandBase<T> {
+    modifying: false;
+}
+declare function createCommand<TReturn extends any, 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 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 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;
+};
+
+type CorrectExecutionContext = {
+    /**
+     * True if user has cancelled the modal interaction.
+     *
+     * User can cancel by hitting the Escape key, or by pressing the "Cancel" button in the progress bar.
+     */
+    isCancelled: boolean;
+    /**
+     * If assigned a method, it will be called when user cancels the modal interaction.
+     */
+    onCancel: () => void;
+    /**
+     * Call this to customize the progress bar.
+     */
+    reportProgress: (info: {
+        value: number;
+        commandName?: string;
+    }) => void;
+    /**
+     * Use the methods in here to control Photoshop state
+     */
+    hostControl: {
+        /**
+         * Call to suspend history on a target document, returns the suspension ID which can be used for resumeHistory
+         */
+        suspendHistory: (info: {
+            documentID: number;
+            name: string;
+        }) => Promise<number>;
+        /**
+         * Call to resume history on a target document
+         */
+        resumeHistory: (suspensionID: number, commit: boolean) => Promise<void>;
+        /** Register a document to be closed when the modal scope exits. See below for details. */
+        registerAutoCloseDocument: (documentID: number) => Promise<void>;
+        /** Unregister a document from being closed when the modal scope exits */
+        unregisterAutoCloseDocument: (documentID: number) => Promise<void>;
+    };
+};
+type CorrectExecuteAsModalOptions = {
+    commandName: string;
+    interactive?: boolean;
+    timeOut?: number;
+};
+type ExtendedExecutionContext = Omit<CorrectExecutionContext, "onCancel"> & ReturnType<typeof createModifyingBatchPlayContext> & {
+    signal: AbortSignal;
+};
+type OptionsWithoutCommandName = Omit<CorrectExecuteAsModalOptions, "commandName">;
+declare function executeAsModal<T>(commandName: string, fn: (executionContext: ExtendedExecutionContext) => Promise<T>, opts?: OptionsWithoutCommandName): Promise<T>;
+
+type SuspendHistoryContext = {};
+declare function suspendHistory<T>(document: Document, historyStateName: string, fn: (context: SuspendHistoryContext) => Promise<T>): Promise<T>;
+
+type CombinedFn<T> = (executionContext: ExtendedExecutionContext, suspendHistoryContext: SuspendHistoryContext) => Promise<T>;
+declare const executeAsModalAndSuspendHistory: <T>(commandName: string, document: Document, fn: CombinedFn<T>) => Promise<T>;
+
+declare const getLayerProperties$1: (document: Document) => Promise<{
+    name: string;
+    layerID: number;
+    visible?: boolean | undefined;
+}[]>;
+
+type PsLayerRef = {
+    id: number;
+    docId: number;
+};
+
+declare function createRenameLayerCommand(layerRef: PsLayerRef, newName: string): UTCommandModifying<unknown>;
+
+declare const getFlattenedDomLayersList: (layers: Layer[]) => Layer[];
+
+type Tree<TRef = unknown> = {
+    ref: TRef;
+    name: string;
+    children?: Tree<TRef>;
+}[];
+
+declare const photoshopDomLayersToTree: (layers: Layer[]) => Tree<Layer>;
+
+declare function openFileByPath(path: string): Promise<photoshop_dom_Document.Document>;
+
+declare function flattenTree<T>(tree: Tree<T>): Tree<T>[0][];
+
+declare function mapTree<TRef, TMappedRef>(tree: Tree<TRef>, mapFn: (node: TRef) => TMappedRef): Tree<TMappedRef>;
+
+declare function mapTreeRef<TRef, TMappedRef>(tree: Tree<TRef>, mapFn: (node: TRef) => TMappedRef): Tree<TMappedRef>;
+
+type LayerRef = {
+    id: number;
+    docId: number;
+};
+
+declare function photoshopGetApplicationInfo(): Promise<{
+    active: boolean;
+    autoShowHomeScreen: boolean;
+    available: number;
+    buildNumber: string;
+    documentArea: {
+        left: number;
+        top: number;
+        right: number;
+        bottom: number;
+    };
+    hostName: string;
+    hostVersion: {
+        versionMajor: number;
+        versionMinor: number;
+        versionFix: number;
+    };
+    localeInfo: {
+        decimalPoint: string;
+    };
+    osVersion: string;
+    panelList: {
+        ID: string;
+        name: string;
+        obscured: boolean;
+        visible: boolean;
+    }[];
+}>;
+
+declare function copyToClipboard(text: string): Promise<void>;
+declare function readFromClipboard(): Promise<string>;
+
+declare const uxpEntrypointsSchema: z.ZodObject<{
+    _pluginInfo: z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+        version: z.ZodString;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+
+declare const layerDescriptorSchema: z.ZodObject<{
+    name: z.ZodString;
+    layerID: z.ZodNumber;
+    mode: z.ZodObject<{
+        _enum: z.ZodLiteral<"blendMode">;
+        _value: z.ZodString;
+    }, z.core.$strip>;
+    background: z.ZodBoolean;
+    itemIndex: z.ZodNumber;
+    visible: z.ZodBoolean;
+    layerKind: z.ZodNumber;
+    layerSection: z.ZodObject<{
+        _value: z.ZodEnum<{
+            layerSectionStart: "layerSectionStart";
+            layerSectionEnd: "layerSectionEnd";
+            layerSectionContent: "layerSectionContent";
+        }>;
+        _enum: z.ZodLiteral<"layerSectionType">;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+type LayerDescriptor = z.infer<typeof layerDescriptorSchema> & {
+    docId: number;
+};
+declare const getFlattenedLayerDescriptorsList: (documentId: number) => Promise<{
+    docId: number;
+    name: string;
+    layerID: number;
+    mode: {
+        _enum: "blendMode";
+        _value: string;
+    };
+    background: boolean;
+    itemIndex: number;
+    visible: boolean;
+    layerKind: number;
+    layerSection: {
+        _value: "layerSectionStart" | "layerSectionEnd" | "layerSectionContent";
+        _enum: "layerSectionType";
+    };
+}[]>;
+
+declare function createGetLayerPropertiesCommand(docId: number): UTCommandNonModifying<{
+    list: {
+        name: string;
+        layerID: number;
+        visible?: boolean | undefined;
+    }[];
+}>;
+declare const getLayerProperties: (documentId: number) => Promise<{
+    name: string;
+    layerID: number;
+    visible?: boolean | undefined;
+}[]>;
+
+declare function createGetLayerCommand(layerRef: PsLayerRef): UTCommandNonModifying<{
+    layerID: number;
+    group?: boolean | undefined;
+    layerEffects?: Record<string, {
+        enabled?: boolean | undefined;
+    } | {
+        enabled: boolean;
+    }[]> | undefined;
+}>;
+declare function getLayerEffects(layerRef: PsLayerRef): Promise<Record<string, boolean>>;
+
+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 UTLayerBuilder = {
+    name: string;
+    docId: number;
+    id: number;
+    visible: boolean;
+    kind: UTLayerKind;
+    blendMode: UTBlendMode;
+    effects: Record<string, boolean>;
+    isClippingMask: boolean;
+    layers?: UTLayerBuilder[];
+};
+type UTLayer = Readonly<Omit<UTLayerBuilder, "layers">> & {
+    layers?: UTLayer[];
+};
+declare const photoshopLayerDescriptorsToUTLayers: (layers: LayerDescriptor[]) => Promise<UTLayer[]>;
+
+type UTLayerWithoutChildren = Omit<UTLayer, "layers">;
+declare function utLayersToTree(layer: UTLayer[]): Tree<UTLayerWithoutChildren>;
+
+declare function utLayerToDomLayer(layer: UTLayer): Layer;
+declare function utLayersToDomLayers(layers: UTLayer[]): Layer[];
+
+type BasicStackFrame = Pick<ErrorStackParser.StackFrame, "functionName" | "fileName" | "lineNumber" | "columnNumber">;
+declare function parseUxpErrorSourcemaps(error: Error, opts?: {
+    unsourcemappedHeaderLines?: number;
+}): Promise<BasicStackFrame[]>;
+declare function getBasicStackFrameAbsoluteFilePath(frame: BasicStackFrame): Promise<string>;
+
+export { type BasicStackFrame, type CorrectBatchPlayOptions, type CorrectExecuteAsModalOptions, type CorrectExecutionContext, type ExtendedExecutionContext, type LayerDescriptor, type LayerRef, type PsLayerRef, type SuspendHistoryContext, type Tree, type UTCommandBase, type UTCommandModifying, type UTCommandNonModifying, type UTCommandResult, type UTLayer, type UTLayerWithoutChildren, batchPlay, batchPlayCommand, batchPlayCommands, copyToClipboard, createCommand, createGetLayerCommand as createGetLayerEffectsCommand, createGetLayerPropertiesCommand, createModifyingBatchPlayContext, createRenameLayerCommand, executeAsModal, executeAsModalAndSuspendHistory, flattenTree, getBasicStackFrameAbsoluteFilePath, getFlattenedDomLayersList, getFlattenedLayerDescriptorsList, getLayerEffects, getLayerProperties$1 as getLayerProperties, getLayerProperties as getLayerPropertiesFromUtTree, mapTree, mapTreeRef, openFileByPath, parseUxpErrorSourcemaps, photoshopDomLayersToTree, photoshopGetApplicationInfo, photoshopLayerDescriptorsToUTLayers, readFromClipboard, suspendHistory, utLayerToDomLayer, utLayersToDomLayers, utLayersToTree, uxpEntrypointsSchema };