motionrender 0.0.0-stage → 0.2.1

package/dist/types/packages/react/src/index.d.ts

@@ -0,0 +1,76 @@
+import { type CSSProperties, type HTMLAttributes, type ImgHTMLAttributes, type ReactElement, type ReactNode } from 'react';
+import { interpolate, spring } from '../../builder/src/index.js';
+export { interpolate, spring };
+export type VideoConfig = {
+    id?: string;
+    width: number;
+    height: number;
+    fps: number;
+    durationInFrames: number;
+};
+/** The frame being drawn, counted from 0 (inside a Sequence: from the start of the sequence). */
+export declare function useCurrentFrame(): number;
+/** The video's width, height, fps and length in frames. */
+export declare function useVideoConfig(): VideoConfig;
+/** Holds the frame until continueRender(handle) is called, for work that is not finished when the component first renders (loading a model, decoding an image). Gives a handle. */
+export declare function delayRender(label?: string): number;
+/** Releases a delayRender handle; the frame is drawn once every handle is released. */
+export declare function continueRender(handle: number): void;
+type MediaProps = {
+    src: string; /** Frames of the source to skip. */
+    startFrom?: number;
+    volume?: number;
+    playbackRate?: number;
+    loop?: boolean; /** Tells apart two clips with the same src shown together. */
+    name?: string;
+};
+/** Plays a sound (an audio asset id, a file, or sfx:name) for as long as it is shown, counted from when it appears. */
+export declare function Audio(props: MediaProps): ReactElement;
+/** Plays a video clip under the component (or over it with layer="front"). left, top, width and height place it, and may change with the frame (the clip then moves or resizes); the default fills the video. */
+export declare function Video(props: MediaProps & {
+    muted?: boolean;
+    left?: number;
+    top?: number;
+    width?: number;
+    height?: number;
+    objectFit?: 'cover' | 'contain' | 'fill'; /** 'back' (default) draws the clip under the component, 'front' over it. */
+    layer?: 'back' | 'front';
+}): ReactElement;
+/** A picture: an asset id declared in config.assets, or a file path. Same as <img>. */
+export declare function Img(props: ImgHTMLAttributes<HTMLImageElement>): ReactElement;
+/** A box that fills the video (position: absolute, all four sides 0), for stacking layers. */
+export declare function AbsoluteFill({ style, children, ...rest }: HTMLAttributes<HTMLDivElement> & {
+    style?: CSSProperties;
+}): ReactElement;
+/** Shows its children from frame `from` for `durationInFrames`, with the frame counted from the start of the sequence. */
+export declare function Sequence({ from, durationInFrames, layout, children }: {
+    from?: number;
+    durationInFrames?: number;
+    layout?: 'absolute-fill' | 'none';
+    name?: string;
+    children?: ReactNode;
+}): ReactElement | null;
+/** Plays its Series.Sequence children one after another. */
+export declare function Series({ children }: {
+    children?: ReactNode;
+}): ReactElement;
+export declare namespace Series {
+    var Sequence: (_props: {
+        durationInFrames: number;
+        offset?: number;
+        children?: ReactNode;
+    }) => ReactElement | null;
+}
+/** Easing functions for interpolate: `interpolate(frame, [0, 30], [0, 1], { easing: Easing.out(Easing.cubic) })`. */
+export declare const Easing: {
+    linear: (t: number) => number;
+    quad: (t: number) => number;
+    cubic: (t: number) => number;
+    sin: (t: number) => number;
+    in: (f: (t: number) => number) => (t: number) => number;
+    out: (f: (t: number) => number) => (t: number) => number;
+    inOut: (f: (t: number) => number) => (t: number) => number;
+    bezier(x1: number, y1: number, x2: number, y2: number): (x: number) => number;
+};
+/** A number from 0 up to 1 that is the same for the same seed on every render (Math.random is not). */
+export declare function random(seed: string | number): number;

package/dist/types/packages/renderer/src/index.d.ts

