@bubblydoo/photoshop-mcp 0.0.2

package/dist-schemas/@adobe-uxp-types/photoshop/src/internal/dom/objects/ConversionOptions.d.ts

@@ -0,0 +1,213 @@
+import type * as Constants from '../Constants';
+/**
+ * Options for converting an image to bitmap mode, using {@link Document.changeMode} with `ChangeMode.BITMAP`.
+ *
+ * @see {@link https://developer.adobe.com/photoshop/uxp/2022/ps_reference/classes/document/#changemode}
+ *
+ * @example
+ * ```javascript
+ * const doc = app.activeDocument;
+ * const options = new BitmapConversionOptions();
+ * options.method = constants.BitmapConversionType.DIFFUSIONDITHER;
+ * options.resolution = 72;
+ * await doc.changeMode(constants.ChangeMode.BITMAP, options);
+ * ```
+ *
+ * @example
+ * ```javascript
+ * // Convert with halftone screen
+ * const options = new BitmapConversionOptions();
+ * options.method = constants.BitmapConversionType.HALFTONESCREEN;
+ * options.frequency = 60;
+ * options.angle = 45;
+ * options.shape = constants.BitmapHalfToneType.ROUND;
+ * await doc.changeMode(constants.ChangeMode.BITMAP, options);
+ * ```
+ *
+ * @targetfolder objects/conversionoptions
+ * @optionobject
+ */
+export class BitmapConversionOptions {
+  private _angle;
+  private _frequency;
+  private _method;
+  private _patternName;
+  private _resolution;
+  private _shape;
+  /**
+   * The angle (in degrees) at which to orient individual dots. See shape property below.
+   * Valid only when the method property is set to `BitmapConversionType.HALFTONESCREEN`.
+   *
+   * @default -
+   * @range -180...180
+   * @minVersion 23.0
+   */
+  get angle(): number;
+  set angle(value: number);
+  /**
+   * The number of dots (per inch) to use.
+   * Valid only when the method property is set to `BitmapConversionType.HALFTONESCREEN`.
+   *
+   * @default -
+   * @range 1.0..999.99
+   * @minVersion 23.0
+   */
+  get frequency(): number;
+  set frequency(value: number);
+  /**
+   * The conversion method.
+   *
+   * @default DIFFUSIONDITHER
+   * @range -
+   * @minVersion 23.0
+   */
+  get method(): Constants.BitmapConversionType;
+  set method(value: Constants.BitmapConversionType);
+  /**
+   * The name of the pattern to use.
+   * Valid only when the method property is set to BitmapConversionType.CUSTOMPATTERN.
+   *
+   * @default
+   * @range -
+   * @minVersion 23.0
+   */
+  get patternName(): string;
+  set patternName(value: string);
+  /**
+   * The output resolution (in pixels per inch).
+   *
+   * @default 72
+   * @range -
+   * @minVersion 23.0
+   */
+  get resolution(): number;
+  set resolution(value: number);
+  /**
+   * The dot shape.
+   * Valid only when the method property is set to BitmapConversionType.HALFTONESCREEN.
+   *
+   * @default -
+   * @range -
+   * @minVersion 23.0
+   */
+  get shape(): Constants.BitmapHalfToneType;
+  set shape(value: Constants.BitmapHalfToneType);
+  /**
+   * The class name of the referenced object: *"BitmapConversionOptions"*.
+   * @minVersion 23.0
+   */
+  get typename(): 'BitmapConversionOptions';
+  /** @ignore */
+  constructor();
+}
+/**
+ * Options for converting an RGB image to an indexed color model using {@link Document.changeMode}
+ *
+ * @see {@link https://developer.adobe.com/photoshop/uxp/2022/ps_reference/classes/document/#changemode}
+ *
+ * @example
+ * ```javascript
+ * const doc = app.activeDocument;
+ * const options = new IndexedConversionOptions();
+ * options.palette = constants.Palette.LOCALPERCEPTUAL;
+ * options.colors = 256;
+ * options.dither = constants.Dither.DIFFUSION;
+ * options.transparency = true;
+ * await doc.changeMode(constants.ChangeMode.INDEXEDCOLOR, options);
+ * ```
+ *
+ * @example
+ * ```javascript
+ * // Convert with web palette
+ * const options = new IndexedConversionOptions();
+ * options.palette = constants.Palette.WEBPALETTE;
+ * options.colors = 216;
+ * options.preserveExactColors = true;
+ * await doc.changeMode(constants.ChangeMode.INDEXEDCOLOR, options);
+ * ```
+ *
+ * @targetfolder objects/conversionoptions
+ * @optionobject
+ * @minVersion 23.0
+ */
+export class IndexedConversionOptions {
+  private _colors;
+  private _dither;
+  private _ditherAmount;
+  private _forced;
+  private _matte;
+  private _palette;
+  private _preserveExactColors;
+  private _transparency;
+  /**
+   * The number of palette colors.
+   *
+   * Valid only with palette types: LOCALADAPTIVE, LOCALPERCEPTUAL,
+   * LOCALSELECTIVE, MACOSPALETTE, UNIFORM, WEBPALETTE, or WINDOWSPALETTE.
+   *
+   * @minVersion 23.0
+   */
+  get colors(): number;
+  set colors(value: number);
+  /**
+   * The type of dithering to be done.
+   *
+   * @minVersion 23.0
+   */
+  get dither(): Constants.Dither;
+  set dither(value: Constants.Dither);
+  /**
+   * The amount of dithering to be done.
+   *
+   * Valid only when dither typ is DIFFUSION.
+   * @minVersion 23.0
+   */
+  get ditherAmount(): number;
+  set ditherAmount(value: number);
+  /**
+   * The set of colors to force into the color palette.
+   *
+   * @minVersion 23.0
+   */
+  get forced(): Constants.ForcedColors;
+  set forced(value: Constants.ForcedColors);
+  /**
+   * The color to use to fill anti-aliased edges adjacent to transparent areas of the image.
+   *
+   * When transparency is false, the matte color is applied to transparent areas.
+   *
+   * @default WHITE
+   * @minVersion 23.0
+   */
+  get matte(): Constants.MatteColor;
+  set matte(value: Constants.MatteColor);
+  /**
+   * The palette type.
+   *
+   * @minVersion 23.0
+   */
+  get palette(): Constants.Palette;
+  set palette(value: Constants.Palette);
+  /**
+   * When true, the image colors matching entries in the color table will not be dithered.
+   *
+   * @minVersion 23.0
+   */
+  get preserveExactColors(): boolean;
+  set preserveExactColors(value: boolean);
+  /**
+   * When true, transparent areas of the image are preserved during conversion to GIF format.
+   *
+   * @minVersion 23.0
+   */
+  get transparency(): boolean;
+  set transparency(value: boolean);
+  /**
+   * The class name of the referenced object: *"IndexedConversionOptions"*.
+   *
+   * @minVersion 23.0
+   */
+  get typename(): 'IndexedConversionOptions';
+  /** @ignore */
+  constructor();
+}

