@linto-ai/transcript-ui-core 0.9.0

package/src/core/helpers/renameSpeaker.ts

@@ -0,0 +1,12 @@
+import type { Core } from "../types"
+
+export function renameSpeaker(
+  core: Core,
+  speakerId: string,
+  newName: string,
+): void {
+  const trimmed = newName.trim()
+  const existing = core.speakers.all.get(speakerId)
+  if (!existing || !trimmed || trimmed === existing.name) return
+  core.speakers.update(speakerId, { name: trimmed })
+}

package/src/core/helpers/speakerEquals.ts

@@ -0,0 +1,6 @@
+export function speakerEquals(
+  a: { name: string; color?: string },
+  b: { name: string; color?: string },
+): boolean {
+  return a.name === b.name && a.color === b.color
+}

package/src/core/helpers/switchTurnSpeaker.ts

@@ -0,0 +1,17 @@
+import type { Core } from "../types"
+
+/** Point a turn at another speaker, in every translation that carries the
+ *  turn (translations of a channel share turn ids). */
+export function switchTurnSpeaker(
+  core: Core,
+  turnId: string,
+  newSpeakerId: string,
+): void {
+  for (const channel of core.channels.values()) {
+    for (const translation of channel.translations.values()) {
+      const turn = translation.getTurn(turnId)
+      if (!turn || turn.speakerId === newSpeakerId) continue
+      translation.updateTurn(turnId, { speakerId: newSpeakerId })
+    }
+  }
+}

package/src/core/helpers/test/countTurnsForSpeaker.test.ts

@@ -0,0 +1,16 @@
+import { describe, expect, it } from "bun:test"
+import { countTurnsForSpeaker } from "../countTurnsForSpeaker"
+import { makeTestCore } from "./makeTestCore"
+
+describe("countTurnsForSpeaker", () => {
+  it("counts the turns assigned to the speaker in the active translation", () => {
+    const core = makeTestCore()
+    expect(countTurnsForSpeaker(core, "spk-1")).toBe(2)
+    expect(countTurnsForSpeaker(core, "spk-2")).toBe(1)
+  })
+
+  it("returns 0 for an unknown speaker", () => {
+    const core = makeTestCore()
+    expect(countTurnsForSpeaker(core, "spk-404")).toBe(0)
+  })
+})

package/src/core/helpers/test/createSpeakerAndAssign.test.ts

@@ -0,0 +1,22 @@
+import { describe, expect, it } from "bun:test"
+import { createSpeakerAndAssign } from "../createSpeakerAndAssign"
+import { makeTestCore } from "./makeTestCore"
+
+describe("createSpeakerAndAssign", () => {
+  it("creates the speaker (with a color) and assigns the turn", () => {
+    const core = makeTestCore()
+    const id = createSpeakerAndAssign(core, "turn-1", "Julie")
+    expect(id).not.toBeNull()
+    const speaker = core.speakers.all.get(id!)
+    expect(speaker?.name).toBe("Julie")
+    expect(speaker?.color).toBeTruthy()
+    expect(
+      core.activeChannel.value?.sourceTranslation.getTurn("turn-1")?.speakerId,
+    ).toBe(id)
+  })
+
+  it("returns null on a blank name", () => {
+    const core = makeTestCore()
+    expect(createSpeakerAndAssign(core, "turn-1", "   ")).toBeNull()
+  })
+})

package/src/core/helpers/test/makeTestCore.ts

@@ -0,0 +1,40 @@
+import { createCore } from "../../createCore"
+import type { Core } from "../../types"
+import type { Turn } from "../../../types/editor"
+
+function makeTurn(id: string, speakerId: string | null): Turn {
+  return { id, speakerId, text: `text of ${id}`, words: [], language: "fr" }
+}
+
+/** A core with one channel, one source translation, three turns and two
+ *  speakers — the minimal document the speaker helpers operate on. */
+export function makeTestCore(): Core {
+  const core = createCore()
+  core.setDocument({
+    title: "test",
+    speakers: new Map([
+      ["spk-1", { id: "spk-1", name: "Marie", color: "#111111" }],
+      ["spk-2", { id: "spk-2", name: "Thomas", color: "#222222" }],
+    ]),
+    channels: [
+      {
+        id: "ch-1",
+        name: "channel 1",
+        duration: 60,
+        translations: [
+          {
+            id: "tr-1",
+            languages: ["fr"],
+            isSource: true,
+            turns: [
+              makeTurn("turn-1", "spk-1"),
+              makeTurn("turn-2", "spk-2"),
+              makeTurn("turn-3", "spk-1"),
+            ],
+          },
+        ],
+      },
+    ],
+  })
+  return core
+}

