@aura3d/editor-runtime 1.0.6 → 1.3.0

package/src/NonlinearAnimationEditor.ts

@@ -0,0 +1,262 @@
+import { TimelineEditorController, type TimelineEditorSnapshot } from "./TimelineEditorController";
+import { TimelineModel, type TimelineClipConfig, type TimelineModelConfig, type TimelineTrackConfig } from "./TimelineModel";
+import { createTimelineTrackConfig, type TimelineEditorTrackKind } from "./TimelineTrackTypes";
+
+export type NonlinearBinAssetKind = "animation" | "audio" | "camera" | "shot" | "sequence" | "caption" | "viseme";
+
+export interface NonlinearBinAsset {
+  readonly id: string;
+  readonly name: string;
+  readonly kind: NonlinearBinAssetKind;
+  readonly assetId?: string | undefined;
+  readonly clipName?: string | undefined;
+  readonly duration?: number | undefined;
+  readonly metadata?: Readonly<Record<string, string | number | boolean>> | undefined;
+}
+
+export interface NonlinearSequenceConfig {
+  readonly id: string;
+  readonly name: string;
+  readonly timeline?: TimelineModelConfig | undefined;
+}
+
+export interface NonlinearSequenceSnapshot {
+  readonly id: string;
+  readonly name: string;
+  readonly trackCount: number;
+  readonly clipCount: number;
+  readonly duration: number;
+}
+
+export interface NonlinearAnimationEditorSnapshot {
+  readonly kind: "nonlinear-animation-editor";
+  readonly activeSequenceId: string;
+  readonly sequenceCount: number;
+  readonly binAssetCount: number;
+  readonly nestedSequenceClipCount: number;
+  readonly totalTrackCount: number;
+  readonly totalClipCount: number;
+  readonly sequences: readonly NonlinearSequenceSnapshot[];
+  readonly activeTimeline: TimelineEditorSnapshot;
+  readonly evidence: {
+    readonly nonlinearSequences: boolean;
+    readonly trimSplitMoveDuplicate: boolean;
+    readonly nestedSequences: boolean;
+    readonly multiTrackTimeline: boolean;
+    readonly serialization: true;
+  };
+}
+
+export interface NonlinearAnimationEditorState {
+  readonly activeSequenceId: string;
+  readonly binAssets: readonly NonlinearBinAsset[];
+  readonly sequences: readonly NonlinearSequenceConfig[];
+}
+
+interface NonlinearSequenceRuntime {
+  readonly id: string;
+  readonly name: string;
+  readonly controller: TimelineEditorController;
+}
+
+export class NonlinearAnimationEditor {
+  private readonly binAssets = new Map<string, NonlinearBinAsset>();
+  private readonly sequences = new Map<string, NonlinearSequenceRuntime>();
+  private activeSequenceId: string;
+
+  constructor(state: NonlinearAnimationEditorState) {
+    if (state.sequences.length === 0) throw new Error("Nonlinear animation editor requires at least one sequence.");
+    for (const asset of state.binAssets) this.addBinAsset(asset);
+    for (const sequence of state.sequences) this.createSequence(sequence);
+    this.activeSequenceId = nonEmpty(state.activeSequenceId, "Active sequence id");
+    this.requireSequence(this.activeSequenceId);
+  }
+
+  addBinAsset(asset: NonlinearBinAsset): NonlinearBinAsset {
+    const clean = sanitizeBinAsset(asset);
+    this.binAssets.set(clean.id, clean);
+    return clean;
+  }
+
+  createSequence(config: NonlinearSequenceConfig): NonlinearSequenceSnapshot {
+    const id = nonEmpty(config.id, "Sequence id");
+    const timeline = new TimelineModel({
+      id,
+      name: config.name,
+      duration: 10,
+      frameRate: 24,
+      loopMode: "none",
+      ...config.timeline
+    });
+    this.sequences.set(id, {
+      id,
+      name: nonEmpty(config.name, "Sequence name"),
+      controller: new TimelineEditorController({ timeline })
+    });
+    return this.sequenceSnapshot(this.requireSequence(id));
+  }
+
+  selectSequence(sequenceId: string): NonlinearAnimationEditorSnapshot {
+    this.activeSequenceId = this.requireSequence(sequenceId).id;
+    return this.snapshot();
+  }
+
+  async addTrack(kind: TimelineEditorTrackKind, name?: string, options: Omit<TimelineTrackConfig, "name" | "type"> = {}): Promise<string> {
+    const track = await this.activeSequence().controller.addTrack(kind, name, options);
+    return track.id;
+  }
+
+  async insertAssetClip(trackId: string, assetId: string, options: Omit<TimelineClipConfig, "name" | "startTime" | "duration" | "assetId" | "clipName"> & {
+    readonly id?: string | undefined;
+    readonly name?: string | undefined;
+    readonly startTime: number;
+    readonly duration?: number | undefined;
+  }): Promise<string> {
+    const asset = this.requireBinAsset(assetId);
+    const clip = await this.activeSequence().controller.addClip(trackId, {
+      ...options,
+      id: options.id ?? `${asset.id}-${Math.round(options.startTime * 1000)}`,
+      name: options.name ?? asset.name,
+      startTime: options.startTime,
+      duration: options.duration ?? asset.duration ?? 1,
+      assetId: asset.assetId ?? asset.id,
+      clipName: asset.clipName ?? asset.name,
+      properties: {
+        ...(options.properties ?? {}),
+        binAssetId: asset.id,
+        binAssetKind: asset.kind
+      }
+    });
+    return clip.id;
+  }
+
+  async insertNestedSequence(trackId: string, sequenceId: string, options: Omit<TimelineClipConfig, "name" | "startTime" | "duration"> & {
+    readonly id?: string | undefined;
+    readonly startTime: number;
+    readonly duration?: number | undefined;
+  }): Promise<string> {
+    const nested = this.requireSequence(sequenceId);
+    const clip = await this.activeSequence().controller.addClip(trackId, {
+      ...options,
+      id: options.id ?? `${sequenceId}-nested-${Math.round(options.startTime * 1000)}`,
+      name: nested.name,
+      startTime: options.startTime,
+      duration: options.duration ?? nested.controller.timeline.duration,
+      properties: {
+        ...(options.properties ?? {}),
+        nestedSequenceId: nested.id
+      }
+    });
+    return clip.id;
+  }
+
+  async moveClip(clipId: string, startTime: number): Promise<void> {
+    await this.activeSequence().controller.moveClip(clipId, startTime);
+  }
+
+  async trimClip(clipId: string, duration: number, startTime?: number): Promise<void> {
+    await this.activeSequence().controller.resizeClip(clipId, duration, startTime);
+  }
+
+  async splitClip(clipId: string, splitTime: number): Promise<readonly string[]> {
+    const clips = await this.activeSequence().controller.splitClip(clipId, splitTime);
+    return clips.map((clip) => clip.id);
+  }
+
+  async duplicateClip(clipId: string, timeOffset?: number): Promise<string> {
+    const clip = await this.activeSequence().controller.duplicateClip(clipId, timeOffset);
+    return clip.id;
+  }
+
+  serialize(): NonlinearAnimationEditorState {
+    return {
+      activeSequenceId: this.activeSequenceId,
+      binAssets: [...this.binAssets.values()],
+      sequences: [...this.sequences.values()].map((sequence) => ({
+        id: sequence.id,
+        name: sequence.name,
+        timeline: sequence.controller.serializeTimeline()
+      }))
+    };
+  }
+
+  snapshot(): NonlinearAnimationEditorSnapshot {
+    const sequences = [...this.sequences.values()];
+    const active = this.activeSequence();
+    const totalTrackCount = sequences.reduce((count, sequence) => count + sequence.controller.timeline.tracks.length, 0);
+    const totalClipCount = sequences.reduce((count, sequence) => count + sequence.controller.timeline.tracks.reduce((clipCount, track) => clipCount + track.clips.length, 0), 0);
+    const nestedSequenceClipCount = sequences.reduce((count, sequence) =>
+      count + sequence.controller.timeline.tracks.reduce((trackCount, track) =>
+        trackCount + track.clips.filter((clip) => typeof clip.properties.nestedSequenceId === "string").length, 0), 0);
+    return {
+      kind: "nonlinear-animation-editor",
+      activeSequenceId: active.id,
+      sequenceCount: sequences.length,
+      binAssetCount: this.binAssets.size,
+      nestedSequenceClipCount,
+      totalTrackCount,
+      totalClipCount,
+      sequences: sequences.map((sequence) => this.sequenceSnapshot(sequence)),
+      activeTimeline: active.controller.snapshot(),
+      evidence: {
+        nonlinearSequences: sequences.length > 1,
+        trimSplitMoveDuplicate: active.controller.history.canUndo || active.controller.history.canRedo,
+        nestedSequences: nestedSequenceClipCount > 0,
+        multiTrackTimeline: totalTrackCount > 1,
+        serialization: true
+      }
+    };
+  }
+
+  private activeSequence(): NonlinearSequenceRuntime {
+    return this.requireSequence(this.activeSequenceId);
+  }
+
+  private requireSequence(id: string): NonlinearSequenceRuntime {
+    const sequence = this.sequences.get(id);
+    if (!sequence) throw new Error(`Unknown nonlinear sequence: ${id}`);
+    return sequence;
+  }
+
+  private requireBinAsset(id: string): NonlinearBinAsset {
+    const asset = this.binAssets.get(id);
+    if (!asset) throw new Error(`Unknown nonlinear bin asset: ${id}`);
+    return asset;
+  }
+
+  private sequenceSnapshot(sequence: NonlinearSequenceRuntime): NonlinearSequenceSnapshot {
+    const timeline = sequence.controller.timeline;
+    return {
+      id: sequence.id,
+      name: sequence.name,
+      trackCount: timeline.tracks.length,
+      clipCount: timeline.tracks.reduce((count, track) => count + track.clips.length, 0),
+      duration: timeline.duration
+    };
+  }
+}
+
+export function createNonlinearAnimationEditor(state: NonlinearAnimationEditorState): NonlinearAnimationEditor {
+  return new NonlinearAnimationEditor(state);
+}
+
+function sanitizeBinAsset(asset: NonlinearBinAsset): NonlinearBinAsset {
+  if (asset.duration !== undefined && (!Number.isFinite(asset.duration) || asset.duration <= 0)) {
+    throw new Error(`Nonlinear bin asset "${asset.id}" duration must be positive when provided.`);
+  }
+  return {
+    id: nonEmpty(asset.id, "Bin asset id"),
+    name: nonEmpty(asset.name, "Bin asset name"),
+    kind: asset.kind,
+    assetId: asset.assetId,
+    clipName: asset.clipName,
+    duration: asset.duration,
+    metadata: asset.metadata
+  };
+}
+
+function nonEmpty(value: string, label: string): string {
+  const trimmed = value.trim();
+  if (!trimmed) throw new Error(`${label} must be a non-empty string.`);
+  return trimmed;
+}

