myrole-docx-editor 0.1.0

package/dist/chunks/vars-blockly-C-cJRHx8.js

@@ -0,0 +1,42 @@
+import * as s from "blockly";
+import { k as p, T as u, m, n as f, o as g, p as h } from "./sdk-BKkeAoJT.js";
+let r = !1;
+function b(o, n, i) {
+  r || (p(), r = !0), o.replaceChildren();
+  const t = document.createElement("div");
+  t.className = "vp-canvas-host", o.append(t);
+  const e = s.inject(t, {
+    // La boîte à outils : sans elle, on peut lire une expression et la
+    // rebrancher, mais pas y AJOUTER quoi que ce soit — c'est la moitié de ce
+    // qu'on vient chercher dans un canvas de blocs.
+    toolbox: m,
+    theme: u,
+    renderer: "geras",
+    trashcan: !0,
+    sounds: !1,
+    grid: { spacing: 20, length: 1, colour: "#e8e9ed", snap: !1 },
+    zoom: { controls: !0, wheel: !0, startScale: 0.95, minScale: 0.3, maxScale: 2 },
+    move: { scrollbars: !0, drag: !0, wheel: !0 }
+  });
+  return e.addChangeListener((a) => {
+    a.isUiEvent || n();
+  }), {
+    load(a) {
+      const c = f(i());
+      g(c.flatMap((d) => d.fields.map((l) => ({ path: l.path, label: l.label })))), s.serialization.workspaces.load({ blocks: { languageVersion: 0, blocks: [a] } }, e), h(e), s.svgResize(e);
+    },
+    read() {
+      return s.serialization.workspaces.save(e)?.blocks?.blocks?.[0] ?? null;
+    },
+    resize() {
+      s.svgResize(e);
+    },
+    dispose() {
+      e.dispose();
+    }
+  };
+}
+export {
+  b as mountBlockly
+};
+//# sourceMappingURL=vars-blockly-C-cJRHx8.js.map

package/dist/chunks/vars-blockly-C-cJRHx8.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"vars-blockly-C-cJRHx8.js","sources":["../../src/vars-blockly.ts"],"sourcesContent":["import * as Blockly from 'blockly'\nimport {\n  decorate, defineBlocks, fieldLibrary, setFields, THEME, TOOLBOX,\n  type BlockJson,\n} from '@myrole/docx-vars'\nimport type { Tag } from '@myrole/docx-tags'\n\n/**\n * Le mode Blockly, chargé à la demande.\n *\n * Le canvas ne se replie pas — c'est ce qui a fait choisir le rendu DOM par\n * défaut — mais il sait ce que le DOM ne fait pas encore aussi bien :\n * restructurer librement une expression au glisser-déposer, avec sa poubelle,\n * son annulation et ses connexions typées.\n *\n * Il vit dans son propre module pour ne peser que si on l'ouvre : un\n * mégaoctet et demi qu'un utilisateur qui ne bascule jamais ne télécharge pas.\n */\n\nlet defined = false\n\nexport interface BlocklyView {\n  load(tree: BlockJson): void\n  read(): BlockJson | null\n  resize(): void\n  dispose(): void\n}\n\nexport function mountBlockly(\n  holder: HTMLElement, onChange: () => void, tags: () => Tag[],\n): BlocklyView {\n  if (!defined) { defineBlocks(); defined = true }\n  holder.replaceChildren()\n  const host = document.createElement('div')\n  host.className = 'vp-canvas-host'\n  holder.append(host)\n\n  const ws = Blockly.inject(host, {\n    // La boîte à outils : sans elle, on peut lire une expression et la\n    // rebrancher, mais pas y AJOUTER quoi que ce soit — c'est la moitié de ce\n    // qu'on vient chercher dans un canvas de blocs.\n    toolbox: TOOLBOX,\n    theme: THEME,\n    renderer: 'geras',\n    trashcan: true,\n    sounds: false,\n    grid: { spacing: 20, length: 1, colour: '#e8e9ed', snap: false },\n    zoom: { controls: true, wheel: true, startScale: 0.95, minScale: 0.3, maxScale: 2 },\n    move: { scrollbars: true, drag: true, wheel: true },\n  })\n  ws.addChangeListener((e) => { if (!e.isUiEvent) onChange() })\n\n  return {\n    load(tree) {\n      // `setFields` alimente le sélecteur du bloc « champ » : sans lui, un clic\n      // sur un champ n'ouvre rien.\n      const groups = fieldLibrary(tags())\n      setFields(groups.flatMap((g) => g.fields.map((f) => ({ path: f.path, label: f.label }))))\n      Blockly.serialization.workspaces.load({ blocks: { languageVersion: 0, blocks: [tree] } }, ws)\n      decorate(ws)\n      Blockly.svgResize(ws)\n    },\n    read() {\n      const state = Blockly.serialization.workspaces.save(ws) as {\n        blocks?: { blocks?: BlockJson[] }\n      }\n      return state?.blocks?.blocks?.[0] ?? null\n    },\n    resize() { Blockly.svgResize(ws) },\n    dispose() { ws.dispose() },\n  }\n}\n"],"names":["defined","mountBlockly","holder","onChange","tags","defineBlocks","host","ws","Blockly","TOOLBOX","THEME","e","tree","groups","fieldLibrary","setFields","g","f","decorate"],"mappings":";;AAmBA,IAAIA,IAAU;AASP,SAASC,EACdC,GAAqBC,GAAsBC,GAC9B;AACb,EAAKJ,MAAWK,EAAA,GAAgBL,IAAU,KAC1CE,EAAO,gBAAA;AACP,QAAMI,IAAO,SAAS,cAAc,KAAK;AACzC,EAAAA,EAAK,YAAY,kBACjBJ,EAAO,OAAOI,CAAI;AAElB,QAAMC,IAAKC,EAAQ,OAAOF,GAAM;AAAA;AAAA;AAAA;AAAA,IAI9B,SAASG;AAAA,IACT,OAAOC;AAAA,IACP,UAAU;AAAA,IACV,UAAU;AAAA,IACV,QAAQ;AAAA,IACR,MAAM,EAAE,SAAS,IAAI,QAAQ,GAAG,QAAQ,WAAW,MAAM,GAAA;AAAA,IACzD,MAAM,EAAE,UAAU,IAAM,OAAO,IAAM,YAAY,MAAM,UAAU,KAAK,UAAU,EAAA;AAAA,IAChF,MAAM,EAAE,YAAY,IAAM,MAAM,IAAM,OAAO,GAAA;AAAA,EAAK,CACnD;AACD,SAAAH,EAAG,kBAAkB,CAACI,MAAM;AAAE,IAAKA,EAAE,aAAWR,EAAA;AAAA,EAAW,CAAC,GAErD;AAAA,IACL,KAAKS,GAAM;AAGT,YAAMC,IAASC,EAAaV,GAAM;AAClC,MAAAW,EAAUF,EAAO,QAAQ,CAACG,MAAMA,EAAE,OAAO,IAAI,CAACC,OAAO,EAAE,MAAMA,EAAE,MAAM,OAAOA,EAAE,MAAA,EAAQ,CAAC,CAAC,GACxFT,EAAQ,cAAc,WAAW,KAAK,EAAE,QAAQ,EAAE,iBAAiB,GAAG,QAAQ,CAACI,CAAI,EAAA,EAAE,GAAKL,CAAE,GAC5FW,EAASX,CAAE,GACXC,EAAQ,UAAUD,CAAE;AAAA,IACtB;AAAA,IACA,OAAO;AAIL,aAHcC,EAAQ,cAAc,WAAW,KAAKD,CAAE,GAGxC,QAAQ,SAAS,CAAC,KAAK;AAAA,IACvC;AAAA,IACA,SAAS;AAAE,MAAAC,EAAQ,UAAUD,CAAE;AAAA,IAAE;AAAA,IACjC,UAAU;AAAE,MAAAA,EAAG,QAAA;AAAA,IAAU;AAAA,EAAA;AAE7B;"}

