@aura3d/editor-runtime 1.4.0 → 1.4.1

package/src/EditorStateModel.ts

@@ -1,336 +0,0 @@
-import { normalizeGizmoSettings, type GizmoPivotMode, type GizmoSettings, type GizmoSpaceMode } from "./Gizmo";
-
-export interface EditorStateStorage {
-  getItem(key: string): string | null;
-  setItem(key: string, value: string): void;
-  removeItem?(key: string): void;
-}
-
-export interface EditorViewportSettings {
-  readonly showGrid: boolean;
-  readonly gridSize: number;
-  readonly gridSubdivisions: number;
-  readonly showAxisGizmo: boolean;
-  readonly showStats: boolean;
-  readonly showWireframe: boolean;
-  readonly showBounds: boolean;
-  readonly showLights: boolean;
-  readonly showCameras: boolean;
-  readonly fov: number;
-  readonly near: number;
-  readonly far: number;
-}
-
-export interface EditorGridSnapSettings {
-  readonly snapToGrid: boolean;
-  readonly positionSnap: number;
-  readonly rotationSnapEnabled: boolean;
-  readonly rotationSnapDegrees: number;
-  readonly scaleSnapEnabled: boolean;
-  readonly scaleSnap: number;
-}
-
-export interface EditorStateSnapshot {
-  readonly activeTool: string;
-  readonly transformSpace: GizmoSpaceMode;
-  readonly pivotMode: GizmoPivotMode;
-  readonly viewport: EditorViewportSettings;
-  readonly gridSnap: EditorGridSnapSettings;
-  readonly persisted: boolean;
-  readonly storageKey: string;
-  readonly changeCount: number;
-  readonly evidence: {
-    readonly oldCodebasePort: true;
-    readonly persistentEditorState: boolean;
-    readonly viewportSettings: boolean;
-    readonly gridSnapSettings: boolean;
-    readonly transformSpacePivotMode: boolean;
-  };
-}
-
-export interface EditorStateChange {
-  readonly property: string;
-  readonly oldValue: unknown;
-  readonly newValue: unknown;
-}
-
-export interface EditorStateModelOptions {
-  readonly storage?: EditorStateStorage;
-  readonly storageKey?: string;
-}
-
-type Listener = (change: EditorStateChange) => void;
-
-const defaultViewportSettings: EditorViewportSettings = {
-  showGrid: true,
-  gridSize: 10,
-  gridSubdivisions: 10,
-  showAxisGizmo: true,
-  showStats: true,
-  showWireframe: false,
-  showBounds: false,
-  showLights: true,
-  showCameras: true,
-  fov: 60,
-  near: 0.1,
-  far: 1000
-};
-
-const defaultGridSnapSettings: EditorGridSnapSettings = {
-  snapToGrid: true,
-  positionSnap: 1,
-  rotationSnapEnabled: false,
-  rotationSnapDegrees: 15,
-  scaleSnapEnabled: false,
-  scaleSnap: 0.1
-};
-
-export class EditorStateModel {
-  private activeToolRef = "select";
-  private transformSpaceRef: GizmoSpaceMode = "world";
-  private pivotModeRef: GizmoPivotMode = "center";
-  private viewportRef: EditorViewportSettings = defaultViewportSettings;
-  private gridSnapRef: EditorGridSnapSettings = defaultGridSnapSettings;
-  private readonly listeners = new Set<Listener>();
-  private readonly storageKey: string;
-  private readonly storage: EditorStateStorage | undefined;
-  private persisted = false;
-  private changes = 0;
-
-  constructor(options: EditorStateModelOptions = {}) {
-    this.storage = options.storage;
-    this.storageKey = options.storageKey ?? "aura3d:editor-state:externalParity";
-    this.load();
-  }
-
-  get activeTool(): string {
-    return this.activeToolRef;
-  }
-
-  get transformSpace(): GizmoSpaceMode {
-    return this.transformSpaceRef;
-  }
-
-  get pivotMode(): GizmoPivotMode {
-    return this.pivotModeRef;
-  }
-
-  setActiveTool(tool: string): void {
-    const normalized = tool.trim();
-    if (normalized.length === 0) throw new Error("Editor state active tool cannot be empty.");
-    this.setValue("activeTool", this.activeToolRef, normalized, (value) => {
-      this.activeToolRef = value;
-    });
-  }
-
-  setTransformSpace(space: GizmoSpaceMode): void {
-    this.setValue("transformSpace", this.transformSpaceRef, space, (value) => {
-      this.transformSpaceRef = value;
-    });
-  }
-
-  setPivotMode(mode: GizmoPivotMode): void {
-    this.setValue("pivotMode", this.pivotModeRef, mode, (value) => {
-      this.pivotModeRef = value;
-    });
-  }
-
-  configureViewport(settings: Partial<EditorViewportSettings>): EditorViewportSettings {
-    const next = normalizeViewportSettings({ ...this.viewportRef, ...settings });
-    this.setValue("viewport", this.viewportRef, next, (value) => {
-      this.viewportRef = value;
-    });
-    return this.viewportRef;
-  }
-
-  configureGridSnap(settings: Partial<EditorGridSnapSettings>): EditorGridSnapSettings {
-    const next = normalizeGridSnapSettings({ ...this.gridSnapRef, ...settings });
-    this.setValue("gridSnap", this.gridSnapRef, next, (value) => {
-      this.gridSnapRef = value;
-    });
-    return this.gridSnapRef;
-  }
-
-  configureFromGizmoSettings(settings: GizmoSettings): void {
-    this.setTransformSpace(settings.spaceMode);
-    this.setPivotMode(settings.pivotMode);
-    this.configureGridSnap({
-      snapToGrid: settings.snapEnabled,
-      positionSnap: settings.positionSnap,
-      rotationSnapEnabled: settings.snapEnabled,
-      rotationSnapDegrees: settings.rotationSnapDegrees,
-      scaleSnapEnabled: settings.snapEnabled,
-      scaleSnap: settings.scaleSnap
-    });
-  }
-
-  gizmoSettings(): GizmoSettings {
-    return normalizeGizmoSettings({
-      snapEnabled: this.gridSnapRef.snapToGrid,
-      positionSnap: this.gridSnapRef.positionSnap,
-      rotationSnapDegrees: this.gridSnapRef.rotationSnapDegrees,
-      scaleSnap: this.gridSnapRef.scaleSnap,
-      spaceMode: this.transformSpaceRef,
-      pivotMode: this.pivotModeRef
-    });
-  }
-
-  snapPosition(value: number): number {
-    return this.gridSnapRef.snapToGrid ? snap(value, this.gridSnapRef.positionSnap) : value;
-  }
-
-  snapRotation(radians: number): number {
-    return this.gridSnapRef.rotationSnapEnabled ? snap(radians, this.gridSnapRef.rotationSnapDegrees * Math.PI / 180) : radians;
-  }
-
-  snapScale(value: number): number {
-    return this.gridSnapRef.scaleSnapEnabled ? snap(value, this.gridSnapRef.scaleSnap) : value;
-  }
-
-  subscribe(listener: Listener): () => void {
-    this.listeners.add(listener);
-    return () => this.listeners.delete(listener);
-  }
-
-  snapshot(): EditorStateSnapshot {
-    return {
-      activeTool: this.activeToolRef,
-      transformSpace: this.transformSpaceRef,
-      pivotMode: this.pivotModeRef,
-      viewport: this.viewportRef,
-      gridSnap: this.gridSnapRef,
-      persisted: this.persisted,
-      storageKey: this.storageKey,
-      changeCount: this.changes,
-      evidence: {
-        oldCodebasePort: true,
-        persistentEditorState: this.persisted,
-        viewportSettings: this.viewportRef.gridSize > 0 && this.viewportRef.fov > 0 && this.viewportRef.far > this.viewportRef.near,
-        gridSnapSettings: this.gridSnapRef.positionSnap > 0 && this.gridSnapRef.rotationSnapDegrees > 0 && this.gridSnapRef.scaleSnap > 0,
-        transformSpacePivotMode: Boolean(this.transformSpaceRef) && Boolean(this.pivotModeRef)
-      }
-    };
-  }
-
-  reset(): void {
-    this.activeToolRef = "select";
-    this.transformSpaceRef = "world";
-    this.pivotModeRef = "center";
-    this.viewportRef = defaultViewportSettings;
-    this.gridSnapRef = defaultGridSnapSettings;
-    this.changes += 1;
-    this.persist();
-    this.emit({ property: "reset", oldValue: null, newValue: this.snapshot() });
-  }
-
-  private setValue<T>(property: string, current: T, next: T, apply: (value: T) => void): void {
-    if (deepEqual(current, next)) return;
-    apply(next);
-    this.changes += 1;
-    this.persist();
-    this.emit({ property, oldValue: current, newValue: next });
-  }
-
-  private emit(change: EditorStateChange): void {
-    for (const listener of this.listeners) listener(change);
-  }
-
-  private persist(): void {
-    if (!this.storage) return;
-    this.storage.setItem(this.storageKey, JSON.stringify({
-      activeTool: this.activeToolRef,
-      transformSpace: this.transformSpaceRef,
-      pivotMode: this.pivotModeRef,
-      viewport: this.viewportRef,
-      gridSnap: this.gridSnapRef
-    }));
-    this.persisted = true;
-  }
-
-  private load(): void {
-    if (!this.storage) return;
-    const text = this.storage.getItem(this.storageKey);
-    if (!text) return;
-    try {
-      const parsed = JSON.parse(text) as unknown;
-      if (!isRecord(parsed)) return;
-      this.activeToolRef = typeof parsed.activeTool === "string" && parsed.activeTool.trim().length > 0 ? parsed.activeTool : this.activeToolRef;
-      this.transformSpaceRef = parsed.transformSpace === "local" ? "local" : "world";
-      this.pivotModeRef = parsed.pivotMode === "active" || parsed.pivotMode === "individual" ? parsed.pivotMode : "center";
-      this.viewportRef = normalizeViewportSettings({ ...this.viewportRef, ...(isRecord(parsed.viewport) ? parsed.viewport : {}) });
-      this.gridSnapRef = normalizeGridSnapSettings({ ...this.gridSnapRef, ...(isRecord(parsed.gridSnap) ? parsed.gridSnap : {}) });
-      this.persisted = true;
-    } catch {
-      this.persisted = false;
-    }
-  }
-}
-
-export function createMemoryEditorStateStorage(initial: Record<string, string> = {}): EditorStateStorage & { readonly values: Record<string, string> } {
-  const values = { ...initial };
-  return {
-    values,
-    getItem(key) {
-      return values[key] ?? null;
-    },
-    setItem(key, value) {
-      values[key] = value;
-    },
-    removeItem(key) {
-      delete values[key];
-    }
-  };
-}
-
-function normalizeViewportSettings(settings: Partial<EditorViewportSettings>): EditorViewportSettings {
-  return {
-    showGrid: booleanOr(settings.showGrid, defaultViewportSettings.showGrid),
-    gridSize: positive(settings.gridSize, defaultViewportSettings.gridSize),
-    gridSubdivisions: Math.max(1, Math.round(positive(settings.gridSubdivisions, defaultViewportSettings.gridSubdivisions))),
-    showAxisGizmo: booleanOr(settings.showAxisGizmo, defaultViewportSettings.showAxisGizmo),
-    showStats: booleanOr(settings.showStats, defaultViewportSettings.showStats),
-    showWireframe: booleanOr(settings.showWireframe, defaultViewportSettings.showWireframe),
-    showBounds: booleanOr(settings.showBounds, defaultViewportSettings.showBounds),
-    showLights: booleanOr(settings.showLights, defaultViewportSettings.showLights),
-    showCameras: booleanOr(settings.showCameras, defaultViewportSettings.showCameras),
-    fov: clamp(positive(settings.fov, defaultViewportSettings.fov), 10, 140),
-    near: positive(settings.near, defaultViewportSettings.near),
-    far: Math.max(positive(settings.far, defaultViewportSettings.far), positive(settings.near, defaultViewportSettings.near) + 1)
-  };
-}
-
-function normalizeGridSnapSettings(settings: Partial<EditorGridSnapSettings>): EditorGridSnapSettings {
-  return {
-    snapToGrid: booleanOr(settings.snapToGrid, defaultGridSnapSettings.snapToGrid),
-    positionSnap: positive(settings.positionSnap, defaultGridSnapSettings.positionSnap),
-    rotationSnapEnabled: booleanOr(settings.rotationSnapEnabled, defaultGridSnapSettings.rotationSnapEnabled),
-    rotationSnapDegrees: positive(settings.rotationSnapDegrees, defaultGridSnapSettings.rotationSnapDegrees),
-    scaleSnapEnabled: booleanOr(settings.scaleSnapEnabled, defaultGridSnapSettings.scaleSnapEnabled),
-    scaleSnap: positive(settings.scaleSnap, defaultGridSnapSettings.scaleSnap)
-  };
-}
-
-function booleanOr(value: unknown, fallback: boolean): boolean {
-  return typeof value === "boolean" ? value : fallback;
-}
-
-function positive(value: unknown, fallback: number): number {
-  const number = Number(value);
-  return Number.isFinite(number) && number > 0 ? number : fallback;
-}
-
-function clamp(value: number, min: number, max: number): number {
-  return Math.max(min, Math.min(max, value));
-}
-
-function snap(value: number, increment: number): number {
-  return Math.round(value / increment) * increment;
-}
-
-function deepEqual(left: unknown, right: unknown): boolean {
-  return JSON.stringify(left) === JSON.stringify(right);
-}
-
-function isRecord(value: unknown): value is Record<string, unknown> {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}

