@linto-ai/transcript-ui-core 0.9.3 → 0.9.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@linto-ai/transcript-ui-core",
-  "version": "0.9.3",
+  "version": "0.9.6",
   "description": "State layer and UI shell for @linto-ai/transcript-ui — core, stores, format adapters, and the TranscriptUI component",
   "keywords": [
     "vue",

package/src/components/SidebarDrawer.vue

@@ -17,11 +17,11 @@ const { t } = useI18n()
 <template>
   <DialogRoot v-model:open="open">
     <DialogPortal disabled>
-      <DialogOverlay class="editor-overlay" />
-      <DialogContent class="sidebar-drawer">
-        <DialogTitle class="sr-only">{{ t("sidebar.speakers") }}</DialogTitle>
+      <DialogOverlay class="transcript-ui-overlay" />
+      <DialogContent class="transcript-ui-sidebar-drawer">
+        <DialogTitle class="transcript-ui-sr-only">{{ t("sidebar.speakers") }}</DialogTitle>
         <DialogClose
-          class="sidebar-close"
+          class="transcript-ui-sidebar-close"
           :aria-label="t('header.closeSidebar')">
           <X :size="20" />
         </DialogClose>

package/src/components/TabBar.vue

@@ -45,7 +45,6 @@ function onSelect(value: string): void {
 
 <template>
   <Tabs
-    v-if="core.llmServices"
     :tabs="tabs"
     :model-value="modelValue"
     @update:model-value="onSelect" />

package/src/components/TranscriptUI.vue

@@ -45,7 +45,7 @@ defineExpose({ core })
 </script>
 
 <template>
-  <div class="editor-root">
+  <div class="transcript-ui-root">
     <Layout
       v-if="core.channels.size"
       :show-header="!props.noHeader" />
@@ -61,7 +61,7 @@ defineExpose({ core })
 @import "@linto-ai/transcript-ui-ui/styles/popover-list.css";
 
 /* Positioning context for the absolute loading overlay. */
-.editor-root {
+.transcript-ui-root {
   position: relative;
   height: 100%;
 }

package/src/components/VerbatimPanel.vue

@@ -1,5 +1,5 @@
 <script setup lang="ts">
-import { DocumentArticle, type DownloadFormat, DownloadMenu } from "@linto-ai/transcript-ui-ui"
+import { DocumentArticle, DownloadMenu } from "@linto-ai/transcript-ui-ui"
 import { computed } from "vue"
 import { useI18n } from "@linto-ai/transcript-ui-i18n"
 import { useCore } from "../core"
@@ -8,14 +8,6 @@ import * as utils from "../utils"
 const core = useCore()
 const { locale } = useI18n()
 
-const formats: DownloadFormat[] = [
-  { format: "docx", labelKey: "format.docx" },
-  { format: "pdf", labelKey: "format.pdf" },
-  { format: "txt", labelKey: "format.txt" },
-  { format: "json", labelKey: "format.json" },
-  { format: "whisperx", labelKey: "format.whisperx" },
-]
-
 const turns = computed(
   () => core.activeChannel.value?.activeTranslation.value.turns.value ?? [],
 )
@@ -45,17 +37,38 @@ function turnText(turn: {
   return turn.words.map((w) => w.text).join(" ")
 }
 
+// "txt" needs no backend — it's just the turns joined into text — so it's
+// the one format the core always fulfills itself. Anything else (docx, pdf,
+// whisperx…) only exists once the host lists it in verbatimFormats, and is
+// then always the host's to fulfill via "verbatim:export".
+function exportAsText(): void {
+  const text = utils.buildVerbatimText(
+    title.value,
+    turns.value.map((turn) => ({
+      speakerName: speakerName(turn.speakerId),
+      time: turn.startTime != null ? utils.formatTime(turn.startTime) : null,
+      languageName: turn.language ? languageName(turn.language) : null,
+      text: turnText(turn),
+    })),
+  )
+  utils.downloadTextFile(`${title.value || "transcript"}.txt`, text)
+}
+
 function onExport(format?: string): void {
   if (!format) return
+  if (format === "txt" && core.verbatimFormatsAreDefault) {
+    exportAsText()
+    return
+  }
   core.emit("verbatim:export", { format })
 }
 </script>
 
 <template>
   <section class="verbatim-panel">
-    <DocumentArticle :formats="formats" @export="onExport">
+    <DocumentArticle>
       <template #toolbar-right>
-        <DownloadMenu :formats="formats" @select="onExport" />
+        <DownloadMenu :formats="core.verbatimFormats" @select="onExport" />
       </template>
 
       <article class="verbatim-panel__content">

package/src/core/createCore.ts

@@ -1,4 +1,5 @@
 import { ref, computed, shallowReactive, type Component } from "vue"
+import type { DownloadFormat } from "@linto-ai/transcript-ui-ui"
 import type { Channel, EditorDocument } from "../types/editor"
 import type {
   Core,
@@ -17,6 +18,12 @@ import { ensureDocumentSpeakers } from "./helpers/ensureDocumentSpeakers"
 import { ensureSpeakersFromTurns } from "./helpers/ensureSpeakersFromTurns"
 import * as utils from "../utils"
 
+// No backend can generate this — it's just the turns joined into text — so
+// it's the one format the core always offers and fulfills itself.
+const DEFAULT_VERBATIM_FORMATS: DownloadFormat[] = [
+  { format: "txt", labelKey: "format.txt" },
+]
+
 export function createCore(options: CoreOptions = {}): Core {
   // ── State ──────────────────────────────────────────────────────────
 
@@ -26,6 +33,9 @@ export function createCore(options: CoreOptions = {}): Core {
   const capabilities = ref<CoreCapabilities>(
     options.capabilities ?? { text: "edit", speakers: "edit" },
   )
+  const verbatimFormatsAreDefault = options.verbatimFormats == null
+  const verbatimFormats =
+    options.verbatimFormats ?? DEFAULT_VERBATIM_FORMATS
 
   // ── Event bus ──────────────────────────────────────────────────────
 
@@ -143,6 +153,8 @@ export function createCore(options: CoreOptions = {}): Core {
     date,
     activeChannelId,
     capabilities,
+    verbatimFormats,
+    verbatimFormatsAreDefault,
     speakers,
     channels,
     activeChannel,

package/src/core/types.ts

@@ -1,4 +1,5 @@
 import type { Component, ComputedRef, Ref, ShallowRef } from "vue"
+import type { DownloadFormat } from "@linto-ai/transcript-ui-ui"
 import type {
   AudioSource,
   Channel,
@@ -149,6 +150,19 @@ export interface CoreOptions {
   document?: EditorDocument
   activeChannelId?: string
   capabilities?: CoreCapabilities
+  /**
+   * Formats offered in the verbatim panel's download menu. The host knows
+   * which export backends actually exist (docx/pdf generation, whisperx
+   * alignment…) — the core doesn't assume any of them, so it stays empty by
+   * default in the sense that the host owns the whole list once it supplies
+   * one: every format then goes through the "verbatim:export" event for the
+   * host to fulfill.
+   *
+   * Left unset, the core falls back to a single "txt" entry it fulfills
+   * itself — no backend needed, it just joins the turns into a plain-text
+   * file client-side.
+   */
+  verbatimFormats?: DownloadFormat[]
 }
 
 // ── Audio Plugin API ────────────────────────────────────────────────────
@@ -556,6 +570,11 @@ export interface Core {
   readonly date: Ref<string | number | null>
   readonly activeChannelId: Ref<string>
   readonly capabilities: Ref<CoreCapabilities>
+  /** Formats shown in the verbatim panel's download menu (see CoreOptions.verbatimFormats). */
+  readonly verbatimFormats: DownloadFormat[]
+  /** True when verbatimFormats is the built-in default — the verbatim panel
+   *  then fulfills "txt" itself instead of emitting "verbatim:export". */
+  readonly verbatimFormatsAreDefault: boolean
 
   // ── Stores ───────────────────────────────────────────────────────────
   readonly speakers: SpeakersStore

package/src/utils/buildVerbatimText.ts

@@ -0,0 +1,28 @@
+/** One turn's data, already resolved to display strings — this function only
+ *  formats/joins, it doesn't know about speakers, i18n, or date formatting. */
+export interface VerbatimTextTurn {
+  speakerName: string
+  time: string | null
+  languageName: string | null
+  text: string
+}
+
+/** Plain-text rendering of a verbatim document: the title, then each turn as
+ *  a "Speaker · time · language" header line followed by its text. */
+export function buildVerbatimText(
+  title: string,
+  turns: VerbatimTextTurn[],
+): string {
+  const lines: string[] = []
+  if (title) lines.push(title, "")
+
+  for (const turn of turns) {
+    const meta = [turn.speakerName, turn.time, turn.languageName]
+      .filter(Boolean)
+      .join(" · ")
+    if (meta) lines.push(meta)
+    lines.push(turn.text, "")
+  }
+
+  return lines.join("\n").trimEnd() + "\n"
+}

package/src/utils/downloadTextFile.ts

@@ -0,0 +1,13 @@
+// Browser file-download helper (Blob + <a download>) for exports the core
+// fulfills itself client-side — no backend involved.
+
+export function downloadTextFile(filename: string, content: string): void {
+  const blob = new Blob([content], { type: "text/plain;charset=utf-8" })
+  const url = URL.createObjectURL(blob)
+  const link = document.createElement("a")
+  link.href = url
+  link.download = filename
+  link.click()
+  // Deferred: revoking synchronously can cancel the download in some browsers.
+  setTimeout(() => URL.revokeObjectURL(url), 0)
+}

package/src/utils/index.ts

@@ -15,5 +15,8 @@ export { renderWaveform, normalizePeaks } from "./waveform"
 export { findActiveWord, hasWordTimestamps, firstWordStart, lastWordEnd } from "./words"
 export { speakText, stopTTS, unlockTTS, isTTSSupported, hasVoices } from "./tts"
 export { computeTurnPlainText } from "./computeTurnPlainText"
+export { buildVerbatimText } from "./buildVerbatimText"
+export type { VerbatimTextTurn } from "./buildVerbatimText"
+export { downloadTextFile } from "./downloadTextFile"
 export { wordsFromText, wordsFromApi, carryWordTimes, layoutWords, parseWordId, wordId } from "./turnWords"
 export type { TimedText } from "./turnWords"

package/src/utils/test/buildVerbatimText.test.ts

@@ -0,0 +1,46 @@
+import { describe, expect, it } from "bun:test"
+import { buildVerbatimText, type VerbatimTextTurn } from "../buildVerbatimText"
+
+function makeTurn(partial: Partial<VerbatimTextTurn>): VerbatimTextTurn {
+  return {
+    speakerName: "",
+    time: null,
+    languageName: null,
+    text: "",
+    ...partial,
+  }
+}
+
+describe("buildVerbatimText", () => {
+  it("starts with the title followed by a blank line before the first turn", () => {
+    const result = buildVerbatimText("Réunion projet X", [
+      makeTurn({ text: "Bonjour" }),
+    ])
+    expect(result).toStartWith("Réunion projet X\n\nBonjour")
+  })
+
+  it("omits the title block when there is none", () => {
+    const result = buildVerbatimText("", [makeTurn({ text: "Bonjour" })])
+    expect(result).not.toStartWith("\n")
+  })
+
+  it("joins the present meta fields with a middle dot, skipping missing ones", () => {
+    const result = buildVerbatimText("", [
+      makeTurn({ speakerName: "Marie", time: "00:12", text: "Salut" }),
+    ])
+    expect(result).toContain("Marie · 00:12\nSalut")
+  })
+
+  it("drops the meta line entirely when nothing resolved", () => {
+    const result = buildVerbatimText("", [makeTurn({ text: "Texte seul" })])
+    expect(result).toBe("Texte seul\n")
+  })
+
+  it("renders one block per turn, in order", () => {
+    const result = buildVerbatimText("", [
+      makeTurn({ speakerName: "Marie", text: "Bonjour" }),
+      makeTurn({ speakerName: "Thomas", text: "Salut" }),
+    ])
+    expect(result).toBe("Marie\nBonjour\n\nThomas\nSalut\n")
+  })
+})