Class VideoEditor

constructor

• new VideoEditor(
      options?: {
          assets?: VideoEditorAssetStore;
          sync?: VideoEditorDocumentSync;
      },
  ): VideoEditor

  Parameters

  • options: { assets?: VideoEditorAssetStore; sync?: VideoEditorDocumentSync } = {}

  Returns VideoEditor

Readonly Internal_editor

Readonly_fullscreen

_isMobileWorkspace

Readonly_timelineContainer

Readonly_timelineSize

Readonly_viewport

Readonly_viewportContainer

Readonly_viewportSize

Readonly_workspaceContainer

Readonly_workspaceSize

Readonly_zoom

canvas

Readonlydoc

effectRenderer

isDisposed

playback

resize

Optional Readonlysync

ReadonlytimelineZoom

_showStats

• get _showStats(): boolean
  Internal

  Returns boolean

• set _showStats(value: boolean): void
  Internal

  Parameters

  • value: boolean

  Returns void

activeAssetBin

• get activeAssetBin(): AssetBin

  The state of the asset bin ui

  Returns AssetBin

• set activeAssetBin(value: AssetBin): void

  The state of the asset bin ui

  Parameters

  • value: AssetBin

  Returns void

canvasZoom

• get canvasZoom(): number

  Returns number

currentTime

• get currentTime(): number

  The current playback time of the video timeline

  Returns number

drag

• get drag(): ClipDragContext

  Returns ClipDragContext

effects

• get effects(): Map<string, VideoEffectAsset>

  The webgl-effects that are loaded into the editor

  Returns Map<string, VideoEffectAsset>

exportProgress

• get exportProgress(): number

  Progress from 0 to 1 while exporting

  Returns number

isMobileWorkspace

• get isMobileWorkspace(): boolean

  Returns boolean

isPaused

• get isPaused(): boolean

  Returns boolean

selection

• get selection(): AnyClip | GapSelection | undefined

  The currently selected video clip on the timeline.

  Returns AnyClip | GapSelection | undefined

tracks

• get tracks(): Track[]

  The audio and video tracks which contain clips

  Returns Track[]

viewportSize

• get viewportSize(): Size

  Returns Size

_transact

• _transact<T>(fn: () => T): T

  Type Parameters

  • T

  Parameters

  • fn: () => T

  Returns T

[dispose]

• "[dispose]"(): void

  Returns void

addClip

• addClip(track: Track, asset: MediaAsset): AnyClip

  Add a new clip at the end of the specified track.

  Parameters

  • track: Track

    The track the clip will be added to.

  • asset: MediaAsset

    The media asset attached to the clip.

  Returns AnyClip

addTrack

• addTrack(trackType: "audio" | "video"): Track

  Add a new track to the timeline.

  Parameters

  • trackType: "audio" | "video"

    The track the clip will be added to.

  Returns Track

createMediaAsset

• createMediaAsset(source: string | Blob): Promise<MediaAsset>

  Create a new media asset with the given source File or URI

  Parameters

  • source: string | Blob

    A Blob or URI string of the clip media.

  Returns Promise<MediaAsset>

dispose

• dispose(): void

  Release resources of the video editor and allow it to be garbage collected.

  Returns void

export

• export(options?: { signal?: AbortSignal }): Promise<Blob>

  Render and encode the video composition.

  Parameters

  • Optionaloptions: { signal?: AbortSignal }

  Returns Promise<Blob>

  A promise that resolves to a Blob.

generateId

• generateId(): string

  Returns string

getPartId

• getPartId(part: string): string

  Parameters

  • part: string

  Returns string

getTrackForMedia

• getTrackForMedia(
      asset: {
          video?:
              | boolean
              | {
                  codec: string;
                  duration: Schema.Rational;
                  firstTimestamp: Schema.Rational;
                  frameRate: number;
                  height: number;
                  rotation: number;
                  width: number;
              };
      },
  ): Track

  Parameters

  • asset: {
        video?:
            | boolean
            | {
                codec: string;
                duration: Schema.Rational;
                firstTimestamp: Schema.Rational;
                frameRate: number;
                height: number;
                rotation: number;
                width: number;
            };
    }

  Returns Track

importJson

• importJson(content: SerializedDocument): void

  Adds assets and tracks from the provided JSON object

  Parameters

  • content: SerializedDocument

  Returns void

pause

• pause(): void

  Returns void

pixelsToSeconds

• pixelsToSeconds(offset: number): number

  Parameters

  • offset: number

  Returns number

play

• play(): void

  Returns void

replaceClipAsset

• replaceClipAsset(asset: MediaAsset): void

  Change the media of the selected clip

  Parameters

  • asset: MediaAsset

  Returns void

secondsToPixels

• secondsToPixels(time: number): number

  Parameters

  • time: number

  Returns number

seekTo

• seekTo(time: number): void

  Seek to the given time of the video.

  Parameters

  • time: number

    The seek time in seconds.

  Returns void

select

• select(item: AnyClip | GapSelection | undefined, seek?: boolean): void

  Select the given track item

  Parameters

  • item: AnyClip | GapSelection | undefined
  • seek: boolean = ...

  Returns void

splitClip

• splitClip(clip: AnyClip, time: number): [AnyClip, AnyClip] | undefined

  Split a clip by replacing it with two new clips which end and start at the given time.

  Does nothing and returns undefined if the time is outside the clip.

  Parameters

  • clip: AnyClip
  • time: number

  Returns [AnyClip, AnyClip] | undefined

  The newly created clip or undefined..