package/dist/index.js

@@ -0,0 +1,53 @@
+import { i as d, r as m, e as p, f as g, l as u, a as w, b as h, c as y, d as b } from "./chunks/sdk-BKkeAoJT.js";
+import { g as D, h as U, j, s as B } from "./chunks/sdk-BKkeAoJT.js";
+async function x(t) {
+  const a = /* @__PURE__ */ new Map(), s = /* @__PURE__ */ new Map();
+  for (const [r] of Object.entries(t.xml)) {
+    if (!r.endsWith(".rels")) continue;
+    const c = r.replace("/_rels/", "/").replace(".rels", "");
+    for (const [, e] of b(t, c)) {
+      if (e.type !== "image" || e.external) continue;
+      const i = t.bin[e.target];
+      if (!i) continue;
+      let o = a.get(e.target);
+      if (!o)
+        try {
+          o = await createImageBitmap(new Blob([i])), a.set(e.target, o);
+        } catch {
+          continue;
+        }
+      s.set(e.target, o);
+    }
+  }
+  return s;
+}
+async function F(t, a, s = {}) {
+  const r = performance.now(), [c] = await Promise.all([
+    typeof t == "string" ? fetch(t).then((n) => n.ok ? n.arrayBuffer() : Promise.reject(new Error(`${n.status} ${t}`))) : Promise.resolve(t),
+    d(s.fontsUrl)
+  ]), e = m(new Uint8Array(c));
+  for (const n of p(e))
+    try {
+      const l = g(n), f = new FontFace(l.family, n.data, { weight: l.weight, style: l.style });
+      await f.load(), document.fonts.add(f);
+    } catch {
+    }
+  const [i, o] = await Promise.all([x(e), u(s.fontsUrl)]);
+  return a.replaceChildren(), w({
+    ...y(e),
+    container: a,
+    images: i,
+    lineRatios: o,
+    footnotes: h(e),
+    devicePixelRatio: window.devicePixelRatio || 1
+  }), { pages: [...a.querySelectorAll("canvas")], ms: Math.round(performance.now() - r) };
+}
+export {
+  D as createDocxEditor,
+  U as defaultFontsUrl,
+  j as evaluateTags,
+  d as installFonts,
+  F as renderDocx,
+  B as sampleValues
+};
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sources":["../src/embed.ts"],"sourcesContent":["/**\n * The renderer, embeddable in ANY page served by the studio.\n *\n * The review dashboard shows a document next to Word's render: with this\n * module the canvas side is the engine composing the document LIVE in the\n * page, not a PNG the bench cached — so a change in the engine shows on the\n * next reload, and the slider compares what the editor would draw.\n *\n *   const { pages } = await renderDocx('/corpus/<name>.docx', hiddenDiv)\n *\n * Fed by `buildRenderInput`, like the editor and the bench: the third surface\n * that mounts the renderer starts from there, as CLAUDE.md asks. What it adds\n * is the platform: fonts loaded before any measurement, embedded fonts of the\n * document, images decoded by the browser.\n */\nimport { embeddedFonts, fontFaceDescriptor, readDocx, relationships, type DocxDocument } from '@myrole/docx-model'\nimport { buildRenderInput, footnoteContent, render, type ImageMap } from '@myrole/docx-render'\nimport { installFonts, lineRatios } from './fonts'\n\nasync function preloadImages(doc: DocxDocument): Promise<ImageMap> {\n  const byTarget = new Map<string, ImageBitmap>()\n  const map: ImageMap = new Map()\n  for (const [path] of Object.entries(doc.xml)) {\n    if (!path.endsWith('.rels')) continue\n    const partPath = path.replace('/_rels/', '/').replace('.rels', '')\n    for (const [, rel] of relationships(doc, partPath)) {\n      if (rel.type !== 'image' || rel.external) continue\n      const bin = doc.bin[rel.target]\n      if (!bin) continue\n      let bitmap = byTarget.get(rel.target)\n      if (!bitmap) {\n        try { bitmap = await createImageBitmap(new Blob([bin as BlobPart])); byTarget.set(rel.target, bitmap) }\n        catch { continue }\n      }\n      map.set(rel.target, bitmap)\n    }\n  }\n  return map\n}\n\nexport interface Rendered {\n  pages: HTMLCanvasElement[]\n  ms: number\n}\n\nexport async function renderDocx(\n  url: string | ArrayBuffer | Uint8Array, container: HTMLElement, opts: { fontsUrl?: string } = {},\n): Promise<Rendered> {\n  const t0 = performance.now()\n  const [buf] = await Promise.all([\n    typeof url === 'string'\n      ? fetch(url).then((r) => (r.ok ? r.arrayBuffer() : Promise.reject(new Error(`${r.status} ${url}`))))\n      : Promise.resolve(url),\n    installFonts(opts.fontsUrl),\n  ])\n  const doc = readDocx(new Uint8Array(buf))\n  for (const f of embeddedFonts(doc)) {\n    try {\n      const d = fontFaceDescriptor(f)\n      const face = new FontFace(d.family, f.data as BufferSource, { weight: d.weight, style: d.style })\n      await face.load()\n      document.fonts.add(face)\n    } catch { /* police corrompue ou format non supporté */ }\n  }\n  const [images, ratios] = await Promise.all([preloadImages(doc), lineRatios(opts.fontsUrl)])\n  container.replaceChildren()\n  render({\n    ...buildRenderInput(doc),\n    container,\n    images,\n    lineRatios: ratios,\n    footnotes: footnoteContent(doc),\n    devicePixelRatio: window.devicePixelRatio || 1,\n  })\n  return { pages: [...container.querySelectorAll('canvas')], ms: Math.round(performance.now() - t0) }\n}\n"],"names":["preloadImages","doc","byTarget","map","path","partPath","rel","relationships","bin","bitmap","renderDocx","url","container","opts","t0","buf","r","installFonts","readDocx","f","embeddedFonts","d","fontFaceDescriptor","face","images","ratios","lineRatios","render","buildRenderInput","footnoteContent"],"mappings":";;AAmBA,eAAeA,EAAcC,GAAsC;AACjE,QAAMC,wBAAe,IAAA,GACfC,wBAAoB,IAAA;AAC1B,aAAW,CAACC,CAAI,KAAK,OAAO,QAAQH,EAAI,GAAG,GAAG;AAC5C,QAAI,CAACG,EAAK,SAAS,OAAO,EAAG;AAC7B,UAAMC,IAAWD,EAAK,QAAQ,WAAW,GAAG,EAAE,QAAQ,SAAS,EAAE;AACjE,eAAW,CAAA,EAAGE,CAAG,KAAKC,EAAcN,GAAKI,CAAQ,GAAG;AAClD,UAAIC,EAAI,SAAS,WAAWA,EAAI,SAAU;AAC1C,YAAME,IAAMP,EAAI,IAAIK,EAAI,MAAM;AAC9B,UAAI,CAACE,EAAK;AACV,UAAIC,IAASP,EAAS,IAAII,EAAI,MAAM;AACpC,UAAI,CAACG;AACH,YAAI;AAAE,UAAAA,IAAS,MAAM,kBAAkB,IAAI,KAAK,CAACD,CAAe,CAAC,CAAC,GAAGN,EAAS,IAAII,EAAI,QAAQG,CAAM;AAAA,QAAE,QAChG;AAAE;AAAA,QAAS;AAEnB,MAAAN,EAAI,IAAIG,EAAI,QAAQG,CAAM;AAAA,IAC5B;AAAA,EACF;AACA,SAAON;AACT;AAOA,eAAsBO,EACpBC,GAAwCC,GAAwBC,IAA8B,CAAA,GAC3E;AACnB,QAAMC,IAAK,YAAY,IAAA,GACjB,CAACC,CAAG,IAAI,MAAM,QAAQ,IAAI;AAAA,IAC9B,OAAOJ,KAAQ,WACX,MAAMA,CAAG,EAAE,KAAK,CAACK,MAAOA,EAAE,KAAKA,EAAE,YAAA,IAAgB,QAAQ,OAAO,IAAI,MAAM,GAAGA,EAAE,MAAM,IAAIL,CAAG,EAAE,CAAC,CAAE,IACjG,QAAQ,QAAQA,CAAG;AAAA,IACvBM,EAAaJ,EAAK,QAAQ;AAAA,EAAA,CAC3B,GACKZ,IAAMiB,EAAS,IAAI,WAAWH,CAAG,CAAC;AACxC,aAAWI,KAAKC,EAAcnB,CAAG;AAC/B,QAAI;AACF,YAAMoB,IAAIC,EAAmBH,CAAC,GACxBI,IAAO,IAAI,SAASF,EAAE,QAAQF,EAAE,MAAsB,EAAE,QAAQE,EAAE,QAAQ,OAAOA,EAAE,OAAO;AAChG,YAAME,EAAK,KAAA,GACX,SAAS,MAAM,IAAIA,CAAI;AAAA,IACzB,QAAQ;AAAA,IAAgD;AAE1D,QAAM,CAACC,GAAQC,CAAM,IAAI,MAAM,QAAQ,IAAI,CAACzB,EAAcC,CAAG,GAAGyB,EAAWb,EAAK,QAAQ,CAAC,CAAC;AAC1F,SAAAD,EAAU,gBAAA,GACVe,EAAO;AAAA,IACL,GAAGC,EAAiB3B,CAAG;AAAA,IACvB,WAAAW;AAAA,IACA,QAAAY;AAAA,IACA,YAAYC;AAAA,IACZ,WAAWI,EAAgB5B,CAAG;AAAA,IAC9B,kBAAkB,OAAO,oBAAoB;AAAA,EAAA,CAC9C,GACM,EAAE,OAAO,CAAC,GAAGW,EAAU,iBAAiB,QAAQ,CAAC,GAAG,IAAI,KAAK,MAAM,YAAY,IAAA,IAAQE,CAAE,EAAA;AAClG;"}

