@video-editor/ui 0.0.1-beta.10

package/README.md

@@ -0,0 +1,3 @@
+# @video-editor/ui
+
+video editor UI package

package/dist/VideoEditorTimeline.d.ts

@@ -0,0 +1,131 @@
+import { ComponentOptionsMixin } from 'vue';
+import { ComponentProvideOptions } from 'vue';
+import { DefineComponent } from 'vue';
+import { ITrackType } from '@video-editor/shared';
+import { IVideoProtocol } from '@video-editor/shared';
+import { PublicProps } from 'vue';
+import { SegmentUnion } from '@video-editor/shared';
+import { TimelineTick } from '..';
+import { TrackUnion } from '@video-editor/shared';
+
+declare const __VLS_component: DefineComponent<__VLS_Props, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {} & {
+"update:currentTime": (value: number) => any;
+"update:zoom": (value: number) => any;
+segmentClick: (payload: {
+segment: SegmentUnion;
+track: TrackUnion;
+}) => any;
+segmentDragEnd: (payload: SegmentDragPayload) => any;
+segmentResizeEnd: (payload: SegmentResizePayload) => any;
+"update:selectedSegmentId": (value: string | null) => any;
+}, string, PublicProps, Readonly<__VLS_Props> & Readonly<{
+"onUpdate:currentTime"?: ((value: number) => any) | undefined;
+"onUpdate:zoom"?: ((value: number) => any) | undefined;
+onSegmentClick?: ((payload: {
+segment: SegmentUnion;
+track: TrackUnion;
+}) => any) | undefined;
+onSegmentDragEnd?: ((payload: SegmentDragPayload) => any) | undefined;
+onSegmentResizeEnd?: ((payload: SegmentResizePayload) => any) | undefined;
+"onUpdate:selectedSegmentId"?: ((value: string | null) => any) | undefined;
+}>, {
+disableInteraction: boolean;
+snapStep: number;
+selectedSegmentId: string | null;
+protocol: IVideoProtocol | null;
+trackTypes: ITrackType[];
+}, {}, {}, {}, string, ComponentProvideOptions, false, {}, HTMLDivElement>;
+
+declare type __VLS_Props = {
+    protocol?: IVideoProtocol | null;
+    currentTime: number;
+    zoom?: number;
+    snapStep?: number;
+    selectedSegmentId?: string | null;
+    trackTypes?: ITrackType[];
+    disableInteraction?: boolean;
+};
+
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        toolbar?(_: {
+            zoom: number;
+            canZoomIn: boolean;
+            canZoomOut: boolean;
+            zoomIn: () => void;
+            zoomOut: () => void;
+            currentTime: number;
+            duration: number;
+            formatTime: (ms: number) => string;
+        }): any;
+        ruler?(_: {
+            ticks: TimelineTick[];
+            pixelsPerMs: number;
+        }): any;
+        playhead?(_: {
+            left: number;
+            currentTime: number;
+        }): any;
+    };
+    refs: {};
+    rootEl: HTMLDivElement;
+};
+
+declare type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+
+declare type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};
+
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+
+declare interface SegmentDragPayload {
+    segment: TimelineSegment;
+    track: TimelineTrack;
+    trackIndex: number;
+    segmentIndex: number;
+    startTime: number;
+    endTime: number;
+    targetTrackIndex: number;
+    targetTrackId: string;
+    isNewTrack: boolean;
+    newTrackInsertIndex?: number;
+    visualTrackIndex: number;
+    isValidTarget: boolean;
+    mouseDeltaY: number;
+}
+
+declare interface SegmentResizePayload {
+    segment: TimelineSegment;
+    track: TimelineTrack;
+    trackIndex: number;
+    segmentIndex: number;
+    startTime: number;
+    endTime: number;
+    edge: 'start' | 'end';
+}
+
+declare interface TimelineSegment {
+    id: string;
+    start: number;
+    end: number;
+    type?: string;
+    color?: string;
+    payload?: unknown;
+}
+
+declare interface TimelineTrack {
+    id: string;
+    label?: string;
+    type?: string;
+    color?: string;
+    isMain?: boolean;
+    payload?: unknown;
+    segments: TimelineSegment[];
+}
+
+export { }

package/dist/VideoEditorTimeline.js

