@hachej/boring-ui-kit 0.4.26 → 0.4.28

package/dist/chat-voice-message.js

@@ -0,0 +1,235 @@
+'use client';
+import { useCallback, useEffect, useLayoutEffect, useRef, useState, useSyncExternalStore } from 'react';
+import { appendToDraft, isVoicePath, mentionedPaths, mentionToken, voiceRefusalLabel, withoutMentions } from './chat-text.js';
+import { useVoiceAttempt } from './voice-attempt.js';
+import { useDictation } from './chat-dictation.js';
+const targetOf = (controller) => {
+    const { identity, conversationId } = controller.getSnapshot();
+    return JSON.stringify([identity.runtimeId, identity.scopeId, identity.principalId, conversationId]);
+};
+const noSubscribe = () => () => { };
+/** Local admission preparation only. Native send/reconcile owns the submission; uploaded bytes stay in the host workspace. */
+export function useVoiceMessage({ controller, config, attachments, labels, admitted, activeController }) {
+    const selected = config ? controller : undefined;
+    const readObservation = useCallback(() => {
+        if (!selected)
+            return '';
+        const snapshot = selected.getSnapshot(), send = snapshot.send;
+        return JSON.stringify([targetOf(selected), snapshot.disposed, send.kind, 'attempt' in send ? send.attempt.requestId : undefined]);
+    }, [selected]);
+    const observation = useSyncExternalStore(selected?.subscribe ?? noSubscribe, readObservation, readObservation);
+    const latest = useRef({ controller, config, admitted, activeController });
+    useLayoutEffect(() => { latest.current = { controller, config, admitted, activeController }; });
+    const [problem, setProblem] = useState();
+    const core = useVoiceAttempt({
+        valid: item => latest.current.controller === item.controller && (!latest.current.activeController || latest.current.activeController.current === item.controller) && Boolean(latest.current.config) && !item.controller.getSnapshot().disposed && targetOf(item.controller) === item.target,
+        refused: result => setProblem(labels[voiceRefusalLabel[result.code ?? 'failed']]),
+    });
+    const { valid, remove, clear, update } = core;
+    const active = () => core.current().find(item => item.phase === 'starting' || item.phase === 'recording') ?? core.current().find(item => item.phase === 'processing' || item.phase === 'sending' || item.phase === 'unconfirmed');
+    const cancel = () => { const item = active(); if (item)
+        remove(item); };
+    const target = selected ? targetOf(selected) : undefined;
+    const configured = Boolean(config);
+    // eslint-disable-next-line react-hooks/exhaustive-deps, react-hooks/set-state-in-effect -- another controller, conversation or config drops the attempts and the problem, once per change
+    useEffect(() => { clear(); setProblem(undefined); }, [controller, target, configured]);
+    useEffect(() => {
+        for (const item of [...core.current()]) {
+            if (!valid(item)) {
+                remove(item);
+                continue;
+            }
+            if (item.phase !== 'unconfirmed')
+                continue;
+            const snapshot = selected?.getSnapshot();
+            if (snapshot?.send.kind === 'admitted' && 'attempt' in snapshot.send && snapshot.send.attempt.requestId === item.requestId) {
+                remove(item);
+                latest.current.admitted?.();
+                // eslint-disable-next-line react-hooks/set-state-in-effect -- the chat's send state settles an unconfirmed attempt; update() republishes the attempt ref
+            }
+            else if (snapshot?.send.kind === 'blocked') {
+                item.phase = 'blocked';
+                update();
+            }
+        }
+        // eslint-disable-next-line react-hooks/exhaustive-deps -- runs when the chat's observation changes; remove/update are per-render closures over refs
+    }, [selected, observation]);
+    const send = async (item, audioOnly = false) => {
+        if (!valid(item) || !item.path || item.phase === 'sending' || item.phase === 'unconfirmed')
+            return;
+        const transcript = audioOnly ? '' : item.transcript ?? '';
+        const text = [...item.mentions.map(mentionToken), mentionToken(item.path), transcript].filter(Boolean).join(' ');
+        const before = item.controller.getSnapshot();
+        if (before.send.kind === 'unknown') {
+            // This recording was never submitted. Do not bind it to another message's uncertain request.
+            const draft = item.controller.getSnapshot().draft.text;
+            if (transcript)
+                item.controller.setText(appendToDraft(draft, transcript));
+            item.phase = 'blocked';
+            update();
+            return;
+        }
+        item.phase = 'sending';
+        update();
+        let submittedDraft;
+        try {
+            const pending = item.controller.send('followUp', { text, restore: { text: transcript } });
+            const after = item.controller.getSnapshot();
+            // Native send synchronously publishes this immutable draft in validation or at its outbox position; equal text is not identity.
+            submittedDraft = after.send.kind === 'validating' && (before.send.kind !== 'validating' || after.send.draft !== before.send.draft)
+                ? after.send.draft : after.outbox[before.outbox.length];
+            const result = await pending;
+            if (!valid(item))
+                return;
+            if (result) {
+                remove(item);
+                latest.current.admitted?.();
+                return;
+            }
+        }
+        catch {
+            if (!valid(item))
+                return;
+            const draft = item.controller.getSnapshot().draft.text;
+            if (transcript)
+                item.controller.setText(appendToDraft(draft, transcript));
+        }
+        const native = item.controller.getSnapshot().send;
+        if (native.kind === 'admitted' && 'attempt' in native && submittedDraft !== undefined && native.attempt.draft === submittedDraft) {
+            remove(item);
+            latest.current.admitted?.();
+            return;
+        }
+        const ownUnknown = native.kind === 'unknown' && 'attempt' in native && submittedDraft !== undefined && native.attempt.draft === submittedDraft;
+        item.phase = native.kind === 'blocked' || (native.kind === 'unknown' && 'attempt' in native && !ownUnknown) ? 'blocked' : 'unconfirmed';
+        if (ownUnknown)
+            item.requestId = native.attempt.requestId;
+        update();
+    };
+    const process = async (item) => {
+        if (!valid(item) || !item.file)
+            return;
+        item.phase = 'processing';
+        update();
+        // Cache each successful half independently: retrying transcription must not upload the same recording again.
+        await Promise.all([
+            item.path ? undefined : (async () => {
+                try {
+                    const results = await item.upload?.([item.file], item.abort.signal);
+                    const path = results?.length === 1 ? results[0]?.path : undefined;
+                    if (valid(item) && path && isVoicePath(path))
+                        item.path = path;
+                }
+                catch { /* Failed uploads remain pending for explicit retry. */ }
+            })(),
+            item.transcript !== undefined ? undefined : (async () => {
+                try {
+                    const text = (await item.transcribe(item.file, item.abort.signal)).trim();
+                    if (valid(item) && text)
+                        item.transcript = text;
+                }
+                catch { /* Never send automatically when transcription fails. */ }
+            })(),
+        ]);
+        if (!valid(item))
+            return;
+        if (!item.path) {
+            item.phase = 'upload-failed';
+            update();
+        }
+        else if (!item.transcript) {
+            item.phase = 'transcribe-failed';
+            update();
+        }
+        else
+            await send(item);
+    };
+    const finish = () => {
+        const item = active();
+        if (!item || !valid(item))
+            return;
+        if (item.phase === 'starting') {
+            cancel();
+            return;
+        }
+        if (item.phase !== 'recording')
+            return;
+        const draft = item.controller.getSnapshot().draft.text;
+        item.mentions = mentionedPaths(draft);
+        item.controller.setText(withoutMentions(draft));
+        void (async () => {
+            const recording = await core.stop(item);
+            if (!valid(item))
+                return;
+            if (!recording) {
+                remove(item);
+                setProblem(labels.voiceNothingHeard);
+                update();
+                return;
+            }
+            const type = recording.mimeType.split(';')[0], ext = type === 'audio/wav' ? 'wav' : type === 'audio/mp4' ? 'mp4' : type === 'audio/ogg' ? 'ogg' : 'webm';
+            const stamp = new Date().toISOString().replace(/[-:]/g, '').replace('T', '-').replace(/\.(\d+)Z$/, '-$1');
+            item.file = new File([recording.audio], `voice-${stamp}.${ext}`, { type });
+            await process(item);
+        })();
+    };
+    const start = () => {
+        if (!controller || !config || active() || controller.getSnapshot().disposed || controller.getSnapshot().send.kind === 'unknown')
+            return;
+        setProblem(undefined);
+        core.start({ controller, mentions: [], transcribe: config.transcribe.bind(config), upload: config.upload?.bind(config) ?? attachments?.upload.bind(attachments), target: targetOf(controller) }, config.maxMs);
+    };
+    // eslint-disable-next-line react-hooks/refs -- the attempts live in a ref that every change pairs with update(); render reads the list as of that update
+    const item = active();
+    // eslint-disable-next-line react-hooks/refs -- the attempts live in a ref that every change pairs with update(); render reads the list as of that update
+    const pending = core.attempts.filter(item => item.phase !== 'starting' && item.phase !== 'recording').map(item => ({
+        id: item.id, path: item.path, phase: item.phase, seconds: item.seconds,
+        retry: () => { if (item.phase === 'upload-failed' || item.phase === 'transcribe-failed')
+            void process(item); },
+        audioOnly: item.phase === 'transcribe-failed' && item.path ? () => { if (item.phase === 'transcribe-failed')
+            void send(item, true); } : undefined,
+        discard: () => { if (valid(item))
+            remove(item); },
+    }));
+    // eslint-disable-next-line react-hooks/refs -- the capture sequence is a ref bumped with update(); render reads it as of that update
+    return { canStart: Boolean(controller && config && !item && !controller.getSnapshot().disposed && controller.getSnapshot().send.kind !== 'unknown'), phase: item?.phase ?? 'idle', seconds: item?.seconds ?? 0, levels: item?.levels ?? [], paused: item?.paused ?? false,
+        pause: item?.phase === 'recording' && item.canPause ? () => core.pause(item) : undefined,
+        resume: item?.phase === 'recording' && item.canPause ? () => core.resume(item) : undefined,
+        captureSequence: core.captureSequence, problem, pending, start, finish, cancel };
+}
+/** Selects retained voice messages or text-only dictation without putting send/draft policy in copied shells. */
+export function useChatVoice({ controller, voice, attachments, labels, onDone }) {
+    const message = useVoiceMessage({ controller, config: voice?.send === 'message' ? voice : undefined, attachments, labels, admitted: () => onDone('sent') });
+    const dictation = useDictation({
+        transcribe: voice?.send === 'message' ? undefined : voice?.transcribe, labels, maxMs: voice?.maxMs, target: controller,
+        onText: async (spoken, signal) => {
+            if (!controller || signal.aborted)
+                return;
+            const fill = () => {
+                if (signal.aborted)
+                    return;
+                controller.setText(appendToDraft(controller.getSnapshot().draft.text, spoken));
+                onDone('drafted');
+            };
+            if (voice?.send !== 'auto') {
+                fill();
+                return;
+            }
+            const draft = controller.getSnapshot().draft.text;
+            const paths = mentionedPaths(draft);
+            controller.setText(withoutMentions(draft));
+            try {
+                const sent = await controller.send(undefined, { text: [...paths.map(mentionToken), spoken].join(' '), restore: { text: spoken } });
+                if (!signal.aborted)
+                    onDone(sent ? 'sent' : 'drafted');
+            }
+            catch {
+                fill();
+            }
+        },
+    });
+    const { cancel } = dictation, send = voice?.send, configured = Boolean(voice);
+    useEffect(() => () => cancel(), [controller, send, configured, cancel]);
+    const phase = message.phase === 'starting' || message.phase === 'recording' ? message.phase : message.phase === 'processing' || message.phase === 'sending' ? 'transcribing' : 'idle';
+    return send === 'message' ? { ...message, phase, levels: message.levels ?? [], paused: message.paused ?? false, pause: message.pause, resume: message.resume } : dictation;
+}