package/dist/react.js

@@ -0,0 +1,36 @@
+import { jsx as g } from "react/jsx-runtime";
+import { forwardRef as v, useRef as n, useEffect as s } from "react";
+import { g as x } from "./chunks/sdk-BKkeAoJT.js";
+const C = v(function({ src: r, className: a, style: d, onReady: h, ...u }, e) {
+  const i = n(null), o = n(null), c = n(u);
+  c.current = u;
+  const f = (t) => {
+    typeof e == "function" ? e(t) : e && (e.current = t);
+  };
+  s(() => {
+    const t = x(i.current, {
+      ...u,
+      onSave: (m) => c.current.onSave?.(m),
+      onChange: () => c.current.onChange?.()
+    });
+    return o.current = t, f(t), h?.(t), r && t.load(r), () => {
+      t.destroy(), o.current = null, f(null);
+    };
+  }, []);
+  const l = n(!0);
+  return s(() => {
+    if (l.current) {
+      l.current = !1;
+      return;
+    }
+    r && o.current && o.current.load(r);
+  }, [r]), /* @__PURE__ */ g("div", { ref: i, className: a, style: { height: "100%", minHeight: 480, ...d } });
+});
+function R() {
+  return n(null);
+}
+export {
+  C as DocxEditor,
+  R as useDocxEditor
+};
+//# sourceMappingURL=react.js.map

