@linker-design-plus/timeline-track 1.0.9 → 1.0.11

package/dist/core/controllers/demoPreviewRebuildState.d.ts

@@ -0,0 +1,54 @@
+import type { Clip, ClipConfig, PlayState, PreviewAspectRatio, Track, TrackInsertionPlacement, TrackType } from '../models/types';
+export interface DemoPreviewClipSnapshot extends ClipConfig {
+    id: string;
+    previewAutoOrder?: number;
+}
+export interface DemoPreviewTrackSnapshot {
+    id: string;
+    type: TrackType;
+    name: string;
+    order: number;
+    isMuted: boolean;
+    clips: DemoPreviewClipSnapshot[];
+}
+export interface DemoPreviewRebuildSnapshot {
+    currentTime: number;
+    speed: number;
+    zoom: number;
+    playState: PlayState;
+    previewAspectRatio: PreviewAspectRatio;
+    selectedClipId: string | null;
+    isPreviewAttached: boolean;
+    tracks: DemoPreviewTrackSnapshot[];
+}
+interface DemoPreviewStateReader {
+    getCurrentTime(): number;
+    getPreviewAspectRatio(): PreviewAspectRatio;
+    getSpeed(): number;
+    getZoom(): number;
+    getPlayState(): PlayState;
+    getSelectedClip(): Clip | null;
+    getTracks(): Track[];
+}
+interface DemoPreviewStateWriter extends DemoPreviewStateReader {
+    addClip(clipConfig: DemoPreviewClipSnapshot): Promise<string>;
+    clearSelection(): void;
+    createTrack(type: TrackType, name?: string, insertionPlacement?: TrackInsertionPlacement, referenceTrackId?: string): string;
+    moveClipToTrack(clipId: string, targetTrackId: string): boolean;
+    muteTrack(trackId: string, isMuted: boolean): boolean;
+    pause(): void;
+    play(): void;
+    renameTrack(trackId: string, newName: string): boolean;
+    resetPreviewAspectRatioToAuto(): void;
+    selectClip(clipId: string): void;
+    setCurrentTime(time: number): void;
+    setPreviewAspectRatio(aspectRatio: {
+        width: number;
+        height: number;
+    }): void;
+    setSpeed(speed: number): void;
+    setZoomByInteraction(zoom: number): void;
+}
+export declare function captureDemoPreviewRebuildSnapshot(manager: DemoPreviewStateReader, isPreviewAttached: boolean): DemoPreviewRebuildSnapshot;
+export declare function restoreDemoPreviewRebuildSnapshot(manager: DemoPreviewStateWriter, snapshot: DemoPreviewRebuildSnapshot): Promise<void>;
+export {};

package/dist/core/controllers/domPreviewBackend.d.ts

@@ -0,0 +1,5 @@
+import type { TimelinePreviewBackend } from './previewBackend';
+import { TimelinePreviewSession } from './timelinePreviewSession';
+export declare class DomPreviewBackend extends TimelinePreviewSession implements TimelinePreviewBackend {
+    destroy(): void;
+}

package/dist/core/controllers/index.d.ts

@@ -0,0 +1,13 @@
+export * from './timelineClipEventController';
+export * from './timelineClipWorkflowController';
+export { DomPreviewBackend } from './domPreviewBackend';
+export * from './previewBackend';
+export { resolvePreviewBackendType } from './previewBackendSupport';
+export { PreviewClockController } from './previewClockController';
+export * from './timelineDurationController';
+export { TimelineEventDispatcher } from './timelineEventDispatcher';
+export { TimelinePlaybackResolver } from './timelinePlaybackResolver';
+export { TimelinePreviewSession } from './timelinePreviewSession';
+export * from './timelineSelectionController';
+export * from './timelineTrackMutationController';
+export { TimelineTrackInfoPanelController } from './timelineTrackInfoPanelController';

package/dist/core/controllers/previewBackend.d.ts