package/src/core/helpers/test/mergeSpeakers.test.ts

@@ -0,0 +1,24 @@
+import { describe, expect, it } from "bun:test"
+import { mergeSpeakers } from "../mergeSpeakers"
+import { makeTestCore } from "./makeTestCore"
+
+describe("mergeSpeakers", () => {
+  it("reassigns every turn then removes the merged-away speaker", () => {
+    const core = makeTestCore()
+    mergeSpeakers(core, "spk-1", "spk-2")
+    const turns = core.activeChannel.value!.sourceTranslation.turns.value
+    expect(turns.every((t) => t.speakerId === "spk-2")).toBe(true)
+    expect(core.speakers.all.has("spk-1")).toBe(false)
+    expect(core.speakers.all.has("spk-2")).toBe(true)
+  })
+
+  it("is a no-op on same ids or unknown speakers", () => {
+    const core = makeTestCore()
+    mergeSpeakers(core, "spk-1", "spk-1")
+    mergeSpeakers(core, "spk-404", "spk-2")
+    expect(core.speakers.all.has("spk-1")).toBe(true)
+    expect(
+      core.activeChannel.value?.sourceTranslation.getTurn("turn-1")?.speakerId,
+    ).toBe("spk-1")
+  })
+})

package/src/core/helpers/test/renameSpeaker.test.ts

@@ -0,0 +1,19 @@
+import { describe, expect, it } from "bun:test"
+import { renameSpeaker } from "../renameSpeaker"
+import { makeTestCore } from "./makeTestCore"
+
+describe("renameSpeaker", () => {
+  it("renames an existing speaker (trimmed)", () => {
+    const core = makeTestCore()
+    renameSpeaker(core, "spk-1", "  Marie Dupont  ")
+    expect(core.speakers.all.get("spk-1")?.name).toBe("Marie Dupont")
+  })
+
+  it("ignores unknown speakers and empty names", () => {
+    const core = makeTestCore()
+    renameSpeaker(core, "spk-404", "X")
+    renameSpeaker(core, "spk-1", "   ")
+    expect(core.speakers.all.get("spk-1")?.name).toBe("Marie")
+    expect(core.speakers.all.has("spk-404")).toBe(false)
+  })
+})

package/src/core/helpers/test/switchTurnSpeaker.test.ts

@@ -0,0 +1,27 @@
+import { describe, expect, it } from "bun:test"
+import { switchTurnSpeaker } from "../switchTurnSpeaker"
+import { makeTestCore } from "./makeTestCore"
+
+function getTurn(core: ReturnType<typeof makeTestCore>, turnId: string) {
+  return core.activeChannel.value?.sourceTranslation.getTurn(turnId)
+}
+
+describe("switchTurnSpeaker", () => {
+  it("reassigns the turn to the new speaker", () => {
+    const core = makeTestCore()
+    switchTurnSpeaker(core, "turn-1", "spk-2")
+    expect(getTurn(core, "turn-1")?.speakerId).toBe("spk-2")
+  })
+
+  it("leaves other turns untouched", () => {
+    const core = makeTestCore()
+    switchTurnSpeaker(core, "turn-1", "spk-2")
+    expect(getTurn(core, "turn-3")?.speakerId).toBe("spk-1")
+  })
+
+  it("ignores unknown turn ids", () => {
+    const core = makeTestCore()
+    switchTurnSpeaker(core, "turn-404", "spk-2")
+    expect(getTurn(core, "turn-1")?.speakerId).toBe("spk-1")
+  })
+})

package/src/core/helpers/updateTurnWords.ts

@@ -0,0 +1,22 @@
+import type { Turn, Word } from "../../types/editor"
+import { findTurnIndex } from "./findTurnIndex"
+
+export function updateTurnWords(
+  turns: Turn[],
+  turnId: string,
+  words: Word[],
+): { turns: Turn[]; updated: Turn } | null {
+  const idx = findTurnIndex(turns, turnId)
+  if (idx === -1) return null
+  const turn = turns[idx]!
+  const updated: Turn = {
+    ...turn,
+    words,
+    text: null,
+    startTime: words[0]?.startTime ?? turn.startTime,
+    endTime: words[words.length - 1]?.endTime ?? turn.endTime,
+  }
+  const next = turns.slice()
+  next[idx] = updated
+  return { turns: next, updated }
+}

