@bycrux/editor 0.11.2 → 1.0.1

package/src/video/__tests__/export-limits.test.ts

@@ -0,0 +1,195 @@
+import { describe, it, expect } from 'vitest'
+import {
+  maxExportResolution,
+  maxExportFps,
+  availableResolutionTiers,
+  availableFpsTiers,
+  currentResolutionTier,
+} from '../export-limits'
+import type { EditorProject as Project, VisualItem, VisualTrack } from '../../schema'
+
+function vtracks(...items: VisualItem[][]): VisualTrack[] {
+  return items.map((its, i) => ({ id: `trk-${i}`, items: its }))
+}
+
+// Minimal project factory — only the fields export-limits touches.
+function makeProject(over: Partial<Project> = {}): Project {
+  return {
+    id: 'p1',
+    status: 'draft',
+    settings: { resolution: [1080, 1920] },
+    tracks: vtracks([]),
+    ...over,
+  }
+}
+
+let nextId = 0
+function videoClip(over: Partial<VisualItem> = {}): VisualItem {
+  nextId += 1
+  return { id: `v${nextId}`, type: 'video', start: 0, end: 5, ...over }
+}
+
+describe('maxExportResolution', () => {
+  it('returns settings.resolution verbatim when tracks is absent', () => {
+    const p = makeProject({ tracks: undefined })
+    expect(maxExportResolution(p)).toEqual([1080, 1920])
+  })
+
+  it('returns settings.resolution verbatim for empty tracks / no video items', () => {
+    const p = makeProject({ tracks: vtracks([], [{ id: 'o1', type: 'overlay', start: 0, end: 5 }]) })
+    expect(maxExportResolution(p)).toEqual([1080, 1920])
+  })
+
+  it('returns settings.resolution verbatim for a track shape with no items array (legacy tolerance)', () => {
+    // Legacy fixtures sometimes carry a track shape missing .items, or the whole
+    // tracks field. Normalizer must swallow both without throwing.
+    const p1 = makeProject({ tracks: [{ id: 't0' } as unknown as VisualTrack] })
+    expect(maxExportResolution(p1)).toEqual([1080, 1920])
+    const p2 = makeProject({ tracks: undefined })
+    expect(maxExportResolution(p2)).toEqual([1080, 1920])
+  })
+
+  it('returns settings.resolution verbatim when video items are missing sourceWidth/sourceHeight', () => {
+    const p = makeProject({ tracks: vtracks([videoClip()]) })
+    expect(maxExportResolution(p)).toEqual([1080, 1920])
+  })
+
+  it('returns the 1080 tier unchanged when all video items are 1080x1920', () => {
+    const p = makeProject({
+      settings: { resolution: [1080, 1920] },
+      tracks: vtracks([videoClip({ sourceWidth: 1080, sourceHeight: 1920 })]),
+    })
+    expect(maxExportResolution(p)).toEqual([1080, 1920])
+  })
+
+  it('returns [2160, 3840] for a portrait project with a 2160x3840 clip', () => {
+    const p = makeProject({
+      settings: { resolution: [1080, 1920] },
+      tracks: vtracks([videoClip({ sourceWidth: 2160, sourceHeight: 3840 })]),
+    })
+    expect(maxExportResolution(p)).toEqual([2160, 3840])
+  })
+
+  it('returns [3840, 2160] for a landscape project with a 3840x2160 clip', () => {
+    const p = makeProject({
+      settings: { resolution: [1920, 1080] },
+      tracks: vtracks([videoClip({ sourceWidth: 3840, sourceHeight: 2160 })]),
+    })
+    expect(maxExportResolution(p)).toEqual([3840, 2160])
+  })
+
+  it('picks the 4K tier when clips are mixed 1080p and 4K', () => {
+    const p = makeProject({
+      settings: { resolution: [1080, 1920] },
+      tracks: vtracks([
+        videoClip({ sourceWidth: 1080, sourceHeight: 1920 }),
+        videoClip({ sourceWidth: 2160, sourceHeight: 3840 }),
+      ]),
+    })
+    expect(maxExportResolution(p)).toEqual([2160, 3840])
+  })
+
+  it('returns settings.resolution verbatim when the source is smaller than the smallest tier', () => {
+    const p = makeProject({
+      settings: { resolution: [1080, 1920] },
+      tracks: vtracks([videoClip({ sourceWidth: 480, sourceHeight: 640 })]),
+    })
+    expect(maxExportResolution(p)).toEqual([1080, 1920])
+  })
+
+  it('keeps the long side proportional and even for a non-16:9 project aspect', () => {
+    const p = makeProject({
+      settings: { resolution: [1000, 1777] },
+      tracks: vtracks([videoClip({ sourceWidth: 1080, sourceHeight: 3000 })]),
+    })
+    const [w, h] = maxExportResolution(p)
+    expect(w).toBe(1080)
+    expect(h % 2).toBe(0)
+    // proportional to the project aspect (1777/1000), within half a pixel of rounding
+    expect(h / w).toBeCloseTo(1777 / 1000, 1)
+  })
+})
+
+describe('maxExportFps', () => {
+  it('returns 30 when settings.fps is 30', () => {
+    expect(maxExportFps(makeProject({ settings: { resolution: [1080, 1920], fps: 30 } }))).toBe(30)
+  })
+
+  it('defaults to 30 when settings.fps is absent', () => {
+    expect(maxExportFps(makeProject({ settings: { resolution: [1080, 1920] } }))).toBe(30)
+  })
+
+  it('returns 60 when settings.fps is 60', () => {
+    expect(maxExportFps(makeProject({ settings: { resolution: [1080, 1920], fps: 60 } }))).toBe(60)
+  })
+})
+
+describe('availableResolutionTiers', () => {
+  it('excludes 1440 and 2160 for a 1080p-sourced project', () => {
+    const p = makeProject({
+      settings: { resolution: [1080, 1920] },
+      tracks: vtracks([videoClip({ sourceWidth: 1080, sourceHeight: 1920 })]),
+    })
+    const tiers = availableResolutionTiers(p)
+    expect(tiers.some(([w, h]) => Math.min(w, h) === 1440)).toBe(false)
+    expect(tiers.some(([w, h]) => Math.min(w, h) === 2160)).toBe(false)
+  })
+
+  it('includes 1080 and 2160 for a 4K-sourced project', () => {
+    const p = makeProject({
+      settings: { resolution: [1080, 1920] },
+      tracks: vtracks([videoClip({ sourceWidth: 2160, sourceHeight: 3840 })]),
+    })
+    const tiers = availableResolutionTiers(p)
+    expect(tiers.some(([w, h]) => Math.min(w, h) === 1080)).toBe(true)
+    expect(tiers.some(([w, h]) => Math.min(w, h) === 2160)).toBe(true)
+  })
+
+  it('filters against the project own short-side when there are no video clips', () => {
+    const p = makeProject({ settings: { resolution: [1080, 1920] }, tracks: vtracks([]) })
+    const tiers = availableResolutionTiers(p)
+    expect(tiers.every(([w, h]) => Math.min(w, h) <= 1080)).toBe(true)
+    expect(tiers.some(([w, h]) => Math.min(w, h) === 1080)).toBe(true)
+    expect(tiers.some(([w, h]) => Math.min(w, h) === 1440)).toBe(false)
+  })
+
+  it('falls back to a single entry equal to settings.resolution when source is below every tier', () => {
+    const p = makeProject({
+      settings: { resolution: [1080, 1920] },
+      tracks: vtracks([videoClip({ sourceWidth: 480, sourceHeight: 640 })]),
+    })
+    expect(availableResolutionTiers(p)).toEqual([[1080, 1920]])
+  })
+})
+
+describe('availableFpsTiers', () => {
+  it('returns [24, 30] when settings.fps is 30', () => {
+    expect(availableFpsTiers(makeProject({ settings: { resolution: [1080, 1920], fps: 30 } }))).toEqual([24, 30])
+  })
+
+  it('returns [24, 30, 60] when settings.fps is 60', () => {
+    expect(availableFpsTiers(makeProject({ settings: { resolution: [1080, 1920], fps: 60 } }))).toEqual([
+      24, 30, 60,
+    ])
+  })
+})
+
+describe('currentResolutionTier', () => {
+  it('returns [1080, 1920] for a matching project with a 4K source', () => {
+    const p = makeProject({
+      settings: { resolution: [1080, 1920] },
+      tracks: vtracks([videoClip({ sourceWidth: 2160, sourceHeight: 3840 })]),
+    })
+    expect(currentResolutionTier(p)).toEqual([1080, 1920])
+  })
+
+  it('returns the closest tier <= current when current matches no standard tier', () => {
+    const p = makeProject({
+      settings: { resolution: [1000, 2000] },
+      tracks: vtracks([videoClip({ sourceWidth: 2160, sourceHeight: 3840 })]),
+    })
+    const tier = currentResolutionTier(p)
+    expect(tier).toBeDefined()
+    expect(Math.min(...tier!)).toBe(720)
+  })
+})