@@ -0,0 +1,53 @@
+import type { ActiveClipPlaybackInfo, Clip, ClipVisualTransform, PlayState, PreviewAspectRatio, PreviewMediaSource, PreviewSourceResolver, TimeMs } from '../models/types';
+export interface TimelinePreviewSyncPayload {
+    activeClips: ActiveClipPlaybackInfo[];
+    nextClips: ActiveClipPlaybackInfo[];
+    firstVideoClip: ActiveClipPlaybackInfo | null;
+    autoAspectRatioClip: ActiveClipPlaybackInfo | null;
+    currentTime: TimeMs;
+    playState: PlayState;
+    speed: number;
+    selectedClipId?: string | null;
+    syncRequestId?: number;
+}
+export interface TimelinePreviewBackendCallbacks {
+    onBufferingStateChange?: (isBuffering: boolean) => void;
+    onSourceLoadingChange?: (pending: number) => void;
+    onSyncProcessed?: (syncRequestId?: number) => void;
+    onAspectRatioChange?: (aspectRatio: PreviewAspectRatio) => void;
+    onVisualTransformCommit?: (clipId: string, visualTransform: ClipVisualTransform) => void;
+    onPendingPreviewRetry?: () => void;
+    onRuntimeError?: (error: unknown) => void;
+}
+export interface PreviewPendingState {
+    mode: 'seek' | 'scrub';
+    targetTime: TimeMs;
+    loadingPending: number;
+    isBuffering: boolean;
+    errorMessage: string | null;
+}
+export interface TimelinePreviewBackend {
+    attach(container: HTMLElement): void;
+    detach(): void;
+    sync(payload: TimelinePreviewSyncPayload): void;
+    applyAspectRatio(aspectRatio: PreviewAspectRatio): void;
+    getAspectRatio(): PreviewAspectRatio;
+    setPendingState?(state: PreviewPendingState | null): void;
+    hasPreview(): boolean;
+    destroy(): void;
+}
+export interface PreviewBackendClockState {
+    currentTime: TimeMs;
+    playState: PlayState;
+    speed: number;
+}
+export interface TimelinePreviewBackendOptions {
+    callbacks?: TimelinePreviewBackendCallbacks;
+    previewSourceResolver?: PreviewSourceResolver;
+    rootClassName?: string;
+    frameClassName?: string;
+    slotClassNamePrefix?: string;
+}
+export type ResolvedPreviewMediaSource = PreviewMediaSource & {
+    clipId: Clip['id'];
+};

package/dist/core/controllers/previewBackendSupport.d.ts

@@ -0,0 +1,2 @@
+import type { PreviewBackendType } from '../models/types';
+export declare function resolvePreviewBackendType(_requested: PreviewBackendType | undefined): Exclude<PreviewBackendType, 'auto'>;

package/dist/core/controllers/previewClockController.d.ts

@@ -0,0 +1,13 @@
+import type { PlayState, TimeMs } from '../models/types';
+import type { PreviewBackendClockState } from './previewBackend';
+export interface PreviewClockTransition {
+    shouldSeek: boolean;
+    currentTime: TimeMs;
+    playState: PlayState;
+    speed: number;
+}
+export declare class PreviewClockController {
+    private lastState;
+    sync(nextState: PreviewBackendClockState): PreviewClockTransition;
+    reset(): void;
+}

package/dist/core/controllers/previewTransformMath.d.ts

@@ -0,0 +1,27 @@
+import type { ClipVisualTransform } from '../models/types';
+export interface PreviewRect {
+    left: number;
+    top: number;
+    width: number;
+    height: number;
+    centerX: number;
+    centerY: number;
+}
+export interface PreviewFrameSize {
+    width: number;
+    height: number;
+}
+export interface PreviewMediaSize {
+    width: number;
+    height: number;
+}
+export declare const DEFAULT_CLIP_VISUAL_TRANSFORM: ClipVisualTransform;
+export declare const MIN_CLIP_VISUAL_SCALE = 0.1;
+export declare const MAX_CLIP_VISUAL_SCALE = 8;
+export declare function clampClipVisualScale(scale: number): number;
+export declare function resolveClipVisualTransform(transform?: Partial<ClipVisualTransform> | null): ClipVisualTransform;
+export declare function areClipVisualTransformsEqual(left?: Partial<ClipVisualTransform> | null, right?: Partial<ClipVisualTransform> | null, epsilon?: number): boolean;
+export declare function calculateContainRect(frame: PreviewFrameSize, media: PreviewMediaSize): PreviewRect;
+export declare function calculatePreviewDisplayRect(frame: PreviewFrameSize, media: PreviewMediaSize, transform?: Partial<ClipVisualTransform> | null): PreviewRect;
+export declare function moveClipVisualTransform(startTransform: Partial<ClipVisualTransform> | null | undefined, deltaX: number, deltaY: number, frame: PreviewFrameSize): ClipVisualTransform;
+export declare function scaleClipVisualTransformFromCenter(centerX: number, centerY: number, pointerX: number, pointerY: number, baseRect: PreviewRect, startTransform?: Partial<ClipVisualTransform> | null): ClipVisualTransform;