package/src/core/index.ts

@@ -0,0 +1,47 @@
+export { createCore } from './createCore'
+export { provideCore, useCore } from './useCore'
+export { CROSS_TRANSLATION_ID } from './stores'
+export type {
+  Core,
+  CorePlugin,
+  CoreEventMap,
+  CoreOptions,
+  CoreCapabilities,
+  TurnEventKey,
+  UISlot,
+  ReadableTranslation,
+  TranslationInfo,
+  TurnStore,
+  TranslationStore,
+  ChannelStore,
+  SpeakersStore,
+  AudioPluginApi,
+  TranscriptionEditorPluginApi,
+  TurnLock,
+  TurnUpdate,
+  WireTurn,
+  TurnSplit,
+  TurnsMerged,
+  TurnDeleted,
+  TurnSpeakerUpdated,
+  SpeakerRenamed,
+  SpeakerReplaced,
+  LivePluginApi,
+  LivePartialEventData,
+  LiveFinalEventData,
+  LiveTranslationEventData,
+  SubtitlePluginApi,
+  WatermarkPluginApi,
+  WatermarkToken,
+  LLMService,
+  LLMServiceInit,
+  LLMServiceStatus,
+  LLMServiceVersion,
+  LLMServiceGeneration,
+  LLMServiceGenerationStatus,
+  LLMServicesPluginApi,
+  ChatRole,
+  ChatMessage,
+  ChatSession,
+  ChatPluginApi,
+} from './types'

package/src/core/modules/eventBus.ts

@@ -0,0 +1,43 @@
+type EventHandler<EventMap, K extends keyof EventMap> = (
+  payload: EventMap[K],
+) => void
+type AnyHandler = (payload: never) => void
+
+export function createEventBus<EventMap>() {
+  const listeners = new Map<keyof EventMap, Set<AnyHandler>>()
+
+  function on<K extends keyof EventMap>(
+    event: K,
+    handler: EventHandler<EventMap, K>,
+  ): () => void {
+    let set = listeners.get(event)
+    if (!set) {
+      set = new Set()
+      listeners.set(event, set)
+    }
+    set.add(handler as AnyHandler)
+    return () => off(event, handler)
+  }
+
+  function off<K extends keyof EventMap>(
+    event: K,
+    handler: EventHandler<EventMap, K>,
+  ): void {
+    listeners.get(event)?.delete(handler as AnyHandler)
+  }
+
+  function emit<K extends keyof EventMap>(
+    event: K,
+    payload: EventMap[K],
+  ): void {
+    listeners.get(event)?.forEach((h) =>
+      (h as EventHandler<EventMap, K>)(payload),
+    )
+  }
+
+  function clear(): void {
+    listeners.clear()
+  }
+
+  return { on, off, emit, clear }
+}

package/src/core/stores/channelStore.ts

@@ -0,0 +1,100 @@
+import { ref, computed, shallowReactive } from "vue"
+import type { Channel } from "../../types/editor"
+import type {
+  ChannelStore,
+  CoreEventMap,
+  ReadableTranslation,
+  TranslationStore,
+} from "../types"
+import { createTranslationStore } from "./translationStore"
+import {
+  CROSS_TRANSLATION_ID,
+  createCrossTranslationStore,
+} from "./crossTranslationStore"
+
+type Emit = <K extends keyof CoreEventMap>(event: K, payload: CoreEventMap[K]) => void
+type On = <K extends keyof CoreEventMap>(
+  event: K,
+  handler: (payload: CoreEventMap[K]) => void,
+) => () => void
+type SpeakersEnsure = (speakerId: string | null, name?: string) => void
+
+export function createChannelStore(
+  channel: Channel,
+  emit: Emit,
+  on: On,
+  speakersEnsure: SpeakersEnsure,
+): ChannelStore {
+  const { id, name, description, duration } = channel
+
+  const translations = shallowReactive(new Map<string, TranslationStore>())
+  let sourceTranslation!: TranslationStore
+
+  for (const tr of channel.translations) {
+    const store = createTranslationStore(tr, emit, speakersEnsure)
+    translations.set(tr.id, store)
+    if (tr.isSource && !sourceTranslation) sourceTranslation = store
+  }
+
+  if (!sourceTranslation) {
+    sourceTranslation = translations.values().next().value!
+  }
+
+  const crossTranslation = createCrossTranslationStore(
+    sourceTranslation,
+    translations,
+    emit,
+    on,
+  )
+
+  const selectableTranslations: ReadableTranslation[] = [...translations.values()]
+  if (crossTranslation) selectableTranslations.push(crossTranslation)
+
+  const activeTranslationId = ref<string | null>(null)
+  const isLoadingHistory = ref(false)
+  const hasMoreHistory = ref(true)
+
+  const activeTranslation = computed<ReadableTranslation>(() => {
+    const activeId = activeTranslationId.value
+    if (activeId === CROSS_TRANSLATION_ID) return crossTranslation ?? sourceTranslation
+    if (activeId) return translations.get(activeId) ?? sourceTranslation
+    return sourceTranslation
+  })
+
+  function setActiveTranslation(translationId: string | null): void {
+    const normalized = translationId === sourceTranslation.id ? null : translationId
+    if (normalized === activeTranslationId.value) return
+    activeTranslationId.value = normalized
+    emit("translation:change", { translationId: activeTranslation.value.id })
+  }
+
+  function reset(): void {
+    for (const translation of translations.values()) {
+      translation.setTurns([])
+    }
+    isLoadingHistory.value = false
+    hasMoreHistory.value = true
+    emit("channel:reset", { channelId: id })
+  }
+
+  function dispose(): void {
+    crossTranslation?.dispose()
+  }
+
+  return {
+    id,
+    name,
+    description,
+    duration,
+    translations,
+    sourceTranslation,
+    crossTranslation,
+    selectableTranslations,
+    activeTranslation,
+    isLoadingHistory,
+    hasMoreHistory,
+    setActiveTranslation,
+    reset,
+    dispose,
+  }
+}