@@ -0,0 +1,270 @@
+import { defineComponent as V, reactive as J, watch as P, onBeforeUnmount as Y, createElementBlock as l, openBlock as r, createCommentVNode as x, normalizeStyle as L, Fragment as v, renderList as j, createElementVNode as y, toDisplayString as h, computed as S, ref as q, createBlock as E, createSlots as G, withCtx as _, unref as w, renderSlot as C, normalizeProps as M, guardReactiveProps as U } from "vue";
+import { _ as D, V as K } from "./index-CIZtI1B_.js";
+import { generateThumbnails as Q } from "@video-editor/protocol";
+import { isVideoFramesSegment as W } from "@video-editor/shared";
+const X = { class: "frames-segment" }, Z = {
+  key: 0,
+  class: "frames-segment__video"
+}, ee = {
+  key: 1,
+  class: "frames-segment__placeholder"
+}, te = { key: 0 }, ne = { key: 1 }, se = { key: 2 }, re = {
+  key: 2,
+  class: "frames-segment__placeholder"
+}, ae = {
+  key: 3,
+  class: "frames-segment__badge"
+}, oe = /* @__PURE__ */ V({
+  name: "FramesSegment",
+  __name: "FramesSegment",
+  props: {
+    segment: {}
+  },
+  setup(o) {
+    const g = o, n = J({ items: [], loading: !1, error: null });
+    let c = 0;
+    P(() => g.segment, (s, i) => {
+      if (!W(s))
+        return;
+      (!i || f(i, s)) && $(s);
+    }, { immediate: !0, deep: !0 }), Y(() => {
+      b();
+    });
+    function f(s, i) {
+      return s.url !== i.url || s.startTime !== i.startTime || s.endTime !== i.endTime || s.fromTime !== i.fromTime;
+    }
+    async function $(s) {
+      if (!s.url)
+        return;
+      const i = ++c;
+      b(), n.loading = !0, n.error = null;
+      try {
+        const m = I(s), u = await Q(s.url, m);
+        if (c !== i)
+          return;
+        const T = u.map((k) => ({
+          tsMs: Math.round(k.ts / 1e3),
+          url: URL.createObjectURL(k.img)
+        }));
+        n.items = T, n.loading = !1;
+      } catch (m) {
+        if (c !== i)
+          return;
+        n.error = m instanceof Error ? m.message : String(m), n.loading = !1;
+      }
+    }
+    function I(s) {
+      const i = Math.max(s.fromTime ?? 0, 0) * 1e3, m = Math.max(s.endTime - s.startTime, 1), u = i + m * 1e3, k = Math.max(Math.floor((u - i) / 8), 2e5);
+      return { start: i, end: u, step: k };
+    }
+    function b() {
+      n.items.forEach((s) => URL.revokeObjectURL(s.url)), n.items = [];
+    }
+    function R() {
+      return {
+        backgroundImage: g.segment.url ? `url(${g.segment.url})` : "",
+        backgroundRepeat: "repeat-x",
+        backgroundSize: "56px 56px",
+        backgroundPosition: "left center"
+      };
+    }
+    return (s, i) => (r(), l("div", X, [
+      o.segment.type === "image" ? (r(), l("div", {
+        key: 0,
+        class: "frames-segment__image",
+        style: L(R())
+      }, null, 4)) : o.segment.type === "video" ? (r(), l(v, { key: 1 }, [
+        n.items.length ? (r(), l("div", Z, [
+          (r(!0), l(v, null, j(n.items, (m) => (r(), l("div", {
+            key: `${o.segment.id}-${m.tsMs}`,
+            class: "frames-segment__thumb",
+            style: L({ backgroundImage: `url(${m.url})` })
+          }, null, 4))), 128))
+        ])) : (r(), l("div", ee, [
+          n.loading ? (r(), l("span", te, "抽帧中…")) : n.error ? (r(), l("span", ne, "生成失败")) : (r(), l("span", se, "未生成缩略图"))
+        ]))
+      ], 64)) : (r(), l("div", re, [
+        y("span", null, h(o.segment.type), 1)
+      ])),
+      o.segment.extra?.label ? (r(), l("span", ae, h(o.segment.extra?.label), 1)) : x("", !0)
+    ]));
+  }
+}), ie = /* @__PURE__ */ D(oe, [["__scopeId", "data-v-dd7a5d19"]]), le = { class: "segment-base" }, ce = { class: "segment-base__content" }, me = { class: "segment-base__pill segment-base__pill--primary" }, de = { class: "segment-base__pill segment-base__pill--muted" }, ue = {
+  key: 0,
+  class: "segment-base__badge"
+}, ge = /* @__PURE__ */ V({
+  name: "SegmentBase",
+  __name: "SegmentBase",
+  props: {
+    segment: {},
+    trackType: {},
+    accentColor: { default: "#222226" }
+  },
+  setup(o) {
+    const g = o, n = S(() => {
+      const c = g.segment?.extra?.label;
+      return typeof c == "string" ? c : null;
+    });
+    return (c, f) => (r(), l("div", le, [
+      y("div", ce, [
+        y("span", me, h(o.trackType), 1),
+        y("span", de, h(o.segment.segmentType), 1)
+      ]),
+      n.value ? (r(), l("span", ue, h(n.value), 1)) : x("", !0)
+    ]));
+  }
+}), pe = /* @__PURE__ */ D(ge, [["__scopeId", "data-v-d386af72"]]), fe = { class: "ve-editor-segment__preview" }, B = "#222226", ke = 0.4, ye = /* @__PURE__ */ V({
+  name: "VideoEditorTimeline",
+  __name: "index",
+  props: {
+    protocol: { default: null },
+    currentTime: {},
+    zoom: {},
+    snapStep: { default: 0 },
+    selectedSegmentId: { default: null },
+    trackTypes: { default: void 0 },
+    disableInteraction: { type: Boolean, default: !1 }
+  },
+  emits: ["update:currentTime", "update:zoom", "update:selectedSegmentId", "segmentClick", "segmentDragEnd", "segmentResizeEnd"],
+  setup(o, { emit: g }) {
+    const n = o, c = g, f = q(n.selectedSegmentId ?? null);
+    P(() => n.selectedSegmentId, (e) => {
+      f.value = e ?? null;
+    });
+    const $ = {
+      frames: B,
+      audio: "#0ea5e9",
+      text: "#16a34a",
+      sticker: "#f97316",
+      effect: "#a855f7",
+      filter: "#64748b"
+    }, I = S(() => n.protocol?.tracks?.length ? n.trackTypes?.length ? n.protocol.tracks.filter((e) => n.trackTypes?.includes(e.trackType)) : n.protocol.tracks : []), b = S(() => I.value.map((e, a) => {
+      const t = $[e.trackType] || B, d = s(t, ke), z = e.trackType === "frames" && e.isMain === !0;
+      return {
+        id: e.trackId || `${e.trackType}-${a}`,
+        label: e.trackType,
+        type: e.trackType,
+        color: t,
+        isMain: z,
+        payload: e,
+        segments: e.children.map((p) => ({
+          id: p.id,
+          start: p.startTime,
+          end: p.endTime,
+          type: p.segmentType,
+          color: d,
+          payload: p
+        }))
+      };
+    })), R = S(() => {
+      if (!n.protocol?.tracks?.length)
+        return 0;
+      const e = n.protocol.tracks.flatMap((a) => a.children.map((t) => t.endTime));
+      return e.length ? Math.max(...e) : 0;
+    });
+    function s(e, a) {
+      const t = e.replace("#", "");
+      if (!(t.length === 3 || t.length === 6))
+        return e;
+      const d = t.length === 3 ? t.split("").map((F) => F + F).join("") : t, z = Number.parseInt(d.slice(0, 2), 16), p = Number.parseInt(d.slice(2, 4), 16), H = Number.parseInt(d.slice(4, 6), 16);
+      return `rgba(${z}, ${p}, ${H}, ${a})`;
+    }
+    function i(e) {
+      return e && typeof e == "object" && "segmentType" in e ? e : null;
+    }
+    function m(e) {
+      const a = e.payload;
+      if (a)
+        return a;
+      if (n.protocol)
+        return n.protocol.tracks.find((t) => t.trackId === e.id);
+    }
+    function u(e) {
+      f.value = e, c("update:selectedSegmentId", e);
+    }
+    function T(e) {
+      const a = i(e.segment.payload), t = m(e.track);
+      a && (u(a.id), t && c("segmentClick", { segment: a, track: t }));
+    }
+    function k(e) {
+      u(e.segment.id);
+    }
+    function A(e) {
+      c("segmentDragEnd", e);
+    }
+    function N(e) {
+      u(e.segment.id);
+    }
+    function O(e) {
+      c("segmentResizeEnd", e);
+    }
+    return (e, a) => (r(), E(K, {
+      tracks: b.value,
+      duration: R.value,
+      "current-time": o.currentTime,
+      zoom: o.zoom,
+      fps: o.protocol?.fps || 30,
+      "snap-step": o.snapStep,
+      "selected-segment-id": f.value ?? null,
+      "disable-interaction": o.disableInteraction,
+      "onUpdate:currentTime": a[0] || (a[0] = (t) => c("update:currentTime", t)),
+      "onUpdate:zoom": a[1] || (a[1] = (t) => c("update:zoom", t)),
+      onSegmentClick: T,
+      onSegmentDragStart: k,
+      onSegmentDragEnd: A,
+      onSegmentResizeStart: N,
+      onSegmentResizeEnd: O,
+      onBackgroundClick: a[2] || (a[2] = (t) => u(null))
+    }, G({
+      segment: _(({ layout: t }) => [
+        (r(!0), l(v, null, j([i(t.segment.payload)], (d) => (r(), l(v, {
+          key: d?.id || t.segment.id
+        }, [
+          d ? (r(), l("div", {
+            key: 0,
+            class: "ve-editor-segment",
+            style: L({ "--ve-segment-accent": t.track.color || B })
+          }, [
+            y("div", fe, [
+              d.segmentType === "frames" ? (r(), E(w(ie), {
+                key: 0,
+                segment: d
+              }, null, 8, ["segment"])) : (r(), E(w(pe), {
+                key: 1,
+                segment: d,
+                "track-type": t.track.type || "unknown",
+                "accent-color": t.track.color
+              }, null, 8, ["segment", "track-type", "accent-color"]))
+            ])
+          ], 4)) : x("", !0)
+        ], 64))), 128))
+      ]),
+      _: 2
+    }, [
+      e.$slots.toolbar ? {
+        name: "toolbar",
+        fn: _((t) => [
+          C(e.$slots, "toolbar", M(U(t)), void 0, !0)
+        ]),
+        key: "0"
+      } : void 0,
+      e.$slots.ruler ? {
+        name: "ruler",
+        fn: _((t) => [
+          C(e.$slots, "ruler", M(U(t)), void 0, !0)
+        ]),
+        key: "1"
+      } : void 0,
+      e.$slots.playhead ? {
+        name: "playhead",
+        fn: _((t) => [
+          C(e.$slots, "playhead", M(U(t)), void 0, !0)
+        ]),
+        key: "2"
+      } : void 0
+    ]), 1032, ["tracks", "duration", "current-time", "zoom", "fps", "snap-step", "selected-segment-id", "disable-interaction"]));
+  }
+}), Se = /* @__PURE__ */ D(ye, [["__scopeId", "data-v-d5455177"]]);
+export {
+  Se as default
+};