@@ -0,0 +1,35 @@
+import { type Browser } from 'playwright';
+import type { Composition } from '../../schema/src/index.js';
+import { type FrameReport } from '../../graphics/src/index.js';
+export type Renderer = {
+    concurrency: number;
+    renderFrame(frame: number): Promise<Buffer>;
+    inspectFrame(frame: number): Promise<FrameReport>;
+    contactSheet(frames: number[], options?: {
+        columns?: number;
+        width?: number;
+    }): Promise<Buffer>;
+    captureFrame(frame: number, output: string): Promise<void>;
+    close(): Promise<void>;
+};
+/** `allowCode` lets code layers run: they execute JavaScript from the composition, so only set it for compositions you trust. */
+export type RendererOptions = {
+    baseDir?: string;
+    concurrency?: number;
+    scale?: number;
+    motionBlur?: boolean;
+    frameTimeoutMs?: number;
+    allowCode?: boolean;
+};
+export declare const scaledSize: (composition: Composition, scale?: number) => {
+    width: number;
+    height: number;
+};
+export declare const browserInstallHint = "Install one with \"ove browser install\" (Playwright's Chromium, about 150 MB), install Google Chrome, or set OVE_CHROMIUM_EXECUTABLE to a Chromium-based browser.";
+export declare function launchBrowser(): Promise<Browser>;
+export declare function describeBrowser(): Promise<string>;
+export declare const defaultConcurrency: () => number;
+export declare function createRenderer(composition: Composition, options?: RendererOptions): Promise<Renderer>;
+export declare function renderFrames(renderer: Pick<Renderer, 'renderFrame' | 'concurrency'>, from: number, to: number, options?: {
+    lookahead?: number;
+}): AsyncGenerator<Buffer>;

package/dist/types/packages/renderer/src/pool.d.ts

@@ -0,0 +1,7 @@
+export type PagePool<P> = {
+    run<T>(label: string, work: (page: P) => Promise<T>): Promise<T>;
+    close(): Promise<void>;
+};
+export declare const defaultFrameTimeoutMs = 120000;
+export declare const isDrawingError: (error: unknown) => boolean;
+export declare function createPagePool<P>(open: () => Promise<P>, discard: (page: P) => Promise<void>, size: number, timeoutMs?: number): Promise<PagePool<P>>;

package/dist/types/packages/renderer/src/video.d.ts

@@ -0,0 +1,9 @@
+import type { Composition } from '../../schema/src/index.js';
+export type VideoFrames = {
+    dir: string;
+    count: number;
+    first: number;
+};
+export declare const videoFrameFile: (video: VideoFrames, index: number) => string;
+export declare const videoCacheRoot: () => string;
+export declare function prepareVideos(composition: Composition, baseDir: string): Promise<Map<string, VideoFrames>>;

package/dist/types/packages/schema/src/captions.d.ts

@@ -0,0 +1,24 @@
+import { z } from 'zod';
+export declare const captionWordSchema: z.ZodObject<{
+    text: z.ZodString;
+    start: z.ZodNumber;
+    end: z.ZodNumber;
+}, z.core.$strip>;
+export declare const captionCueSchema: z.ZodObject<{
+    text: z.ZodString;
+    start: z.ZodNumber;
+    end: z.ZodNumber;
+    words: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        text: z.ZodString;
+        start: z.ZodNumber;
+        end: z.ZodNumber;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+export type CaptionWord = z.infer<typeof captionWordSchema>;
+export type CaptionCue = z.infer<typeof captionCueSchema>;
+export declare function groupCaptionWords(words: CaptionWord[], maxWords?: number): CaptionCue[];
+export declare function parseCaptions(text: string, name?: string, maxWords?: number): CaptionCue[];
+export declare function formatCaptions(cues: CaptionCue[], format: 'srt' | 'vtt'): string;
+export declare const captionKey: (word: string) => string;
+export declare function dropFillerWords(cues: CaptionCue[]): CaptionCue[];
+export declare const captionLines: (cues: CaptionCue[], maxWords: number) => CaptionCue[];

package/dist/types/packages/schema/src/expression.d.ts

@@ -0,0 +1 @@
+export declare function evaluateExpression(source: string, scope: Record<string, unknown>): unknown;