@lalternative/editor 0.9.0 → 0.10.0

package/dist/index.js

@@ -226,15 +226,15 @@ function useSelectionToolbar(editor) {
         setSelection(null);
         return;
       }
-      const text2 = state.doc.textBetween(from, to, " ").trim();
-      if (text2 === "") {
+      const text3 = state.doc.textBetween(from, to, " ").trim();
+      if (text3 === "") {
         setSelection(null);
         return;
       }
       const start = editor.view.coordsAtPos(from);
       const end = editor.view.coordsAtPos(to);
       setSelection({
-        text: text2,
+        text: text3,
         rect: {
           x: (start.left + end.right) / 2,
           top: Math.min(start.top, end.top),
@@ -655,10 +655,10 @@ function renderProposal(s, actions) {
   const wrap = document.createElement("span");
   wrap.className = "lalt-suggestion";
   wrap.setAttribute("contenteditable", "false");
-  const text2 = document.createElement("span");
-  text2.className = "lalt-suggestion__new";
-  text2.textContent = s.after;
-  wrap.appendChild(text2);
+  const text3 = document.createElement("span");
+  text3.className = "lalt-suggestion__new";
+  text3.textContent = s.after;
+  wrap.appendChild(text3);
   if (actions) {
     wrap.appendChild(button("reject", actions.rejectLabel, "\u2715", () => actions.onReject(s.id)));
     wrap.appendChild(button("accept", actions.acceptLabel, "\u2713", () => actions.onAccept(s.id)));
@@ -681,12 +681,12 @@ function button(kind, label, glyph, onClick) {
 
 // src/passage.ts
 var WORD = /[\p{L}\p{N}'’-]/u;
-function expandToWords(text2, from, to) {
+function expandToWords(text3, from, to) {
   if (from >= to) return { from, to };
   let start = from;
-  while (start > 0 && WORD.test(text2[start - 1]) && WORD.test(text2[start])) start--;
+  while (start > 0 && WORD.test(text3[start - 1]) && WORD.test(text3[start])) start--;
   let end = to;
-  while (end < text2.length && WORD.test(text2[end]) && WORD.test(text2[end - 1])) end++;
+  while (end < text3.length && WORD.test(text3[end]) && WORD.test(text3[end - 1])) end++;
   return { from: start, to: end };
 }
 function splitRevision(before, after) {
@@ -772,29 +772,492 @@ function text(node) {
   }
   return out;
 }
+
+// src/writing.ts
+var MIN_PASSAGE_CHARS = 12;
+function canAssist(passage) {
+  return passage.trim().length >= MIN_PASSAGE_CHARS;
+}
+var WritingNotAvailableError = class extends Error {
+  constructor() {
+    super("writing assistance is not configured");
+    this.name = "WritingNotAvailableError";
+  }
+};
+var defaultRevisionPresets = [
+  "Rends-le plus concret",
+  "Raccourcis",
+  "Simplifie",
+  "Rends-le plus direct"
+];
+function normalizeInstruction(instruction) {
+  const trimmed = instruction.trim();
+  return trimmed === "" ? null : trimmed;
+}
+function proposalChanges(passage, proposal) {
+  return splitRevision(passage, proposal);
+}
+function hostOf(url) {
+  try {
+    return new URL(url).hostname.replace(/^www\./, "");
+  } catch {
+    return url;
+  }
+}
+
+// src/RevisionPrompt.tsx
+import { useState as useState5 } from "react";
+import { Fragment, jsx as jsx4, jsxs as jsxs4 } from "react/jsx-runtime";
+var defaultRevisionPromptLabels = {
+  title: "Retravailler le passage",
+  instruction: "Consigne",
+  placeholder: "Ex. : ajoute un exemple concret",
+  submit: "Retravailler",
+  busy: "R\xE9\xE9criture\u2026",
+  proposal: "Proposition",
+  unchanged: "Le mod\xE8le n\u2019a rien chang\xE9.",
+  accept: "Remplacer",
+  reject: "Garder l\u2019original",
+  close: "Fermer"
+};
+var errorMessage = (error) => error instanceof Error ? error.message : String(error);
+function RevisionPrompt({
+  passage,
+  revise,
+  onAccept,
+  onClose,
+  presets = defaultRevisionPresets,
+  labels = defaultRevisionPromptLabels,
+  formatError = errorMessage
+}) {
+  const [instruction, setInstruction] = useState5("");
+  const [busy, setBusy] = useState5(false);
+  const [error, setError] = useState5(null);
+  const [proposal, setProposal] = useState5(null);
+  const send = async (value) => {
+    const normalized = normalizeInstruction(value);
+    if (!normalized || busy) return;
+    setBusy(true);
+    setError(null);
+    try {
+      setProposal(await revise(passage, normalized));
+    } catch (err) {
+      setError(formatError(err));
+    } finally {
+      setBusy(false);
+    }
+  };
+  const unchanged = proposal !== null && proposalChanges(passage, proposal).length === 0;
+  return /* @__PURE__ */ jsx4("div", { className: "lalt-dialog", role: "dialog", "aria-modal": "true", "aria-label": labels.title, children: /* @__PURE__ */ jsxs4("div", { className: "lalt-dialog__panel", children: [
+    /* @__PURE__ */ jsxs4("div", { className: "lalt-dialog__header", children: [
+      /* @__PURE__ */ jsx4("h2", { className: "lalt-dialog__title", children: labels.title }),
+      /* @__PURE__ */ jsx4("button", { type: "button", className: "lalt-dialog__close", "aria-label": labels.close, onClick: onClose, children: "\xD7" })
+    ] }),
+    /* @__PURE__ */ jsx4("blockquote", { className: "lalt-dialog__passage", children: passage }),
+    proposal !== null ? /* @__PURE__ */ jsxs4(Fragment, { children: [
+      /* @__PURE__ */ jsx4("p", { className: "lalt-dialog__caption", children: labels.proposal }),
+      /* @__PURE__ */ jsx4("div", { className: "lalt-dialog__proposal", children: unchanged ? labels.unchanged : proposal }),
+      /* @__PURE__ */ jsxs4("div", { className: "lalt-dialog__actions", children: [
+        /* @__PURE__ */ jsx4(
+          "button",
+          {
+            type: "button",
+            className: "lalt-dialog__primary",
+            disabled: unchanged,
+            onClick: () => onAccept(proposal),
+            children: labels.accept
+          }
+        ),
+        /* @__PURE__ */ jsx4("button", { type: "button", className: "lalt-dialog__secondary", onClick: onClose, children: labels.reject })
+      ] })
+    ] }) : /* @__PURE__ */ jsxs4(Fragment, { children: [
+      /* @__PURE__ */ jsx4("label", { className: "lalt-dialog__caption", htmlFor: "lalt-revision-instruction", children: labels.instruction }),
+      /* @__PURE__ */ jsx4(
+        "textarea",
+        {
+          id: "lalt-revision-instruction",
+          className: "lalt-dialog__input",
+          autoFocus: true,
+          rows: 2,
+          value: instruction,
+          placeholder: labels.placeholder,
+          onChange: (e) => setInstruction(e.target.value),
+          onKeyDown: (e) => {
+            if (e.key === "Enter" && !e.shiftKey) {
+              e.preventDefault();
+              void send(instruction);
+            }
+          }
+        }
+      ),
+      /* @__PURE__ */ jsx4("div", { className: "lalt-dialog__presets", children: presets.map((preset) => /* @__PURE__ */ jsx4(
+        "button",
+        {
+          type: "button",
+          className: "lalt-dialog__chip",
+          disabled: busy,
+          onClick: () => void send(preset),
+          children: preset
+        },
+        preset
+      )) }),
+      error && /* @__PURE__ */ jsx4("p", { className: "lalt-dialog__error", role: "alert", children: error }),
+      /* @__PURE__ */ jsx4(
+        "button",
+        {
+          type: "button",
+          className: "lalt-dialog__primary",
+          disabled: busy || normalizeInstruction(instruction) === null,
+          onClick: () => void send(instruction),
+          children: busy ? labels.busy : labels.submit
+        }
+      )
+    ] })
+  ] }) });
+}
+
+// src/SourcesPanel.tsx
+import { useEffect as useEffect5, useState as useState6 } from "react";
+import { jsx as jsx5, jsxs as jsxs5 } from "react/jsx-runtime";
+var defaultSourcesPanelLabels = {
+  title: "Sources pour ce passage",
+  searching: "Recherche\u2026",
+  empty: "Aucune source trouv\xE9e.",
+  open: "Ouvrir",
+  insert: "Ins\xE9rer",
+  close: "Fermer"
+};
+var errorMessage2 = (error) => error instanceof Error ? error.message : String(error);
+function SourcesPanel({
+  passage,
+  findSources,
+  onInsert,
+  onClose,
+  renderActions,
+  labels = defaultSourcesPanelLabels,
+  formatError = errorMessage2
+}) {
+  const [sources, setSources] = useState6([]);
+  const [busy, setBusy] = useState6(true);
+  const [error, setError] = useState6(null);
+  useEffect5(() => {
+    let current = true;
+    setBusy(true);
+    setError(null);
+    findSources(passage).then((found) => current && setSources(found)).catch((err) => current && setError(formatError(err))).finally(() => current && setBusy(false));
+    return () => {
+      current = false;
+    };
+  }, [passage, findSources, formatError]);
+  return /* @__PURE__ */ jsx5("div", { className: "lalt-dialog", role: "dialog", "aria-modal": "true", "aria-label": labels.title, children: /* @__PURE__ */ jsxs5("div", { className: "lalt-dialog__panel", children: [
+    /* @__PURE__ */ jsxs5("div", { className: "lalt-dialog__header", children: [
+      /* @__PURE__ */ jsx5("h2", { className: "lalt-dialog__title", children: labels.title }),
+      /* @__PURE__ */ jsx5("button", { type: "button", className: "lalt-dialog__close", "aria-label": labels.close, onClick: onClose, children: "\xD7" })
+    ] }),
+    /* @__PURE__ */ jsx5("blockquote", { className: "lalt-dialog__passage", children: passage }),
+    busy && /* @__PURE__ */ jsx5("p", { className: "lalt-dialog__status", children: labels.searching }),
+    error && /* @__PURE__ */ jsx5("p", { className: "lalt-dialog__error", role: "alert", children: error }),
+    !busy && !error && sources.length === 0 && /* @__PURE__ */ jsx5("p", { className: "lalt-dialog__status", children: labels.empty }),
+    /* @__PURE__ */ jsx5("ul", { className: "lalt-sources", children: sources.map((source) => /* @__PURE__ */ jsxs5("li", { className: "lalt-sources__item", children: [
+      /* @__PURE__ */ jsx5("p", { className: "lalt-sources__title", children: source.title || source.url }),
+      source.excerpt && /* @__PURE__ */ jsx5("p", { className: "lalt-sources__excerpt", children: source.excerpt }),
+      /* @__PURE__ */ jsxs5("div", { className: "lalt-sources__footer", children: [
+        /* @__PURE__ */ jsx5("span", { className: "lalt-sources__host", children: hostOf(source.url) }),
+        /* @__PURE__ */ jsx5("a", { className: "lalt-dialog__chip", href: source.url, target: "_blank", rel: "noopener noreferrer", children: labels.open }),
+        /* @__PURE__ */ jsx5("button", { type: "button", className: "lalt-dialog__chip", onClick: () => onInsert(source), children: labels.insert }),
+        renderActions?.(source)
+      ] })
+    ] }, source.url)) })
+  ] }) });
+}
+
+// src/dictation.ts
+function isDictationSupported(env = browserEnvironment()) {
+  return env.hasGetUserMedia && env.hasMediaRecorder;
+}
+function browserEnvironment() {
+  return {
+    hasGetUserMedia: typeof navigator !== "undefined" && !!navigator.mediaDevices?.getUserMedia,
+    hasMediaRecorder: typeof MediaRecorder !== "undefined"
+  };
+}
+var MIME_CANDIDATES = [
+  "audio/webm;codecs=opus",
+  "audio/webm",
+  "audio/ogg;codecs=opus",
+  "audio/ogg",
+  "audio/mp4"
+];
+function pickMimeType(isTypeSupported = typeof MediaRecorder === "undefined" ? void 0 : (type) => MediaRecorder.isTypeSupported(type)) {
+  if (!isTypeSupported) return void 0;
+  return MIME_CANDIDATES.find((type) => isTypeSupported(type));
+}
+function spacedTranscript(preceding, transcript) {
+  const text3 = transcript.trim();
+  if (text3 === "") return "";
+  return preceding === "" || /\s$/.test(preceding) ? text3 : ` ${text3}`;
+}
+function insertTranscript(editor, transcript) {
+  const { from } = editor.state.selection;
+  const preceding = editor.state.doc.textBetween(Math.max(0, from - 1), from, "\n", " ");
+  const text3 = spacedTranscript(preceding, transcript);
+  if (text3 === "") return false;
+  return editor.chain().focus().insertContent(text3).run();
+}
+
+// src/useDictation.ts
+import { useCallback as useCallback2, useEffect as useEffect6, useRef as useRef3, useState as useState7 } from "react";
+function useDictation({ transcribe }) {
+  const [state, setState] = useState7("idle");
+  const [supported, setSupported] = useState7(false);
+  const [error, setError] = useState7(null);
+  const recorder = useRef3(null);
+  const stream = useRef3(null);
+  const transcribeRef = useRef3(transcribe);
+  transcribeRef.current = transcribe;
+  const release = useCallback2(() => {
+    stream.current?.getTracks().forEach((track) => track.stop());
+    stream.current = null;
+    recorder.current = null;
+  }, []);
+  useEffect6(() => {
+    setSupported(isDictationSupported());
+    return release;
+  }, [release]);
+  const start = useCallback2(async () => {
+    if (recorder.current) return;
+    if (!isDictationSupported()) {
+      setError(new Error("dictation is not supported in this browser"));
+      return;
+    }
+    setError(null);
+    try {
+      stream.current = await navigator.mediaDevices.getUserMedia({ audio: true });
+      const mimeType = pickMimeType();
+      const next = new MediaRecorder(stream.current, mimeType ? { mimeType } : void 0);
+      next.start();
+      recorder.current = next;
+      setState("recording");
+    } catch (err) {
+      release();
+      setError(err instanceof Error ? err : new Error(String(err)));
+      setState("idle");
+    }
+  }, [release]);
+  const stop = useCallback2(async () => {
+    const active = recorder.current;
+    if (!active) return null;
+    const audio = await new Promise((resolve, reject) => {
+      const chunks = [];
+      active.ondataavailable = (event) => {
+        if (event.data.size > 0) chunks.push(event.data);
+      };
+      active.onerror = () => reject(new Error("recording failed"));
+      active.onstop = () => resolve(new Blob(chunks, { type: active.mimeType || "audio/webm" }));
+      active.stop();
+    }).finally(release);
+    if (audio.size === 0) {
+      setState("idle");
+      return null;
+    }
+    setState("transcribing");
+    try {
+      const text3 = (await transcribeRef.current(audio)).trim();
+      return text3 === "" ? null : text3;
+    } catch (err) {
+      setError(err instanceof Error ? err : new Error(String(err)));
+      return null;
+    } finally {
+      setState("idle");
+    }
+  }, [release]);
+  const toggle = useCallback2(async () => {
+    if (recorder.current) return stop();
+    await start();
+    return null;
+  }, [start, stop]);
+  return { state, supported, error, start, stop, toggle };
+}
+
+// src/DictationButton.tsx
+import { useEffect as useEffect7 } from "react";
+import { jsx as jsx6 } from "react/jsx-runtime";
+var defaultDictationLabels = {
+  start: "Dicter",
+  stop: "Arr\xEAter la dict\xE9e",
+  transcribing: "Transcription\u2026",
+  unsupported: "La dict\xE9e n\u2019est pas disponible dans ce navigateur"
+};
+function DictationButton({
+  transcribe,
+  onTranscript,
+  onError,
+  labels = defaultDictationLabels,
+  icon = /* @__PURE__ */ jsx6("span", { "aria-hidden": true, children: "\u25CF" }),
+  disabled = false,
+  className
+}) {
+  const { state, supported, error, toggle } = useDictation({ transcribe });
+  useEffect7(() => {
+    if (error) onError?.(error);
+  }, [error, onError]);
+  const label = !supported ? labels.unsupported : state === "recording" ? labels.stop : state === "transcribing" ? labels.transcribing : labels.start;
+  return /* @__PURE__ */ jsx6(
+    "button",
+    {
+      type: "button",
+      className: ["lalt-dictation", className].filter(Boolean).join(" "),
+      "data-state": state,
+      "aria-pressed": state === "recording",
+      "aria-label": label,
+      title: error?.message ?? label,
+      disabled: disabled || !supported || state === "transcribing",
+      onMouseDown: (e) => e.preventDefault(),
+      onClick: async () => {
+        const text3 = await toggle();
+        if (text3) onTranscript(text3);
+      },
+      children: icon
+    }
+  );
+}
+
+// src/answer.ts
+function text2(value, marks) {
+  return marks ? { type: "text", text: value, marks } : { type: "text", text: value };
+}
+function paragraph(content) {
+  return content.length > 0 ? { type: "paragraph", content } : { type: "paragraph" };
+}
+function link(value, href) {
+  return text2(value, [{ type: "link", attrs: { href } }]);
+}
+var MARKER = /\[(\d+)\]/g;
+function linkMarkers(block2, citations) {
+  const hrefs = new Map(citations.filter((c) => c.href).map((c) => [c.index, c.href]));
+  const nodes = [];
+  let last = 0;
+  for (const match of block2.matchAll(MARKER)) {
+    const href = hrefs.get(Number(match[1]));
+    if (!href) continue;
+    const at = match.index ?? 0;
+    if (at > last) nodes.push(text2(block2.slice(last, at)));
+    nodes.push(link(match[0], href));
+    last = at + match[0].length;
+  }
+  if (last < block2.length) nodes.push(text2(block2.slice(last)));
+  return nodes;
+}
+function prose(answer, citations) {
+  return answer.split(/\n{2,}/).map((block2) => block2.trim()).filter((block2) => block2 !== "").map((block2) => paragraph(linkMarkers(block2, citations)));
+}
+function sourcesList(citations, sourcesLabel, numbered) {
+  const linkable = citations.filter((c) => !!c.href);
+  if (linkable.length === 0) return [];
+  return [
+    paragraph([text2(sourcesLabel, [{ type: "italic" }])]),
+    {
+      type: "bulletList",
+      content: linkable.map((c) => {
+        const title = c.title.trim() || c.href;
+        return {
+          type: "listItem",
+          content: [paragraph([link(numbered ? `[${c.index}] ${title}` : title, c.href)])]
+        };
+      })
+    }
+  ];
+}
+function webSourceToNodes(source) {
+  const nodes = [paragraph([link(source.title.trim() || source.url, source.url)])];
+  const excerpt = source.excerpt?.trim();
+  if (excerpt) nodes.push(paragraph([text2(excerpt)]));
+  nodes.push(paragraph([text2(hostOf(source.url), [{ type: "italic" }])]));
+  return [{ type: "blockquote", content: nodes }];
+}
+function answerToNodes(params) {
+  const nodes = [];
+  const question = params.question.trim();
+  if (question) nodes.push({ type: "blockquote", content: [paragraph([text2(question)])] });
+  nodes.push(...prose(params.answer, params.citations));
+  nodes.push(...sourcesList(params.citations, params.sourcesLabel, true));
+  return nodes;
+}
+function headingFromQuestion(question) {
+  const trimmed = question.trim().replace(/\s*[?!.]+\s*$/, "");
+  if (!trimmed) return "";
+  return trimmed.charAt(0).toUpperCase() + trimmed.slice(1);
+}
+function conversationToNodes(params) {
+  const nodes = [];
+  const sources = [];
+  const seen = /* @__PURE__ */ new Set();
+  let question = "";
+  for (const turn of params.turns) {
+    if (turn.role === "user") {
+      question = turn.content;
+      continue;
+    }
+    if (turn.clarify) continue;
+    const heading = headingFromQuestion(question);
+    if (heading) nodes.push({ type: "heading", attrs: { level: 3 }, content: [text2(heading)] });
+    nodes.push(...prose(turn.content, turn.citations ?? []));
+    for (const citation of turn.citations ?? []) {
+      if (!citation.href || seen.has(citation.href)) continue;
+      seen.add(citation.href);
+      sources.push(citation);
+    }
+    question = "";
+  }
+  nodes.push(...sourcesList(sources, params.sourcesLabel, false));
+  return nodes;
+}
 export {
+  DictationButton,
   EditorScreen,
   InlineSuggestions,
+  MIN_PASSAGE_CHARS,
+  RevisionPrompt,
   SelectionToolbar,
   SlashCommands,
   SlashMenu,
+  SourcesPanel,
+  WritingNotAvailableError,
+  answerToNodes,
   blockFormats,
   blocksFromDoc,
+  canAssist,
+  conversationToNodes,
+  defaultDictationLabels,
   defaultFormatLabels,
+  defaultRevisionPresets,
+  defaultRevisionPromptLabels,
   defaultSaveLabels,
   defaultSlashItems,
   defaultSlashLabels,
+  defaultSourcesPanelLabels,
   diffBlocks,
   docFromBlocks,
   docToMarkdown,
   expandToWords,
   filterSlashItems,
+  headingFromQuestion,
+  hostOf,
   inlineSuggestionsKey,
+  insertTranscript,
+  isDictationSupported,
+  linkMarkers,
+  normalizeInstruction,
+  pickMimeType,
   placeToolbar,
+  proposalChanges,
   readViewport,
   shapesFromDoc,
+  spacedTranscript,
   splitRevision,
+  useDictation,
   useSelectionToolbar,
-  useViewport
+  useViewport,
+  webSourceToNodes
 };
 //# sourceMappingURL=index.js.map