package/dist-schemas/@adobe-uxp-types/photoshop/src/internal/dom/objects/ImagingBounds.d.ts

@@ -0,0 +1,53 @@
+/**
+ * Defines a rectangle. This is a WIP.
+ *
+ * @targetfolder objects
+ * @optionobject
+ */
+export class ImagingBounds {
+  private _left;
+  private _right;
+  private _top;
+  private _bottom;
+  /**
+   * Coordinate of the left edge.
+   * @minVersion 22.5
+   */
+  get left(): number;
+  set left(coordinate: number);
+  /**
+   * Coordinate of the right edge.
+   * @minVersion 22.5
+   */
+  get right(): number;
+  set right(coordinate: number);
+  /**
+   * Coordinate of the top edge.
+   * @minVersion 22.5
+   */
+  get top(): number;
+  set top(coordinate: number);
+  /**
+   * Coordinate of the bottom edge.
+   * @minVersion 22.5
+   */
+  get bottom(): number;
+  set bottom(coordinate: number);
+  /**
+   * Calculated width.
+   * @minVersion 22.5
+   */
+  get width(): number;
+  /**
+   * Calculated height.
+   * @minVersion 22.5
+   */
+  get height(): number;
+  /**
+   * The class name of the referenced object: *"Bounds"*.
+   * @minVersion 22.5
+   */
+  get typename(): 'Bounds';
+  /** @ignore */
+  constructor();
+}