package/dist/chat-voice.d.ts

@@ -0,0 +1,7 @@
+export { useVoiceAttempt } from './voice-attempt.js';
+export type { VoiceAttempt, VoiceAttemptOptions } from './voice-attempt.js';
+export { useDictation } from './chat-dictation.js';
+export type { Dictation, DictationPhase, DictationLabels, DictationOptions } from './chat-dictation.js';
+export { useChatVoice, useVoiceMessage } from './chat-voice-message.js';
+export type { ChatVoiceHandle, ChatVoiceOptions, PendingVoice, VoiceMessageConfig, VoiceMessageHandle, VoicePhase, VoiceRecorderOptions } from './chat-voice-message.js';
+//# sourceMappingURL=chat-voice.d.ts.map

package/dist/chat-voice.js

@@ -0,0 +1,4 @@
+'use client';
+export { useVoiceAttempt } from './voice-attempt.js';
+export { useDictation } from './chat-dictation.js';
+export { useChatVoice, useVoiceMessage } from './chat-voice-message.js';

package/dist/experience-catalog.d.ts

@@ -33,8 +33,8 @@ export declare const layoutProps: {
         maxElements: z.ZodDefault<z.ZodNumber>;
         minWidth: z.ZodDefault<z.ZodNumber>;
         regenerate: z.ZodDefault<z.ZodArray<z.ZodEnum<{
-            open: "open";
             phase: "phase";
+            open: "open";
             request: "request";
         }>>>;
         prompt: z.ZodOptional<z.ZodString>;
@@ -127,8 +127,8 @@ export declare const experienceCatalog: import("@json-render/core").Catalog<{
                 maxElements: z.ZodDefault<z.ZodNumber>;
                 minWidth: z.ZodDefault<z.ZodNumber>;
                 regenerate: z.ZodDefault<z.ZodArray<z.ZodEnum<{
-                    open: "open";
                     phase: "phase";
+                    open: "open";
                     request: "request";
                 }>>>;
                 prompt: z.ZodOptional<z.ZodString>;

package/dist/experience-region-tree.d.ts

@@ -13,7 +13,7 @@ export declare function experienceRegion(descriptor: ExperienceDescriptor, name:
         candidates: string[];
         maxElements: number;
         minWidth: number;
-        regenerate: ("open" | "phase" | "request")[];
+        regenerate: ("phase" | "open" | "request")[];
         kinds?: string[] | undefined;
         prompt?: string | undefined;
     };

package/dist/markdown-editor-labels.d.ts

@@ -0,0 +1,83 @@
+import type { MarkdownEditorMenuLabels } from './viewer-components.js';
+import { type TextDraftLabels } from './text-draft-labels.js';
+/**
+ * Every word the markdown editor draws itself. `locale` picks the English or French set; `labels` overrides single keys
+ * (for example `{ saved: 'Enregistré', sourceName: title => title }`). Text a host supplies (`title`, `placeholder`, a save
+ * result's `reason`) is shown as given.
+ */
+export interface MarkdownEditorLabels extends MarkdownEditorMenuLabels, TextDraftLabels {
+    readonly formatting: string;
+    readonly readOnly: string;
+    readonly closed: string;
+    readonly saving: string;
+    readonly saveUnconfirmed: string;
+    readonly changedElsewhere: string;
+    readonly unsaved: string;
+    readonly saved: string;
+    readonly save: string;
+    readonly defaultTitle: string;
+    readonly defaultPlaceholder: string;
+    /** Accessible name of the Markdown source box. */
+    readonly sourceName: (title: string) => string;
+    /** Accessible name of the rich text surface. */
+    readonly richName: (title: string) => string;
+    readonly textFormatting: string;
+    readonly bold: string;
+    readonly italic: string;
+    readonly strike: string;
+    readonly highlight: string;
+    readonly code: string;
+    readonly heading: (level: 1 | 2 | 3) => string;
+    readonly bulletList: string;
+    readonly numberedList: string;
+    readonly taskList: string;
+    readonly quote: string;
+    readonly codeBlock: string;
+    readonly link: string;
+    readonly table: string;
+    readonly horizontalRule: string;
+    readonly addTableRow: string;
+    readonly addTableColumn: string;
+    readonly deleteTable: string;
+    readonly linkAddress: string;
+    readonly applyLink: string;
+    readonly removeLink: string;
+    readonly cancel: string;
+    readonly documentOutline: string;
+    readonly goToHeading: (text: string) => string;
+    readonly untitledHeading: string;
+    readonly headingNotSelected: string;
+    readonly uncertainNotice: string;
+    readonly checkSaveOutcome: string;
+    readonly stopChecking: string;
+    readonly conflictNotice: string;
+    readonly checkSavedVersion: string;
+    readonly discardLocal: string;
+    readonly conflictFallback: string;
+    readonly saveFallback: string;
+    readonly saveFailed: string;
+    readonly operationFailed: string;
+    /** The source-only notice. `reasons` are the kit's English reason names; the French set translates the known ones. */
+    readonly richOff: (reasons: readonly string[]) => string;
+    readonly preservedBlockName: (kind: string) => string;
+    readonly frontMatterCode: string;
+    readonly proposedLineChanges: string;
+    readonly diffFallback: string;
+    readonly noTextChanges: string;
+    readonly crlfLineEnding: string;
+    readonly noNewline: string;
+    readonly showUnchangedLines: (count: number) => string;
+    readonly hideUnchangedLines: (count: number) => string;
+    readonly proposedEdit: string;
+    readonly reviewChanges: string;
+    readonly exactBeforeAfter: string;
+    readonly before: string;
+    readonly after: string;
+    readonly adopted: string;
+    readonly acceptAndSave: string;
+    readonly dismissProposal: string;
+}
+export type MarkdownEditorLabelOverrides = Partial<MarkdownEditorLabels>;
+export declare const markdownEditorLabels: Record<'en' | 'fr', MarkdownEditorLabels>;
+export declare function resolveMarkdownEditorLabels(locale: 'en' | 'fr', overrides?: MarkdownEditorLabelOverrides): MarkdownEditorLabels;
+//# sourceMappingURL=markdown-editor-labels.d.ts.map

package/dist/markdown-editor-labels.js

@@ -0,0 +1,75 @@
+import { textDraftLabels } from './text-draft-labels.js';
+const frenchBlocks = { 'Front matter': 'Métadonnées', Footnote: 'Note de bas de page', Reference: 'Référence' };
+const frenchReasons = {
+    'bare carriage returns': 'des retours chariot isolés',
+    'mixed line endings': 'des fins de ligne mélangées',
+    'NUL characters': 'des caractères NUL',
+    'blocks whose source spans the rich editor cannot retain': 'des blocs dont la source ne peut pas être conservée à l’identique',
+    'content the rich editor cannot read': 'un contenu que l’éditeur mis en forme ne sait pas lire',
+};
+export const markdownEditorLabels = {
+    en: {
+        ...textDraftLabels.en,
+        moreActions: 'More actions', editorMode: 'Editor mode', formatted: 'Formatted', markdown: 'Markdown', showOutline: 'Show outline',
+        formatting: 'Formatting', readOnly: 'Read only', closed: 'Closed', saving: 'Saving…', saveUnconfirmed: 'Save unconfirmed',
+        changedElsewhere: 'Changed elsewhere', unsaved: 'Unsaved changes', saved: 'Saved', save: 'Save',
+        defaultTitle: 'Document', defaultPlaceholder: 'Start writing',
+        sourceName: title => `${title} Markdown source`, richName: title => `${title} rich text`, textFormatting: 'Text formatting',
+        bold: 'Bold', italic: 'Italic', strike: 'Strikethrough', highlight: 'Highlight', code: 'Code',
+        heading: level => `Heading ${level}`, bulletList: 'Bullet list', numberedList: 'Numbered list', taskList: 'Task list',
+        quote: 'Quote', codeBlock: 'Code block', link: 'Link', table: 'Table', horizontalRule: 'Horizontal rule',
+        addTableRow: 'Add table row', addTableColumn: 'Add table column', deleteTable: 'Delete table',
+        linkAddress: 'Link address', applyLink: 'Apply link', removeLink: 'Remove link', cancel: 'Cancel',
+        documentOutline: 'Document outline', goToHeading: text => `Go to heading: ${text}`, untitledHeading: 'Untitled heading',
+        headingNotSelected: 'The heading could not be selected',
+        uncertainNotice: 'Save acknowledgement was lost. Keep editing while its outcome is checked.',
+        checkSaveOutcome: 'Check save outcome', stopChecking: 'Stop checking and refresh, keeping my draft',
+        conflictNotice: 'The saved document changed. Your local text has been kept.',
+        checkSavedVersion: 'Check saved version', discardLocal: 'Discard local changes and reload',
+        conflictFallback: 'The document changed elsewhere. Your text is still available.',
+        saveFallback: 'The document could not be saved. Your text is still available.',
+        saveFailed: 'The save could not be completed. Your text is still available.',
+        operationFailed: 'The operation could not be completed. Your text is still available.',
+        richOff: reasons => `Rich editing is off because this document contains ${reasons.join(', ')}, which it could not keep exactly. You can still edit the Markdown source.`,
+        preservedBlockName: kind => kind, frontMatterCode: 'Front matter code',
+        proposedLineChanges: 'Proposed line changes', diffFallback: 'Detailed line alignment unavailable; showing changed block.',
+        noTextChanges: 'No text changes', crlfLineEnding: 'CRLF line ending', noNewline: 'No newline at end',
+        showUnchangedLines: count => `Show ${count} unchanged lines`, hideUnchangedLines: count => `Hide ${count} unchanged lines`,
+        proposedEdit: 'Proposed edit', reviewChanges: 'Review text changes', exactBeforeAfter: 'Exact before and after', before: 'Before', after: 'After',
+        adopted: 'Adopted', acceptAndSave: 'Accept and save', dismissProposal: 'Dismiss proposal',
+    },
+    fr: {
+        ...textDraftLabels.fr,
+        moreActions: 'Plus d’actions', editorMode: 'Mode d’édition', formatted: 'Mis en forme', markdown: 'Markdown', showOutline: 'Afficher le plan',
+        formatting: 'Mise en forme', readOnly: 'Lecture seule', closed: 'Fermé', saving: 'Enregistrement…', saveUnconfirmed: 'Enregistrement non confirmé',
+        changedElsewhere: 'Modifié ailleurs', unsaved: 'Modifications non enregistrées', saved: 'Enregistré', save: 'Enregistrer',
+        defaultTitle: 'Document', defaultPlaceholder: 'Commencez à écrire',
+        sourceName: title => `${title}, source Markdown`, richName: title => `${title}, texte mis en forme`, textFormatting: 'Mise en forme du texte',
+        bold: 'Gras', italic: 'Italique', strike: 'Barré', highlight: 'Surligné', code: 'Code',
+        heading: level => `Titre ${level}`, bulletList: 'Liste à puces', numberedList: 'Liste numérotée', taskList: 'Liste de tâches',
+        quote: 'Citation', codeBlock: 'Bloc de code', link: 'Lien', table: 'Tableau', horizontalRule: 'Ligne de séparation',
+        addTableRow: 'Ajouter une ligne', addTableColumn: 'Ajouter une colonne', deleteTable: 'Supprimer le tableau',
+        linkAddress: 'Adresse du lien', applyLink: 'Appliquer le lien', removeLink: 'Retirer le lien', cancel: 'Annuler',
+        documentOutline: 'Plan du document', goToHeading: text => `Aller au titre : ${text}`, untitledHeading: 'Titre sans nom',
+        headingNotSelected: 'Le titre n’a pas pu être sélectionné',
+        uncertainNotice: 'L’accusé d’enregistrement a été perdu. Continuez à écrire pendant que le résultat est vérifié.',
+        checkSaveOutcome: 'Vérifier l’enregistrement', stopChecking: 'Arrêter la vérification et actualiser, en gardant mon brouillon',
+        conflictNotice: 'Le document enregistré a changé. Votre texte local a été conservé.',
+        checkSavedVersion: 'Vérifier la version enregistrée', discardLocal: 'Abandonner mes modifications et recharger',
+        conflictFallback: 'Le document a été modifié ailleurs. Votre texte est toujours disponible.',
+        saveFallback: 'Le document n’a pas pu être enregistré. Votre texte est toujours disponible.',
+        saveFailed: 'L’enregistrement n’a pas pu aboutir. Votre texte est toujours disponible.',
+        operationFailed: 'L’opération n’a pas pu aboutir. Votre texte est toujours disponible.',
+        richOff: reasons => `La mise en forme est désactivée car ce document contient ${reasons.map(reason => frenchReasons[reason] ?? reason).join(', ')}, qu’elle ne saurait pas conserver à l’identique. Vous pouvez toujours modifier la source Markdown.`,
+        preservedBlockName: kind => frenchBlocks[kind] ?? kind,
+        frontMatterCode: 'Code des métadonnées', proposedLineChanges: 'Changements de lignes proposés',
+        diffFallback: 'Alignement détaillé indisponible ; affichage du bloc modifié.', noTextChanges: 'Aucun changement de texte',
+        crlfLineEnding: 'Fin de ligne CRLF', noNewline: 'Aucun saut de ligne à la fin',
+        showUnchangedLines: count => `Afficher ${count} lignes inchangées`, hideUnchangedLines: count => `Masquer ${count} lignes inchangées`,
+        proposedEdit: 'Modification proposée', reviewChanges: 'Examiner les changements', exactBeforeAfter: 'Avant et après, à l’identique', before: 'Avant', after: 'Après',
+        adopted: 'Adoptée', acceptAndSave: 'Accepter et enregistrer', dismissProposal: 'Ignorer la proposition',
+    },
+};
+export function resolveMarkdownEditorLabels(locale, overrides) {
+    return overrides ? { ...markdownEditorLabels[locale], ...overrides } : markdownEditorLabels[locale];
+}

package/dist/markdown-editor.d.ts

@@ -9,10 +9,14 @@ export type { MarkdownAutosave, MarkdownFlush } from './markdown-autosave.js';
 import type { MarkdownController } from './markdown.js';
 import { type MarkdownImageResolver } from './markdown-extensions.js';
 import { type MarkdownRichSafety } from './markdown-safety.js';
+import { type MarkdownEditorLabelOverrides } from './markdown-editor-labels.js';
 import { type MarkdownMountedTools } from './markdown-mounted.js';
 export { checkMarkdownRichSafety } from './markdown-safety.js';
 export type { MarkdownRichSafety } from './markdown-safety.js';
 export type { MarkdownImageResolver } from './markdown-extensions.js';
+export { markdownEditorLabels } from './markdown-editor-labels.js';
+export type { MarkdownEditorLabels, MarkdownEditorLabelOverrides } from './markdown-editor-labels.js';
+export type { TextDraftLabels } from './text-draft-labels.js';
 export type { MarkdownMountedTools, MarkdownMountedSubject, MarkdownMountedSelection, MarkdownMountedInspection } from './markdown-mounted.js';
 export interface MarkdownEditorProps {
     readonly highlights?: readonly MarkdownDecoration[];
@@ -44,8 +48,10 @@ export interface MarkdownEditorProps {
     readonly onSaveResult?: (result: SaveResult) => void;
     /** Selection formatting by default. Pinned shows the full row on desktop or above the phone keyboard while editing. */
     readonly formattingToolbar?: 'selection' | 'pinned';
-    /** Locale of the built-in view menu. */
+    /** Language of everything the editor draws itself: status, alerts, buttons, accessible names. */
     readonly locale?: 'en' | 'fr';
+    /** Overrides single words of the `locale` set, e.g. `{ saved: 'Enregistré', sourceName: title => title }`. */
+    readonly labels?: MarkdownEditorLabelOverrides;
 }
 /** Borrows the controller. The host owns document selection, access and disposal. */
 export declare function MarkdownEditor(props: MarkdownEditorProps): import("react").JSX.Element;