@pixerate/editor 0.231.0 → 0.232.0

package/dist/effects/templates.d.ts

@@ -0,0 +1,56 @@
+/**
+ * Helpers for sequence templates and the sequences they fill to (see `EffectSequence`): the
+ * values a template takes as a JSON Schema, checking values before asking the provider, checking
+ * a sequence before loading it, and which input a layer's subject feeds. Dependency-free.
+ */
+import type { JsonSchema } from '../tools/schema.js';
+import { type EffectDescription, type EffectLayer, type EffectLayerRole, type EffectSequence, type EffectSubjectKind, type EffectSummary, type EffectTemplateSearchOptions, type EffectTemplateSlot, type EffectTemplateSummary } from './types.js';
+export declare const EFFECT_SEQUENCE_NAME: RegExp;
+/** True for a subject slot (`image`, `video`, `svg`). */
+export declare const isSubjectTemplateSlot: (slot: Pick<EffectTemplateSlot, "type">) => boolean;
+/** The kind of a subject (`image`, `video`, `svg`, `text`, `slot`), or undefined when it is none of them. */
+export declare function effectSubjectKind(subject: unknown): EffectSubjectKind | undefined;
+/** What a slot takes, in a few words ("words (up to 40 characters)", "a colour like #FF5A36"). */
+export declare function templateSlotTakes(slot: EffectTemplateSlot): string;
+/** The problem with one value for a slot, as a sentence, or undefined when it fits. */
+export declare function templateValueProblem(slot: EffectTemplateSlot, value: unknown): string | undefined;
+/**
+ * Every problem with `values` for a template's slots, as sentences: unknown slots, wrong types,
+ * out-of-range numbers, text too long. Empty when they fit. Slots left out take their defaults.
+ */
+export declare function checkTemplateValues(slots: readonly EffectTemplateSlot[], values: unknown): string[];
+/** One slot's value as a JSON Schema. */
+export declare function templateSlotSchema(slot: EffectTemplateSlot): JsonSchema;
+/** The values a template takes as a strict JSON Schema (every slot optional; `additionalProperties: false`). */
+export declare function templateValuesSchema(slots: readonly EffectTemplateSlot[]): JsonSchema & {
+    type: 'object';
+};
+/** The defaults of a template's text, colour and number slots: an example `values` object to change. */
+export declare function templateDefaultValues(slots: readonly EffectTemplateSlot[]): Record<string, string | number>;
+/** One line on a slot: its name, type, what it takes and its default. */
+export declare function templateSlotSummary(slot: EffectTemplateSlot): string;
+/** Templates matching every word of `query` (in name, id, tags or description) and every tag, best first. */
+export declare function searchTemplateSummaries<T extends EffectTemplateSummary>(catalog: readonly T[], options?: EffectTemplateSearchOptions): T[];
+/** Where a layer sits: its `role`, else `subject` when it has a `rect`, else `background`. */
+export declare const effectLayerRole: (layer: Pick<EffectLayer, "role" | "rect">) => EffectLayerRole;
+/**
+ * The image input a layer's subject feeds: `source` when the effect has it, else its first image
+ * input; undefined when it takes no picture (a generator: then the layer cannot have a subject).
+ */
+export declare function effectLayerInput(description: Pick<EffectDescription, 'inputs'>): string | undefined;
+/** The uses a layer's effect may have (a transition belongs on `EffectSequenceShot.transition`, a camera move on `camera`). */
+export declare const EFFECT_LAYER_USES: readonly ["generator", "filter", "overlay", "title"];
+/** True for an effect a layer can show. */
+export declare const effectLayerOffered: (e: Pick<EffectSummary, "kind" | "uses">) => boolean;
+/** Problems with one subject, or undefined when it is sound. */
+export declare function effectSubjectProblem(subject: unknown): string | undefined;
+/**
+ * Every problem with a sequence's shape, as sentences ("shot 2, layer 1: …"). With `catalog`, also
+ * effect ids it does not list, layer effects that cannot be layers and transitions without the
+ * use `transition`. Empty when the sequence is sound.
+ */
+export declare function checkEffectSequence(sequence: unknown, catalog?: readonly Pick<EffectSummary, 'id' | 'kind' | 'uses'>[]): string[];
+/** Every effect id a sequence names (layers and transitions), each once. */
+export declare function effectSequenceEffects(sequence: EffectSequence): string[];
+/** Subject slots a sequence leaves for the host (`{ slot }` subjects), each once. */
+export declare function effectSequenceSlots(sequence: EffectSequence): string[];