package/src/video/__tests__/hover-scrub.test.ts

@@ -0,0 +1,163 @@
+/// <reference types="vitest/globals" />
+/**
+ * The preview-axis override store. Small, but it carries the invariant the
+ * whole feature rests on: hover changes which frame the preview paints and
+ * NOTHING else — not the playhead, not where playback resumes.
+ */
+import { describe, it, expect, vi } from 'vitest'
+import { createHoverScrub, gateTimeSink, handOverToHover } from '../hover-scrub'
+import { createPlaybackClock } from '../playback-clock'
+
+describe('createHoverScrub', () => {
+  it('starts with no override — the preview follows the playhead', () => {
+    expect(createHoverScrub().get()).toBeNull()
+  })
+
+  it('notifies subscribers when the hovered time changes', () => {
+    const store = createHoverScrub()
+    const sub = vi.fn()
+    store.subscribe(sub)
+
+    store.set(4)
+    expect(store.get()).toBe(4)
+    expect(sub).toHaveBeenCalledTimes(1)
+
+    store.set(null)
+    expect(store.get()).toBeNull()
+    expect(sub).toHaveBeenCalledTimes(2)
+  })
+
+  it('stays silent on a repeat write', () => {
+    // Load-bearing: the clock subscription clears this on every playback tick,
+    // which without the guard would notify ~60 times a second forever.
+    const store = createHoverScrub()
+    const sub = vi.fn()
+    store.subscribe(sub)
+
+    store.set(null)
+    expect(sub).not.toHaveBeenCalled()
+
+    store.set(2)
+    store.set(2)
+    expect(sub).toHaveBeenCalledTimes(1)
+  })
+
+  it('unsubscribes cleanly', () => {
+    const store = createHoverScrub()
+    const sub = vi.fn()
+    store.subscribe(sub)()
+    store.set(1)
+    expect(sub).not.toHaveBeenCalled()
+  })
+
+  it('never touches the playback clock', () => {
+    // The invariant in one assertion: hovering must not move the playhead, or
+    // the red line and the scrubber handle would chase the pointer and Space
+    // would start playing from wherever it happened to rest.
+    const clock = createPlaybackClock()
+    const store = createHoverScrub()
+    clock.set(7)
+
+    store.set(1)
+    store.set(2)
+    expect(clock.get()).toBe(7)
+  })
+
+  it('is cleared by a clock move, the way VideoEditor wires it', () => {
+    // Any real playhead movement — a playback tick, an arrow step, a seek —
+    // cancels the hover preview, so a stale override can never pin the picture
+    // to a frame the playhead has left.
+    const clock = createPlaybackClock()
+    const store = createHoverScrub()
+    clock.subscribe(() => store.set(null))
+
+    store.set(3)
+    expect(store.get()).toBe(3)
+
+    clock.set(9)
+    expect(store.get()).toBeNull()
+  })
+})
+
+describe('the clock bridge, gated on hover-preview', () => {
+  // These drive the SAME functions `PreviewPlayer` wires in, rather than a copy
+  // of the rule — mounting the preview stack would need a real canvas and a
+  // decoder, but the rule itself is pure and belongs under test either way.
+  const makeTimeSink = gateTimeSink
+
+  it('drops the seek echo while hover-previewing, so the playhead stays put', () => {
+    // Showing a hovered frame seeks the source, and that seek reports its new
+    // position back. Unguarded, that is exactly what dragged the red playhead
+    // after the yellow cursor.
+    const clock = createPlaybackClock()
+    const hover = createHoverScrub()
+    const sink = makeTimeSink(clock, hover)
+    clock.set(10)
+
+    hover.set(42)
+    sink(42)   // the echo of the hover seek
+    sink(42.5) // and the tick after it
+
+    expect(clock.get()).toBe(10)
+  })
+
+  it('lets playback through once the override is gone', () => {
+    const clock = createPlaybackClock()
+    const hover = createHoverScrub()
+    const sink = makeTimeSink(clock, hover)
+    clock.set(10)
+
+    hover.set(42)
+    sink(42)
+    expect(clock.get()).toBe(10)
+
+    hover.set(null)
+    sink(42.1)
+    expect(clock.get()).toBe(42.1)
+  })
+
+  it('hands the playhead over to the hovered frame when playback starts', () => {
+    // Play from the yellow line, and bring the red one with it, so the two
+    // agree rather than the playhead being stranded at its pre-hover position.
+    const clock = createPlaybackClock()
+    const hover = createHoverScrub()
+    clock.set(10)
+    hover.set(42)
+
+    expect(handOverToHover(clock, hover)).toBe(true)
+    expect(clock.get()).toBe(42)
+    expect(hover.get()).toBeNull()
+  })
+
+  it('leaves the playhead alone when play starts with no hover standing', () => {
+    // Every ordinary press of play: nothing hovered, nothing to hand over.
+    const clock = createPlaybackClock()
+    const hover = createHoverScrub()
+    clock.set(10)
+
+    expect(handOverToHover(clock, hover)).toBe(false)
+    expect(clock.get()).toBe(10)
+  })
+
+  it('is a no-op for a host that never wired the store', () => {
+    const clock = createPlaybackClock()
+    clock.set(10)
+    expect(handOverToHover(clock, undefined)).toBe(false)
+    gateTimeSink(clock, undefined)(3)
+    expect(clock.get()).toBe(3)
+  })
+
+  it('resumes writing straight after the hand-over', () => {
+    // The tick right after play must land, or the playhead would freeze at the
+    // hand-over point while the picture kept moving.
+    const clock = createPlaybackClock()
+    const hover = createHoverScrub()
+    const sink = gateTimeSink(clock, hover)
+    hover.set(42)
+    handOverToHover(clock, hover)
+
+    sink(42.2)
+    sink(42.4)
+    expect(clock.get()).toBe(42.4)
+  })
+})

