@video-editor/ui 0.0.1-beta.7

package/README.md

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

package/dist/VideoEditorTimeline.d.ts

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