package/src/PropertyPanel.ts

@@ -0,0 +1,82 @@
+import { CommandHistory } from "./CommandHistory";
+import { InspectorModel, type InspectorEditableValue, type InspectorProperty } from "./InspectorModel";
+
+export interface PropertyPanelField extends InspectorProperty {
+  readonly label: string;
+}
+
+export interface PropertyPanelOptions {
+  readonly history?: CommandHistory;
+  readonly inspector?: InspectorModel;
+  readonly onEdit?: (path: readonly string[], value: InspectorEditableValue) => void;
+}
+
+export class PropertyPanel {
+  readonly history: CommandHistory;
+  readonly inspector: InspectorModel;
+  private disposers: (() => void)[] = [];
+
+  constructor(options: PropertyPanelOptions = {}) {
+    this.history = options.history ?? new CommandHistory();
+    this.inspector = options.inspector ?? new InspectorModel();
+  }
+
+  describe(target: object): readonly PropertyPanelField[] {
+    return this.inspector.describe(target).map((property) => ({
+      ...property,
+      label: property.path.join(".")
+    }));
+  }
+
+  async edit(target: object, path: readonly string[], value: InspectorEditableValue): Promise<void> {
+    await this.history.execute(this.inspector.createSetPropertyCommand(target, path, value));
+  }
+
+  render(target: object | undefined, container: HTMLElement, options: Pick<PropertyPanelOptions, "onEdit"> = {}): readonly PropertyPanelField[] {
+    this.dispose();
+    container.replaceChildren();
+    if (!target) return [];
+    const fields = this.describe(target);
+    const documentRef = container.ownerDocument;
+    for (const field of fields) {
+      const row = documentRef.createElement("label");
+      row.className = "aura-property-panel__row";
+      const name = documentRef.createElement("span");
+      name.className = "aura-property-panel__label";
+      name.textContent = field.label;
+      row.append(name);
+      if (field.editable) {
+        const input = documentRef.createElement("input");
+        input.className = "aura-property-panel__input";
+        input.name = field.label;
+        input.value = String(field.value);
+        input.type = field.type === "number" ? "number" : field.type === "boolean" ? "checkbox" : "text";
+        if (field.type === "boolean") input.checked = Boolean(field.value);
+        const change = (): void => {
+          const value = parseInput(input, field.type);
+          void this.edit(target, field.path, value).then(() => options.onEdit?.(field.path, value));
+        };
+        input.addEventListener("change", change);
+        this.disposers.push(() => input.removeEventListener("change", change));
+        row.append(input);
+      } else {
+        const value = documentRef.createElement("span");
+        value.className = "aura-property-panel__value";
+        value.textContent = field.type;
+        row.append(value);
+      }
+      container.append(row);
+    }
+    return fields;
+  }
+
+  dispose(): void {
+    for (const dispose of this.disposers.splice(0)) dispose();
+  }
+}
+
+function parseInput(input: HTMLInputElement, type: InspectorProperty["type"]): InspectorEditableValue {
+  if (type === "number") return Number(input.value);
+  if (type === "boolean") return input.checked;
+  return input.value;
+}