package/dist/react.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"react.js","sources":["../src/react.tsx"],"sourcesContent":["/**\n * The React face of the SDK.\n *\n *   <DocxEditor src={file} onSave={(bytes) => upload(bytes)} style={{ height: '100vh' }} />\n *\n * The component owns one `createDocxEditor` for its lifetime; `src` changes\n * reload the document in place, every other option is read at mount. React is\n * an optional peer: nothing here runs unless `myrole-docx-editor/react` is\n * imported.\n */\nimport { useEffect, useRef, forwardRef, type CSSProperties } from 'react'\nimport { createDocxEditor, type DocxEditorHandle, type DocxEditorOptions } from './sdk'\n\nexport interface DocxEditorProps extends Omit<DocxEditorOptions, 'onReady'> {\n  /** the document: bytes, a Blob/File, or a URL */\n  src?: ArrayBuffer | Uint8Array | Blob | string\n  className?: string\n  style?: CSSProperties\n  /** the handle, once mounted */\n  onReady?: (editor: DocxEditorHandle) => void\n}\n\nexport const DocxEditor = forwardRef<DocxEditorHandle | null, DocxEditorProps>(function DocxEditor(\n  { src, className, style, onReady, ...options }, ref,\n) {\n  const host = useRef<HTMLDivElement>(null)\n  const handle = useRef<DocxEditorHandle | null>(null)\n  // The latest callbacks, without remounting the editor when they change.\n  const latest = useRef(options)\n  latest.current = options\n\n  // The forwarded ref is filled HERE, not by useImperativeHandle: that one\n  // runs in the layout phase, before this effect has created anything, and\n  // would hand the parent a null for the component's whole life.\n  const give = (h: DocxEditorHandle | null) => {\n    if (typeof ref === 'function') ref(h)\n    else if (ref) ref.current = h\n  }\n\n  useEffect(() => {\n    const h = createDocxEditor(host.current!, {\n      ...options,\n      onSave: (b) => latest.current.onSave?.(b),\n      onChange: () => latest.current.onChange?.(),\n    })\n    handle.current = h\n    give(h)\n    onReady?.(h)\n    if (src) void h.load(src)\n    return () => { h.destroy(); handle.current = null; give(null) }\n    // eslint-disable-next-line react-hooks/exhaustive-deps\n  }, [])\n\n  const first = useRef(true)\n  useEffect(() => {\n    if (first.current) { first.current = false; return }\n    if (src && handle.current) void handle.current.load(src)\n  }, [src])\n\n  return <div ref={host} className={className} style={{ height: '100%', minHeight: 480, ...style }} />\n})\n\n/** A ref to hand to `<DocxEditor ref={…}>`, and the handle once it exists. */\nexport function useDocxEditor() {\n  return useRef<DocxEditorHandle | null>(null)\n}\n\nexport type { DocxEditorHandle, DocxEditorOptions } from './sdk'\n"],"names":["DocxEditor","forwardRef","src","className","style","onReady","options","ref","host","useRef","handle","latest","give","h","useEffect","createDocxEditor","b","first","jsx","useDocxEditor"],"mappings":";;;AAsBO,MAAMA,IAAaC,EAAqD,SAC7E,EAAE,KAAAC,GAAK,WAAAC,GAAW,OAAAC,GAAO,SAAAC,GAAS,GAAGC,EAAA,GAAWC,GAChD;AACA,QAAMC,IAAOC,EAAuB,IAAI,GAClCC,IAASD,EAAgC,IAAI,GAE7CE,IAASF,EAAOH,CAAO;AAC7B,EAAAK,EAAO,UAAUL;AAKjB,QAAMM,IAAO,CAACC,MAA+B;AAC3C,IAAI,OAAON,KAAQ,aAAYA,EAAIM,CAAC,IAC3BN,QAAS,UAAUM;AAAA,EAC9B;AAEA,EAAAC,EAAU,MAAM;AACd,UAAMD,IAAIE,EAAiBP,EAAK,SAAU;AAAA,MACxC,GAAGF;AAAA,MACH,QAAQ,CAACU,MAAML,EAAO,QAAQ,SAASK,CAAC;AAAA,MACxC,UAAU,MAAML,EAAO,QAAQ,WAAA;AAAA,IAAW,CAC3C;AACD,WAAAD,EAAO,UAAUG,GACjBD,EAAKC,CAAC,GACNR,IAAUQ,CAAC,GACPX,KAAUW,EAAE,KAAKX,CAAG,GACjB,MAAM;AAAE,MAAAW,EAAE,QAAA,GAAWH,EAAO,UAAU,MAAME,EAAK,IAAI;AAAA,IAAE;AAAA,EAEhE,GAAG,CAAA,CAAE;AAEL,QAAMK,IAAQR,EAAO,EAAI;AACzB,SAAAK,EAAU,MAAM;AACd,QAAIG,EAAM,SAAS;AAAE,MAAAA,EAAM,UAAU;AAAO;AAAA,IAAO;AACnD,IAAIf,KAAOQ,EAAO,WAAcA,EAAO,QAAQ,KAAKR,CAAG;AAAA,EACzD,GAAG,CAACA,CAAG,CAAC,GAED,gBAAAgB,EAAC,OAAA,EAAI,KAAKV,GAAM,WAAAL,GAAsB,OAAO,EAAE,QAAQ,QAAQ,WAAW,KAAK,GAAGC,IAAM,CAAG;AACpG,CAAC;AAGM,SAASe,IAAgB;AAC9B,SAAOV,EAAgC,IAAI;AAC7C;"}

