@video-editor/shared 0.0.1-beta.9 → 1.0.0-beta.1

package/dist/index.d.ts

@@ -6,13 +6,26 @@ declare interface AudioSegment<T extends ITrackType> extends ISegment<T> {
     fadeInDuration?: number;
     fadeOutDuration?: number;
     playRate?: number;
+    /**
+     * Play the same source window [fromTime, fromTime + (endTime - startTime) * playRate]
+     * backwards. `fromTime` still anchors the window start. Default false.
+     */
+    reversed?: boolean;
 }
 
+/**
+ * CSS-style cubic-bezier easing: solve x(t) = progress for t, return y(t).
+ * Newton iterations with a bisection fallback; no dependencies.
+ */
+export declare function cubicBezierEase(x1: number, y1: number, x2: number, y2: number, progress: number): number;
+
 /**
  * Protocol version constant
  */
 export declare const CURRENT_PROTOCOL_VERSION: "1.0.0";
 
+export declare function easeKeyframeProgress(easing: IKeyframeEasing | undefined, progress: number): number;
+
 declare interface EffectSegment<T extends ITrackType> extends ISegment<T> {
     segmentType: T;
     effectId: string;
@@ -50,6 +63,14 @@ export declare interface IBackground {
     opacity?: number;
 }
 
+/** Chroma key (green/blue screen) removal for a visual segment. */
+export declare interface IChromaKey {
+    color: string;
+    similarity: number;
+    smoothness?: number;
+    spillSuppress?: number;
+}
+
 export declare interface IDropShadow {
     color?: string;
     opacity?: number;
@@ -71,9 +92,9 @@ declare interface IFramesSegment extends ISegment<'frames'> {
     opacity?: number;
     fillMode?: IFillMode;
     animation?: IAnimation;
-    transitionIn?: ITransition;
-    transitionOut?: ITransition;
     palette?: IPalette;
+    mask?: IMask;
+    chromaKey?: IChromaKey;
     background?: `rgba(${number},${number},${number},${number})`;
 }
 
@@ -84,6 +105,38 @@ export declare interface IImageFramesSegment extends IFramesSegment {
     format: 'img' | 'gif';
 }
 
+export declare interface IKeyframe {
+    /** Timeline time relative to segment.startTime, in ms (not scaled by playRate). */
+    timeMs: number;
+    value: number;
+    /** Easing toward the next keyframe. Defaults to 'linear'. */
+    easing?: IKeyframeEasing;
+}
+
+export declare type IKeyframeEasing = 'linear' | 'easeIn' | 'easeOut' | 'easeInOut' | [number, number, number, number];
+
+export declare type IKeyframeProperty = 'opacity' | 'position.x' | 'position.y' | 'scale' | 'rotation' | 'volume' | 'intensity';
+
+export declare interface IKeyframeTrack {
+    property: IKeyframeProperty;
+    /** Sorted ascending by timeMs; at least one frame. */
+    frames: IKeyframe[];
+}
+
+/**
+ * Shape mask applied to a visual segment. The mask lives in the segment's own
+ * display box: `center` is normalized to [-1, 1] with the origin at the box
+ * center (+x right, +y up), `size` is the box-relative full extent in [0, 1].
+ */
+export declare interface IMask {
+    shape: 'rect' | 'ellipse';
+    center: [number, number];
+    size: [number, number];
+    feather?: number;
+    rotation?: number;
+    inverse?: boolean;
+}
+
 export declare interface IPalette {
     temperature: number;
     hue: number;
@@ -115,6 +168,8 @@ export declare interface ISegment<T extends ITrackType = ITrackType> {
     endTime: number;
     segmentType: T;
     url?: string;
+    /** Optional per-property animation curves; see docs/rfcs/0002-keyframe-curves.md. */
+    keyframes?: IKeyframeTrack[];
     extra?: SegmentExtra<T> | null;
 }
 
@@ -183,6 +238,18 @@ export declare type ITrack<T extends ITrackType> = {
     trackId: string;
     trackType: T;
     children: TrackTypeMapSegment[T][];
+    /**
+     * When true, the track's visual output is skipped (renderer draws nothing for
+     * its segments). Purely a presentation flag: the segments stay in the protocol
+     * and keep participating in timeline layout, duration and export.
+     */
+    hidden?: boolean;
+    /**
+     * When true, the track's audio output is skipped (audio segments and the audio
+     * of video segments stay silent). Purely a presentation flag: it never mutates
+     * per-segment `volume`.
+     */
+    muted?: boolean;
     extra?: TrackExtra<T> | null;
 } & (T extends 'frames' ? {
     isMain?: boolean;
@@ -202,11 +269,21 @@ export declare interface ITransition {
     duration: number;
 }
 
+export declare interface ITransitionEdge extends ITransition {
+    fromSegmentId: string;
+    toSegmentId: string;
+}
+
 export declare interface IVideoFramesSegment extends IFramesSegment {
     type: 'video';
     fromTime?: number;
     volume?: number;
     playRate?: number;
+    /**
+     * Play the same source window [fromTime, fromTime + (endTime - startTime) * playRate]
+     * backwards. `fromTime` still anchors the window start. Default false.
+     */
+    reversed?: boolean;
 }
 
 /**
@@ -221,14 +298,40 @@ export declare interface IVideoProtocol {
     height: number;
     fps: number;
     tracks: TrackUnion[];
+    transitions?: ITransitionEdge[];
     extra?: ProtocolExtra | null;
 }
 
+/**
+ * Map an absolute timeline time (ms) onto the source media time (ms).
+ *
+ * Forward:  `fromTime + relMs * rate`
+ * Reversed: `fromTime + (span - relMs * rate)` — the same source window
+ * `[fromTime, fromTime + span]` read from its end back to its start.
+ */
+export declare function mapSourceTimeMs(segment: SourceTimedSegment, timelineMs: number): number;
+
+/**
+ * Shared source-time mapping helpers.
+ *
+ * A media segment occupies a timeline window `[startTime, endTime]` and reads a
+ * source window `[fromTime, fromTime + sourceSpanMs]`. Every consumer (preview
+ * evaluator, transition planner, audio manager, compose pipeline) must agree on
+ * this mapping, otherwise preview and export drift apart.
+ */
+/**
+ * Clamp a play rate into the supported range.
+ * Non-finite or missing values fall back to 1.
+ */
+export declare function normalizePlayRate(playRate?: number): number;
+
 export declare type ProtocolExtra = ProtocolExtraRegistry extends Record<string, never> ? Record<string, never> : NonNullable<ProtocolExtraRegistry>;
 
 export declare interface ProtocolExtraRegistry {
 }
 
+export declare function sampleKeyframes(track: IKeyframeTrack, relMs: number): number;
+
 export declare type SegmentExtra<T extends ITrackType> = T extends keyof SegmentExtraRegistry ? NonNullable<SegmentExtraRegistry[T]> : Record<string, never>;
 
 export declare interface SegmentExtraRegistry {
@@ -236,6 +339,24 @@ export declare interface SegmentExtraRegistry {
 
 export declare type SegmentUnion = TrackTypeMapSegment[ITrackType];
 
+/**
+ * Length of the source window consumed by the segment, in ms.
+ * `(endTime - startTime) * playRate`.
+ */
+export declare function sourceSpanMs(segment: SourceTimedSegment): number;
+
+/** Minimal shape needed to map a timeline time onto a source time. */
+export declare interface SourceTimedSegment {
+    startTime: number;
+    endTime: number;
+    /** Source window start in ms. Defaults to 0. */
+    fromTime?: number;
+    /** Playback speed multiplier. Defaults to 1. */
+    playRate?: number;
+    /** Play the same source window backwards. Defaults to false. */
+    reversed?: boolean;
+}
+
 declare interface StickerSegment<T extends ITrackType> extends ISegment<T> {
     segmentType: T;
     format: 'img' | 'gif';
@@ -244,6 +365,8 @@ declare interface StickerSegment<T extends ITrackType> extends ISegment<T> {
     animation?: IAnimation;
     transform?: ITransform;
     palette?: IPalette;
+    mask?: IMask;
+    chromaKey?: IChromaKey;
 }
 
 declare interface TextSegment<T extends ITrackType> extends ISegment<T> {

package/dist/index.js

@@ -1,46 +1,131 @@
-const i = "1.0.0";
-function r(e) {
+const S = {
+  easeIn: [0.42, 0, 1, 1],
+  easeOut: [0, 0, 0.58, 1],
+  easeInOut: [0.42, 0, 0.58, 1]
+};
+function E(e, n) {
+  const t = e.frames, i = t[0];
+  if (!i)
+    return Number.NaN;
+  if (t.length === 1 || n <= i.timeMs)
+    return i.value;
+  const r = t[t.length - 1];
+  if (n >= r.timeMs)
+    return r.value;
+  for (let a = 0; a < t.length - 1; a++) {
+    const s = t[a], c = t[a + 1];
+    if (n < s.timeMs || n > c.timeMs)
+      continue;
+    const u = c.timeMs - s.timeMs;
+    if (u <= 0)
+      return c.value;
+    const f = (n - s.timeMs) / u;
+    return s.value + (c.value - s.value) * p(s.easing, f);
+  }
+  return r.value;
+}
+function p(e, n) {
+  if (!e || e === "linear")
+    return n;
+  const t = Array.isArray(e) ? e : S[e];
+  return t ? d(t[0], t[1], t[2], t[3], n) : n;
+}
+function d(e, n, t, i, r) {
+  if (r <= 0)
+    return 0;
+  if (r >= 1)
+    return 1;
+  const a = (o) => y(o, e, t), s = (o) => y(o, n, i), c = (o) => v(o, e, t);
+  let u = r;
+  for (let o = 0; o < 8; o++) {
+    const T = a(u) - r;
+    if (Math.abs(T) < 1e-6)
+      return s(u);
+    const M = c(u);
+    if (Math.abs(M) < 1e-6)
+      break;
+    u -= T / M;
+  }
+  let f = 0, l = 1;
+  for (u = r; l - f > 1e-6; )
+    a(u) < r ? f = u : l = u, u = (f + l) / 2;
+  return s(u);
+}
+function y(e, n, t) {
+  const i = 1 - e;
+  return 3 * i * i * e * n + 3 * i * e * e * t + e * e * e;
+}
+function v(e, n, t) {
+  const i = 1 - e;
+  return 3 * i * i * n + 6 * i * e * (t - n) + 3 * e * e * (1 - t);
+}
+const A = 0.1, x = 100;
+function h(e) {
+  return typeof e != "number" || !Number.isFinite(e) ? 1 : Math.max(A, Math.min(x, e));
+}
+function m(e) {
+  return typeof e != "number" || !Number.isFinite(e) ? 0 : Math.max(0, e);
+}
+function b(e) {
+  return Math.max(0, m(e.endTime) - m(e.startTime)) * h(e.playRate);
+}
+function R(e, n) {
+  const t = Math.max(0, m(n) - m(e.startTime)), i = m(e.fromTime), r = h(e.playRate);
+  if (e.reversed === !0) {
+    const a = b(e);
+    return Math.max(i, i + Math.max(0, a - t * r));
+  }
+  return Math.max(0, i + t * r);
+}
+const _ = "1.0.0";
+function I(e) {
   return e.segmentType === "frames";
 }
-function u(e) {
+function O(e) {
   return e.segmentType === "frames" && "type" in e && e.type === "video";
 }
-function s(e) {
+function P(e) {
   return e.segmentType === "text";
 }
-function f(e) {
+function k(e) {
   return e.segmentType === "sticker";
 }
-function m(e) {
+function z(e) {
   return e.segmentType === "audio";
 }
-function c(e) {
+function F(e) {
   return e.segmentType === "effect";
 }
-function o(e) {
+function D(e) {
   return e.segmentType === "filter";
 }
-function T(e) {
+function Y(e) {
   return e.endTime - e.startTime;
 }
-function g(e, t) {
-  return e >= t.startTime && e < t.endTime;
+function g(e, n) {
+  return e >= n.startTime && e < n.endTime;
 }
-const n = ["frames", "text", "sticker", "audio", "effect", "filter"];
-function a(e) {
-  return n.includes(e);
+const N = ["frames", "text", "sticker", "audio", "effect", "filter"];
+function C(e) {
+  return N.includes(e);
 }
 export {
-  i as CURRENT_PROTOCOL_VERSION,
-  n as TRACK_TYPES,
-  T as getSegmentDuration,
-  m as isAudioSegment,
-  c as isEffectSegment,
-  o as isFilterSegment,
-  r as isFramesSegment,
-  f as isStickerSegment,
-  s as isTextSegment,
+  _ as CURRENT_PROTOCOL_VERSION,
+  N as TRACK_TYPES,
+  d as cubicBezierEase,
+  p as easeKeyframeProgress,
+  Y as getSegmentDuration,
+  z as isAudioSegment,
+  F as isEffectSegment,
+  D as isFilterSegment,
+  I as isFramesSegment,
+  k as isStickerSegment,
+  P as isTextSegment,
   g as isTimeInSegment,
-  a as isValidTrackType,
-  u as isVideoFramesSegment
+  C as isValidTrackType,
+  O as isVideoFramesSegment,
+  R as mapSourceTimeMs,
+  h as normalizePlayRate,
+  E as sampleKeyframes,
+  b as sourceSpanMs
 };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@video-editor/shared",
   "type": "module",
-  "version": "0.0.1-beta.9",
+  "version": "1.0.0-beta.1",
   "description": "video editor shared libs",
   "author": "",
   "license": "ISC",
@@ -20,6 +20,7 @@
     "dist"
   ],
   "scripts": {
-    "build": "vite build --config vite.config.ts"
+    "build": "vite build --config vite.config.ts",
+    "test": "vitest run --config ./vitest.config.ts"
   }
 }