package/src/EpisodeReviewPanel.ts

@@ -1,236 +0,0 @@
-export type EpisodeReviewStatus = "draft" | "needs-review" | "approved" | "rejected";
-
-export interface EpisodeReviewRejectedFrame {
-  readonly id: string;
-  readonly time: number;
-  readonly reason: string;
-}
-
-export interface EpisodeReviewNote {
-  readonly id: string;
-  readonly author: string;
-  readonly text: string;
-  readonly time?: number;
-}
-
-export interface EpisodeReviewWaveformLane {
-  readonly id: string;
-  readonly label: string;
-  readonly startTime: number;
-  readonly duration: number;
-  readonly peakCount: number;
-  readonly pathPointCount: number;
-}
-
-export interface EpisodeReviewManualVisemeEdit {
-  readonly id: string;
-  readonly characterId: string;
-  readonly visemeId: string;
-  readonly startTime: number;
-  readonly endTime: number;
-  readonly reason?: string;
-}
-
-export interface EpisodeReviewPanelState {
-  readonly packageId: string;
-  readonly packageHash?: string;
-  readonly status: EpisodeReviewStatus;
-  readonly reviewer?: string;
-  readonly approvedAt?: string;
-  readonly notes: readonly EpisodeReviewNote[];
-  readonly rejectedFrames: readonly EpisodeReviewRejectedFrame[];
-  readonly waveformLanes?: readonly EpisodeReviewWaveformLane[];
-  readonly manualVisemeEdits?: readonly EpisodeReviewManualVisemeEdit[];
-}
-
-export interface EpisodeReviewPanelSnapshot extends EpisodeReviewPanelState {
-  readonly kind: "episode-review-panel";
-  readonly approvalRecorded: boolean;
-  readonly rejectedFrameCount: number;
-  readonly noteCount: number;
-  readonly waveformLaneCount: number;
-  readonly manualVisemeEditCount: number;
-  readonly reviewUiEvidence: {
-    readonly waveformReview: boolean;
-    readonly manualVisemeEdits: boolean;
-    readonly visualFrameReview: boolean;
-    readonly reviewerNotes: boolean;
-  };
-}
-
-export class EpisodeReviewPanel {
-  private state: EpisodeReviewPanelState;
-
-  constructor(state: EpisodeReviewPanelState) {
-    this.state = sanitizeReviewState(state);
-  }
-
-  addNote(note: EpisodeReviewNote): EpisodeReviewPanelSnapshot {
-    this.state = sanitizeReviewState({
-      ...this.state,
-      notes: [...this.state.notes, sanitizeReviewNote(note)]
-    });
-    return this.snapshot();
-  }
-
-  rejectFrame(frame: EpisodeReviewRejectedFrame): EpisodeReviewPanelSnapshot {
-    this.state = sanitizeReviewState({
-      ...this.state,
-      status: "rejected",
-      rejectedFrames: [...this.state.rejectedFrames, sanitizeRejectedFrame(frame)]
-    });
-    return this.snapshot();
-  }
-
-  setWaveformLanes(waveformLanes: readonly EpisodeReviewWaveformLane[]): EpisodeReviewPanelSnapshot {
-    this.state = sanitizeReviewState({
-      ...this.state,
-      waveformLanes: waveformLanes.map(sanitizeWaveformLane)
-    });
-    return this.snapshot();
-  }
-
-  applyManualVisemeEdit(edit: EpisodeReviewManualVisemeEdit): EpisodeReviewPanelSnapshot {
-    const sanitized = sanitizeManualVisemeEdit(edit);
-    this.state = sanitizeReviewState({
-      ...this.state,
-      manualVisemeEdits: [
-        ...((this.state.manualVisemeEdits ?? []).filter((candidate) => candidate.id !== sanitized.id)),
-        sanitized
-      ]
-    });
-    return this.snapshot();
-  }
-
-  approve(reviewer: string, approvedAt = new Date(0).toISOString()): EpisodeReviewPanelSnapshot {
-    const name = nonEmpty(reviewer, "Episode review reviewer");
-    if (this.state.rejectedFrames.length > 0) {
-      throw new Error("Episode review cannot be approved while rejected frames are present.");
-    }
-    this.state = sanitizeReviewState({
-      ...this.state,
-      status: "approved",
-      reviewer: name,
-      approvedAt
-    });
-    return this.snapshot();
-  }
-
-  markNeedsReview(): EpisodeReviewPanelSnapshot {
-    this.state = sanitizeReviewState({
-      ...this.state,
-      status: "needs-review",
-      reviewer: undefined,
-      approvedAt: undefined
-    });
-    return this.snapshot();
-  }
-
-  serialize(): EpisodeReviewPanelState {
-    return sanitizeReviewState(this.state);
-  }
-
-  snapshot(): EpisodeReviewPanelSnapshot {
-    const waveformLanes = this.state.waveformLanes ?? [];
-    const manualVisemeEdits = this.state.manualVisemeEdits ?? [];
-    return {
-      kind: "episode-review-panel",
-      ...this.serialize(),
-      approvalRecorded: this.state.status === "approved" && Boolean(this.state.reviewer),
-      rejectedFrameCount: this.state.rejectedFrames.length,
-      noteCount: this.state.notes.length,
-      waveformLaneCount: waveformLanes.length,
-      manualVisemeEditCount: manualVisemeEdits.length,
-      reviewUiEvidence: {
-        waveformReview: waveformLanes.length > 0,
-        manualVisemeEdits: manualVisemeEdits.length > 0,
-        visualFrameReview: this.state.rejectedFrames.length > 0,
-        reviewerNotes: this.state.notes.length > 0
-      }
-    };
-  }
-}
-
-export function createEpisodeReviewPanel(state: EpisodeReviewPanelState): EpisodeReviewPanel {
-  return new EpisodeReviewPanel(state);
-}
-
-function sanitizeReviewState(state: EpisodeReviewPanelState): EpisodeReviewPanelState {
-  return {
-    packageId: nonEmpty(state.packageId, "Episode review packageId"),
-    packageHash: state.packageHash,
-    status: state.status,
-    reviewer: state.reviewer,
-    approvedAt: state.approvedAt,
-    notes: state.notes.map(sanitizeReviewNote),
-    rejectedFrames: state.rejectedFrames.map(sanitizeRejectedFrame),
-    waveformLanes: (state.waveformLanes ?? []).map(sanitizeWaveformLane),
-    manualVisemeEdits: (state.manualVisemeEdits ?? []).map(sanitizeManualVisemeEdit)
-  };
-}
-
-function sanitizeReviewNote(note: EpisodeReviewNote): EpisodeReviewNote {
-  return {
-    id: nonEmpty(note.id, "Episode review note id"),
-    author: nonEmpty(note.author, "Episode review note author"),
-    text: nonEmpty(note.text, "Episode review note text"),
-    time: note.time
-  };
-}
-
-function sanitizeRejectedFrame(frame: EpisodeReviewRejectedFrame): EpisodeReviewRejectedFrame {
-  if (!Number.isFinite(frame.time) || frame.time < 0) {
-    throw new Error("Episode review rejected frame time must be a non-negative finite number.");
-  }
-  return {
-    id: nonEmpty(frame.id, "Episode review rejected frame id"),
-    time: frame.time,
-    reason: nonEmpty(frame.reason, "Episode review rejected frame reason")
-  };
-}
-
-function sanitizeWaveformLane(lane: EpisodeReviewWaveformLane): EpisodeReviewWaveformLane {
-  if (!Number.isFinite(lane.startTime) || lane.startTime < 0) {
-    throw new Error("Episode review waveform lane startTime must be a non-negative finite number.");
-  }
-  if (!Number.isFinite(lane.duration) || lane.duration < 0) {
-    throw new Error("Episode review waveform lane duration must be a non-negative finite number.");
-  }
-  if (!Number.isInteger(lane.peakCount) || lane.peakCount < 0) {
-    throw new Error("Episode review waveform lane peakCount must be a non-negative integer.");
-  }
-  if (!Number.isInteger(lane.pathPointCount) || lane.pathPointCount < 0) {
-    throw new Error("Episode review waveform lane pathPointCount must be a non-negative integer.");
-  }
-  return {
-    id: nonEmpty(lane.id, "Episode review waveform lane id"),
-    label: nonEmpty(lane.label, "Episode review waveform lane label"),
-    startTime: lane.startTime,
-    duration: lane.duration,
-    peakCount: lane.peakCount,
-    pathPointCount: lane.pathPointCount
-  };
-}
-
-function sanitizeManualVisemeEdit(edit: EpisodeReviewManualVisemeEdit): EpisodeReviewManualVisemeEdit {
-  if (!Number.isFinite(edit.startTime) || edit.startTime < 0) {
-    throw new Error("Episode review manual viseme startTime must be a non-negative finite number.");
-  }
-  if (!Number.isFinite(edit.endTime) || edit.endTime <= edit.startTime) {
-    throw new Error("Episode review manual viseme endTime must be greater than startTime.");
-  }
-  return {
-    id: nonEmpty(edit.id, "Episode review manual viseme id"),
-    characterId: nonEmpty(edit.characterId, "Episode review manual viseme characterId"),
-    visemeId: nonEmpty(edit.visemeId, "Episode review manual viseme visemeId"),
-    startTime: edit.startTime,
-    endTime: edit.endTime,
-    reason: edit.reason
-  };
-}
-
-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;
-}