package/dist/types/packages/docx-editor/src/chrome.d.ts

@@ -0,0 +1,28 @@
+import type { EditContext } from '../../docx-model/src/index';
+import type { Editor } from './editor';
+import type { Shell } from './ui/shell';
+export interface ChromeHost {
+    shell: Shell;
+    zoom: {
+        get(): number;
+        set(z: number): void;
+    };
+    styles(): {
+        id: string;
+        name: string;
+    }[];
+    preview: {
+        get(): boolean;
+        set(on: boolean): void;
+    };
+    readOnly: {
+        get(): boolean;
+        set(on: boolean): void;
+    };
+}
+export interface Chrome {
+    refresh(ctx: EditContext | null, hasSel: boolean): void;
+    /** Redraw the ribbon — when an extension adds a command, or a setting changes. */
+    rebuild(): void;
+}
+export declare function mountChrome(root: HTMLElement, editor: Editor, host: ChromeHost): Chrome;

package/dist/types/packages/docx-editor/src/commands.d.ts

@@ -0,0 +1,16 @@
+import type { Command } from './editor';
+/**
+ * Les commandes de l'éditeur.
+ *
+ * Toutes passent par `editor.registerCommand` — y compris celles-ci. C'est
+ * volontaire : une extension qui ajoute un bouton emprunte exactement le même
+ * chemin que le gras, et l'hôte n'a rien à savoir de ce qu'on lui ajoute.
+ *
+ * `active` et `enabled` sont des FONCTIONS relues à chaque composition. Un état
+ * d'interface qu'on maintiendrait à la main finit toujours par mentir.
+ */
+export declare const FONTS: string[];
+export declare const SIZES: number[];
+/** Quatre traits, décalés selon l'alignement — l'icône de Word, en SVG. */
+export declare function alignIcon(align: string): SVGElement;
+export declare function builtinCommands(): Command[];

package/dist/types/packages/docx-editor/src/comments.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Word's comments, and where they sit in the text.
+ *
+ * `word/comments.xml` holds the comments; the body marks each range with
+ * `w:commentRangeStart` / `w:commentRangeEnd` between the runs. The offsets
+ * are counted the way `paragraphText` counts — `w:t` text, a tab, a break —
+ * so a comment's range is addressable by the editor like any selection.
+ */
+import { type DocxDocument } from '../../docx-model/src/index';
+export interface Comment {
+    id: string;
+    author: string;
+    date?: string;
+    text: string;
+}
+export interface CommentRange extends Comment {
+    para: number;
+    from: number;
+    to: number;
+}
+/** The comments, in the order comments.xml declares them. */
+export declare function commentsOf(doc: DocxDocument): Comment[];
+/** Each comment with its range in the body — a comment whose range is not in the flow is left out. */
+export declare function commentRanges(doc: DocxDocument): CommentRange[];

package/dist/types/packages/docx-editor/src/editor.d.ts

