@elserlabs/timeline 0.0.2

package/dist/interfaces/canvas.d.ts

@@ -0,0 +1,21 @@
+import { FabricObject } from 'fabric';
+
+export interface IDropInfo {
+    isSecondaryOverlapped: boolean;
+    primaryPositions: {
+        trackIndex?: number;
+        trackId: string;
+        positions: Record<string, {
+            top: number;
+            left: number;
+        }>;
+    };
+    secondaryTracks: Record<string, {
+        objects: FabricObject[];
+        index: number;
+    }>;
+    primaryTracks: Record<string, {
+        objects: FabricObject[];
+        index: number;
+    }>;
+}

package/dist/mixins/canvas.d.ts

@@ -0,0 +1,17 @@
+import { FabricObject } from 'fabric';
+import { default as Timeline } from '../timeline';
+
+declare class CanvasMixin {
+    private ___eventListeners;
+    ___activeObjects: FabricObject[];
+    resize(this: Timeline, payload: {
+        width?: number;
+        height?: number;
+    }, { force }?: {
+        force?: boolean;
+    }): void;
+    pauseEventListeners(this: Timeline): void;
+    resumeEventListeners(this: Timeline): false | undefined;
+    updateCachingActiveObjects(this: Timeline, newObjects: FabricObject[]): void;
+}
+export default CanvasMixin;

package/dist/mixins/track-items.d.ts

@@ -0,0 +1,20 @@
+import { FabricObject } from 'fabric';
+import { default as Timeline } from '../timeline';
+import { ITrackItemAndDetails } from '@designcombo/types';
+
+declare class TrackItemsMixin {
+    addTrackItem(this: Timeline, trackItem: ITrackItemAndDetails): void;
+    alignItemsToTrack(this: Timeline): void;
+    updateTrackItemsToHistory(this: Timeline): void;
+    deleteTrackItemToHistory(this: Timeline, ids: string[]): void;
+    uodateTrackItemIdsOrdering(this: Timeline): void;
+    selectTrackItemByIds(this: Timeline, trackItemIds: string[]): void;
+    synchronizeTrackItemsState(this: Timeline): void;
+    deleteTrackItemById(this: Timeline, ids: string[]): void;
+    deleteActiveTrackItem(this: Timeline): false | undefined;
+    updateTrackItemCoords(this: Timeline, updateActiveObject?: boolean): void;
+    getTrackItems(this: Timeline): FabricObject<Partial<import('fabric').FabricObjectProps>, import('fabric').SerializedObjectProps, import('fabric').ObjectEvents>[];
+    setTrackItemCoords(this: Timeline): void;
+    setActiveTrackItemCoords(this: Timeline): void;
+}
+export default TrackItemsMixin;

package/dist/mixins/tracks.d.ts

@@ -0,0 +1,15 @@
+import { default as Timeline } from '../timeline';
+import { ITrackItem } from '@designcombo/types';
+
+declare class TracksMixin {
+    findOrCreateTrack(this: Timeline, trackItemData: ITrackItem, { trackId, trackIndex }: {
+        trackId?: string;
+        trackIndex?: number;
+    }): string;
+    removeTracks(this: Timeline): void;
+    renderTracks(this: Timeline): void;
+    filterEmptyTracks(this: Timeline): void;
+    refreshTrackLayout(this: Timeline): void;
+    adjustMagneticTrack(this: Timeline): void;
+}
+export default TracksMixin;

package/dist/mixins/transitions.d.ts

@@ -0,0 +1,10 @@
+import { default as Timeline } from '../timeline';
+
+declare class TransitionsMixin {
+    removeTransitions(this: Timeline): void;
+    renderTransitions(this: Timeline): void;
+    updateTrackTransitionsItemCoords(this: Timeline): void;
+    alignTransitionsToTrack(this: Timeline, alignActiveObjects?: boolean): void;
+    updateTransitions(this: Timeline, handleListeners?: boolean): void;
+}
+export default TransitionsMixin;

package/dist/objects/drag-track-item.d.ts