package/dist/core/controllers/previewTransformOverlay.d.ts

@@ -0,0 +1,45 @@
+import type { ClipVisualTransform } from '../models/types';
+import { type PreviewFrameSize, type PreviewRect } from './previewTransformMath';
+export interface PreviewTransformOverlayState {
+    clipId: string;
+    transform: ClipVisualTransform;
+    frameSize: PreviewFrameSize;
+    baseRect: PreviewRect;
+    displayRect: PreviewRect;
+}
+interface PreviewTransformOverlayCallbacks {
+    onPreviewTransformChange?: (clipId: string, transform: ClipVisualTransform | null) => void;
+    onPreviewTransformCommit?: (clipId: string, transform: ClipVisualTransform) => void;
+}
+export declare class PreviewTransformOverlay {
+    private frameElement;
+    private overlayElement;
+    private boxElement;
+    private readonly handleElements;
+    private readonly handlePointerDownHandlers;
+    private state;
+    private interaction;
+    private readonly callbacks;
+    private readonly boundPointerMove;
+    private readonly boundPointerUp;
+    private readonly boundVisibilityChange;
+    private readonly boundWindowBlur;
+    constructor(callbacks?: PreviewTransformOverlayCallbacks);
+    attach(frameElement: HTMLElement): void;
+    detach(): void;
+    sync(state: PreviewTransformOverlayState | null): void;
+    private createHandle;
+    private readonly handleMovePointerDown;
+    private getHandlePointerDown;
+    private bindDocumentListeners;
+    private unbindDocumentListeners;
+    private handleDocumentPointerMove;
+    private finishInteraction;
+    private render;
+    private positionHandle;
+    private toLocalPoint;
+    private getFrameBounds;
+    private getDocument;
+    private setGlobalCursor;
+}
+export {};

package/dist/core/controllers/timelineClipConfigController.d.ts

@@ -0,0 +1,15 @@
+import { Theme, Clip } from '../models';
+export interface TimelineClipConfigControllerConfig {
+    container: HTMLElement;
+    theme: Theme;
+    getSelectedClip: () => Clip | null;
+    updateClip: (clipId: string, updates: Partial<Clip>) => void;
+}
+export declare class TimelineClipConfigController {
+    private panel;
+    private config;
+    init(config: TimelineClipConfigControllerConfig): void;
+    update(): void;
+    destroy(): void;
+    private convertTheme;
+}

package/dist/core/controllers/timelineClipEventController.d.ts

@@ -0,0 +1,32 @@
+import type { Clip, PlayState } from '../models/types';
+export interface ClipMutationEffectHandlers {
+    notifySelectionChange: () => void;
+    emitSelectedClipChangeIfNeeded: () => void;
+    handleClipChange: () => void;
+    checkTrackDurationChange?: () => void;
+}
+export interface ClipUpdateMutationEffectHandlers extends ClipMutationEffectHandlers {
+    reloadClipThumbnailsIfNeeded?: () => void;
+}
+export interface ClipSelectPlan {
+    shouldJumpToTime: boolean;
+    jumpTime: number | null;
+    shouldSelectClip: boolean;
+}
+export declare function applyClipMutationEffects(handlers: ClipMutationEffectHandlers): void;
+export declare function applyClipUpdateEffects(handlers: ClipUpdateMutationEffectHandlers): void;
+export declare function shouldReloadClipThumbnails(clip: Clip, originalClip?: Clip, hasThumbnailProvider?: boolean): boolean;
+export declare function calculateCanPlayState(clips: Pick<Clip, 'endTime'>[], currentTime: number): boolean;
+interface SyncCanPlayStateOptions {
+    currentCanPlay: boolean;
+    nextCanPlay: boolean;
+    playState: PlayState;
+    clipEndTime: number;
+    setCanPlay: (value: boolean) => void;
+    pauseTimeline: () => void;
+    setCurrentTime: (time: number) => void;
+    emitCanPlayChange: (canPlay: boolean) => void;
+}
+export declare function syncCanPlayState(options: SyncCanPlayStateOptions): boolean;
+export declare function createClipSelectPlan(clip: Pick<Clip, 'id' | 'startTime'>): ClipSelectPlan;
+export {};