package/src/core/stores/crossTranslationStore.ts

@@ -0,0 +1,141 @@
+import { computed } from "vue"
+import type { Turn } from "../../types/editor"
+import type {
+  CoreEventMap,
+  ReadableTranslation,
+  TranslationStore,
+} from "../types"
+import { extractLangCode } from "../../utils/extractLangCode"
+import { isSameLanguage } from "../../utils/isSameLanguage"
+
+export const CROSS_TRANSLATION_ID = "cross"
+
+type Emit = <K extends keyof CoreEventMap>(
+  event: K,
+  payload: CoreEventMap[K],
+) => void
+type On = <K extends keyof CoreEventMap>(
+  event: K,
+  handler: (payload: CoreEventMap[K]) => void,
+) => () => void
+
+export interface CrossTranslationStore extends ReadableTranslation {
+  /** Unsubscribe the underlying turn-event relay. */
+  dispose(): void
+}
+
+/**
+ * Virtual, read-only translation for a bilingual document: each turn is shown
+ * in the *other* language. Returns null when not applicable — i.e. the source
+ * doesn't have exactly two languages, or a translation track is missing for one
+ * of them. Otherwise turn content is composed from the two matching translation
+ * tracks (keyed by turnId). Stores nothing — `turns` is a computed.
+ *
+ * Because the active-translation event scope filters on `translationId`, and the
+ * real tracks emit under their own id, this store relays their turn events under
+ * `CROSS_TRANSLATION_ID` so that subtitle/scroller listeners fire while cross is
+ * active. Call `dispose()` to detach the relay.
+ */
+export function createCrossTranslationStore(
+  source: TranslationStore,
+  translations: Map<string, TranslationStore>,
+  emit: Emit,
+  on: On,
+): CrossTranslationStore | null {
+  const langs = source.languages.map(extractLangCode)
+  if (langs.length !== 2) return null
+  const tracksByLanguage = new Map<string, TranslationStore>()
+
+  for (const tr of translations.values()) {
+    if (tr.id === source.id) {
+      continue
+    }
+    if (tr.languages.length !== 1) {
+      return null
+    }
+    if (!tr.languages[0]) {
+      return null
+    }
+
+    tracksByLanguage.set(extractLangCode(tr.languages[0]), tr)
+  }
+
+  for (const lang of langs) {
+    if (!tracksByLanguage.has(lang)) {
+      return null
+    }
+  }
+
+  const [langA, langB] = langs
+  if (!langA || !langB) return null
+
+  // The two translation tracks the cross composes from (excludes any extra
+  // language track). Both tracks hold every turn — one in each language — so
+  // membership alone isn't enough to pick a side (see relay below).
+  const crossTrackIds = new Set([
+    tracksByLanguage.get(langA)!.id,
+    tracksByLanguage.get(langB)!.id,
+  ])
+
+  const turns = computed<Turn[]>(() =>
+    source.turns.value.map((turn) => getTurn(turn.id) ?? turn),
+  )
+
+  function getTurn(turnId: string): Turn | undefined {
+    const sourceTurn = source.getTurn(turnId)
+    if (!sourceTurn) return undefined
+
+    const target = isSameLanguage(sourceTurn.language, langA) ? langB : langA
+    if (!target) return sourceTurn
+
+    const targetTurn = tracksByLanguage.get(target)?.getTurn(turnId)
+    if (!targetTurn) return sourceTurn
+
+    return targetTurn
+  }
+
+  // ── Relay underlying track events under the cross id ──────────────────
+  // The active-translation scope filters on translationId, and the real tracks
+  // emit under their own id, so we re-emit as "cross". Both tracks hold every
+  // turn, so we relay only the side opposite the original — i.e. where the
+  // turn's language differs from its sourceLanguage. This is data-driven, so it
+  // doesn't depend on the source/translation event ordering.
+  const unsubs: Array<() => void> = []
+
+  function isOppositeSide(turn: Turn, translationId: string): boolean {
+    if (!crossTrackIds.has(translationId)) return false
+    if (turn.sourceLanguage == null) return true
+    return !isSameLanguage(turn.language, turn.sourceLanguage)
+  }
+
+  function relayAddOrUpdate(event: "turn:add" | "turn:update"): void {
+    unsubs.push(
+      on(event, ({ turn, translationId }) => {
+        if (!isOppositeSide(turn, translationId)) return
+        emit(event, { turn, translationId: CROSS_TRANSLATION_ID })
+      }),
+    )
+  }
+  relayAddOrUpdate("turn:add")
+  relayAddOrUpdate("turn:update")
+  unsubs.push(
+    on("turn:remove", ({ turnId, translationId }) => {
+      if (!crossTrackIds.has(translationId)) return
+      emit("turn:remove", { turnId, translationId: CROSS_TRANSLATION_ID })
+    }),
+  )
+
+  function dispose(): void {
+    unsubs.forEach((fn) => fn())
+    unsubs.length = 0
+  }
+
+  return {
+    id: CROSS_TRANSLATION_ID,
+    isSource: false,
+    languages: source.languages,
+    turns,
+    getTurn,
+    dispose,
+  }
+}