package/dist/VideoTimeline.d.ts

@@ -0,0 +1,200 @@
+import { ComponentOptionsMixin } from 'vue';
+import { ComponentProvideOptions } from 'vue';
+import { DefineComponent } from 'vue';
+import { PublicProps } from 'vue';
+import { TimelineSegment as TimelineSegment_2 } from './types';
+
+declare const __VLS_component: DefineComponent<__VLS_Props, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {} & {
+"update:currentTime": (value: number) => any;
+"update:zoom": (value: number) => any;
+segmentClick: (layout: SegmentLayout, event: MouseEvent) => any;
+segmentDragStart: (payload: SegmentDragPayload) => any;
+segmentDrag: (payload: SegmentDragPayload) => any;
+segmentDragEnd: (payload: SegmentDragPayload) => any;
+segmentResizeStart: (payload: SegmentResizePayload) => any;
+segmentResize: (payload: SegmentResizePayload) => any;
+segmentResizeEnd: (payload: SegmentResizePayload) => any;
+backgroundClick: (event: MouseEvent) => any;
+}, string, PublicProps, Readonly<__VLS_Props> & Readonly<{
+"onUpdate:currentTime"?: ((value: number) => any) | undefined;
+"onUpdate:zoom"?: ((value: number) => any) | undefined;
+onSegmentClick?: ((layout: SegmentLayout, event: MouseEvent) => any) | undefined;
+onSegmentDragStart?: ((payload: SegmentDragPayload) => any) | undefined;
+onSegmentDrag?: ((payload: SegmentDragPayload) => any) | undefined;
+onSegmentDragEnd?: ((payload: SegmentDragPayload) => any) | undefined;
+onSegmentResizeStart?: ((payload: SegmentResizePayload) => any) | undefined;
+onSegmentResize?: ((payload: SegmentResizePayload) => any) | undefined;
+onSegmentResizeEnd?: ((payload: SegmentResizePayload) => any) | undefined;
+onBackgroundClick?: ((event: MouseEvent) => any) | undefined;
+}>, {
+minZoom: number;
+maxZoom: number;
+disableInteraction: boolean;
+snapStep: number;
+trackHeight: number;
+trackGap: number;
+rulerHeight: number;
+minSegmentDuration: number;
+selectedSegmentId: string | null;
+fps: number;
+}, {}, {}, {}, string, ComponentProvideOptions, false, {
+viewportRef: HTMLDivElement;
+contentRef: HTMLDivElement;
+tracksRef: HTMLDivElement;
+}, HTMLDivElement>;
+
+declare type __VLS_Props = {
+    tracks: TimelineTrack[];
+    currentTime: number;
+    duration?: number;
+    zoom?: number;
+    minZoom?: number;
+    maxZoom?: number;
+    snapStep?: number;
+    trackHeight?: number;
+    trackGap?: number;
+    rulerHeight?: number;
+    minSegmentDuration?: number;
+    selectedSegmentId?: string | null;
+    disableInteraction?: boolean;
+    fps?: number;
+};
+
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        toolbar?(_: {
+            zoom: number;
+            canZoomIn: boolean;
+            canZoomOut: boolean;
+            zoomIn: typeof zoomIn;
+            zoomOut: typeof zoomOut;
+            currentTime: number;
+            duration: number;
+            formatTime: typeof formatTime;
+        }): any;
+        ruler?(_: {
+            ticks: TimelineTick[];
+            pixelsPerMs: number;
+        }): any;
+        playhead?(_: {
+            left: number;
+            currentTime: number;
+        }): any;
+        track?(_: {
+            track: TimelineTrack;
+            index: number;
+            segments: SegmentLayout[];
+            pixelsPerMs: number;
+            height: number;
+        }): any;
+        segment?(_: {
+            layout: SegmentLayout;
+            segment: TimelineSegment_2;
+            track: TimelineTrack;
+            isSelected: boolean;
+        }): any;
+        segment?(_: {
+            layout: {
+                left: number;
+                top: number;
+                segment: TimelineSegment_2;
+                track: TimelineTrack;
+                trackIndex: number;
+                segmentIndex: number;
+                width: number;
+                isSelected: boolean;
+            };
+            segment: TimelineSegment_2;
+            track: TimelineTrack;
+            isSelected: boolean;
+        }): any;
+    };
+    refs: {
+        viewportRef: HTMLDivElement;
+        contentRef: HTMLDivElement;
+        tracksRef: HTMLDivElement;
+    };
+    rootEl: HTMLDivElement;
+};
+
+declare type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+
+declare type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};
+
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+
+declare function formatTime(ms: number): string;
+
+declare interface SegmentDragPayload {
+    segment: TimelineSegment;
+    track: TimelineTrack;
+    trackIndex: number;
+    segmentIndex: number;
+    startTime: number;
+    endTime: number;
+    targetTrackIndex: number;
+    targetTrackId: string;
+    isNewTrack: boolean;
+    newTrackInsertIndex?: number;
+    visualTrackIndex: number;
+    isValidTarget: boolean;
+    mouseDeltaY: number;
+}
+
+declare interface SegmentLayout {
+    segment: TimelineSegment;
+    track: TimelineTrack;
+    trackIndex: number;
+    segmentIndex: number;
+    left: number;
+    width: number;
+    isSelected: boolean;
+}
+
+declare interface SegmentResizePayload {
+    segment: TimelineSegment;
+    track: TimelineTrack;
+    trackIndex: number;
+    segmentIndex: number;
+    startTime: number;
+    endTime: number;
+    edge: 'start' | 'end';
+}
+
+declare interface TimelineSegment {
+    id: string;
+    start: number;
+    end: number;
+    type?: string;
+    color?: string;
+    payload?: unknown;
+}
+
+declare interface TimelineTick {
+    position: number;
+    timeMs: number;
+    isMajor: boolean;
+    label?: string;
+}
+
+declare interface TimelineTrack {
+    id: string;
+    label?: string;
+    type?: string;
+    color?: string;
+    isMain?: boolean;
+    payload?: unknown;
+    segments: TimelineSegment[];
+}
+
+declare function zoomIn(): void;
+
+declare function zoomOut(): void;
+
+export { }

package/dist/VideoTimeline.js

@@ -0,0 +1,4 @@
+import { V as f } from "./index-CIZtI1B_.js";
+export {
+  f as default
+};