@june-ai/june-ui 0.2.7 → 0.2.8

package/dist/chunk-G6YPSE6J.cjs

@@ -0,0 +1,520 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }// src/features/document-editor/document-engine.ts
+var _core = require('@tiptap/core');
+
+// src/utils/errors.ts
+var JuneError = class _JuneError extends Error {
+  constructor(code, message, options = {}) {
+    super(message);
+    Object.setPrototypeOf(this, _JuneError.prototype);
+    this.name = "JuneError";
+    this.code = code;
+    this.details = options.details;
+    if (options.cause !== void 0) {
+      this.cause = options.cause;
+    }
+  }
+};
+function isJuneError(value) {
+  return value instanceof JuneError;
+}
+function toJuneError(error, fallbackCode, message) {
+  if (error instanceof JuneError) return error;
+  const text = _nullishCoalesce(message, () => ( (error instanceof Error ? error.message : String(error))));
+  return new JuneError(fallbackCode, text, { cause: error });
+}
+
+// src/features/document-editor/document-extensions.ts
+
+var _extensionhighlight = require('@tiptap/extension-highlight'); var _extensionhighlight2 = _interopRequireDefault(_extensionhighlight);
+var _extensionimage = require('@tiptap/extension-image'); var _extensionimage2 = _interopRequireDefault(_extensionimage);
+var _extensionsubscript = require('@tiptap/extension-subscript'); var _extensionsubscript2 = _interopRequireDefault(_extensionsubscript);
+var _extensionsuperscript = require('@tiptap/extension-superscript'); var _extensionsuperscript2 = _interopRequireDefault(_extensionsuperscript);
+var _extensiontable = require('@tiptap/extension-table');
+var _extensiontextalign = require('@tiptap/extension-text-align'); var _extensiontextalign2 = _interopRequireDefault(_extensiontextalign);
+var _extensiontextstyle = require('@tiptap/extension-text-style');
+var _markdown = require('@tiptap/markdown');
+var _starterkit = require('@tiptap/starter-kit'); var _starterkit2 = _interopRequireDefault(_starterkit);
+
+// src/features/document-editor/document-pagination.ts
+
+var _state = require('@tiptap/pm/state');
+var _view = require('@tiptap/pm/view');
+var paginationKey = new (0, _state.PluginKey)("juneDocPagination");
+var configs = /* @__PURE__ */ new WeakMap();
+var SPLITTABLE = /* @__PURE__ */ new Set(["bulletList", "orderedList", "listItem", "blockquote"]);
+function gapWidget(height) {
+  return () => {
+    const el = document.createElement("div");
+    el.className = "june-doc__page-gap";
+    el.contentEditable = "false";
+    el.setAttribute("aria-hidden", "true");
+    el.style.height = `${height}px`;
+    return el;
+  };
+}
+function build(doc, breaks) {
+  return _view.DecorationSet.create(
+    doc,
+    breaks.map(
+      (b) => _view.Decoration.widget(b.pos, gapWidget(b.height), {
+        side: -1,
+        ignoreSelection: true,
+        key: `jd-gap-${b.pos}-${Math.round(b.height)}`
+      })
+    )
+  );
+}
+function collectUnits(doc) {
+  const units = [];
+  const walk = (parent, start, inheritedBreak) => {
+    parent.forEach((child, offset, index) => {
+      const pos = start + offset;
+      const breakPos = index === 0 && inheritedBreak !== null ? inheritedBreak : pos;
+      if (SPLITTABLE.has(child.type.name) && child.childCount > 0) {
+        walk(child, pos + 1, breakPos);
+      } else {
+        units.push({ pos, breakPos, node: child });
+      }
+    });
+  };
+  walk(doc, 0, null);
+  return units;
+}
+function measure(view, cfg) {
+  const prose = view.dom;
+  const proseRect = prose.getBoundingClientRect();
+  const scale = prose.offsetWidth ? proseRect.width / prose.offsetWidth : 1;
+  if (!scale || !proseRect.width) return { breaks: [], pages: 1 };
+  const gaps = [...prose.querySelectorAll(".june-doc__page-gap")].map((g) => {
+    const r = g.getBoundingClientRect();
+    return { top: (r.top - proseRect.top) / scale, height: r.height / scale };
+  });
+  const gapsAbove = (y) => gaps.reduce((sum, g) => g.top <= y + 0.5 ? sum + g.height : sum, 0);
+  const contentH = Math.max(80, cfg.pageHeight - cfg.padTop - cfg.padBottom);
+  const stride = cfg.pageHeight + cfg.gap;
+  const breaks = /* @__PURE__ */ new Map();
+  let pageStart = 0;
+  let added = 0;
+  let force = false;
+  for (const unit of collectUnits(view.state.doc)) {
+    const el = view.nodeDOM(unit.pos);
+    if (!(el instanceof HTMLElement)) continue;
+    const r = el.getBoundingClientRect();
+    const rawTop = (r.top - proseRect.top) / scale;
+    const natural = rawTop - gapsAbove(rawTop);
+    const h = r.height / scale;
+    let top = natural + added;
+    let bottom = top + h;
+    const overflows = bottom > pageStart + contentH + 0.5 && top > pageStart + 1;
+    if (force || overflows) {
+      const target = pageStart + stride;
+      if (top < target) {
+        const spacer = target - top;
+        breaks.set(unit.breakPos, (_nullishCoalesce(breaks.get(unit.breakPos), () => ( 0))) + spacer);
+        added += spacer;
+        top = target;
+        bottom = top + h;
+      }
+      pageStart = target;
+      while (top >= pageStart + stride) pageStart += stride;
+      force = false;
+    }
+    while (bottom > pageStart + contentH + 0.5) pageStart += stride;
+    if (unit.node.type.name === "pageBreak") force = true;
+  }
+  const pages = Math.max(1, Math.round(pageStart / stride) + 1 + (force ? 1 : 0));
+  return {
+    breaks: [...breaks].map(([pos, height]) => ({ pos, height: Math.round(height * 10) / 10 })).sort((a, b) => a.pos - b.pos),
+    pages
+  };
+}
+var same = (a, b) => a.length === b.length && a.every((x, i) => x.pos === b[i].pos && Math.abs(x.height - b[i].height) < 1);
+var DocumentPagination = _core.Extension.create({
+  name: "juneDocPagination",
+  addProseMirrorPlugins() {
+    return [
+      new (0, _state.Plugin)({
+        key: paginationKey,
+        state: {
+          init: () => ({ breaks: [], pages: 1, decorations: _view.DecorationSet.empty, epoch: 0 }),
+          apply(tr, prev, _old, state) {
+            const meta = tr.getMeta(paginationKey);
+            if (_optionalChain([meta, 'optionalAccess', _ => _.remeasure])) return { ...prev, epoch: prev.epoch + 1 };
+            if (_optionalChain([meta, 'optionalAccess', _2 => _2.breaks])) {
+              return { ...prev, breaks: meta.breaks, pages: _nullishCoalesce(meta.pages, () => ( prev.pages)), decorations: build(state.doc, meta.breaks) };
+            }
+            if (tr.docChanged) {
+              const breaks = prev.breaks.map((b) => ({ ...b, pos: tr.mapping.map(b.pos, -1) })).filter((b) => b.pos >= 0 && b.pos <= state.doc.content.size);
+              return { ...prev, breaks, decorations: prev.decorations.map(tr.mapping, tr.doc) };
+            }
+            return prev;
+          }
+        },
+        props: {
+          decorations: (state) => _optionalChain([paginationKey, 'access', _3 => _3.getState, 'call', _4 => _4(state), 'optionalAccess', _5 => _5.decorations])
+        },
+        view(view) {
+          let frame = null;
+          let rounds = 0;
+          const schedule = (reset) => {
+            if (reset) rounds = 0;
+            if (frame !== null || typeof window === "undefined") return;
+            const raf = _nullishCoalesce(window.requestAnimationFrame, () => ( ((cb) => window.setTimeout(() => cb(0), 16))));
+            frame = raf(() => {
+              frame = null;
+              if (view.isDestroyed) return;
+              const cfg = configs.get(view);
+              const current = paginationKey.getState(view.state);
+              if (!current) return;
+              const next = _optionalChain([cfg, 'optionalAccess', _6 => _6.enabled]) ? measure(view, cfg) : { breaks: [], pages: 1 };
+              if (same(next.breaks, current.breaks) && next.pages === current.pages) return;
+              if (++rounds > 4) return;
+              view.dispatch(view.state.tr.setMeta(paginationKey, next).setMeta("addToHistory", false));
+            });
+          };
+          schedule(true);
+          return {
+            update(v, prevState) {
+              const pg = paginationKey.getState(v.state);
+              const prevPg = paginationKey.getState(prevState);
+              if (v.state.doc !== prevState.doc || _optionalChain([pg, 'optionalAccess', _7 => _7.epoch]) !== _optionalChain([prevPg, 'optionalAccess', _8 => _8.epoch])) schedule(true);
+              else if (pg !== prevPg) schedule(false);
+            },
+            destroy() {
+              frame = null;
+            }
+          };
+        }
+      })
+    ];
+  }
+});
+function setPaginationConfig(editor, cfg) {
+  if (editor.isDestroyed) return;
+  const prev = configs.get(editor.view);
+  configs.set(editor.view, cfg);
+  if (!prev || prev.enabled !== cfg.enabled || prev.pageHeight !== cfg.pageHeight || prev.gap !== cfg.gap || prev.padTop !== cfg.padTop || prev.padBottom !== cfg.padBottom) {
+    remeasurePagination(editor);
+  }
+}
+function remeasurePagination(editor) {
+  if (editor.isDestroyed) return;
+  const s = paginationKey.getState(editor.state);
+  if (!s) return;
+  editor.view.dispatch(editor.state.tr.setMeta(paginationKey, { remeasure: true }).setMeta("addToHistory", false));
+}
+function getPageCount(editor) {
+  return editor && _optionalChain([paginationKey, 'access', _9 => _9.getState, 'call', _10 => _10(editor.state), 'optionalAccess', _11 => _11.pages]) || 1;
+}
+
+// src/features/document-editor/document-search.ts
+
+
+
+var searchKey = new (0, _state.PluginKey)("juneDocSearch");
+function findMatches(doc, term, caseSensitive) {
+  if (!term) return [];
+  const needle = caseSensitive ? term : term.toLowerCase();
+  const out = [];
+  doc.descendants((node, pos) => {
+    if (!node.isTextblock) return true;
+    let text = "";
+    const map = [];
+    node.forEach((child, offset) => {
+      const start = pos + 1 + offset;
+      if (child.isText && child.text) {
+        for (let i = 0; i < child.text.length; i++) map.push(start + i);
+        text += child.text;
+      } else {
+        map.push(start);
+        text += "\uFFFC";
+      }
+    });
+    const hay = caseSensitive ? text : text.toLowerCase();
+    let idx = hay.indexOf(needle);
+    while (idx !== -1) {
+      out.push({ from: map[idx], to: map[idx + needle.length - 1] + 1 });
+      idx = hay.indexOf(needle, idx + needle.length);
+    }
+    return false;
+  });
+  return out;
+}
+function build2(doc, term, caseSensitive, current) {
+  const matches = findMatches(doc, term, caseSensitive);
+  const active = matches.length ? Math.min(Math.max(current, 0), matches.length - 1) : -1;
+  const decorations = _view.DecorationSet.create(
+    doc,
+    matches.map(
+      (m, i) => _view.Decoration.inline(m.from, m.to, {
+        class: i === active ? "june-doc__match june-doc__match--active" : "june-doc__match"
+      })
+    )
+  );
+  return { term, caseSensitive, current: active, matches, decorations };
+}
+var DocumentSearch = _core.Extension.create({
+  name: "juneDocSearch",
+  addProseMirrorPlugins() {
+    return [
+      new (0, _state.Plugin)({
+        key: searchKey,
+        state: {
+          init: () => ({ term: "", caseSensitive: false, current: -1, matches: [], decorations: _view.DecorationSet.empty }),
+          apply(tr, prev, _old, state) {
+            const meta = tr.getMeta(searchKey);
+            if (!meta && !tr.docChanged) return prev;
+            if (!meta && !prev.term) return prev;
+            return build2(
+              state.doc,
+              _nullishCoalesce(_optionalChain([meta, 'optionalAccess', _12 => _12.term]), () => ( prev.term)),
+              _nullishCoalesce(_optionalChain([meta, 'optionalAccess', _13 => _13.caseSensitive]), () => ( prev.caseSensitive)),
+              _nullishCoalesce(_optionalChain([meta, 'optionalAccess', _14 => _14.current]), () => ( prev.current))
+            );
+          }
+        },
+        props: {
+          decorations: (state) => _optionalChain([searchKey, 'access', _15 => _15.getState, 'call', _16 => _16(state), 'optionalAccess', _17 => _17.decorations])
+        }
+      })
+    ];
+  }
+});
+function getSearchState(editor) {
+  return editor ? searchKey.getState(editor.state) : void 0;
+}
+function setSearch(editor, meta) {
+  editor.view.dispatch(editor.state.tr.setMeta(searchKey, meta));
+}
+function gotoMatch(editor, step) {
+  const s = getSearchState(editor);
+  if (!s || !s.matches.length) return;
+  const n = s.matches.length;
+  const current = s.current < 0 ? 0 : (s.current + step + n) % n;
+  setSearch(editor, { current });
+  const m = s.matches[current];
+  editor.chain().setTextSelection(m).scrollIntoView().run();
+}
+function replaceCurrent(editor, replacement) {
+  const s = getSearchState(editor);
+  if (!s || s.current < 0) return;
+  const m = s.matches[s.current];
+  editor.chain().command(({ tr }) => {
+    if (replacement) tr.insertText(replacement, m.from, m.to);
+    else tr.delete(m.from, m.to);
+    return true;
+  }).run();
+  gotoMatch(editor, 0);
+}
+function replaceAll(editor, replacement) {
+  const s = getSearchState(editor);
+  if (!s || !s.matches.length) return 0;
+  const matches = [...s.matches].reverse();
+  editor.chain().command(({ tr }) => {
+    for (const m of matches) {
+      if (replacement) tr.insertText(replacement, m.from, m.to);
+      else tr.delete(m.from, m.to);
+    }
+    return true;
+  }).run();
+  return matches.length;
+}
+
+// src/features/document-editor/document-extensions.ts
+var PageBreak = _core.Node.create({
+  name: "pageBreak",
+  group: "block",
+  atom: true,
+  selectable: true,
+  parseHTML() {
+    return [{ tag: "div[data-page-break]" }];
+  },
+  renderHTML({ HTMLAttributes }) {
+    return [
+      "div",
+      _core.mergeAttributes.call(void 0, HTMLAttributes, {
+        "data-page-break": "true",
+        class: "june-doc__page-break",
+        style: "break-after: page; page-break-after: always;"
+      })
+    ];
+  },
+  // Markdown has no page break; a thematic break is the closest stable equivalent.
+  renderMarkdown: () => "---",
+  addCommands() {
+    return {
+      setPageBreak: () => ({ chain }) => chain().insertContent([{ type: this.name }, { type: "paragraph" }]).run()
+    };
+  },
+  addKeyboardShortcuts() {
+    return { "Mod-Enter": () => this.editor.commands.setPageBreak() };
+  }
+});
+function createDocumentExtensions() {
+  return [
+    _starterkit2.default.configure({
+      heading: { levels: [1, 2, 3] },
+      // Tiptap v3 StarterKit already includes Link and Underline
+      link: { openOnClick: false, autolink: true, defaultProtocol: "https" }
+    }),
+    _extensiontextalign2.default.configure({ types: ["heading", "paragraph"] }),
+    _extensiontable.TableKit,
+    _extensiontextstyle.TextStyle,
+    _extensiontextstyle.Color,
+    _extensiontextstyle.FontFamily,
+    _extensiontextstyle.FontSize,
+    _extensionhighlight2.default.configure({ multicolor: true }),
+    _extensionsubscript2.default,
+    _extensionsuperscript2.default,
+    _extensionimage2.default.configure({
+      inline: false,
+      allowBase64: true,
+      resize: { enabled: true, minWidth: 48, minHeight: 32, alwaysPreserveAspectRatio: true }
+    }),
+    PageBreak,
+    DocumentSearch,
+    DocumentPagination,
+    // inactive until the live editor sets a page geometry
+    _markdown.Markdown
+  ];
+}
+
+// src/features/document-editor/document-utils.ts
+var emptyDoc = () => ({ type: "doc", content: [{ type: "paragraph" }] });
+function isDocJSON(value) {
+  if (!value || typeof value !== "object") return false;
+  const v = value;
+  return v.type === "doc" && (v.content === void 0 || Array.isArray(v.content));
+}
+function looksLikeDocJSON(text) {
+  return /^\s*\{\s*"type"\s*:\s*"doc"/.test(text);
+}
+function tryParseDocJSON(text) {
+  try {
+    const value = JSON.parse(text);
+    return isDocJSON(value) ? value : null;
+  } catch (e) {
+    return null;
+  }
+}
+var keyCache = /* @__PURE__ */ new WeakMap();
+function docKey(doc) {
+  let key = keyCache.get(doc);
+  if (key === void 0) {
+    key = JSON.stringify(doc);
+    keyCache.set(doc, key);
+  }
+  return key;
+}
+function plainText(node) {
+  const n = node;
+  if (typeof n.text === "string") return n.text;
+  return (_nullishCoalesce(n.content, () => ( []))).map(plainText).join(" ");
+}
+function countWords(text) {
+  const trimmed = text.trim();
+  return trimmed ? trimmed.split(/\s+/).length : 0;
+}
+var wordCache = /* @__PURE__ */ new WeakMap();
+function wordCountOf(doc) {
+  let count = wordCache.get(doc);
+  if (count === void 0) {
+    count = countWords(plainText(doc));
+    wordCache.set(doc, count);
+  }
+  return count;
+}
+function slugify(value) {
+  return value.toLowerCase().normalize("NFKD").replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 60);
+}
+function debounce(fn, wait) {
+  let timer = null;
+  const run = () => {
+    timer = null;
+    fn();
+  };
+  const debounced = (() => {
+    if (timer !== null) clearTimeout(timer);
+    timer = setTimeout(run, wait);
+  });
+  debounced.cancel = () => {
+    if (timer !== null) {
+      clearTimeout(timer);
+      timer = null;
+    }
+  };
+  debounced.flush = () => {
+    if (timer !== null) {
+      clearTimeout(timer);
+      run();
+    }
+  };
+  return debounced;
+}
+function sanitizeHref(input) {
+  const value = input.trim();
+  if (!value) return null;
+  if (/^(https?:|mailto:|tel:)/i.test(value)) return value;
+  if (/^[a-z][a-z0-9+.-]*:/i.test(value)) return null;
+  if (value.startsWith("/") || value.startsWith("#")) return value;
+  return `https://${value}`;
+}
+
+// src/features/document-editor/document-engine.ts
+var scratch = null;
+function scratchEditor() {
+  if (!scratch || scratch.isDestroyed) {
+    scratch = new (0, _core.Editor)({ extensions: createDocumentExtensions(), content: "" });
+  }
+  return scratch;
+}
+function parseDocumentContent(text) {
+  const editor = scratchEditor();
+  const trimmed = text.trim();
+  try {
+    if (looksLikeDocJSON(trimmed)) {
+      const json = tryParseDocJSON(trimmed);
+      if (!json) throw new Error("The document JSON could not be parsed");
+      editor.schema.nodeFromJSON(json).check();
+      editor.commands.setContent(json, { emitUpdate: false });
+    } else {
+      editor.commands.setContent(trimmed, { contentType: "markdown", emitUpdate: false });
+    }
+    return editor.getJSON();
+  } catch (error) {
+    throw toJuneError(error, "DOCUMENT_ERROR", "The document content is invalid");
+  }
+}
+function load(doc) {
+  const editor = scratchEditor();
+  editor.commands.setContent(doc, { emitUpdate: false });
+  return editor;
+}
+var docToHtml = (doc) => load(doc).getHTML();
+var docToMarkdown = (doc) => load(doc).getMarkdown();
+var docToText = (doc) => load(doc).getText({ blockSeparator: "\n\n" });
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+exports.JuneError = JuneError; exports.isJuneError = isJuneError; exports.toJuneError = toJuneError; exports.emptyDoc = emptyDoc; exports.docKey = docKey; exports.wordCountOf = wordCountOf; exports.slugify = slugify; exports.debounce = debounce; exports.sanitizeHref = sanitizeHref; exports.setPaginationConfig = setPaginationConfig; exports.remeasurePagination = remeasurePagination; exports.getPageCount = getPageCount; exports.getSearchState = getSearchState; exports.setSearch = setSearch; exports.gotoMatch = gotoMatch; exports.replaceCurrent = replaceCurrent; exports.replaceAll = replaceAll; exports.createDocumentExtensions = createDocumentExtensions; exports.parseDocumentContent = parseDocumentContent; exports.docToHtml = docToHtml; exports.docToMarkdown = docToMarkdown; exports.docToText = docToText;