package/dist/core/controllers/timelineClipWorkflowController.d.ts

@@ -0,0 +1,30 @@
+import type { Clip, Track } from '../models/types';
+interface MutationWorkflowOptions {
+    applied: boolean;
+    isExecutingHistoryAction: boolean;
+    recordHistory?: () => void;
+    applyEffects: () => void;
+}
+interface MoveClipWorkflowOptions extends MutationWorkflowOptions {
+    clipId: string;
+    sourceTrackId: string;
+    targetTrackId: string;
+    clipBefore: Clip;
+    clipAfter: Clip;
+    sourceTrackSnapshot: Track | null;
+    targetTrackSnapshot: Track | null;
+    recordMoveClipBetweenTracks?: (clipId: string, sourceTrackId: string, targetTrackId: string, clipBefore: Clip, clipAfter: Clip, sourceTrackSnapshot: Track | null, targetTrackSnapshot: Track | null) => void;
+}
+interface SplitClipWorkflowOptions {
+    clip1: Clip;
+    clip2: Clip;
+    isExecutingHistoryAction: boolean;
+    recordSplitClip?: (clip1: Clip, clip2: Clip) => void;
+    emitClipUpdated: (clip: Clip) => void;
+    emitClipAdded: (clip: Clip) => void;
+    applyEffects: () => void;
+}
+export declare function applyClipMutationWorkflow(options: MutationWorkflowOptions): boolean;
+export declare function applyMoveClipWorkflow(options: MoveClipWorkflowOptions): boolean;
+export declare function applySplitClipWorkflow(options: SplitClipWorkflowOptions): void;
+export {};

package/dist/core/controllers/timelineDurationController.d.ts

@@ -0,0 +1,14 @@
+import type { Clip, TimeMs } from '../models/types';
+export declare const MIN_TIMELINE_DURATION = 3600000;
+export declare const TIMELINE_DURATION_PADDING = 300000;
+interface SyncTrackDurationChangeOptions {
+    clips: Clip[];
+    lastTrackDuration: TimeMs;
+    setLastTrackDuration: (duration: TimeMs) => void;
+    setTimelineDuration: (duration: TimeMs) => void;
+    emitTrackDurationChange: (duration: TimeMs) => void;
+}
+export declare function calculateTrackTotalDuration(clips: Pick<Clip, 'startTime' | 'duration'>[]): TimeMs;
+export declare function calculateTimelineDuration(trackDuration: TimeMs): TimeMs;
+export declare function syncTrackDurationChange(options: SyncTrackDurationChangeOptions): TimeMs;
+export {};

package/dist/core/controllers/timelineEventDispatcher.d.ts

@@ -0,0 +1,12 @@
+import { TimelineEvent, EventListener as TimelineEventListener } from '../models/types';
+type InitialPayloadProvider = () => any;
+export declare class TimelineEventDispatcher {
+    private readonly initialPayloadProviders;
+    private listeners;
+    constructor(initialPayloadProviders?: Partial<Record<TimelineEvent, InitialPayloadProvider>>);
+    on(event: TimelineEvent, listener: TimelineEventListener): void;
+    off(event: TimelineEvent, listener: TimelineEventListener): void;
+    emit(event: TimelineEvent, data?: any): void;
+    clear(): void;
+}
+export {};

package/dist/core/controllers/timelinePlaybackResolver.d.ts

@@ -0,0 +1,17 @@
+import type { ActiveClipPlaybackInfo, Clip, TimeMs, TrackType } from '../models/types';
+export interface PlaybackTrackSnapshot {
+    id: string;
+    type: TrackType;
+    order: number;
+    isMuted?: boolean;
+    clips: Clip[];
+}
+export interface ResolvedPlaybackPlan {
+    activeClips: ActiveClipPlaybackInfo[];
+    nextClips: ActiveClipPlaybackInfo[];
+    firstVideoClip: ActiveClipPlaybackInfo | null;
+}
+export declare class TimelinePlaybackResolver {
+    resolveActiveClipsAtTime(tracks: PlaybackTrackSnapshot[], time: TimeMs): ActiveClipPlaybackInfo[];
+    resolvePlaybackPlan(tracks: PlaybackTrackSnapshot[], time: TimeMs): ResolvedPlaybackPlan;
+}

