@molecule/app-feature-video-timeline-angular 0.0.1-stage → 1.1.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (2) hide show
  1. package/README.md +594 -4
  2. package/package.json +4 -4
package/README.md CHANGED
@@ -1,11 +1,601 @@
1
+ <!--
2
+ AUTO-GENERATED — DO NOT EDIT THIS FILE.
3
+ Generated by `mlcl sync-docs` from the package's src/index.ts JSDoc + mlcl/registry.json.
4
+ Edits here are overwritten on the next commit (molecule's pre-commit hook regenerates).
5
+ To change this document, edit the module-level JSDoc in src/index.ts.
6
+ Generated: 2026-11-21T12:46:32.995Z
7
+ -->
8
+
1
9
  # @molecule/app-feature-video-timeline-angular
2
10
 
3
- Multi-track video timeline composing track-lane rows with a time ruler, playhead, zoom controls, and ripple/insert edit modes
11
+ Angular multi-track video timeline for video editors, DAWs and animation
12
+ tools. Composes one `<TrackLane>` per track row with a shared time ruler,
13
+ playhead, zoom slider + Ctrl+wheel zoom, and ripple/insert edit modes.
14
+
15
+ Angular counterpart of `@molecule/app-feature-video-timeline-react`: the
16
+ same props (React names), the same DOM for the same input, and the same
17
+ callback calls, so an app switches framework by changing only the package
18
+ name it imports.
19
+
20
+ Exports `VideoTimeline`, the `Track` and `VideoTimelineMode` types,
21
+ and the pure-function helpers `clampZoom`, `zoomFromWheelDelta`,
22
+ `computeRulerTicks`, `computeRippleUpdates`, and `formatTickTime`
23
+ that back the zoom math, ruler tick generation, and ripple-mode
24
+ fan-out.
25
+
26
+ > **Auto-generated, AI-first package reference** for the [molecule.dev](https://molecule.dev) ecosystem.
27
+ > It is written to be read by coding agents as much as by people, and is generated from this
28
+ > package's source — edit `src/index.ts` JSDoc, not this file.
29
+
30
+ ## Quick Start
31
+
32
+ ```ts
33
+ import { Component, signal } from '@angular/core'
34
+ import { VideoTimeline } from '@molecule/app-feature-video-timeline-angular'
35
+
36
+ @Component({
37
+ selector: 'app-editor',
38
+ standalone: true,
39
+ imports: [VideoTimeline],
40
+ template: `
41
+ <div
42
+ mol-video-timeline
43
+ [tracks]="tracks"
44
+ [currentTime]="currentTime()"
45
+ [duration]="60"
46
+ [pixelsPerSecond]="zoom()"
47
+ mode="ripple"
48
+ [onSeek]="seek"
49
+ ></div>
50
+ `,
51
+ })
52
+ export class Editor {
53
+ readonly currentTime = signal(3.2)
54
+ readonly zoom = signal(20)
55
+ readonly tracks = [
56
+ {
57
+ id: 'v1',
58
+ kind: 'video',
59
+ clips: [{ id: 'a', startTime: 0, duration: 5, label: 'Intro' }],
60
+ },
61
+ {
62
+ id: 'a1',
63
+ kind: 'audio',
64
+ clips: [{ id: 'b', startTime: 0, duration: 12 }],
65
+ },
66
+ ]
67
+
68
+ seek = (time: number): void => {
69
+ this.currentTime.set(time)
70
+ }
71
+ }
72
+ ```
73
+
74
+ ## Type
75
+
76
+ `feature`
77
+
78
+ ## Installation
79
+
80
+ ```bash
81
+ npm install @molecule/app-feature-video-timeline-angular @angular/common @angular/core @angular/platform-browser @molecule/app-angular @molecule/app-feature-track-lane-angular @molecule/app-ui @molecule/app-ui-angular
82
+ ```
83
+
84
+ ## API
85
+
86
+ ### Interfaces
87
+
88
+ #### `Track`
89
+
90
+ One track row on a `<VideoTimeline>`. Tracks are rendered in array
91
+ order top-to-bottom and each track delegates clip rendering to a
92
+ `<TrackLane>` row.
93
+
94
+ ```typescript
95
+ interface Track {
96
+ /** Stable identifier — used as the row key and lane id passed to handlers. */
97
+ id: string
98
+ /** The kind of media on this track. */
99
+ kind: TrackKind
100
+ /** Clips on this track. Order is preserved as-is. */
101
+ clips: Clip[]
102
+ /** Optional human-friendly track name; falls back to a translated kind label. */
103
+ name?: string
104
+ }
105
+ ```
106
+
107
+ #### `VideoTimelineProps`
108
+
109
+ Props accepted by {@link VideoTimeline} — the same props
110
+ `@molecule/app-feature-video-timeline-react` accepts. Node-valued fields of
111
+ a clip's `label` are `TemplateRef`s in Angular.
112
+
113
+ ```typescript
114
+ interface VideoTimelineProps {
115
+ /** Tracks to render. Order is preserved as-is. */
116
+ tracks: Track[]
117
+ /** Current playhead time in seconds. Drives the playhead vertical line. */
118
+ currentTime: number
119
+ /** Total timeline duration in seconds — used to size the scrollable body. */
120
+ duration: number
121
+ /** Called when the user clicks/scrubs the ruler. */
122
+ onSeek?: (time: number) => void
123
+ /** Called when a clip on a lane is dragged horizontally. */
124
+ onClipMove?: (clipId: string, startTime: number, trackId: string) => void
125
+ /** Called when a clip's right-edge resize handle is dragged. */
126
+ onClipResize?: (clipId: string, duration: number, trackId: string) => void
127
+ /** Horizontal scale (px per second). Defaults to 20. */
128
+ pixelsPerSecond?: number
129
+ /** Lower zoom bound for Ctrl+wheel / slider. Defaults to 2. */
130
+ zoomMin?: number
131
+ /** Upper zoom bound for Ctrl+wheel / slider. Defaults to 200. */
132
+ zoomMax?: number
133
+ /** Edit mode for clip drags. Defaults to `'ripple'`. */
134
+ mode?: VideoTimelineMode
135
+ /** Called when the user changes the zoom (slider or Ctrl+wheel). */
136
+ onZoomChange?: (pixelsPerSecond: number) => void
137
+ /** Optional currently-selected clip id. */
138
+ selectedClipId?: string
139
+ /** Called when a clip is clicked (no drag). */
140
+ onClipClick?: (clipId: string, trackId: string) => void
141
+ /** Per-track row height in pixels. Defaults to 44. */
142
+ trackHeight?: number
143
+ /** Width of the leading lane-header column in pixels. Defaults to 120. */
144
+ laneHeaderWidth?: number
145
+ /** Height of the time ruler row in pixels. Defaults to 28. */
146
+ rulerHeight?: number
147
+ /** Extra classes merged onto the root element. */
148
+ className?: string
149
+ }
150
+ ```
151
+
152
+ ### Types
153
+
154
+ #### `TrackKind`
155
+
156
+ The kind of media a track holds. Drives the lane name fallback,
157
+ the default clip color, and the data attribute parents can hook
158
+ onto for kind-specific styling.
159
+
160
+ ```typescript
161
+ type TrackKind = 'video' | 'audio' | 'subtitle'
162
+ ```
163
+
164
+ #### `VideoTimelineMode`
165
+
166
+ Edit mode applied to clip drags.
167
+
168
+ - `insert` — dragging a clip just drops it at the new position; other clips
169
+ on the lane stay where they are.
170
+ - `ripple` — dragging a clip shifts every later clip on the same lane by
171
+ the same delta, preserving inter-clip gaps.
172
+
173
+ ```typescript
174
+ type VideoTimelineMode = 'ripple' | 'insert'
175
+ ```
176
+
177
+ ### Classes
178
+
179
+ #### `VideoTimeline`
180
+
181
+ VideoTimeline component.
182
+
183
+ A multi-track video timeline: one `<TrackLane>` per track row with a shared
184
+ time ruler at the top, a vertical playhead, and a zoom slider row.
185
+ Pointer-down on the ruler scrubs `onSeek`; Ctrl+wheel anywhere over the body
186
+ changes zoom; the slider is keyboard-accessible. All styling routes through
187
+ `getClassMap()` and all user-visible text routes through `useTranslation()`.
188
+
189
+ The host IS React's root `<div>` (`div[mol-video-timeline]`): `role`, the
190
+ translated `aria-label`, `data-mol-id` and `data-mode` live on it.
191
+
192
+ In `'ripple'` mode (default), dragging a clip on a lane shifts every
193
+ subsequent clip on that lane by the same delta — `onClipMove` is called once
194
+ per affected clip. In `'insert'` mode, only the dragged clip moves.
195
+
196
+ ```typescript
197
+ @Component({
198
+ selector: 'div[mol-video-timeline]',
199
+ standalone: true,
200
+ imports: [TrackLane],
201
+ inputs: [
202
+ 'tracks',
203
+ 'currentTime',
204
+ 'duration',
205
+ 'onSeek',
206
+ 'onClipMove',
207
+ 'onClipResize',
208
+ 'pixelsPerSecond',
209
+ 'zoomMin',
210
+ 'zoomMax',
211
+ 'mode',
212
+ 'onZoomChange',
213
+ 'selectedClipId',
214
+ 'onClipClick',
215
+ 'trackHeight',
216
+ 'laneHeaderWidth',
217
+ 'rulerHeight',
218
+ 'className',
219
+ ],
220
+ host: {
221
+ role: 'group',
222
+ 'data-mol-id': 'video-timeline',
223
+ '[attr.aria-label]': 'rootLabel()',
224
+ '[attr.data-mode]': 'modeOf()',
225
+ '[class]': 'rootClasses()',
226
+ '[style.width]': `'100%'`,
227
+ '[style.overflow]': `'hidden'`,
228
+ },
229
+ template: `<div data-mol-id="video-timeline-controls" [class]="controlsClasses()"><span data-mol-id="video-timeline-mode"><span [class]="srOnlyClasses()">{{ modeLabel() }}</span>{{ modeText() }}</span><button type="button" data-mol-id="video-timeline-zoom-out" [attr.aria-label]="zoomOutLabel()" [class]="buttonClasses()" (click)="zoomOut()"> {{ zoomOutIcon() }} </button><input type="range" data-mol-id="video-timeline-zoom-slider" [attr.aria-label]="zoomLabel()" [attr.min]="zoomMinOf()" [attr.max]="zoomMaxOf()" step="1" [attr.value]="sliderValue()" (input)="handleZoomInput($event)" /><button type="button" data-mol-id="video-timeline-zoom-in" [attr.aria-label]="zoomInLabel()" [class]="buttonClasses()" (click)="zoomIn()"> {{ zoomInIcon() }} </button></div><div data-mol-id="video-timeline-ruler-row" [style]="rulerRowStyle()"><div data-mol-id="video-timeline-ruler-header" [style]="rulerHeaderStyle()"></div><div #rulerBody role="slider" tabindex="0" [attr.aria-label]="rulerLabel()" aria-valuemin="0" [attr.aria-valuemax]="safeDuration()" [attr.aria-valuenow]="currentTime ?? null" [attr.aria-valuetext]="playheadLabel()" data-mol-id="video-timeline-ruler" [style]="rulerBodyStyle()" (pointerdown)="onRulerPointerDown($event)" (pointermove)="onRulerPointerMove($event)" (pointerup)="onRulerPointerUp($event)" (pointercancel)="onRulerPointerUp($event)">@for (tick of ticks(); track tick.time) {<div><div data-mol-id="video-timeline-tick" [attr.data-time]="tick.time" [style]="tickStyle(tick)"></div><span data-mol-id="video-timeline-tick-label" [attr.data-time]="tick.time" [style]="tickLabelStyle(tick)"> {{ tickText(tick) }} </span></div>}<div data-mol-id="video-timeline-playhead-ruler" aria-hidden="true" [style]="playheadInRulerStyle()"></div></div></div><div data-mol-id="video-timeline-tracks" [style]="tracksScrollStyle()" (wheel)="onBodyWheel($event)"><div [style]="tracksInnerStyle()">@for (track of tracks ?? []; track track.id) {<div data-mol-id="video-timeline-track" [attr.data-track-id]="track.id" [attr.data-track-kind]="track.kind"><div mol-track-lane [name]="laneName(track)" [clips]="track.clips" [pixelsPerSecond]="safeScale()" [height]="trackHeightOf()" [lane]="track.id" [selectedClipId]="selectedClipId" [onClipMove]="moveFor(track)" [onClipResize]="resizeFor(track)" [onClipClick]="clickFor(track)"></div></div>}<div data-mol-id="video-timeline-playhead" aria-hidden="true" [style]="playheadStyle()"></div></div></div>`,
230
+ })
231
+ export class VideoTimeline implements OnDestroy {
232
+ tracks?: Track[]
233
+ currentTime?: number
234
+ duration?: number
235
+ onSeek?: (time: number) => void
236
+ onClipMove?: (clipId: string, startTime: number, trackId: string) => void
237
+ onClipResize?: (clipId: string, duration: number, trackId: string) => void
238
+ pixelsPerSecond?: number
239
+ zoomMin?: number
240
+ zoomMax?: number
241
+ mode?: VideoTimelineMode
242
+ onZoomChange?: (pixelsPerSecond: number) => void
243
+ selectedClipId?: string
244
+ onClipClick?: (clipId: string, trackId: string) => void
245
+ trackHeight?: number
246
+ laneHeaderWidth?: number
247
+ rulerHeight?: number
248
+ className?: string
249
+
250
+ private readonly i18n = useTranslation()
251
+
252
+ private seekDrag: SeekDragState | null = null
253
+
254
+ @ViewChild('rulerBody') rulerBodyRef?: ElementRef<HTMLDivElement>
255
+
256
+ cm(): UIClassMap {
257
+ return getClassMap()
258
+ }
259
+
260
+ rootClasses(): string {
261
+ return this.cm().cn(this.className)
262
+ }
263
+
264
+ controlsClasses(): string {
265
+ return this.cm().cn(this.cm().flex({ align: 'center', gap: 'sm' }), this.cm().sp('p', 2))
266
+ }
267
+
268
+ buttonClasses(): string {
269
+ return this.cm().cn(this.cm().cursorPointer)
270
+ }
271
+
272
+ srOnlyClasses(): string {
273
+ return this.cm().cn(this.cm().srOnly)
274
+ }
275
+
276
+ safeDuration(): number {
277
+ return (this.duration ?? 0) > 0 ? (this.duration as number) : 0
278
+ }
279
+
280
+ scaleOf(): number {
281
+ return this.pixelsPerSecond ?? DEFAULT_PIXELS_PER_SECOND
282
+ }
283
+
284
+ safeScale(): number {
285
+ return this.scaleOf() > 0 ? this.scaleOf() : 1
286
+ }
287
+
288
+ zoomMinOf(): number {
289
+ return this.zoomMin ?? DEFAULT_ZOOM_MIN
290
+ }
291
+
292
+ zoomMaxOf(): number {
293
+ return this.zoomMax ?? DEFAULT_ZOOM_MAX
294
+ }
295
+
296
+ modeOf(): VideoTimelineMode {
297
+ return this.mode ?? 'ripple'
298
+ }
299
+
300
+ trackHeightOf(): number {
301
+ return this.trackHeight ?? DEFAULT_TRACK_HEIGHT
302
+ }
303
+
304
+ laneHeaderWidthOf(): number {
305
+ return this.laneHeaderWidth ?? DEFAULT_LANE_HEADER_WIDTH
306
+ }
307
+
308
+ rulerHeightOf(): number {
309
+ return this.rulerHeight ?? DEFAULT_RULER_HEIGHT
310
+ }
311
+
312
+ bodyWidth(): number {
313
+ return Math.max(0, this.safeDuration() * this.safeScale())
314
+ }
315
+
316
+ ticks(): { time: number; pixel: number }[] {
317
+ return computeRulerTicks(this.safeDuration(), this.safeScale())
318
+ }
319
+
320
+ playheadPx(): number {
321
+ return clipToPixels({ startTime: this.currentTime ?? 0, duration: 0 }, this.safeScale()).left
322
+ }
323
+
324
+ sliderValue(): number {
325
+ return Math.round(clampZoom(this.safeScale(), this.zoomMinOf(), this.zoomMaxOf()))
326
+ }
327
+
328
+ rulerLabel(): string {
329
+ return this.i18n.t('videoTimeline.aria.ruler', {}, { defaultValue: 'Time ruler' })
330
+ }
331
+
332
+ playheadLabel(): string {
333
+ return this.i18n.t(
334
+ 'videoTimeline.aria.playhead',
335
+ { time: (this.currentTime ?? 0).toFixed(2) },
336
+ { defaultValue: 'Playhead at {{time}}s' },
337
+ )
338
+ }
339
+
340
+ zoomLabel(): string {
341
+ return this.i18n.t('videoTimeline.aria.zoom', {}, { defaultValue: 'Timeline zoom' })
342
+ }
343
+
344
+ zoomInLabel(): string {
345
+ return this.i18n.t('videoTimeline.zoom.in', {}, { defaultValue: 'Zoom in' })
346
+ }
347
+
348
+ zoomOutLabel(): string {
349
+ return this.i18n.t('videoTimeline.zoom.out', {}, { defaultValue: 'Zoom out' })
350
+ }
351
+
352
+ modeLabel(): string {
353
+ return this.i18n.t('videoTimeline.aria.mode', {}, { defaultValue: 'Edit mode' })
354
+ }
355
+
356
+ rootLabel(): string {
357
+ return this.i18n.t('videoTimeline.aria.root', {}, { defaultValue: 'Video timeline' })
358
+ }
359
+
360
+ modeText(): string {
361
+ return this.modeOf() === 'ripple'
362
+ ? this.i18n.t('videoTimeline.mode.ripple', {}, { defaultValue: 'Ripple' })
363
+ : this.i18n.t('videoTimeline.mode.insert', {}, { defaultValue: 'Insert' })
364
+ }
365
+
366
+ zoomOutIcon(): string {
367
+ return this.i18n.t('videoTimeline.zoom.out.icon', {}, { defaultValue: '−' })
368
+ }
369
+
370
+ zoomInIcon(): string {
371
+ return this.i18n.t('videoTimeline.zoom.in.icon', {}, { defaultValue: '+' })
372
+ }
373
+
374
+ trackKindLabel(kind: TrackKind): string {
375
+ switch (kind) {
376
+ case 'video':
377
+ return this.i18n.t('videoTimeline.trackKind.video', {}, { defaultValue: 'Video' })
378
+ case 'audio':
379
+ return this.i18n.t('videoTimeline.trackKind.audio', {}, { defaultValue: 'Audio' })
380
+ case 'subtitle':
381
+ return this.i18n.t('videoTimeline.trackKind.subtitle', {}, { defaultValue: 'Subtitle' })
382
+ }
383
+ }
384
+
385
+ laneName(track: Track): string {
386
+ return track.name ?? this.trackKindLabel(track.kind)
387
+ }
4
388
 
389
+ moveFor(track: Track): (clipId: string, startTime: number) => void {
390
+ return (clipId: string, startTime: number) => this.handleClipMove(track.id, clipId, startTime)
391
+ }
392
+
393
+ resizeFor(track: Track): (clipId: string, duration: number) => void {
394
+ return (clipId: string, clipDuration: number) =>
395
+ this.onClipResize?.(clipId, clipDuration, track.id)
396
+ }
397
+
398
+ clickFor(track: Track): (clipId: string) => void {
399
+ return (clipId: string) => this.onClipClick?.(clipId, track.id)
400
+ }
401
+ // … truncated — 21 more members: clientXToTime, onRulerPointerDown, onRulerPointerMove, onRulerPointerUp, onBodyWheel, handleClipMove, zoomOut, zoomIn, handleZoomInput, rulerRowStyle, rulerHeaderStyle, rulerBodyStyle, tickStyle, tickLabelStyle, tickText, playheadInRulerStyle, playheadStyle, playheadSharedStyle, tracksScrollStyle, tracksInnerStyle, ngOnDestroy; the full declaration is in node_modules/@molecule/app-feature-video-timeline-angular/dist/video-timeline.component.d.ts
402
+ ```
403
+
404
+ _(Member comments are left out to fit; the full declaration is in `node_modules/@molecule/app-feature-video-timeline-angular/dist/video-timeline.component.d.ts`.)_
405
+
406
+ ### Functions
407
+
408
+ #### `clampZoom(value, min, max)`
409
+
410
+ Clamp a candidate `pixelsPerSecond` value into `[min, max]`. Used by
411
+ the zoom slider, Ctrl+wheel, and any external zoom button that calls
412
+ `onZoomChange`.
413
+
414
+ ```typescript
415
+ function clampZoom(value: number, min: number, max: number): number
416
+ ```
417
+
418
+ - `value` — Candidate horizontal scale in px/sec.
419
+ - `min` — Lower bound (inclusive).
420
+ - `max` — Upper bound (inclusive).
421
+
422
+ **Returns:** The clamped value.
423
+
424
+ #### `zoomFromWheelDelta(current, deltaY, min, max)`
425
+
426
+ Compute the next zoom value for a Ctrl+wheel notch. Negative `deltaY`
427
+ (scroll-up) zooms in; positive zooms out. Result is clamped into
428
+ `[min, max]`.
429
+
430
+ ```typescript
431
+ function zoomFromWheelDelta(current: number, deltaY: number, min: number, max: number): number
432
+ ```
433
+
434
+ - `current` — Current `pixelsPerSecond`.
435
+ - `deltaY` — Wheel `deltaY` (sign-only — magnitude is ignored).
436
+ - `min` — Lower zoom bound.
437
+ - `max` — Upper zoom bound.
438
+
439
+ **Returns:** The clamped next zoom value.
440
+
441
+ #### `computeRulerTicks(duration, pixelsPerSecond)`
442
+
443
+ Compute time tick marks for the ruler. Picks an interval (1, 2, 5, 10,
444
+ 30, or 60 seconds, etc.) so that adjacent ticks are at least
445
+ `MIN_TICK_PIXEL_SPACING` apart on screen. Always emits a tick at 0 and
446
+ stops at the last tick `<= duration`.
447
+
448
+ ```typescript
449
+ function computeRulerTicks(
450
+ duration: number,
451
+ pixelsPerSecond: number,
452
+ ): { time: number; pixel: number }[]
453
+ ```
454
+
455
+ - `duration` — Total duration in seconds.
456
+ - `pixelsPerSecond` — Horizontal scale.
457
+
458
+ **Returns:** Tick descriptors with `{ time, pixel }`.
459
+
460
+ #### `computeRippleUpdates(clips, draggedClipId, proposedStartTime)`
461
+
462
+ Compute the ripple-mode update for a clip drag on a single lane.
463
+ Returns one update per affected clip — at minimum the dragged clip,
464
+ plus every clip whose original `startTime` is strictly greater (which
465
+ shifts by the same `delta`).
466
+
467
+ Negative deltas are clamped so no clip's `startTime` goes below 0
468
+ (the dragged clip is the limiting factor — later clips can never
469
+ cross zero before it does, since they all started later).
470
+
471
+ ```typescript
472
+ function computeRippleUpdates(
473
+ clips: Clip[],
474
+ draggedClipId: string,
475
+ proposedStartTime: number,
476
+ ): { id: string; startTime: number }[]
477
+ ```
478
+
479
+ - `clips` — All clips on the lane (any order).
480
+ - `draggedClipId` — The id of the clip being dragged.
481
+ - `proposedStartTime` — The candidate new `startTime` for the dragged clip.
482
+
483
+ **Returns:** Array of `{ id, startTime }` updates to apply.
484
+
485
+ #### `formatTickTime(seconds)`
486
+
487
+ Format a tick time for the ruler — `mm:ss` over a minute, `s.s` below.
488
+
489
+ ```typescript
490
+ function formatTickTime(seconds: number): string
491
+ ```
492
+
493
+ - `seconds` — Time in seconds.
494
+
495
+ **Returns:** Formatted string for the tick label.
496
+
497
+ ### Constants
498
+
499
+ #### `DEFAULT_PIXELS_PER_SECOND`
500
+
501
+ Default horizontal scale.
502
+
503
+ ```typescript
504
+ const DEFAULT_PIXELS_PER_SECOND: 20
505
+ ```
506
+
507
+ #### `DEFAULT_ZOOM_MIN`
508
+
509
+ Default lower zoom bound.
510
+
511
+ ```typescript
512
+ const DEFAULT_ZOOM_MIN: 2
5
513
  ```
6
- npm install @molecule/app-feature-video-timeline-angular
514
+
515
+ #### `DEFAULT_ZOOM_MAX`
516
+
517
+ Default upper zoom bound.
518
+
519
+ ```typescript
520
+ const DEFAULT_ZOOM_MAX: 200
7
521
  ```
8
522
 
9
- Part of the [Molecule](https://www.molecule.dev) package fleet. This page carries the manifest summary; the full generated documentation ships with the package's first committed version.
523
+ #### `DEFAULT_TRACK_HEIGHT`
524
+
525
+ Default per-track row height.
526
+
527
+ ```typescript
528
+ const DEFAULT_TRACK_HEIGHT: 44
529
+ ```
530
+
531
+ #### `DEFAULT_LANE_HEADER_WIDTH`
532
+
533
+ Default lane-header column width.
534
+
535
+ ```typescript
536
+ const DEFAULT_LANE_HEADER_WIDTH: 120
537
+ ```
538
+
539
+ #### `DEFAULT_RULER_HEIGHT`
540
+
541
+ Default ruler height.
542
+
543
+ ```typescript
544
+ const DEFAULT_RULER_HEIGHT: 28
545
+ ```
546
+
547
+ #### `ZOOM_WHEEL_FACTOR`
548
+
549
+ Multiplier per Ctrl+wheel notch (positive deltaY zooms out).
550
+
551
+ ```typescript
552
+ const ZOOM_WHEEL_FACTOR: 1.1
553
+ ```
554
+
555
+ #### `MIN_TICK_PIXEL_SPACING`
556
+
557
+ Minimum spacing (px) between adjacent ruler ticks.
558
+
559
+ ```typescript
560
+ const MIN_TICK_PIXEL_SPACING: 60
561
+ ```
562
+
563
+ ## Injection Notes
564
+
565
+ ### Requirements
566
+
567
+ Peer dependencies:
568
+
569
+ - `@angular/common` ^22.0.0
570
+ - `@angular/core` ^22.0.0
571
+ - `@angular/platform-browser` ^22.0.0
572
+ - `@molecule/app-angular` ^3.5.0
573
+ - `@molecule/app-feature-track-lane-angular` ^1.0.0
574
+ - `@molecule/app-ui` ^1.0.1
575
+ - `@molecule/app-ui-angular` ^1.1.0
576
+
577
+ ### Runtime Dependencies
578
+
579
+ - `@angular/common`
580
+ - `@angular/core`
581
+ - `@angular/platform-browser`
582
+ - `@molecule/app-angular`
583
+ - `@molecule/app-feature-track-lane-angular`
584
+ - `@molecule/app-ui`
585
+ - `@molecule/app-ui-angular`
586
+
587
+ - The host IS React's root `<div>` — render `div[mol-video-timeline]` and
588
+ bind the React-named inputs (`[onSeek]`, `[onClipMove]`, … take functions).
589
+ - Requires a bonded ClassMap (`cm.flex`, `cm.cn`, …) and the binding's i18n
590
+ provider for the translated labels — rendering throws without a ClassMap.
591
+ - Ripple mode (default) shifts all later clips on the same lane by the same
592
+ delta when a clip is dragged, preserving inter-clip gaps. Switch to
593
+ `mode="insert"` to drop the dragged clip at its new position without
594
+ disturbing the rest of the lane.
595
+ - Every visible string comes from `useTranslation()` (`videoTimeline.aria.*`,
596
+ `videoTimeline.trackKind.*`, `videoTimeline.mode.*`, `videoTimeline.zoom.*`),
597
+ so a locale switch re-renders the timeline.
598
+
599
+ ## Translations
10
600
 
11
- License: Apache-2.0
601
+ Translation strings are provided by `@molecule/app-locales-feature-video-timeline`.
package/package.json CHANGED
@@ -1,6 +1,6 @@
1
1
  {
2
2
  "name": "@molecule/app-feature-video-timeline-angular",
3
- "version": "0.0.1-stage",
3
+ "version": "1.1.0",
4
4
  "description": "Multi-track video timeline composing track-lane rows with a time ruler, playhead, zoom controls, and ripple/insert edit modes",
5
5
  "homepage": "https://www.molecule.dev/packages/app-feature-video-timeline-angular",
6
6
  "type": "module",
@@ -62,13 +62,13 @@
62
62
  "@angular/compiler-cli": "22.2.3",
63
63
  "@angular/core": "22.2.3",
64
64
  "@angular/platform-browser": "22.2.3",
65
- "@molecule/app-angular": "3.7.2",
65
+ "@molecule/app-angular": "3.9.0",
66
66
  "@molecule/app-feature-track-lane-angular": "1.1.0",
67
67
  "@molecule/app-framework-conformance": "0.0.0",
68
68
  "@molecule/app-i18n": "1.2.2",
69
69
  "@molecule/app-icons": "1.0.4",
70
- "@molecule/app-ui": "1.4.0",
71
- "@molecule/app-ui-angular": "1.2.1",
70
+ "@molecule/app-ui": "1.5.0",
71
+ "@molecule/app-ui-angular": "1.3.1",
72
72
  "@types/node": "26.6.5",
73
73
  "jsdom": "30.1.3",
74
74
  "rxjs": "7.8.2",