package/src/video/__tests__/keyframeOps.canKeyframeProp.test.ts

@@ -0,0 +1,61 @@
+import { describe, it, expect } from 'vitest'
+import { canKeyframe, canKeyframeProp, transformProps } from '../keyframeOps'
+import type { VisualItem } from '../../schema'
+
+/** SP9d — keyframeability is per property per kind. */
+describe('canKeyframe / canKeyframeProp', () => {
+  const mk = (type: string, over: Partial<VisualItem> = {}) =>
+    ({ id: 'x', type, src: '/tmp/a', start: 0, end: 3, ...over } as unknown as VisualItem)
+
+  const FIVE = ['offsetX', 'offsetY', 'scale', 'rotation', 'opacity'] as const
+
+  it('overlays keep every property', () => {
+    const ov = mk('overlay')
+    expect(canKeyframe(ov)).toBe(true)
+    for (const p of FIVE) expect(canKeyframeProp(ov, p)).toBe(true)
+  })
+
+  for (const kind of ['video', 'image'] as const) {
+    it(`${kind} clips animate geometry but NOT opacity`, () => {
+      const clip = mk(kind)
+      expect(canKeyframe(clip)).toBe(true)
+      for (const p of ['offsetX', 'offsetY', 'scale', 'rotation'] as const) {
+        expect(canKeyframeProp(clip, p)).toBe(true)
+      }
+      expect(canKeyframeProp(clip, 'opacity')).toBe(false)
+    })
+  }
+
+  it('an unknown or missing kind is keyframeable nowhere', () => {
+    expect(canKeyframe(null)).toBe(false)
+    expect(canKeyframe(undefined)).toBe(false)
+    expect(canKeyframe(mk('audio'))).toBe(false)
+    expect(canKeyframeProp(mk('audio'), 'scale')).toBe(false)
+    expect(canKeyframeProp(null, 'scale')).toBe(false)
+  })
+
+  it('canKeyframe is true iff SOME property is keyframeable', () => {
+    for (const kind of ['overlay', 'video', 'image', 'audio', 'caption']) {
+      const item = mk(kind)
+      const anyProp = FIVE.some(p => canKeyframeProp(item, p))
+      expect(canKeyframe(item)).toBe(anyProp)
+    }
+  })
+
+  it('transformProps drops opacity for a clip and keeps it for an overlay', () => {
+    expect(transformProps(mk('overlay'))).toContain('opacity')
+    expect(transformProps(mk('video'))).not.toContain('opacity')
+    expect(transformProps(mk('image'))).not.toContain('opacity')
+    // ...and still carries the geometry props, so keying a clip does something.
+    expect(transformProps(mk('video'))).toContain('scale')
+    expect(transformProps(mk('video'))).toContain('rotation')
+  })
+
+  it('a per-axis clip drops opacity too, and keeps scaleX/scaleY', () => {
+    const clip = mk('video', { scaleX: 1.2, scaleY: 0.8 } as Partial<VisualItem>)
+    const props = transformProps(clip)
+    expect(props).not.toContain('opacity')
+    expect(props).toContain('scaleX')
+    expect(props).toContain('scaleY')
+  })
+})