package/dist/core/controllers/timelinePreviewSession.d.ts

@@ -0,0 +1,94 @@
+import type { ActiveClipPlaybackInfo, ClipVisualTransform, PlayState, PreviewAspectRatio, TimeMs, TrackType } from '../models/types';
+import type { PreviewPendingState } from './previewBackend';
+interface TimelinePreviewSessionCallbacks {
+    onBufferingStateChange?: (isBuffering: boolean) => void;
+    onSourceLoadingChange?: (pending: number) => void;
+    onSyncProcessed?: (syncRequestId?: number) => void;
+    onAspectRatioChange?: (aspectRatio: PreviewAspectRatio) => void;
+    onVisualTransformCommit?: (clipId: string, visualTransform: ClipVisualTransform) => void;
+    onPendingPreviewRetry?: () => void;
+}
+interface TimelinePreviewSessionDependencies {
+    createMediaElement?: (kind: TrackType, role: 'current' | 'preload') => HTMLMediaElement;
+    createAspectRatioProbe?: () => HTMLVideoElement;
+    createAudioContext?: () => AudioContext | null;
+    rootClassName?: string;
+    frameClassName?: string;
+    slotClassNamePrefix?: string;
+}
+export interface TimelinePreviewSyncPayload {
+    activeClips: ActiveClipPlaybackInfo[];
+    nextClips: ActiveClipPlaybackInfo[];
+    firstVideoClip: ActiveClipPlaybackInfo | null;
+    autoAspectRatioClip: ActiveClipPlaybackInfo | null;
+    currentTime: TimeMs;
+    playState: PlayState;
+    speed: number;
+    selectedClipId?: string | null;
+    syncRequestId?: number;
+}
+export declare class TimelinePreviewSession {
+    private container;
+    private rootElement;
+    private frameElement;
+    private pendingOverlayElement;
+    private pendingOverlayStatusElement;
+    private pendingOverlayDetailElement;
+    private pendingOverlayActionElement;
+    private resizeObserver;
+    private readonly trackSlots;
+    private audioContext;
+    private masterGainNode;
+    private isBuffering;
+    private loadingCount;
+    private selectedClipId;
+    private transientVisualTransform;
+    private readonly callbacks;
+    private readonly dependencies;
+    private readonly transformOverlay;
+    private requestedAspectRatio;
+    private resolvedAutoAspectRatio;
+    private aspectRatioProbe;
+    private aspectRatioProbeSrc;
+    private isAspectRatioProbeLoading;
+    private pendingState;
+    constructor(callbacks?: TimelinePreviewSessionCallbacks, dependencies?: TimelinePreviewSessionDependencies);
+    hasPreview(): boolean;
+    attach(container: HTMLElement): void;
+    detach(): void;
+    setPendingState(state: PreviewPendingState | null): void;
+    sync(payload: TimelinePreviewSyncPayload): void;
+    applyAspectRatio(aspectRatio: PreviewAspectRatio): void;
+    getAspectRatio(): PreviewAspectRatio;
+    private createMediaElement;
+    private createSlot;
+    private destroySlot;
+    private getTrackSlots;
+    private swapTrackSlots;
+    private assignClipToSlot;
+    private configureAudioRouting;
+    private syncCurrentSlot;
+    private preparePreloadSlot;
+    private setSlotVisible;
+    private getAudioContext;
+    private getMasterGainNode;
+    private resumeAudioContext;
+    private updateFrameLayout;
+    private maybeResolveAutoAspectRatio;
+    private getAspectRatioProbe;
+    private tryResolveAutoAspectRatioFromSlot;
+    private handleResolvedAutoAspectRatio;
+    private refreshBufferingState;
+    private setBufferingState;
+    private refreshLoadingState;
+    private setLoadingCount;
+    private refreshPendingOverlay;
+    private handlePreviewTransformChange;
+    private refreshVisualLayout;
+    private refreshSlotVisualLayout;
+    private buildSelectedOverlayState;
+    private getFrameSize;
+    private getMediaSize;
+    private getEffectiveVisualTransform;
+}
+export {};