@@ -0,0 +1,33 @@
+import { Rect, RectProps } from 'fabric';
+
+export interface PreviewTrackItemProps extends Pick<RectProps, "width" | "height" | "top" | "left"> {
+    id: string;
+    type: string;
+    duration: number;
+}
+declare class PreviewTrackItem extends Rect {
+    static type: string;
+    duration: number;
+    fromId: string;
+    toId: string;
+    isSelected: boolean;
+    name: string;
+    durationString: string;
+    itemType: string;
+    static getDefaults(): Record<string, any>;
+    static ownDefaults: {
+        objectCaching: boolean;
+        borderColor: string;
+        stroke: string;
+        strokeWidth: number;
+        borderOpacityWhenMoving: number;
+        hoverCursor: string;
+        rx: number;
+        ry: number;
+    };
+    constructor(props: PreviewTrackItemProps);
+    _render(ctx: CanvasRenderingContext2D): void;
+    drawTextIdentity(ctx: CanvasRenderingContext2D): void;
+    private drawRoundedRect;
+}
+export default PreviewTrackItem;

package/dist/objects/helper.d.ts

@@ -0,0 +1,29 @@
+import { Group, GroupProps, Rect } from 'fabric';
+import { IMetadata, ItemType } from '@designcombo/types';
+
+export interface HelperProps extends Partial<GroupProps> {
+    id: string;
+    metadata: Partial<IMetadata>;
+    tScale: number;
+    kind: "top" | "center" | "bottom";
+    activeGuideFill?: string;
+}
+declare class Helper extends Group {
+    static type: string;
+    guide: Rect;
+    topGuide: Rect;
+    bottomGuide: Rect;
+    metadata: Partial<IMetadata>;
+    accepts: ItemType[];
+    kind: string;
+    activeGuideFill?: string;
+    static getDefaults(): Record<string, any>;
+    static ownDefaults: {
+        selectable: boolean;
+        evented: boolean;
+    };
+    constructor(props: HelperProps);
+    updateCoords(size: number): void;
+    setSelected(selected: boolean): void;
+}
+export default Helper;

package/dist/objects/index.d.ts

@@ -0,0 +1,7 @@
+export { default as Track, type TrackItemProps } from './track';
+export { default as Helper, type HelperProps } from './helper';
+export { default as Placeholder } from './placeholder';
+export { default as Transition } from './transition';
+export { default as Trimmable, type TrimmableProps } from './trimmable';
+export { default as Resizable, type ResizableProps } from './resizable';
+export { default as PreviewTrackItem, type PreviewTrackItemProps } from './drag-track-item';

package/dist/objects/placeholder.d.ts

@@ -0,0 +1,36 @@
+import { FabricObject, Rect, RectProps } from 'fabric';
+import { ItemType } from '@designcombo/types';
+
+interface PlaceholderProps extends Pick<RectProps, "width" | "height" | "top" | "left"> {
+    id: string;
+}
+declare class Placeholder extends Rect {
+    static type: string;
+    guideItemId?: string;
+    distXToActCenter?: number;
+    trackItemType?: ItemType;
+    defaultPos?: {
+        x: number;
+        y: number;
+    };
+    draggedObject: FabricObject;
+    static getDefaults(): Record<string, any>;
+    static ownDefaults: {
+        rx: number;
+        ry: number;
+        objectCaching: boolean;
+        borderColor: string;
+        strokeWidth: number;
+        fill: string;
+        stroke: string;
+        selectable: boolean;
+        borderOpacityWhenMoving: number;
+        hoverCursor: string;
+        strokeDashArray: number[];
+        evented: boolean;
+    };
+    constructor(props: PlaceholderProps);
+    _render(ctx: CanvasRenderingContext2D): void;
+    updateSelected(ctx: CanvasRenderingContext2D): void;
+}
+export default Placeholder;

package/dist/objects/resizable.d.ts

@@ -0,0 +1,36 @@
+import { Control, Rect, RectProps } from 'fabric';
+import { IDisplay } from '@designcombo/types';
+
+export interface ResizableBaseProps extends Pick<RectProps, "width" | "height" | "top" | "left"> {
+    id: string;
+    tScale: number;
+    display: IDisplay;
+}
+export type ResizableProps<T extends object = {}> = ResizableBaseProps & T;
+declare class Resizable extends Rect {
+    static type: string;
+    id: string;
+    isSelected: boolean;
+    tScale: number;
+    display: IDisplay;
+    static createControls(): {
+        controls: Record<string, Control>;
+    };
+    static getDefaults(): Record<string, any>;
+    static ownDefaults: {
+        rx: number;
+        ry: number;
+        objectCaching: boolean;
+        borderColor: string;
+        stroke: string;
+        strokeWidth: number;
+        fill: string;
+        borderOpacityWhenMoving: number;
+        hoverCursor: string;
+    };
+    constructor(props: ResizableProps);
+    setSelected(selected: boolean): void;
+    _render(ctx: CanvasRenderingContext2D): void;
+    updateSelected(ctx: CanvasRenderingContext2D): void;
+}
+export default Resizable;