package/dist/effects/types.d.cts

@@ -275,6 +275,204 @@ export interface CameraMoveSample {
     /** Ms of the cut, when the move has one. */
     cut?: number;
 }
+/** A box in a sequence's stage units (pixels of `EffectSequence.stage`). */
+export interface EffectRect {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+/**
+ * Something a layer shows or applies its effect to: a picture or SVG (a URL, a `data:` URL or
+ * `<svg>` markup), a video by URL, words, or `{ slot }`: a subject the host fills in by name.
+ */
+export type EffectSubject = {
+    image: string;
+} | {
+    video: string;
+} | {
+    svg: string;
+} | {
+    text: string;
+    font?: string;
+    weight?: number | string;
+} | {
+    slot: string;
+};
+/** The kinds of subject, as `EffectSubject` keys. */
+export declare const EFFECT_SUBJECT_KINDS: readonly ["image", "video", "svg", "text", "slot"];
+export type EffectSubjectKind = (typeof EFFECT_SUBJECT_KINDS)[number];
+/**
+ * Where a layer sits in a shot's stack: `background` under the shot's own content, `subject`
+ * with it, `overlay` above everything.
+ */
+export type EffectLayerRole = 'background' | 'subject' | 'overlay';
+export declare const EFFECT_LAYER_ROLES: readonly EffectLayerRole[];
+/** When a layer starts or stops: ms after its shot starts, or `{ shots: n }` for when the n-th shot after its own begins. */
+export type EffectLayerTime = number | {
+    shots: number;
+};
+/**
+ * One layer of a shot (the shape of Flair's `SceneLayer`): a catalog effect, optionally applied
+ * to a subject, or a bare subject (no `effect`), placed on the stage for a stretch of time.
+ * The subject feeds the effect's `source` input, else its first image input.
+ */
+export interface EffectLayer {
+    /** A name unique in the sequence. */
+    id?: string;
+    /** The effect's id (a generator, filter, overlay or title). Absent for a bare subject. */
+    effect?: string;
+    /** A preset of the effect's, by name; its values are written out in `values` too. */
+    preset?: string;
+    /** Control values over the effect's defaults. */
+    values?: Record<string, EffectValue>;
+    subject?: EffectSubject;
+    /** Default `subject` when placed with `rect`, else `background`. */
+    role?: EffectLayerRole;
+    /** Where it sits, in stage units; it moves with the camera. Absent: it fills the screen. */
+    rect?: EffectRect;
+    /** When it starts (default 0: as its shot starts). */
+    from?: EffectLayerTime;
+    /** When it stops (default `{ shots: 1 }`: as the next shot starts). */
+    until?: EffectLayerTime;
+    /** 0–1 (default 1). */
+    opacity?: number;
+    /** Ms it fades in and out over (default 0: it cuts). */
+    fade?: number;
+}
+/**
+ * A transition into a shot (the shape of Flair's `ShotTransition`): an effect with the use
+ * `transition` blends the outgoing shot's last frame (`from`) into the incoming shot (`to`) as
+ * `progress` runs 0 → 1 over `ms`.
+ */
+export interface EffectShotTransition {
+    effect: string;
+    /** Length (ms), default `EFFECT_TRANSITION_MS`. */
+    ms?: number;
+    preset?: string;
+    values?: Record<string, EffectValue>;
+}
+/** How long a shot transition takes when it does not say (ms). */
+export declare const EFFECT_TRANSITION_MS = 800;
+/** One shot of a sequence. */
+export interface EffectSequenceShot {
+    /** Ms the shot holds after its lead-in (the longer of its camera move and its transition). */
+    hold: number;
+    /** Words shown large over the shot. */
+    title?: string;
+    /** Words shown small at the foot of the shot. */
+    caption?: string;
+    camera?: {
+        /** What the camera frames, in stage units (default the whole stage). */
+        framing?: EffectRect;
+        /** A `transition` camera move into this framing. */
+        in?: CameraMoveSpec;
+        /** A `hold` camera move while the shot holds. */
+        during?: CameraMoveSpec;
+    };
+    /** Bottom to top. */
+    layers: EffectLayer[];
+    /** How the shot before gives way to this one; absent on the first shot. */
+    transition?: EffectShotTransition;
+}
+/**
+ * A sequence of shots built from catalog effects: what a template fills to. Renderer-neutral;
+ * editors load it into their own documents (an animation's shots, a video's clips).
+ */
+export interface EffectSequence {
+    name: string;
+    title?: string;
+    /** Stage size in pixels; rects and framings are in these units. */
+    stage: CameraStage;
+    shots: EffectSequenceShot[];
+}
+/** One template of a provider's catalog. */
+export interface EffectTemplateSummary {
+    /** Stable id. */
+    id: string;
+    name: string;
+    description: string;
+    tags?: readonly string[];
+    /** How many shots it fills to. */
+    shots: number;
+    /** Length with its defaults (ms), when the provider knows it. */
+    durationMs?: number;
+}
+/** The kinds of template slot: a subject (`image`, `video`, `svg`), `text`, `color` or `number`. */
+export declare const EFFECT_TEMPLATE_SLOT_TYPES: readonly ["image", "video", "svg", "text", "color", "number"];
+export type EffectTemplateSlotType = (typeof EFFECT_TEMPLATE_SLOT_TYPES)[number];
+interface EffectTemplateSlotBase {
+    /** Letters, digits, `-` and `_`, starting with a letter. */
+    name: string;
+    /** What a form shows for it. */
+    label: string;
+    /** A sentence on what it is for. */
+    description?: string;
+}
+/**
+ * A slot for a picture, SVG or video. Its default (which may be large) is not described, only
+ * whether there is one; with none, an unfilled slot is left for the host (`openSlots`).
+ */
+export interface EffectTemplateSubjectSlot extends EffectTemplateSlotBase {
+    type: 'image' | 'video' | 'svg';
+    hasDefault: boolean;
+}
+export interface EffectTemplateTextSlot extends EffectTemplateSlotBase {
+    type: 'text';
+    default: string;
+    /** The most characters it takes. */
+    maxLength?: number;
+}
+/** A colour, `#RRGGBB`. */
+export interface EffectTemplateColorSlot extends EffectTemplateSlotBase {
+    type: 'color';
+    default: string;
+}
+export interface EffectTemplateNumberSlot extends EffectTemplateSlotBase {
+    type: 'number';
+    default: number;
+    min?: number;
+    max?: number;
+    /** Whole numbers only. */
+    integer?: boolean;
+}
+/** A slot of a template, shaped for a form (Flair's `describeTemplateSlots`). */
+export type EffectTemplateSlot = EffectTemplateSubjectSlot | EffectTemplateTextSlot | EffectTemplateColorSlot | EffectTemplateNumberSlot;
+/** A template with its slots, in the order a form shows them. */
+export interface EffectTemplateDescription extends EffectTemplateSummary {
+    slots: readonly EffectTemplateSlot[];
+}
+/**
+ * What fills a slot: words, a colour or a number; for a subject slot a URL or markup, a subject
+ * object, or `{ slot: name }` to leave it for the host.
+ */
+export type EffectTemplateValue = string | number | EffectSubject;
+export type EffectTemplateValues = Readonly<Record<string, EffectTemplateValue>>;
+export interface EffectTemplateSearchOptions {
+    /** Only templates matching every word (in name, id, tags or description). */
+    query?: string;
+    /** Only templates carrying every one of these tags. */
+    tags?: readonly string[];
+    /** Most results to return. */
+    limit?: number;
+}
+export interface EffectTemplateOptions {
+    /** The sequence's name: lowercase words and dashes (default the template's id). */
+    name?: string;
+}
+/** What `instantiateTemplate` gives. Values that do not fit are refused all at once, never in part. */
+export type EffectTemplateResult = {
+    ok: true;
+    sequence: EffectSequence;
+    /** Subject slots left for the host to fill (no value and no default, or `{ slot }`). */
+    openSlots: readonly string[];
+    /** What the provider left out or changed, in sentences (empty when nothing was). */
+    notes: readonly string[];
+} | {
+    ok: false;
+    /** Each a sentence naming the slot and what it takes. */
+    errors: readonly string[];
+};
 /** What a provider can do, so editors can degrade cleanly. */
 export interface EffectProviderCapabilities {
     /** Renders off the main thread. */
@@ -293,6 +491,8 @@ export interface EffectProviderCapabilities {
     supportsAuthoring?: boolean;
     /** Lists `camera` effects and implements `cameraView` (and maybe `sampleCameraMove`). */
     supportsCamera?: boolean;
+    /** Implements `listTemplates`, `describeTemplate` and `instantiateTemplate`. */
+    supportsTemplates?: boolean;
 }
 export type MaybePromise<T> = T | Promise<T>;
 /**
@@ -342,4 +542,16 @@ export interface EffectProvider {
      * `sampleEffectCameraMove` falls back to `cameraView` per frame. Errors as for `cameraView`.
      */
     sampleCameraMove?(id: string, request: CameraMoveSampleRequest): MaybePromise<CameraMoveSample>;
+    /** Sequence templates, best match first. Present when `capabilities.supportsTemplates`. */
+    listTemplates?(options?: EffectTemplateSearchOptions): MaybePromise<readonly EffectTemplateSummary[]>;
+    /** A template with its slots. Unknown ids throw `UnknownTemplateError`. */
+    describeTemplate?(id: string): MaybePromise<EffectTemplateDescription>;
+    /**
+     * Fills a template's slots and returns the sequence. Slots left out take their defaults.
+     * Values that do not fit (an unknown slot, a wrong type, out of range) give `{ ok: false,
+     * errors }`, each error a sentence. Unknown ids throw `UnknownTemplateError`. Every effect
+     * the sequence names is in the provider's `list()`.
+     */
+    instantiateTemplate?(id: string, values?: EffectTemplateValues, options?: EffectTemplateOptions): MaybePromise<EffectTemplateResult>;
 }
+export {};

package/dist/effects/types.d.ts

@@ -275,6 +275,204 @@ export interface CameraMoveSample {
     /** Ms of the cut, when the move has one. */
     cut?: number;
 }
+/** A box in a sequence's stage units (pixels of `EffectSequence.stage`). */
+export interface EffectRect {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+/**
+ * Something a layer shows or applies its effect to: a picture or SVG (a URL, a `data:` URL or
+ * `<svg>` markup), a video by URL, words, or `{ slot }`: a subject the host fills in by name.
+ */
+export type EffectSubject = {
+    image: string;
+} | {
+    video: string;
+} | {
+    svg: string;
+} | {
+    text: string;
+    font?: string;
+    weight?: number | string;
+} | {
+    slot: string;
+};
+/** The kinds of subject, as `EffectSubject` keys. */
+export declare const EFFECT_SUBJECT_KINDS: readonly ["image", "video", "svg", "text", "slot"];
+export type EffectSubjectKind = (typeof EFFECT_SUBJECT_KINDS)[number];
+/**
+ * Where a layer sits in a shot's stack: `background` under the shot's own content, `subject`
+ * with it, `overlay` above everything.
+ */
+export type EffectLayerRole = 'background' | 'subject' | 'overlay';
+export declare const EFFECT_LAYER_ROLES: readonly EffectLayerRole[];
+/** When a layer starts or stops: ms after its shot starts, or `{ shots: n }` for when the n-th shot after its own begins. */
+export type EffectLayerTime = number | {
+    shots: number;
+};
+/**
+ * One layer of a shot (the shape of Flair's `SceneLayer`): a catalog effect, optionally applied
+ * to a subject, or a bare subject (no `effect`), placed on the stage for a stretch of time.
+ * The subject feeds the effect's `source` input, else its first image input.
+ */
+export interface EffectLayer {
+    /** A name unique in the sequence. */
+    id?: string;
+    /** The effect's id (a generator, filter, overlay or title). Absent for a bare subject. */
+    effect?: string;
+    /** A preset of the effect's, by name; its values are written out in `values` too. */
+    preset?: string;
+    /** Control values over the effect's defaults. */
+    values?: Record<string, EffectValue>;
+    subject?: EffectSubject;
+    /** Default `subject` when placed with `rect`, else `background`. */
+    role?: EffectLayerRole;
+    /** Where it sits, in stage units; it moves with the camera. Absent: it fills the screen. */
+    rect?: EffectRect;
+    /** When it starts (default 0: as its shot starts). */
+    from?: EffectLayerTime;
+    /** When it stops (default `{ shots: 1 }`: as the next shot starts). */
+    until?: EffectLayerTime;
+    /** 0–1 (default 1). */
+    opacity?: number;
+    /** Ms it fades in and out over (default 0: it cuts). */
+    fade?: number;
+}
+/**
+ * A transition into a shot (the shape of Flair's `ShotTransition`): an effect with the use
+ * `transition` blends the outgoing shot's last frame (`from`) into the incoming shot (`to`) as
+ * `progress` runs 0 → 1 over `ms`.
+ */
+export interface EffectShotTransition {
+    effect: string;
+    /** Length (ms), default `EFFECT_TRANSITION_MS`. */
+    ms?: number;
+    preset?: string;
+    values?: Record<string, EffectValue>;
+}
+/** How long a shot transition takes when it does not say (ms). */
+export declare const EFFECT_TRANSITION_MS = 800;
+/** One shot of a sequence. */
+export interface EffectSequenceShot {
+    /** Ms the shot holds after its lead-in (the longer of its camera move and its transition). */
+    hold: number;
+    /** Words shown large over the shot. */
+    title?: string;
+    /** Words shown small at the foot of the shot. */
+    caption?: string;
+    camera?: {
+        /** What the camera frames, in stage units (default the whole stage). */
+        framing?: EffectRect;
+        /** A `transition` camera move into this framing. */
+        in?: CameraMoveSpec;
+        /** A `hold` camera move while the shot holds. */
+        during?: CameraMoveSpec;
+    };
+    /** Bottom to top. */
+    layers: EffectLayer[];
+    /** How the shot before gives way to this one; absent on the first shot. */
+    transition?: EffectShotTransition;
+}
+/**
+ * A sequence of shots built from catalog effects: what a template fills to. Renderer-neutral;
+ * editors load it into their own documents (an animation's shots, a video's clips).
+ */
+export interface EffectSequence {
+    name: string;
+    title?: string;
+    /** Stage size in pixels; rects and framings are in these units. */
+    stage: CameraStage;
+    shots: EffectSequenceShot[];
+}
+/** One template of a provider's catalog. */
+export interface EffectTemplateSummary {
+    /** Stable id. */
+    id: string;
+    name: string;
+    description: string;
+    tags?: readonly string[];
+    /** How many shots it fills to. */
+    shots: number;
+    /** Length with its defaults (ms), when the provider knows it. */
+    durationMs?: number;
+}
+/** The kinds of template slot: a subject (`image`, `video`, `svg`), `text`, `color` or `number`. */
+export declare const EFFECT_TEMPLATE_SLOT_TYPES: readonly ["image", "video", "svg", "text", "color", "number"];
+export type EffectTemplateSlotType = (typeof EFFECT_TEMPLATE_SLOT_TYPES)[number];
+interface EffectTemplateSlotBase {
+    /** Letters, digits, `-` and `_`, starting with a letter. */
+    name: string;
+    /** What a form shows for it. */
+    label: string;
+    /** A sentence on what it is for. */
+    description?: string;
+}
+/**
+ * A slot for a picture, SVG or video. Its default (which may be large) is not described, only
+ * whether there is one; with none, an unfilled slot is left for the host (`openSlots`).
+ */
+export interface EffectTemplateSubjectSlot extends EffectTemplateSlotBase {
+    type: 'image' | 'video' | 'svg';
+    hasDefault: boolean;
+}
+export interface EffectTemplateTextSlot extends EffectTemplateSlotBase {
+    type: 'text';
+    default: string;
+    /** The most characters it takes. */
+    maxLength?: number;
+}
+/** A colour, `#RRGGBB`. */
+export interface EffectTemplateColorSlot extends EffectTemplateSlotBase {
+    type: 'color';
+    default: string;
+}
+export interface EffectTemplateNumberSlot extends EffectTemplateSlotBase {
+    type: 'number';
+    default: number;
+    min?: number;
+    max?: number;
+    /** Whole numbers only. */
+    integer?: boolean;
+}
+/** A slot of a template, shaped for a form (Flair's `describeTemplateSlots`). */
+export type EffectTemplateSlot = EffectTemplateSubjectSlot | EffectTemplateTextSlot | EffectTemplateColorSlot | EffectTemplateNumberSlot;
+/** A template with its slots, in the order a form shows them. */
+export interface EffectTemplateDescription extends EffectTemplateSummary {
+    slots: readonly EffectTemplateSlot[];
+}
+/**
+ * What fills a slot: words, a colour or a number; for a subject slot a URL or markup, a subject
+ * object, or `{ slot: name }` to leave it for the host.
+ */
+export type EffectTemplateValue = string | number | EffectSubject;
+export type EffectTemplateValues = Readonly<Record<string, EffectTemplateValue>>;
+export interface EffectTemplateSearchOptions {
+    /** Only templates matching every word (in name, id, tags or description). */
+    query?: string;
+    /** Only templates carrying every one of these tags. */
+    tags?: readonly string[];
+    /** Most results to return. */
+    limit?: number;
+}
+export interface EffectTemplateOptions {
+    /** The sequence's name: lowercase words and dashes (default the template's id). */
+    name?: string;
+}
+/** What `instantiateTemplate` gives. Values that do not fit are refused all at once, never in part. */
+export type EffectTemplateResult = {
+    ok: true;
+    sequence: EffectSequence;
+    /** Subject slots left for the host to fill (no value and no default, or `{ slot }`). */
+    openSlots: readonly string[];
+    /** What the provider left out or changed, in sentences (empty when nothing was). */
+    notes: readonly string[];
+} | {
+    ok: false;
+    /** Each a sentence naming the slot and what it takes. */
+    errors: readonly string[];
+};
 /** What a provider can do, so editors can degrade cleanly. */
 export interface EffectProviderCapabilities {
     /** Renders off the main thread. */
@@ -293,6 +491,8 @@ export interface EffectProviderCapabilities {
     supportsAuthoring?: boolean;
     /** Lists `camera` effects and implements `cameraView` (and maybe `sampleCameraMove`). */
     supportsCamera?: boolean;
+    /** Implements `listTemplates`, `describeTemplate` and `instantiateTemplate`. */
+    supportsTemplates?: boolean;
 }
 export type MaybePromise<T> = T | Promise<T>;
 /**
@@ -342,4 +542,16 @@ export interface EffectProvider {
      * `sampleEffectCameraMove` falls back to `cameraView` per frame. Errors as for `cameraView`.
      */
     sampleCameraMove?(id: string, request: CameraMoveSampleRequest): MaybePromise<CameraMoveSample>;
+    /** Sequence templates, best match first. Present when `capabilities.supportsTemplates`. */
+    listTemplates?(options?: EffectTemplateSearchOptions): MaybePromise<readonly EffectTemplateSummary[]>;
+    /** A template with its slots. Unknown ids throw `UnknownTemplateError`. */
+    describeTemplate?(id: string): MaybePromise<EffectTemplateDescription>;
+    /**
+     * Fills a template's slots and returns the sequence. Slots left out take their defaults.
+     * Values that do not fit (an unknown slot, a wrong type, out of range) give `{ ok: false,
+     * errors }`, each error a sentence. Unknown ids throw `UnknownTemplateError`. Every effect
+     * the sequence names is in the provider's `list()`.
+     */
+    instantiateTemplate?(id: string, values?: EffectTemplateValues, options?: EffectTemplateOptions): MaybePromise<EffectTemplateResult>;
 }
+export {};

package/dist/image-editor/controller.d.cts

@@ -1023,6 +1023,18 @@ export declare class ImageEditorController {
      * non-pixel layer, or when the layer is completely transparent.
      */
     getLayerDataURL(id: string): string | null;
+    private maskedImageCache;
+    /**
+     * A pixel layer's own pixels with its raster and vector masks applied, cropped to what shows: a
+     * PNG data URL and its document bounds, or `null` for an unknown or non-pixel layer, or when
+     * nothing shows. Opacity, blending, filters and effects are left out, as in `getLayerDataURL`.
+     * Use it for a masked layer, whose stored pixels (a whole copy, for Separate Subject's subject)
+     * are not what it shows.
+     */
+    getMaskedLayerImage(id: string): {
+        url: string;
+        bounds: CropBox;
+    } | null;
     /**
      * Composites the layer stack in document space without a canvas (annotation layers need one
      * and are left out): `rect` (default: the canvas) as RGBA, straight alpha. Crop, rotation and

package/dist/image-editor/controller.d.ts

@@ -1023,6 +1023,18 @@ export declare class ImageEditorController {
      * non-pixel layer, or when the layer is completely transparent.
      */
     getLayerDataURL(id: string): string | null;
+    private maskedImageCache;
+    /**
+     * A pixel layer's own pixels with its raster and vector masks applied, cropped to what shows: a
+     * PNG data URL and its document bounds, or `null` for an unknown or non-pixel layer, or when
+     * nothing shows. Opacity, blending, filters and effects are left out, as in `getLayerDataURL`.
+     * Use it for a masked layer, whose stored pixels (a whole copy, for Separate Subject's subject)
+     * are not what it shows.
+     */
+    getMaskedLayerImage(id: string): {
+        url: string;
+        bounds: CropBox;
+    } | null;
     /**
      * Composites the layer stack in document space without a canvas (annotation layers need one
      * and are left out): `rect` (default: the canvas) as RGBA, straight alpha. Crop, rotation and