package/src/core/stores/index.ts

@@ -0,0 +1,7 @@
+export { createTranslationStore } from "./translationStore"
+export {
+  createCrossTranslationStore,
+  CROSS_TRANSLATION_ID,
+} from "./crossTranslationStore"
+export { createChannelStore } from "./channelStore"
+export { createSpeakersStore } from "./speakersStore"

package/src/core/stores/speakersStore.ts

@@ -0,0 +1,53 @@
+import { shallowReactive } from "vue"
+import type { Speaker } from "../../types/editor"
+import type { CoreEventMap, SpeakersStore } from "../types"
+import { ensureSpeaker } from "../helpers/ensureSpeaker"
+import { speakerEquals } from "../helpers/speakerEquals"
+
+type Emit = <K extends keyof CoreEventMap>(event: K, payload: CoreEventMap[K]) => void
+
+export function createSpeakersStore(
+  emit: Emit,
+): SpeakersStore & { clear(): void } {
+  const all = shallowReactive(new Map<string, Speaker>())
+
+  function ensure(speakerId: string | null, name?: string): void {
+    const speaker = ensureSpeaker(all, speakerId, name)
+    if (!speaker) return
+    all.set(speaker.id, speaker)
+    emit("speaker:add", { speaker })
+  }
+
+  function update(speakerId: string, patch: Partial<Omit<Speaker, "id">>): void {
+    const existing = all.get(speakerId)
+    if (!existing) return
+    const updated = { ...existing, ...patch }
+    if (speakerEquals(existing, updated)) return
+    all.set(speakerId, updated)
+    emit("speaker:update", { speaker: updated })
+  }
+
+  function updateOrCreate(speaker: Speaker): void {
+    const existing = all.get(speaker.id)
+    if (existing) {
+      if (speakerEquals(existing, speaker)) return
+      all.set(speaker.id, speaker)
+      emit("speaker:update", { speaker })
+    } else {
+      all.set(speaker.id, speaker)
+      emit("speaker:add", { speaker })
+    }
+  }
+
+  function remove(speakerId: string): void {
+    if (!all.has(speakerId)) return
+    all.delete(speakerId)
+    emit("speaker:remove", { speakerId })
+  }
+
+  function clear(): void {
+    all.clear()
+  }
+
+  return { all, ensure, update, updateOrCreate, delete: remove, clear }
+}