package/dist/objects/track.d.ts

@@ -0,0 +1,28 @@
+import { Rect } from 'fabric';
+import { IMetadata } from '@designcombo/types';
+
+export interface TrackItemProps extends Pick<Rect, "top" | "left" | "width" | "height"> {
+    id: string;
+    top: number;
+    left: number;
+    tScale: number;
+    accepts: string[];
+    items: string[];
+    magnetic?: boolean;
+    static?: boolean;
+    metadata?: Partial<IMetadata>;
+}
+declare class Track extends Rect {
+    static ownDefaults: Partial<Rect<Partial<import('fabric').RectProps>, import('fabric').SerializedRectProps, import('fabric').ObjectEvents>>;
+    static type: string;
+    id: string;
+    accepts: string[];
+    metadata?: Partial<IMetadata>;
+    items: string[];
+    magnetic?: boolean;
+    static?: boolean;
+    static getDefaults(): Record<string, any>;
+    constructor(props: TrackItemProps);
+    updateCoords(size: number): void;
+}
+export default Track;

package/dist/objects/transition-guide.d.ts

@@ -0,0 +1,38 @@
+import { Control, Rect, RectProps } from 'fabric';
+
+interface TransitionGuideProps extends Pick<RectProps, "width" | "height" | "top" | "left"> {
+    id: string;
+}
+declare class TransitionGuide extends Rect {
+    static type: string;
+    duration: number;
+    fromId: string;
+    toId: string;
+    itemType: string;
+    isSelected: boolean;
+    static createControls(): {
+        controls: Record<string, Control>;
+    };
+    static getDefaults(): Record<string, any>;
+    static ownDefaults: {
+        objectCaching: boolean;
+        borderColor: string;
+        stroke: string;
+        strokeWidth: number;
+        fill: string;
+        borderOpacityWhenMoving: number;
+        hoverCursor: string;
+        lockMovementX: boolean;
+        lockMovementY: boolean;
+        duration: number;
+        rx: number;
+        ry: number;
+    };
+    constructor(props: TransitionGuideProps);
+    updateCoords(): void;
+    _render(ctx: CanvasRenderingContext2D): void;
+    drawTextIdentity(ctx: CanvasRenderingContext2D): void;
+    setSelected(selected: boolean): void;
+    updateSelected(ctx: CanvasRenderingContext2D): void;
+}
+export default TransitionGuide;

package/dist/objects/transition.d.ts

@@ -0,0 +1,44 @@
+import { Control, Rect, RectProps } from 'fabric';
+
+interface TransitionProps extends Pick<RectProps, "width" | "height" | "top" | "left"> {
+    id: string;
+    tScale: number;
+    duration: number;
+    fromId: string;
+    toId: string;
+    kind: string;
+    strokeDashArray?: number[];
+}
+declare class Transition extends Rect {
+    static type: string;
+    duration: number;
+    fromId: string;
+    toId: string;
+    kind: string;
+    isSelected: boolean;
+    availableDrop: boolean;
+    static createControls(): {
+        controls: Record<string, Control>;
+    };
+    static getDefaults(): Record<string, any>;
+    static ownDefaults: {
+        objectCaching: boolean;
+        borderColor: string;
+        stroke: string;
+        strokeWidth: number;
+        fill: string;
+        borderOpacityWhenMoving: number;
+        hoverCursor: string;
+        lockMovementX: boolean;
+        lockMovementY: boolean;
+        duration: number;
+        rx: number;
+        ry: number;
+    };
+    constructor(props: TransitionProps);
+    updateCoords(): void;
+    _render(ctx: CanvasRenderingContext2D): void;
+    setSelected(selected: boolean): void;
+    updateSelected(ctx: CanvasRenderingContext2D): void;
+}
+export default Transition;

package/dist/objects/trimmable.d.ts