package/src/RenderQueuePanel.ts

@@ -0,0 +1,106 @@
+export type RenderQueuePanelItemStatus = "queued" | "running" | "done" | "failed";
+
+export interface RenderQueuePanelItem {
+  readonly id: string;
+  readonly label: string;
+  readonly status: RenderQueuePanelItemStatus;
+  readonly progress: number;
+  readonly currentFrame?: number;
+  readonly totalFrames?: number;
+  readonly outputPath?: string;
+  readonly error?: string;
+}
+
+export interface RenderQueuePanelSnapshot {
+  readonly kind: "render-queue-panel";
+  readonly itemCount: number;
+  readonly queuedCount: number;
+  readonly runningCount: number;
+  readonly doneCount: number;
+  readonly failedCount: number;
+  readonly progress: number;
+  readonly items: readonly RenderQueuePanelItem[];
+  readonly outputPaths: readonly string[];
+  readonly errors: readonly string[];
+}
+
+export class RenderQueuePanel {
+  private readonly items = new Map<string, RenderQueuePanelItem>();
+
+  constructor(items: readonly RenderQueuePanelItem[] = []) {
+    for (const item of items) this.upsert(item);
+  }
+
+  upsert(item: RenderQueuePanelItem): RenderQueuePanelSnapshot {
+    this.items.set(item.id, sanitizeRenderQueueItem(item));
+    return this.snapshot();
+  }
+
+  updateProgress(id: string, progress: number, options: {
+    readonly currentFrame?: number;
+    readonly totalFrames?: number;
+    readonly status?: RenderQueuePanelItemStatus;
+    readonly outputPath?: string;
+    readonly error?: string;
+  } = {}): RenderQueuePanelSnapshot {
+    const existing = this.items.get(id);
+    if (!existing) throw new Error(`Render queue item does not exist: ${id}`);
+    return this.upsert({
+      ...existing,
+      progress,
+      status: options.status ?? existing.status,
+      currentFrame: options.currentFrame ?? existing.currentFrame,
+      totalFrames: options.totalFrames ?? existing.totalFrames,
+      outputPath: options.outputPath ?? existing.outputPath,
+      error: options.error ?? existing.error
+    });
+  }
+
+  snapshot(): RenderQueuePanelSnapshot {
+    const items = [...this.items.values()].sort((a, b) => a.id.localeCompare(b.id));
+    const sum = items.reduce((total, item) => total + item.progress, 0);
+    return {
+      kind: "render-queue-panel",
+      itemCount: items.length,
+      queuedCount: items.filter((item) => item.status === "queued").length,
+      runningCount: items.filter((item) => item.status === "running").length,
+      doneCount: items.filter((item) => item.status === "done").length,
+      failedCount: items.filter((item) => item.status === "failed").length,
+      progress: items.length === 0 ? 0 : sum / items.length,
+      items,
+      outputPaths: items.flatMap((item) => item.outputPath ? [item.outputPath] : []),
+      errors: items.flatMap((item) => item.error ? [item.error] : [])
+    };
+  }
+}
+
+export function createRenderQueuePanel(items: readonly RenderQueuePanelItem[] = []): RenderQueuePanel {
+  return new RenderQueuePanel(items);
+}
+
+function sanitizeRenderQueueItem(item: RenderQueuePanelItem): RenderQueuePanelItem {
+  const progress = Number.isFinite(item.progress) ? Math.min(1, Math.max(0, item.progress)) : Number.NaN;
+  if (!Number.isFinite(progress)) throw new Error("Render queue item progress must be finite.");
+  if (item.currentFrame !== undefined && (!Number.isFinite(item.currentFrame) || item.currentFrame < 0)) {
+    throw new Error("Render queue currentFrame must be a non-negative finite number.");
+  }
+  if (item.totalFrames !== undefined && (!Number.isFinite(item.totalFrames) || item.totalFrames <= 0)) {
+    throw new Error("Render queue totalFrames must be a positive finite number.");
+  }
+  return {
+    id: nonEmpty(item.id, "Render queue item id"),
+    label: nonEmpty(item.label, "Render queue item label"),
+    status: item.status,
+    progress,
+    currentFrame: item.currentFrame,
+    totalFrames: item.totalFrames,
+    outputPath: item.outputPath,
+    error: item.error
+  };
+}
+
+function nonEmpty(value: string, label: string): string {
+  const trimmed = value.trim();
+  if (!trimmed) throw new Error(`${label} must be a non-empty string.`);
+  return trimmed;
+}

