@remotion/web-renderer 4.0.402 → 4.0.404

package/dist/background-keepalive.d.ts

@@ -0,0 +1,9 @@
+import { type LogLevel } from 'remotion';
+export type BackgroundKeepalive = {
+    waitForTick: () => Promise<void>;
+    [Symbol.dispose]: () => void;
+};
+export declare function createBackgroundKeepalive({ fps, logLevel }: {
+    fps: number;
+    logLevel: LogLevel;
+}): BackgroundKeepalive;

package/dist/can-render-media-on-web.d.ts

@@ -0,0 +1,3 @@
+import type { CanRenderMediaOnWebOptions, CanRenderMediaOnWebResult } from './can-render-types';
+export type { CanRenderIssue, CanRenderMediaOnWebOptions, CanRenderMediaOnWebResult, } from './can-render-types';
+export declare const canRenderMediaOnWeb: (options: CanRenderMediaOnWebOptions) => Promise<CanRenderMediaOnWebResult>;

package/dist/can-render-types.d.ts

@@ -0,0 +1,27 @@
+import type { WebRendererAudioCodec, WebRendererContainer, WebRendererQuality, WebRendererVideoCodec } from './mediabunny-mappings';
+import type { WebRendererOutputTarget } from './output-target';
+export type CanRenderIssueType = 'video-codec-unsupported' | 'audio-codec-unsupported' | 'webgl-unsupported' | 'webcodecs-unavailable' | 'container-codec-mismatch' | 'transparent-video-unsupported' | 'invalid-dimensions' | 'output-target-unsupported';
+export type CanRenderIssue = {
+    type: CanRenderIssueType;
+    message: string;
+    severity: 'error' | 'warning';
+};
+export type CanRenderMediaOnWebResult = {
+    canRender: boolean;
+    issues: CanRenderIssue[];
+    resolvedVideoCodec: WebRendererVideoCodec;
+    resolvedAudioCodec: WebRendererAudioCodec | null;
+    resolvedOutputTarget: WebRendererOutputTarget;
+};
+export type CanRenderMediaOnWebOptions = {
+    container?: WebRendererContainer;
+    videoCodec?: WebRendererVideoCodec;
+    audioCodec?: WebRendererAudioCodec | null;
+    width: number;
+    height: number;
+    transparent?: boolean;
+    muted?: boolean;
+    videoBitrate?: number | WebRendererQuality;
+    audioBitrate?: number | WebRendererQuality;
+    outputTarget?: WebRendererOutputTarget | null;
+};

package/dist/check-webgl-support.d.ts

@@ -0,0 +1,2 @@
+import type { CanRenderIssue } from './can-render-types';
+export declare const checkWebGLSupport: () => CanRenderIssue | null;

package/dist/create-audio-sample-source.d.ts

@@ -0,0 +1,9 @@
+import { AudioSampleSource, type Quality } from 'mediabunny';
+export declare const createAudioSampleSource: ({ muted, codec, bitrate, }: {
+    muted: boolean;
+    codec: "aac" | "alaw" | "flac" | "mp3" | "opus" | "pcm-f32" | "pcm-f32be" | "pcm-f64" | "pcm-f64be" | "pcm-s16" | "pcm-s16be" | "pcm-s24" | "pcm-s24be" | "pcm-s32" | "pcm-s32be" | "pcm-s8" | "pcm-u8" | "ulaw" | "vorbis" | null;
+    bitrate: number | Quality;
+}) => {
+    audioSampleSource: AudioSampleSource;
+    [Symbol.dispose]: () => void;
+} | null;

package/dist/drawing/elements-and-bounds.d.ts

@@ -0,0 +1,9 @@
+import type { Precompositing } from './calculate-transforms';
+export type ElementAndBounds = {
+    element: Element;
+    bounds: DOMRect;
+    transform: DOMMatrix;
+    parentRect: DOMRect;
+    precompositing: Precompositing;
+    establishes3DRenderingContext: DOMMatrix | null;
+};

package/dist/drawing/get-pretransform-rect.d.ts

@@ -1 +1 @@
-export declare function getPreTransformRect(targetRect: DOMRect, matrix: DOMMatrix): DOMRect;
+export declare function getPreTransformRect(targetRect: DOMRect, matrix: DOMMatrix): DOMRect | null;

package/dist/drawing/handle-3d-transform.d.ts