@@ -0,0 +1,46 @@
+import { Control, Rect, RectProps } from 'fabric';
+import { ITrim } from '@designcombo/types';
+
+interface IDisplay {
+    from: number;
+    to: number;
+}
+export interface TrimmableBaseProps extends Pick<RectProps, "width" | "height" | "top" | "left"> {
+    id: string;
+    tScale: number;
+    display: IDisplay;
+    trim: ITrim;
+}
+export type TrimmableProps<T extends object = {}> = TrimmableBaseProps & T;
+declare class Trimmable extends Rect {
+    static type: string;
+    id: string;
+    resourceId: string;
+    tScale: number;
+    isSelected: boolean;
+    display: IDisplay;
+    trim: ITrim;
+    duration: number;
+    src: string;
+    static createControls(): {
+        controls: Record<string, Control>;
+    };
+    static ownDefaults: {
+        rx: number;
+        ry: number;
+        objectCaching: boolean;
+        borderColor: string;
+        stroke: string;
+        strokeWidth: number;
+        fill: string;
+        borderOpacityWhenMoving: number;
+        hoverCursor: string;
+    };
+    constructor(options: TrimmableProps);
+    _render(ctx: CanvasRenderingContext2D): void;
+    setSelected(selected: boolean): void;
+    updateSelected(ctx: CanvasRenderingContext2D): void;
+    onResizeSnap(): void;
+    setSrc(src: string): void;
+}
+export default Trimmable;

package/dist/resize/audio.d.ts

@@ -0,0 +1,13 @@
+import { TransformActionHandler } from 'fabric';
+
+/**
+ * Action handler to change object's width
+ * Needs to be wrapped with `wrapWithFixedAnchor` to be effective
+ * @param {Event} eventData javascript event that is doing the transform
+ * @param {Object} transform javascript object containing a series of information around the current transform
+ * @param {number} x current mouse x position, canvas normalized
+ * @param {number} y current mouse y position, canvas normalized
+ * @return {Boolean} true if some change happened
+ */
+export declare const changeAudioWidth: TransformActionHandler;
+export declare const resizeAudio: TransformActionHandler<import('fabric').Transform>;

package/dist/resize/common.d.ts

@@ -0,0 +1,13 @@
+import { TransformActionHandler } from 'fabric';
+
+/**
+ * Action handler to change object's width
+ * Needs to be wrapped with `wrapWithFixedAnchor` to be effective
+ * @param {Event} eventData javascript event that is doing the transform
+ * @param {Object} transform javascript object containing a series of information around the current transform
+ * @param {number} x current mouse x position, canvas normalized
+ * @param {number} y current mouse y position, canvas normalized
+ * @return {Boolean} true if some change happened
+ */
+export declare const changeObjectWidth: TransformActionHandler;
+export declare const changeWidth: TransformActionHandler<import('fabric').Transform>;

package/dist/resize/index.d.ts

@@ -0,0 +1 @@
+export * from './resize';

package/dist/resize/media.d.ts

@@ -0,0 +1,13 @@
+import { TransformActionHandler } from 'fabric';
+
+/**
+ * Action handler to change object's width
+ * Needs to be wrapped with `wrapWithFixedAnchor` to be effective
+ * @param {Event} eventData javascript event that is doing the transform
+ * @param {Object} transform javascript object containing a series of information around the current transform
+ * @param {number} x current mouse x position, canvas normalized
+ * @param {number} y current mouse y position, canvas normalized
+ * @return {Boolean} true if some change happened
+ */
+export declare const changeVideoWidth: TransformActionHandler;
+export declare const resizeMedia: TransformActionHandler<import('fabric').Transform>;

package/dist/resize/resize.d.ts

@@ -0,0 +1,6 @@
+export declare const resize: {
+    audio: import('fabric').TransformActionHandler<import('fabric').Transform>;
+    media: import('fabric').TransformActionHandler<import('fabric').Transform>;
+    common: import('fabric').TransformActionHandler<import('fabric').Transform>;
+    transition: import('fabric').TransformActionHandler<import('fabric').Transform>;
+};

package/dist/resize/template.d.ts

@@ -0,0 +1,13 @@
+import { TransformActionHandler } from 'fabric';
+
+/**
+ * Action handler to change object's width
+ * Needs to be wrapped with `wrapWithFixedAnchor` to be effective
+ * @param {Event} eventData javascript event that is doing the transform
+ * @param {Object} transform javascript object containing a series of information around the current transform
+ * @param {number} x current mouse x position, canvas normalized
+ * @param {number} y current mouse y position, canvas normalized
+ * @return {Boolean} true if some change happened
+ */
+export declare const changeTemplateWidth: TransformActionHandler;
+export declare const resizeTemplate: TransformActionHandler<import('fabric').Transform>;