package/dist-schemas/@adobe-uxp-types/photoshop/src/internal/dom/objects/PathPointInfo.d.ts

@@ -0,0 +1,84 @@
+import type * as Constants from '../Constants';
+/**
+ * Used to create a {@link PathPoint}, which represents the anchor and control-handle endpoints for a path segment.
+ * Each point (the anchor point, left-direction point, and right-direction point) is an array containing X and Y
+ * position coordinates.
+ *
+ *  - Use the JavaScript `new` operator to create these objects, and store them in the {@link SubPathInfo.entireSubPath}
+ * property before using that object to create a path item with {@link PathItems.add}()
+ *
+ *  - The resulting {@link SubPathItem} object contains the resulting {@link PathPoint} objects. Use the {@link PathPoint} object
+ * to retrieve information about the points that describe existing path segments. The properties are read-only.
+ *
+ * For paths that are straight segments (not curved), the coordinates of all three points are the same. For curved
+ * segments, the coordinates are different. The difference between the anchor point and the left or right
+ * direction points determines the arc of the curve. Use the left direction point to bend the curve "outward" or
+ * make it convex; or use the right direction point to bend the curve "inward" or make it concave.
+ *
+ *  ## PathPointInfo sample script
+ *
+ * ```typescript
+ *      function drawLine(doc: Document, start: number[], stop: number[]) {
+ *          const startPoint = new PathPointInfo();
+ *          startPoint.anchor = start;
+ *          startPoint.leftDirection = start;
+ *          startPoint.rightDirection = start;
+ *          startPoint.kind = Constants.PointKind.CORNERPOINT;
+ *
+ *          const stopPoint = new PathPointInfo();
+ *          stopPoint.anchor = stop;
+ *          stopPoint.leftDirection = stop;
+ *          stopPoint.rightDirection = stop;
+ *          stopPoint.kind = Constants.PointKind.CORNERPOINT;
+ *
+ *          const spi = new SubPathInfo();
+ *          spi.closed = false;
+ *          spi.operation = Constants.ShapeOperation.SHAPEXOR;
+ *          spi.entireSubPath = [startPoint, stopPoint];
+ *
+ *          const line = doc.pathItems.add("Line", [spi]);
+ *          line.strokePath(Constants.ToolType.PENCIL);
+ *          line.remove();
+ *      }
+ *
+ *      drawLine(app.activeDocument, [100,100], [200,200]);
+ * ```
+ * @minVersion 23.3
+ */
+export class PathPointInfo {
+  private _anchor;
+  private _kind;
+  private _leftDirection;
+  private _rightDirection;
+  /**
+   * The X and Y coordinates of the anchor point of the curve.
+   * @minVersion 23.3
+   */
+  get anchor(): number[];
+  set anchor(coordinates: number[]);
+  /**
+   * The role (corner or smooth) this point plays in the containing path segment.
+   * @minVersion 23.3
+   */
+  get kind(): Constants.PointKind;
+  set kind(role: Constants.PointKind);
+  /**
+   * The location of the left-direction endpoint('in' position).
+   * @minVersion 23.3
+   */
+  get leftDirection(): number[];
+  set leftDirection(location: number[]);
+  /**
+   * The location of the right-direction endpoint('out' position).
+   * @minVersion 23.3
+   */
+  get rightDirection(): number[];
+  set rightDirection(location: number[]);
+  /**
+   * The class name of the referenced object: *"PathPointInfo"*.
+   * @minVersion 23.3
+   */
+  get typename(): 'PathPointInfo';
+  /** @ignore */
+  constructor();
+}