package/src/SceneOutliner.ts

@@ -0,0 +1,78 @@
+import { HierarchyModel, type HierarchyNodeDescriptor } from "./HierarchyModel";
+import type { SelectionId } from "./Selection";
+import type { AnimationSceneNode } from "./AnimationSceneEditor";
+
+export interface SceneOutlinerItem extends HierarchyNodeDescriptor {
+  readonly icon: string;
+  readonly kind: string;
+}
+
+export interface SceneOutlinerOptions {
+  readonly selectedIds?: ReadonlySet<SelectionId>;
+  readonly onSelect?: (id: SelectionId) => void;
+}
+
+export class SceneOutliner {
+  private readonly hierarchy = new HierarchyModel();
+  private disposers: (() => void)[] = [];
+
+  describe(root: AnimationSceneNode, selectedIds: ReadonlySet<SelectionId> = new Set()): readonly SceneOutlinerItem[] {
+    return this.hierarchy.flatten(root, selectedIds).map((item) => {
+      const node = findNode(root, String(item.id));
+      const kind = node?.kind ?? "unknown";
+      return {
+        ...item,
+        kind,
+        icon: iconForKind(kind)
+      };
+    });
+  }
+
+  render(root: AnimationSceneNode, container: HTMLElement, options: SceneOutlinerOptions = {}): readonly SceneOutlinerItem[] {
+    this.dispose();
+    const items = this.describe(root, options.selectedIds);
+    container.replaceChildren();
+    const documentRef = container.ownerDocument;
+    for (const item of items) {
+      const row = documentRef.createElement("button");
+      row.type = "button";
+      row.className = "aura-scene-outliner__item";
+      row.dataset.nodeId = String(item.id);
+      row.dataset.kind = item.kind;
+      row.dataset.selected = String(item.selected);
+      row.style.paddingLeft = `${item.depth * 14}px`;
+      row.textContent = `${item.icon} ${item.name}`;
+      const click = (): void => options.onSelect?.(item.id);
+      row.addEventListener("click", click);
+      this.disposers.push(() => row.removeEventListener("click", click));
+      container.append(row);
+    }
+    return items;
+  }
+
+  dispose(): void {
+    for (const dispose of this.disposers.splice(0)) dispose();
+  }
+}
+
+function iconForKind(kind: string): string {
+  switch (kind) {
+    case "character": return "[CHAR]";
+    case "set": return "[SET]";
+    case "prop": return "[PROP]";
+    case "camera": return "[CAM]";
+    case "light": return "[LIGHT]";
+    case "audio": return "[AUD]";
+    case "material": return "[MAT]";
+    default: return "[NODE]";
+  }
+}
+
+function findNode(root: AnimationSceneNode, id: string): AnimationSceneNode | undefined {
+  if (root.id === id) return root;
+  for (const child of root.children) {
+    const found = findNode(child, id);
+    if (found) return found;
+  }
+  return undefined;
+}