package/dist/resize/transition.d.ts

@@ -0,0 +1,4 @@
+import { TransformActionHandler } from 'fabric';
+
+export declare const changeTransitionWidth: TransformActionHandler;
+export declare const resizeTransitionWidth: TransformActionHandler<import('fabric').Transform>;

package/dist/scrollbar/index.d.ts

@@ -0,0 +1,57 @@
+import { TMat2D, TPointerEvent } from 'fabric';
+import { default as Timeline } from '../timeline';
+import { ScrollbarProps, ScrollbarsProps, ScrollbarXProps, ScrollbarYProps } from './types';
+
+export declare class Scrollbars {
+    canvas: Timeline;
+    fill: string;
+    stroke: string;
+    lineWidth: number;
+    hideX: boolean;
+    hideY: boolean;
+    scrollbarMinWidth: number;
+    scrollbarSize: number;
+    scrollSpace: number;
+    padding: number;
+    extraMarginX: number;
+    extraMarginY: number;
+    offsetX: number;
+    offsetY: number;
+    scrollbarWidth: number;
+    scrollbarColor: string;
+    onViewportChange?: (left: number) => void;
+    private _bar?;
+    private _barViewport;
+    private _originalMouseDown;
+    private _originalMouseMove;
+    private _originalMouseUp;
+    constructor(canvas: Timeline, props?: ScrollbarsProps);
+    initBehavior(): void;
+    getScrollbar(e: TPointerEvent): {
+        type: string;
+        start: number;
+        vpt: TMat2D;
+    } | undefined;
+    mouseDownHandler(e: TPointerEvent): void;
+    mouseMoveHandler(e: TPointerEvent): void;
+    mouseUpHandler(e: TPointerEvent): void;
+    beforeRenderHandler(): void;
+    afterRenderHandler(): void;
+    render(ctx: CanvasRenderingContext2D, mapRect: ScrollbarProps, objectRect: ScrollbarProps): void;
+    drawScrollbarX(ctx: CanvasRenderingContext2D, mapRect: ScrollbarXProps, objectRect: ScrollbarXProps): void;
+    drawScrollbarY(ctx: CanvasRenderingContext2D, mapRect: ScrollbarYProps, objectRect: ScrollbarYProps): void;
+    drawRect(ctx: CanvasRenderingContext2D, props: {
+        x: number;
+        y: number;
+        w: number;
+        h: number;
+    }): void;
+    getObjectsBoundingRect(): {
+        left: number;
+        top: number;
+        right: number;
+        bottom: number;
+    };
+    applyViewportLimits(vpt: TMat2D): void;
+    dispose(): void;
+}

package/dist/scrollbar/types.d.ts

@@ -0,0 +1,26 @@
+export type ScrollbarsProps = {
+    fill?: string;
+    stroke?: string;
+    lineWidth?: number;
+    hideX?: boolean;
+    hideY?: boolean;
+    scrollbarMinWidth?: number;
+    scrollbarSize?: number;
+    scrollSpace?: number;
+    padding?: number;
+    extraMarginX?: number;
+    extraMarginY?: number;
+    offsetX?: number;
+    offsetY?: number;
+    scrollbarWidth?: number;
+    scrollbarColor?: string;
+    onViewportChange?: (left: number) => void;
+};
+export type ScrollbarProps = {
+    left: number;
+    top: number;
+    right: number;
+    bottom: number;
+};
+export type ScrollbarXProps = Pick<ScrollbarProps, "left" | "right">;
+export type ScrollbarYProps = Pick<ScrollbarProps, "top" | "bottom">;

package/dist/scrollbar/util.d.ts

@@ -0,0 +1,15 @@
+import { TPointerEventInfo } from 'fabric';
+import { default as Timeline } from '../timeline';
+
+type SizeProps = {
+    min: number;
+    max: number;
+};
+type MouseWheelOptions = {
+    offsetX?: number;
+    offsetY?: number;
+    extraMarginX?: number;
+    extraMarginY?: number;
+} & Partial<SizeProps>;
+export declare const makeMouseWheel: (canvas: Timeline, options?: MouseWheelOptions) => (wheelEvent: TPointerEventInfo<WheelEvent>) => void;
+export {};