@@ -0,0 +1,293 @@
+import { type MarginPatch, type DocViews, type DocxDocument, type DocPos, type EditContext, type PageSetup, type ParaPatch, type RunPatch } from '../../docx-model/src/index';
+import { type ImageRect, type LineTrace, type MarkRect, type ResumeState, type SelRect, type TableRect } from '../../docx-render/src/index';
+export interface EditorHooks {
+    /** appelé après chaque composition, avec ce qu'il faut pour la barre d'outils */
+    onContext?(ctx: EditContext | null, hasSelection: boolean): void;
+    onStatus?(text: string): void;
+}
+/**
+ * Ce que la composition rend en plus de sa trace : les rectangles de ce qui
+ * n'a pas d'adresse de caractère — une image, un tableau.
+ */
+export interface ComposeOut {
+    image(r: ImageRect): void;
+    table(r: TableRect): void;
+    /**
+     * Boîte réservée à un affichage d'extension.
+     *
+     * Le renderer l'a écartée dans le flux comme un mot insécable, sans rien y
+     * peindre : c'est l'hôte qui vient poser dedans. Voir extensions.md.
+     */
+    mark(r: MarkRect): void;
+}
+/** Ce que l'hôte fournit : comment composer le document, et où. */
+export interface EditorSetup {
+    container: HTMLElement;
+    doc: DocxDocument;
+    /** compose le document et renvoie les lignes tracées */
+    compose(views: DocViews, container: HTMLElement, paintFrom: number, out: ComposeOut, resume?: ResumeState): LineTrace[];
+    /** recalcule les vues dérivées après un changement de structure */
+    derive(doc: DocxDocument): DocViews;
+    /**
+     * Re-style UN paragraphe.
+     *
+     * Une frappe ne change la cascade que d'un paragraphe ; la refaire pour tout
+     * le document coûte 106 ms sur un contrat de 42 pages, à chaque touche.
+     * L'hôte s'en charge parce que lui seul sait résoudre les `rId` d'image.
+     */
+    styleOne(doc: DocxDocument, para: number): DocViews['styled'][number] | undefined;
+    /** Format d'une section — la règle en a besoin, l'éditeur ne le calcule pas. */
+    pageSetupOf(doc: DocxDocument, section: number): PageSetup | null;
+    /** Ajoute une image décodée à la carte que la composition utilise. */
+    addImage?(path: string, bitmap: ImageBitmap): void;
+    /**
+     * Où envoyer le document quand il a changé.
+     *
+     * L'éditeur décide QUAND — après une accalmie, et au changement d'onglet —
+     * l'hôte décide OÙ. Une exception ici laisse le document « à enregistrer » :
+     * on ne fait pas semblant d'avoir réussi.
+     */
+    persist?(bytes: Uint8Array): void | Promise<void>;
+    hooks?: EditorHooks;
+}
+export declare function createEditor(setup: EditorSetup): {
+    compose: (dirty?: number) => void;
+    /** Pages réellement recomposées au dernier appel — ce que la reprise a épargné. */
+    lastComposed: () => {
+        at: number | undefined;
+        from: number | undefined;
+        to: number | undefined;
+        pages: number;
+        snaps: number | undefined;
+        bounds: number | undefined;
+    };
+    /** remplace le document — au chargement d'un fichier */
+    load(next: DocxDocument): void;
+    readonly lines: LineTrace[];
+    readonly views: DocViews;
+    readonly document: DocxDocument;
+    readonly pages: number;
+    /** Texte d'un paragraphe, lu dans le modèle — jamais en retard d'une frappe. */
+    textOf: (para: number, part?: string) => string;
+    paragraphCount: () => number;
+    context: () => EditContext | null;
+    hasSelection: () => boolean;
+    /** Rectangles des images dessinées — ce que la souris vise. */
+    imageRects: () => {
+        para: number;
+        index: number;
+        page: number;
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+        anchored: boolean;
+    }[];
+    /**
+     * Le champ invisible qui reçoit la frappe.
+     *
+     * Une extension qui veut passer AVANT l'éditeur au clavier — une liste de
+     * complétion, par exemple — n'a pas d'autre point d'accroche : c'est lui
+     * qui porte l'écoute, et une capture posée dessus s'exécute d'abord.
+     */
+    inputEl: () => HTMLTextAreaElement;
+    /** Boîtes réservées aux affichages d'extension, telles que dessinées. */
+    markRects: () => {
+        mark: string;
+        page: number;
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+        fontPx: number;
+    }[];
+    /**
+     * Pose un peintre de calque : il reçoit les couches et les boîtes réservées
+     * après chaque nettoyage, et y dépose ce qu'il veut. Rend de quoi le retirer.
+     */
+    registerLayerPainter(fn: (layers: HTMLElement[], marks: MarkRect[]) => void): () => boolean;
+    /** Rectangles des tableaux dessinés, un par page occupée. */
+    tableRects: () => {
+        table: number;
+        page: number;
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    }[];
+    /** Objet sélectionné — une image ou un tableau pris comme un tout, ou `null`. */
+    selectedObject: () => {
+        kind: "image";
+        para: number;
+        index: number;
+    } | {
+        kind: "table";
+        table: number;
+    } | {
+        kind: "extern";
+        id: string;
+    } | null;
+    /** Sélectionne une image par son paragraphe et son rang. */
+    selectObject(para: number, index: number): void;
+    /**
+     * Prend un objet d'EXTENSION, sur la plage de texte qu'il occupe.
+     *
+     * La plage est posée — la suppression, la copie et le remplacement en
+     * dépendent — mais rien n'est dessiné : ni curseur, ni surlignage. C'est
+     * l'extension qui montre ce qui est pris.
+     */
+    selectExternal(id: string, anchor: DocPos, focus?: DocPos): void;
+    /** Sélectionne un TABLEAU entier, par son rang dans `views.tables`. */
+    selectTable(table: number): void;
+    /** Déplace le tableau sélectionné devant le bloc qui porte ce paragraphe. */
+    moveTable(target: number): boolean;
+    /** Pose la taille d'une image, en points. */
+    setImageSize: (para: number, index: number, wPt: number, hPt: number) => void;
+    /** La sélection courante et son texte — de quoi la piloter du dehors. */
+    selection: () => {
+        anchor: {
+            para: number;
+            off: number;
+            part?: string;
+        };
+        focus: {
+            para: number;
+            off: number;
+            part?: string;
+        };
+        text: string;
+    } | null;
+    /** Pose la sélection. Une seule adresse donne un simple curseur. */
+    selectRange(anchor: DocPos, focus?: DocPos): void;
+    selectAll: () => void;
+    /** Bornes du paragraphe entier, telles que la mise en page les a dessinées. */
+    paragraphRange: (para: number) => {
+        from: number;
+        to: number;
+    } | null;
+    /** Insère du texte au curseur, ou remplace la sélection. */
+    insert: (text: string) => void;
+    deleteSelection: () => void;
+    splitAtCaret: () => void;
+    format: (patch: RunPatch) => void;
+    formatPara: (patch: ParaPatch) => void;
+    table: (what: "row" | "col", how: "above" | "below" | "left" | "right" | "delete") => void;
+    resizeImage: (index: number, factor: number) => void;
+    insertBreak: (kind: "page" | "column" | "line") => void;
+    insertImage: (data: Uint8Array, ext: string) => Promise<boolean>;
+    setMargins: (patch: MarginPatch, section?: number) => void;
+    setTableColumn: (col: number, widthPt: number) => void;
+    /** Format d'une section — celle du curseur par défaut. */
+    pageSetup: (section?: number) => PageSetup | null;
+    /** Section à laquelle appartient une page dessinée — ce que la règle suit. */
+    sectionOfPage(page: number): number;
+    undo: () => void;
+    redo: () => void;
+    canUndo: () => boolean;
+    canRedo: () => boolean;
+    save: () => Uint8Array<ArrayBufferLike>;
+    /** État de l'enregistrement, tel que la barre d'état le montre. */
+    saveState: () => "à jour" | "à enregistrer" | "enregistrement…" | "échec";
+    /** Force l'envoi maintenant, sans attendre l'accalmie. */
+    saveNow: () => Promise<void>;
+    focus: () => void;
+    /** Agrandit l'affichage. Le canvas n'est pas recomposé : c'est du CSS. */
+    setZoom(z: number): void;
+    getZoom: () => number;
+    /** Lock the document: navigation and copy stay, every edit is refused. */
+    setReadOnly(on: boolean): void;
+    isReadOnly: () => boolean;
+    /**
+     * Detach from the page. The window listeners would otherwise outlive the
+     * element — a React remount would then drive two editors with one mouse.
+     */
+    dispose(): void;
+    /**
+     * Enregistre une commande.
+     *
+     * Elle devient utilisable par son identifiant (`run`), et la barre d'outils
+     * la propose si on lui donne un `group`. C'est le seul point d'entrée pour
+     * ajouter quelque chose : l'hôte n'a pas à connaître ce qu'on ajoute.
+     */
+    registerCommand(cmd: Command): () => void;
+    commands: () => Command[];
+    /**
+     * Enregistre un fournisseur de décorations.
+     *
+     * Il est rappelé à chaque peinture et rend les marques à poser, chacune
+     * ancrée à une plage de caractères. L'hôte les matérialise là où le
+     * renderer a dessiné ce texte — l'extension ne peint jamais sur le canvas.
+     */
+    registerDecorations(provider: DecorationProvider): () => void;
+    /** Rectangles réellement dessinés pour une ancre — le `measure` du contrat. */
+    rectsFor: (a: {
+        para: number;
+        from: number;
+        to: number;
+    }) => SelRect[];
+    /** Position du curseur, dans les termes du contrat d'extension. */
+    caret: () => {
+        para: number;
+        offset: number;
+    } | null;
+    /** Exécute une commande par son identifiant. */
+    run(id: string, arg?: unknown): boolean;
+    /** S'abonne à un événement. Rend la fonction de désabonnement. */
+    on(ev: EditorEvent, fn: (payload: never) => void): () => boolean;
+    off(ev: EditorEvent, fn: (payload: never) => void): void;
+};
+export type Editor = ReturnType<typeof createEditor>;
+/**
+ * Ce qu'une extension peut écouter.
+ *
+ * `change` court après toute modification du document, `selection` après tout
+ * déplacement du curseur, `render` après chaque composition, `context` avec
+ * l'état complet sous le curseur, `commands` quand le registre bouge.
+ */
+export type EditorEvent = 'change' | 'selection' | 'render' | 'context' | 'commands' | 'load' | 'save';
+/**
+ * Une commande ajoutée par l'hôte ou par une extension.
+ *
+ * `group` la place dans la barre d'outils ; sans lui elle reste appelable par
+ * `editor.run(id)` sans rien afficher. `active` et `enabled` sont relus à
+ * chaque composition — un état d'interface maintenu à la main finit par mentir.
+ */
+/**
+ * Une marque ancrée à une plage de caractères.
+ *
+ * C'est la moitié « décoration » du contrat d'extension, celle qui manquait ici :
+ * le registre de commandes décrit des ACTIONS, une décoration décrit une
+ * MARQUE. Les deux sont complémentaires, pas concurrents.
+ *
+ * L'ancre est celle du POC variables — `{para, from, to}` — pour qu'un badge
+ * écrit là-bas se pose ici sans rien changer.
+ */
+export interface Decoration {
+    id: string;
+    anchor: {
+        para: number;
+        from: number;
+        to: number;
+    };
+    /** classe CSS posée sur le rectangle */
+    className?: string;
+    /** contenu, posé sur le premier rectangle seulement */
+    render?(): Node;
+    onSelect?(): void;
+}
+/** Rappelé à chaque peinture ; rend les marques à poser. */
+export type DecorationProvider = (editor: Editor) => Decoration[];
+export interface Command {
+    id: string;
+    label: string;
+    title?: string;
+    /** groupe de la barre d'outils : `edition`, `police`, `paragraphe`, `inserer`… */
+    group?: string;
+    /** icône dessinée, sinon le libellé sert de texte */
+    icon?: () => Node;
+    run(editor: Editor, arg?: unknown): void;
+    /** bouton enfoncé ? relu à chaque composition */
+    active?(editor: Editor): boolean;
+    /** bouton disponible ? relu à chaque composition */
+    enabled?(editor: Editor): boolean;
+}