package/dist/core/controllers/timelineSelectionController.d.ts

@@ -0,0 +1,17 @@
+import type { Clip } from '../models/types';
+export interface SelectedClipSnapshot {
+    clip: Clip | null;
+    hasSelectedClip: boolean;
+}
+interface ResolveSelectedClipOptions {
+    getSelectedClip: () => Clip | null;
+    findFallbackSelectedClip?: () => Clip | null;
+}
+interface EmitSelectedClipChangeOptions {
+    lastSelectedClipId: string | null;
+    resolveSelectedClip: () => SelectedClipSnapshot;
+    emitSelectedClipChange: (payload: SelectedClipSnapshot) => void;
+}
+export declare function resolveSelectedClipSnapshot(options: ResolveSelectedClipOptions): SelectedClipSnapshot;
+export declare function emitSelectedClipChangeIfNeeded(options: EmitSelectedClipChangeOptions): string | null;
+export {};

package/dist/core/controllers/timelineTrackInfoPanelController.d.ts

@@ -0,0 +1,19 @@
+import { Theme, Track } from '../models';
+interface InitTrackInfoPanelOptions {
+    container: HTMLElement;
+    theme?: Theme;
+    timeScaleHeight?: number;
+    includeTimeScaleSpacer?: boolean;
+    onRenameTrack: (trackId: string, newName: string) => void;
+    onRemoveTrack: (trackId: string) => void;
+    onMuteTrack: (trackId: string, isMuted: boolean) => void;
+}
+export declare class TimelineTrackInfoPanelController {
+    private panel;
+    init(options: InitTrackInfoPanelOptions): void;
+    hasPanel(): boolean;
+    update(tracks: Track[]): void;
+    setScrollTop(scrollTop: number): void;
+    destroy(): void;
+}
+export {};

package/dist/core/controllers/timelineTrackMutationController.d.ts

@@ -0,0 +1,46 @@
+import type { MoveClipToTrackCommandResult, RemoveClipCommandResult, TrackPlacementCommandResult } from '../commands/timelineCommands';
+import type { Clip, TrackType } from '../models/types';
+import type { TimelineTrackCollection } from '../tracks/timelineTrackCollection';
+interface CreateTrackHandler {
+    (type: TrackType, name?: string): string;
+}
+interface ApplyClipPlacementOptions {
+    clip: Clip;
+    placement: TrackPlacementCommandResult;
+    trackCollection: TimelineTrackCollection;
+    createTrack: CreateTrackHandler;
+}
+interface ApplyPreparedClipMoveOptions {
+    command: Extract<MoveClipToTrackCommandResult, {
+        status: 'ready';
+    }>;
+    trackCollection: TimelineTrackCollection;
+}
+interface ApplyClipMoveToNewTrackOptions {
+    clip: Clip;
+    currentTrackId: string;
+    trackType: TrackType;
+    trackName?: string;
+    trackCollection: TimelineTrackCollection;
+    createTrack: CreateTrackHandler;
+}
+interface ClipMutationSideEffectHandlers {
+    checkTrackDurationChange?: () => void;
+    updateCanPlayState?: () => void;
+    updateTrackInfoPanel?: () => void;
+    handleClipChange?: () => void;
+}
+interface ClipMoveSideEffectHandlers {
+    notifySelectionChange: () => void;
+    updateTrackInfoPanel: () => void;
+    syncPreviewSession: () => void;
+    cleanupEmptyTracks?: () => void;
+    batchDraw?: () => void;
+}
+export declare function applyClipPlacement(options: ApplyClipPlacementOptions): boolean;
+export declare function applyClipRemoval(trackCollection: TimelineTrackCollection, command: RemoveClipCommandResult, clipId: string): boolean;
+export declare function applyPreparedClipMove(options: ApplyPreparedClipMoveOptions): boolean;
+export declare function applyClipMoveToNewTrack(options: ApplyClipMoveToNewTrackOptions): boolean;
+export declare function applyClipMutationSideEffects(handlers: ClipMutationSideEffectHandlers): void;
+export declare function applyClipMoveSideEffects(handlers: ClipMoveSideEffectHandlers): void;
+export {};