@@ -2,10 +2,10 @@ export declare const getPrecomposeRectFor3DTransform: ({ element, parentRect, ma
     element: HTMLElement | SVGElement;
     parentRect: DOMRect;
     matrix: DOMMatrix;
-}) => DOMRect;
-export declare const handle3dTransform: ({ matrix, precomposeRect, tempCanvas, rectAfterTransforms, internalState, }: {
+}) => DOMRect | null;
+export declare const handle3dTransform: ({ matrix, sourceRect, tempCanvas, rectAfterTransforms, internalState, }: {
     matrix: DOMMatrix;
-    precomposeRect: DOMRect;
+    sourceRect: DOMRect;
     tempCanvas: OffscreenCanvas;
     rectAfterTransforms: DOMRect;
     internalState: {

package/dist/drawing/precompose-and-draw.d.ts

@@ -0,0 +1,33 @@
+import type { Precompositing } from './calculate-transforms';
+import type { ElementAndBounds } from './elements-and-bounds';
+export declare const precompose: ({ element, logLevel, parentRect, internalState, precompositing, totalMatrix, rect, isIn3dRenderingContext, }: {
+    element: HTMLElement | SVGElement;
+    logLevel: "error" | "info" | "trace" | "verbose" | "warn";
+    parentRect: DOMRect;
+    internalState: {
+        getDrawn3dPixels: () => number;
+        getPrecomposedTiles: () => number;
+        addPrecompose: ({ canvasWidth, canvasHeight, }: {
+            canvasWidth: number;
+            canvasHeight: number;
+        }) => void;
+        helperCanvasState: import("../internal-state").HelperCanvasState;
+        [Symbol.dispose]: () => void;
+        getWaitForReadyTime: () => number;
+        addWaitForReadyTime: (time: number) => void;
+        getAddSampleTime: () => number;
+        addAddSampleTime: (time: number) => void;
+        getCreateFrameTime: () => number;
+        addCreateFrameTime: (time: number) => void;
+        getAudioMixingTime: () => number;
+        addAudioMixingTime: (time: number) => void;
+    };
+    precompositing: Precompositing;
+    totalMatrix: DOMMatrix;
+    rect: DOMRect;
+    isIn3dRenderingContext: DOMMatrix | null;
+}) => Promise<{
+    drawable: OffscreenCanvas;
+    rectAfterTransforms: DOMRect;
+    elementsToBeRenderedIndependently: ElementAndBounds[];
+} | null>;

package/dist/drawing/renoun.d.ts

@@ -0,0 +1,125 @@
+/** Image format for encoded screenshot output. */
+export type ImageFormat = 'png' | 'jpeg' | 'webp';
+/** Options for rendering a screenshot to canvas. */
+export interface RenderOptions {
+    /**
+     * Canvas background color. Set to `null` (or omit) for a transparent canvas.
+     * When provided, the string is passed directly to `fillStyle`.
+     */
+    backgroundColor?: string | null;
+    /**
+     * Optional existing canvas to render into.
+     * When omitted, a new canvas element is created.
+     */
+    canvas?: HTMLCanvasElement;
+    /**
+     * Rendering scale factor. Defaults to `window.devicePixelRatio` (or `1`).
+     */
+    scale?: number;
+    /**
+     * Crop origin X (CSS pixels) relative to the element's left edge.
+     * Defaults to the element's left edge.
+     */
+    x?: number;
+    /**
+     * Crop origin Y (CSS pixels) relative to the element's top edge.
+     * Defaults to the element's top edge.
+     */
+    y?: number;
+    /**
+     * Output width in CSS pixels. Defaults to the element's width.
+     */
+    width?: number;
+    /**
+     * Output height in CSS pixels. Defaults to the element's height.
+     */
+    height?: number;
+    /**
+     * Controls how `position: fixed` elements outside the captured subtree are
+     * handled.
+     *
+     * - `none` – ignore all fixed elements outside `element`.
+     * - `intersecting` – include fixed elements whose bounding rect intersects the capture rect.
+     * - `all` – include all fixed elements that overlap the viewport.
+     */
+    includeFixed?: 'none' | 'intersecting' | 'all';
+    /**
+     * CSS selector used to skip elements from rendering.
+     * Defaults to `[data-screenshot-ignore]`. Set to `null` or an empty string
+     * to disable selector-based skipping.
+     */
+    ignoreSelector?: string | null;
+}
+/** Options for encoding a canvas to an image format. */
+export interface EncodeOptions {
+    /**
+     * Image format to encode. Defaults to `'png'`.
+     */
+    format?: ImageFormat;
+    /**
+     * Image quality for lossy formats (`jpeg`, `webp`). A number between `0` and `1`.
+     * Ignored for `png`. Defaults to `0.92`.
+     */
+    quality?: number;
+}
+/** Combined options for one-shot screenshot methods that render and encode. */
+export type ScreenshotOptions = RenderOptions & EncodeOptions;
+/**
+ * A promise-like object representing a screenshot capture. The underlying
+ * render happens once; subsequent calls to `.canvas()`, `.blob()`, or `.url()`
+ * reuse the same rendered canvas.
+ */
+export interface ScreenshotTask extends Promise<HTMLCanvasElement> {
+    /** Returns the rendered canvas. */
+    canvas(): Promise<HTMLCanvasElement>;
+    /** Encodes the rendered canvas to a Blob. */
+    blob(options?: EncodeOptions): Promise<Blob>;
+    /**
+     * Encodes the rendered canvas to a Blob and creates an object URL.
+     * Remember to call `URL.revokeObjectURL(url)` when done to avoid memory leaks.
+     */
+    url(options?: EncodeOptions): Promise<string>;
+}
+/**
+ * Renders a DOM element into a canvas using modern browser features.
+ *
+ * Returns a `ScreenshotTask` that is both a Promise and provides methods
+ * to encode the rendered canvas. The underlying render happens once;
+ * subsequent calls to `.canvas()`, `.blob()`, or `.url()` reuse the same result.
+ *
+ * This implementation targets evergreen browsers only and assumes a real DOM +
+ * Canvas2D environment (not Node.js).
+ *
+ * @example
+ * // Capture handle pattern - render once, encode multiple ways
+ * const shot = screenshot(element, { scale: 2 })
+ * const canvas = await shot.canvas()
+ * const pngBlob = await shot.blob({ format: 'png' })
+ * const webpUrl = await shot.url({ format: 'webp', quality: 0.9 })
+ *
+ * @example
+ * // Direct await returns the canvas
+ * const canvas = await screenshot(element)
+ *
+ * @example
+ * // One-shot convenience methods
+ * const canvas = await screenshot.canvas(element, { scale: 2 })
+ * const blob = await screenshot.blob(element, { format: 'jpeg', quality: 0.85 })
+ * const url = await screenshot.url(element, { format: 'png' })
+ */
+declare function screenshot(target: Element | string, options?: RenderOptions): ScreenshotTask;
+declare namespace screenshot {
+    var canvas: (target: string | Element, options?: RenderOptions | undefined) => Promise<HTMLCanvasElement>;
+}
+declare namespace screenshot {
+    var blob: (target: string | Element, options?: ScreenshotOptions | undefined) => Promise<Blob>;
+}
+declare namespace screenshot {
+    var url: (target: string | Element, options?: ScreenshotOptions | undefined) => Promise<string>;
+}
+export { screenshot };
+declare global {
+    interface CanvasRenderingContext2D {
+        _filterPolyfillValue?: string;
+    }
+}

package/dist/drawing/transform-in-3d.d.ts

@@ -1,9 +1,9 @@
 import type { HelperCanvasState } from '../internal-state';
-export declare const transformIn3d: ({ matrix, sourceCanvas, untransformedRect, rectAfterTransforms, internalState, }: {
-    untransformedRect: DOMRect;
+export declare const transformIn3d: ({ matrix, sourceCanvas, sourceRect, destRect, internalState, }: {
+    sourceRect: DOMRect;
     matrix: DOMMatrix;
     sourceCanvas: OffscreenCanvas;
-    rectAfterTransforms: DOMRect;
+    destRect: DOMRect;
     internalState: {
         getDrawn3dPixels: () => number;
         getPrecomposedTiles: () => number;
@@ -22,7 +22,4 @@ export declare const transformIn3d: ({ matrix, sourceCanvas, untransformedRect,
         getAudioMixingTime: () => number;
         addAudioMixingTime: (time: number) => void;
     };
-}) => {
-    canvas: OffscreenCanvas;
-    rect: DOMRect;
-};
+}) => OffscreenCanvas;

package/dist/drawing/transform-origin.d.ts

@@ -0,0 +1,21 @@
+export type Transform = {
+    matrices: DOMMatrix[];
+    element: Element;
+    transformOrigin: string;
+    boundingClientRect: DOMRect | null;
+};
+export declare const parseTransformOriginOrPerspectiveOrigin: (transformOrigin: string) => {
+    x: number;
+    y: number;
+} | null;
+export declare const getInternalOrigin: (origin: string, boundingClientRect: DOMRect) => {
+    x: number;
+    y: number;
+};
+export declare const getGlobalOrigin: ({ origin, boundingClientRect, }: {
+    origin: string;
+    boundingClientRect: DOMRect;
+}) => {
+    x: number;
+    y: number;
+};

package/dist/drawing/transform-perspective-origin.d.ts

@@ -0,0 +1,17 @@
+export type Transform = {
+    matrices: DOMMatrix[];
+    element: Element;
+    transformOrigin: string;
+    boundingClientRect: DOMRect | null;
+};
+export declare const parseTransformOriginOrPerspectiveOrigin: (transformOrigin: string) => {
+    x: number;
+    y: number;
+} | null;
+export declare const getAbsoluteOrigin: ({ origin, boundingClientRect, }: {
+    origin: string;
+    boundingClientRect: DOMRect;
+}) => {
+    x: number;
+    y: number;
+};