package/dist/types/packages/docx-editor/src/embed.d.ts

@@ -0,0 +1,7 @@
+export interface Rendered {
+    pages: HTMLCanvasElement[];
+    ms: number;
+}
+export declare function renderDocx(url: string | ArrayBuffer | Uint8Array, container: HTMLElement, opts?: {
+    fontsUrl?: string;
+}): Promise<Rendered>;

package/dist/types/packages/docx-editor/src/font-manifest.d.ts

@@ -0,0 +1,7 @@
+export interface FontFaceSpec {
+    family: string;
+    weight: number;
+    style: 'normal' | 'italic';
+    file: string;
+}
+export declare const FONT_FACES: FontFaceSpec[];

package/dist/types/packages/docx-editor/src/fonts.d.ts

@@ -0,0 +1,5 @@
+export declare function defaultFontsUrl(): string;
+/** Declare every shipped face once, then wait for them like the app did. */
+export declare function installFonts(fontsUrl?: string): Promise<void>;
+/** Line-height ratios read in the served TTFs — `fontLineRatios` on our directory. */
+export declare function lineRatios(fontsUrl?: string): Promise<Partial<Record<"Times New Roman" | "New York" | "Arial" | "Symbol" | "Calibri" | "Avenir Book" | "Avenir" | "Avenir Next" | "Gill Sans Light" | "Century Gothic" | "Verdana" | "Century Schoolbook" | "Avenir Heavy" | "Bookman Old Style" | "Aptos" | "Consolas" | "Abadi MT Condensed Extra Bold" | "Abadi MT Condensed Light" | "Angsana New" | "Apple Color Emoji" | "Apple Symbols" | "Aptos Narrow" | "Arial Hebrew" | "Arial Narrow" | "Arial Rounded MT Bold" | "Arial Unicode MS" | "Avenir Light" | "Baskerville Old Face" | "Batang" | "Bauhaus 93" | "Big Caslon" | "Calibri Light" | "Cambria" | "Cambria Math" | "Candara" | "Century" | "Comic Sans MS" | "Corbel" | "Cordia New" | "Courier" | "Courier New" | "DengXian" | "DengXian Light" | "Didot" | "Edwardian Script ITC" | "Euphemia UCAS" | "Eurostile" | "Franklin Gothic Book" | "Franklin Gothic Demi" | "Franklin Gothic Demi Cond" | "Franklin Gothic Medium" | "Franklin Gothic Medium Cond" | "Futura" | "Garamond" | "Geneva" | "Georgia" | "Gill Sans" | "Gill Sans MT" | "Helvetica" | "Helvetica Neue" | "Hoefler Text" | "Lucida Grande" | "Lucida Sans" | "Lucida Sans Unicode" | "MS Gothic" | "MS Mincho" | "MS UI Gothic" | "Malgun Gothic" | "Mangal" | "Microsoft Sans Serif" | "Microsoft YaHei" | "Microsoft Yi Baiti" | "Monotype Sorts" | "NSimSun" | "News Gothic MT" | "Optima" | "PMingLiU" | "PT Mono" | "Palatino" | "Palatino Linotype" | "Segoe UI Symbol" | "SimSun" | "Skia" | "Stencil" | "Tahoma" | "Times" | "Trebuchet MS" | "Tw Cen MT" | "Tw Cen MT Condensed" | "Webdings" | "Wingdings" | "Wingdings 2" | "Wingdings 3" | "Yu Gothic Light" | "Yu Mincho" | "Arial Black" | "Avenir Black", number>>>;

package/dist/types/packages/docx-editor/src/html.d.ts

@@ -0,0 +1,13 @@
+import type { PastedBlock } from '../../docx-model/src/index';
+/** Décode une URI `data:` en octets, ou rend `null` si ce n'en est pas une. */
+export declare function dataUri(src: string): {
+    data: Uint8Array;
+    ext: string;
+} | null;
+/**
+ * Découpe le HTML en blocs : paragraphes, listes, tableaux, images.
+ *
+ * Les espaces sont normalisées comme le ferait un navigateur — le HTML de Word
+ * est plein de retours à la ligne et d'indentation qui ne sont pas du texte.
+ */
+export declare function htmlToBlocks(html: string): PastedBlock[];

package/dist/types/packages/docx-editor/src/index.d.ts

@@ -0,0 +1,20 @@
+/**
+ * myrole-docx-editor — the MyRole engine as an SDK.
+ *
+ *   import { createDocxEditor } from 'myrole-docx-editor'
+ *   const editor = createDocxEditor(document.getElementById('app'), { onSave })
+ *   await editor.load(file)
+ *
+ * React: `import { DocxEditor } from 'myrole-docx-editor/react'`.
+ */
+export { createDocxEditor } from './sdk';
+export type { DocxEditorHandle, DocxEditorOptions, DocxEditorEvent, ChromeMode, Theme } from './sdk';
+export { renderDocx } from './embed';
+export type { Rendered } from './embed';
+export { installFonts, defaultFontsUrl } from './fonts';
+export type { Editor, EditorEvent, Command, Decoration, DecorationProvider } from './editor';
+export type { Tag } from '../../docx-tags/src/index';
+export type { DocxDocument, DocPos, EditContext, RunPatch, ParaPatch, MarginPatch } from '../../docx-model/src/index';
+export { sampleValues, evaluateTags } from '../../docx-vars/src/index';
+export type { LibraryExtras, LibraryField, LibrarySnippet } from './vars-library';
+export type { Comment, CommentRange } from './comments';

package/dist/types/packages/docx-editor/src/inspector-ui.d.ts

@@ -0,0 +1,6 @@
+/**
+ * UI de l'inspecteur — panneau latéral avec onglets.
+ */
+import type { InspectorData } from './inspector';
+export declare function renderInspector(data: InspectorData): void;
+export declare function setupInspectorControls(): void;