@vizel/core 0.0.1-alpha.1

package/dist/index14.js

@@ -0,0 +1,150 @@
+import { PluginKey as S, Plugin as A } from "./index41.js";
+import { DecorationSet as E, Decoration as M } from "./index49.js";
+import { VIZEL_DEFAULT_IMAGE_MAX_FILE_SIZE as _, VIZEL_DEFAULT_FILE_MIME_TYPES as P } from "./index12.js";
+const d = new S("vizel-image-upload"), U = (e) => typeof e == "object" && e !== null && "type" in e && (e.type === "add" || e.type === "remove");
+function T(e) {
+  const { placeholderClass: o = "vizel-image-placeholder", imageClass: r = "vizel-image-uploading" } = e;
+  return new A({
+    key: d,
+    state: {
+      init() {
+        return E.empty;
+      },
+      apply(t, i) {
+        let a = i.map(t.mapping, t.doc);
+        const s = t.getMeta(d), n = U(s) ? s : void 0;
+        if (n?.type === "add") {
+          const { id: l, pos: g, previewSrc: p } = n, c = document.createElement("div");
+          c.setAttribute("class", o);
+          const u = document.createElement("img");
+          u.setAttribute("class", r), u.src = p, c.appendChild(u);
+          const m = document.createElement("div");
+          m.setAttribute("class", "vizel-image-spinner"), c.appendChild(m);
+          const f = M.widget(g, c, { id: l });
+          a = a.add(t.doc, [f]);
+        } else n?.type === "remove" && (a = a.remove(
+          a.find(void 0, void 0, (l) => l.id === n.id)
+        ));
+        return a;
+      }
+    },
+    props: {
+      decorations(t) {
+        return d.getState(t) ?? E.empty;
+      }
+    }
+  });
+}
+function F(e, o) {
+  const r = d.getState(e);
+  if (!r)
+    return null;
+  const t = r.find(void 0, void 0, (i) => i.id === o);
+  return t.length > 0 ? t[0]?.from ?? null : null;
+}
+function x(e, o) {
+  const r = o.maxFileSize ?? _, t = o.allowedTypes ?? P;
+  if (!t.includes(e.type))
+    return {
+      type: "invalid_type",
+      message: `File type "${e.type}" is not allowed. Allowed types: ${t.join(", ")}`,
+      file: e
+    };
+  if (e.size > r) {
+    const i = (r / 1048576).toFixed(1);
+    return {
+      type: "file_too_large",
+      message: `File size (${(e.size / (1024 * 1024)).toFixed(1)}MB) exceeds maximum allowed size (${i}MB)`,
+      file: e
+    };
+  }
+  return null;
+}
+function v(e) {
+  const { onUpload: o, maxFileSize: r, allowedTypes: t, onValidationError: i, onUploadError: a } = e;
+  return (s, n, l) => {
+    const g = x(s, {
+      ...r !== void 0 && { maxFileSize: r },
+      ...t !== void 0 && { allowedTypes: t }
+    });
+    if (g) {
+      i?.(g);
+      return;
+    }
+    const p = {}, c = new FileReader();
+    c.readAsDataURL(s), c.onload = () => {
+      if (typeof c.result != "string") return;
+      const u = c.result, m = n.state.tr;
+      m.selection.empty || m.deleteSelection(), m.setMeta(d, {
+        type: "add",
+        id: p,
+        pos: l,
+        previewSrc: u
+      }), n.dispatch(m), o(s).then((f) => {
+        const y = F(n.state, p);
+        if (y === null)
+          return;
+        const { schema: h } = n.state, z = h.nodes.image?.create({ src: f });
+        if (!z) {
+          console.warn("Image node type not found in schema");
+          return;
+        }
+        const I = n.state.tr.replaceWith(y, y, z).setMeta(d, {
+          type: "remove",
+          id: p
+        });
+        n.dispatch(I);
+      }).catch((f) => {
+        if (a?.(f, s), F(n.state, p) !== null) {
+          const h = n.state.tr.setMeta(d, {
+            type: "remove",
+            id: p
+          });
+          n.dispatch(h);
+        }
+      });
+    };
+  };
+}
+function b(e, o, r) {
+  const t = o.clipboardData?.files;
+  if (!t || t.length === 0)
+    return !1;
+  const i = Array.from(t).filter((s) => s.type.startsWith("image/"));
+  if (i.length === 0)
+    return !1;
+  o.preventDefault();
+  const a = e.state.selection.from;
+  for (const s of i)
+    r(s, e, a);
+  return !0;
+}
+function B(e, o, r, t) {
+  if (r)
+    return !1;
+  const i = o.dataTransfer?.files;
+  if (!i || i.length === 0)
+    return !1;
+  const a = Array.from(i).filter((l) => l.type.startsWith("image/"));
+  if (a.length === 0)
+    return !1;
+  o.preventDefault();
+  const n = e.posAtCoords({
+    left: o.clientX,
+    top: o.clientY
+  })?.pos ?? e.state.selection.from;
+  for (const l of a)
+    t(l, e, n);
+  return !0;
+}
+function C() {
+  return d;
+}
+export {
+  T as createVizelImageUploadPlugin,
+  v as createVizelImageUploader,
+  C as getVizelImageUploadPluginKey,
+  B as handleVizelImageDrop,
+  b as handleVizelImagePaste,
+  x as validateVizelImageFile
+};

package/dist/index15.js

@@ -0,0 +1,20 @@
+import t from "@tiptap/extension-link";
+import { default as i } from "@tiptap/extension-link";
+function n(e = {}) {
+  return t.configure({
+    openOnClick: e.openOnClick ?? !0,
+    autolink: e.autolink ?? !0,
+    linkOnPaste: e.linkOnPaste ?? !0,
+    defaultProtocol: e.defaultProtocol ?? "https",
+    HTMLAttributes: {
+      class: "vizel-link",
+      rel: "noopener noreferrer nofollow",
+      target: "_blank",
+      ...e.HTMLAttributes
+    }
+  });
+}
+export {
+  i as Link,
+  n as createVizelLinkExtension
+};

package/dist/index16.js

@@ -0,0 +1,17 @@
+import { Markdown as a } from "./index43.js";
+function i(n = {}) {
+  const { indentation: e = { style: "space", size: 2 }, gfm: o = !0, breaks: t = !1 } = n, r = {
+    gfm: o,
+    breaks: t
+  };
+  return a.configure({
+    indentation: e,
+    markedOptions: r
+  });
+}
+const c = i();
+export {
+  a as TiptapMarkdown,
+  c as VizelMarkdown,
+  i as createVizelMarkdownExtension
+};

package/dist/index17.js

@@ -0,0 +1,308 @@
+import { Node as v, mergeAttributes as y, InputRule as k } from "@tiptap/core";
+import L from "katex";
+import { default as H } from "katex";
+function f(t, r, o) {
+  try {
+    return { html: L.renderToString(t, {
+      displayMode: r,
+      throwOnError: !1,
+      strict: !1,
+      trust: !1,
+      ...o
+    }), error: null };
+  } catch (a) {
+    const l = a instanceof Error ? a.message : "Invalid LaTeX";
+    return {
+      html: `<span class="vizel-math-error">${l}</span>`,
+      error: l
+    };
+  }
+}
+const E = /\$([^$\n]+)\$$/, b = /\$\$([^$]+)\$\$$/;
+function x(t) {
+  return new k({
+    find: t.find,
+    handler: ({ state: r, range: o, match: a }) => {
+      const l = t.getAttributes?.(a) ?? {}, { tr: n } = r, s = t.type.create(l);
+      n.replaceWith(o.from, o.to, s);
+    }
+  });
+}
+const z = {
+  name: "mathInline",
+  start: "$",
+  tokenize(t) {
+    const r = t.match(/^\$([^$\n]+?)\$/);
+    if (r?.[1])
+      return {
+        type: "mathInline",
+        raw: r[0],
+        latex: r[1]
+      };
+  }
+}, g = {
+  name: "mathBlock",
+  start: "$$",
+  tokenize(t) {
+    const r = t.match(/^\$\$([\s\S]+?)\$\$/);
+    if (r?.[1])
+      return {
+        type: "mathBlock",
+        raw: r[0],
+        latex: r[1].trim()
+      };
+  }
+}, $ = v.create({
+  name: "mathInline",
+  group: "inline",
+  inline: !0,
+  atom: !0,
+  selectable: !0,
+  draggable: !1,
+  addOptions() {
+    return {
+      katexOptions: {},
+      inlineInputRules: !0,
+      blockInputRules: !0
+    };
+  },
+  addAttributes() {
+    return {
+      latex: {
+        default: "",
+        parseHTML: (t) => t.getAttribute("data-latex") || "",
+        renderHTML: (t) => ({
+          "data-latex": t.latex
+        })
+      }
+    };
+  },
+  parseHTML() {
+    return [
+      {
+        tag: 'span[data-type="math-inline"]'
+      }
+    ];
+  },
+  renderHTML({ HTMLAttributes: t }) {
+    return [
+      "span",
+      y(t, {
+        "data-type": "math-inline",
+        class: "vizel-math vizel-math-inline"
+      })
+    ];
+  },
+  addNodeView() {
+    return ({ node: t, getPos: r, editor: o }) => {
+      const a = document.createElement("span");
+      a.classList.add("vizel-math", "vizel-math-inline"), a.setAttribute("data-type", "math-inline"), a.setAttribute("contenteditable", "false");
+      const l = document.createElement("span");
+      l.classList.add("vizel-math-render"), a.appendChild(l);
+      const n = document.createElement("input");
+      n.type = "text", n.classList.add("vizel-math-input"), n.value = t.attrs.latex, n.style.display = "none", a.appendChild(n);
+      let s = !1;
+      const c = (e) => {
+        const { html: i } = f(e, !1, this.options.katexOptions);
+        l.innerHTML = i;
+      }, d = () => {
+        o.isEditable && (s = !0, a.classList.add("vizel-math-editing"), l.style.display = "none", n.style.display = "inline", n.value = t.attrs.latex, n.focus(), n.select());
+      }, u = () => {
+        if (!s) return;
+        s = !1, a.classList.remove("vizel-math-editing"), l.style.display = "", n.style.display = "none";
+        const e = n.value.trim(), i = typeof r == "function" ? r() : null;
+        i != null && (e === "" ? o.chain().focus().deleteRange({ from: i, to: i + t.nodeSize }).run() : e !== t.attrs.latex && o.chain().focus().updateAttributes("mathInline", { latex: e }).run());
+      }, m = (e) => {
+        s || (e.preventDefault(), e.stopPropagation(), d());
+      }, h = () => u(), p = (e) => {
+        e.key === "Enter" ? (e.preventDefault(), u()) : e.key === "Escape" && (e.preventDefault(), n.value = t.attrs.latex, u());
+      };
+      return a.addEventListener("click", m), n.addEventListener("blur", h), n.addEventListener("keydown", p), c(t.attrs.latex), {
+        dom: a,
+        update(e) {
+          return e.type.name !== "mathInline" ? !1 : (s || c(e.attrs.latex), !0);
+        },
+        selectNode() {
+          a.classList.add("vizel-math-selected");
+        },
+        deselectNode() {
+          a.classList.remove("vizel-math-selected");
+        },
+        destroy() {
+          a.removeEventListener("click", m), n.removeEventListener("blur", h), n.removeEventListener("keydown", p);
+        }
+      };
+    };
+  },
+  addInputRules() {
+    return this.options.inlineInputRules ? [
+      x({
+        find: E,
+        type: this.type,
+        getAttributes: (t) => ({ latex: t[1] })
+      })
+    ] : [];
+  },
+  addCommands() {
+    return {
+      insertMath: ({ latex: t }) => ({ commands: r }) => r.insertContent({
+        type: this.name,
+        attrs: { latex: t }
+      })
+    };
+  },
+  // Markdown support (GitHub compatible)
+  markdownTokenizer: z,
+  parseMarkdown(t) {
+    return {
+      type: "mathInline",
+      attrs: {
+        latex: t.latex || ""
+      }
+    };
+  },
+  renderMarkdown(t) {
+    return `$${t.attrs?.latex || ""}$`;
+  }
+}), M = v.create({
+  name: "mathBlock",
+  group: "block",
+  atom: !0,
+  selectable: !0,
+  draggable: !0,
+  addOptions() {
+    return {
+      katexOptions: {},
+      inlineInputRules: !0,
+      blockInputRules: !0
+    };
+  },
+  addAttributes() {
+    return {
+      latex: {
+        default: "",
+        parseHTML: (t) => t.getAttribute("data-latex") || "",
+        renderHTML: (t) => ({
+          "data-latex": t.latex
+        })
+      }
+    };
+  },
+  parseHTML() {
+    return [
+      {
+        tag: 'div[data-type="math-block"]'
+      }
+    ];
+  },
+  renderHTML({ HTMLAttributes: t }) {
+    return [
+      "div",
+      y(t, {
+        "data-type": "math-block",
+        class: "vizel-math vizel-math-block"
+      })
+    ];
+  },
+  addNodeView() {
+    return ({ node: t, getPos: r, editor: o }) => {
+      const a = document.createElement("div");
+      a.classList.add("vizel-math", "vizel-math-block"), a.setAttribute("data-type", "math-block"), a.setAttribute("contenteditable", "false");
+      const l = document.createElement("div");
+      l.classList.add("vizel-math-render"), a.appendChild(l);
+      const n = document.createElement("div");
+      n.classList.add("vizel-math-edit-container"), n.style.display = "none";
+      const s = document.createElement("textarea");
+      s.classList.add("vizel-math-textarea"), s.value = t.attrs.latex, s.placeholder = "Enter LaTeX expression...", n.appendChild(s);
+      const c = document.createElement("div");
+      c.classList.add("vizel-math-preview"), n.appendChild(c), a.appendChild(n);
+      let d = !1;
+      const u = (e) => {
+        const { html: i } = f(e, !0, this.options.katexOptions);
+        l.innerHTML = i;
+      }, m = (e) => {
+        const { html: i } = f(e, !0, this.options.katexOptions);
+        c.innerHTML = i;
+      }, h = () => {
+        o.isEditable && (d = !0, a.classList.add("vizel-math-editing"), l.style.display = "none", n.style.display = "", s.value = t.attrs.latex, m(t.attrs.latex), s.focus());
+      }, p = () => {
+        if (!d) return;
+        d = !1, a.classList.remove("vizel-math-editing"), l.style.display = "", n.style.display = "none";
+        const e = s.value.trim(), i = typeof r == "function" ? r() : null;
+        i != null && (e === "" ? o.chain().focus().deleteRange({ from: i, to: i + t.nodeSize }).run() : e !== t.attrs.latex && o.chain().focus().updateAttributes("mathBlock", { latex: e }).run());
+      };
+      return a.addEventListener("click", (e) => {
+        !d && e.target === a && (e.preventDefault(), e.stopPropagation(), h());
+      }), l.addEventListener("click", (e) => {
+        e.preventDefault(), e.stopPropagation(), h();
+      }), s.addEventListener("blur", (e) => {
+        const i = e.relatedTarget;
+        i instanceof HTMLElement && n.contains(i) || p();
+      }), s.addEventListener("keydown", (e) => {
+        e.key === "Escape" && (e.preventDefault(), s.value = t.attrs.latex, p()), e.key === "Enter" && (e.ctrlKey || e.metaKey) && (e.preventDefault(), p());
+      }), s.addEventListener("input", () => {
+        m(s.value);
+      }), u(t.attrs.latex), {
+        dom: a,
+        update(e) {
+          return e.type.name !== "mathBlock" ? !1 : (d || u(e.attrs.latex), !0);
+        },
+        selectNode() {
+          a.classList.add("vizel-math-selected");
+        },
+        deselectNode() {
+          a.classList.remove("vizel-math-selected");
+        }
+      };
+    };
+  },
+  addInputRules() {
+    return this.options.blockInputRules ? [
+      x({
+        find: b,
+        type: this.type,
+        getAttributes: (t) => ({ latex: t[1]?.trim() })
+      })
+    ] : [];
+  },
+  addCommands() {
+    return {
+      insertMathBlock: ({ latex: t }) => ({ commands: r }) => r.insertContent({
+        type: this.name,
+        attrs: { latex: t }
+      })
+    };
+  },
+  addKeyboardShortcuts() {
+    return {
+      Backspace: () => {
+        const { selection: t } = this.editor.state, { $anchor: r } = t;
+        return r.node().type.name === "mathBlock" ? this.editor.commands.deleteSelection() : !1;
+      }
+    };
+  },
+  // Markdown support (GitHub compatible)
+  markdownTokenizer: g,
+  parseMarkdown(t) {
+    return {
+      type: "mathBlock",
+      attrs: {
+        latex: t.latex || ""
+      }
+    };
+  },
+  renderMarkdown(t) {
+    return `$$
+${t.attrs?.latex || ""}
+$$`;
+  }
+});
+function w(t = {}) {
+  return [$.configure(t), M.configure(t)];
+}
+export {
+  M as VizelMathBlock,
+  $ as VizelMathInline,
+  w as createVizelMathematicsExtensions,
+  H as katex
+};

package/dist/index18.js

@@ -0,0 +1,52 @@
+import { TableRow as s } from "@tiptap/extension-table";
+import { VizelTable as i, VizelTableHeader as o, VizelTableCell as r } from "./index25.js";
+import { VizelTableWithControls as a } from "./index22.js";
+function z(l = {}) {
+  const { controls: t = !0, ...e } = l;
+  return [
+    t ? a.configure({
+      resizable: e.resizable ?? !1,
+      cellMinWidth: e.cellMinWidth ?? 50,
+      lastColumnResizable: e.lastColumnResizable ?? !0,
+      HTMLAttributes: {
+        class: "vizel-table",
+        ...e.tableHTMLAttributes
+      },
+      // Pass control options (default to true if not explicitly set)
+      showColumnInsert: typeof t == "object" ? t.showColumnInsert ?? !0 : !0,
+      showRowInsert: typeof t == "object" ? t.showRowInsert ?? !0 : !0,
+      showRowHandle: typeof t == "object" ? t.showRowHandle ?? !0 : !0
+    }) : i.configure({
+      resizable: e.resizable ?? !1,
+      cellMinWidth: e.cellMinWidth ?? 50,
+      lastColumnResizable: e.lastColumnResizable ?? !0,
+      HTMLAttributes: {
+        class: "vizel-table",
+        ...e.tableHTMLAttributes
+      }
+    }),
+    s.configure({
+      HTMLAttributes: {
+        class: "vizel-table-row"
+      }
+    }),
+    o.configure({
+      HTMLAttributes: {
+        class: "vizel-table-header",
+        ...e.headerHTMLAttributes
+      }
+    }),
+    r.configure({
+      HTMLAttributes: {
+        class: "vizel-table-cell",
+        ...e.cellHTMLAttributes
+      }
+    })
+  ];
+}
+export {
+  i as VizelTable,
+  r as VizelTableCell,
+  o as VizelTableHeader,
+  z as createVizelTableExtensions
+};

package/dist/index19.js

@@ -0,0 +1,29 @@
+import i from "./index44.js";
+import a from "./index45.js";
+function o(s = {}) {
+  const { taskList: t = {}, taskItem: e = {} } = s;
+  return [
+    a.configure({
+      HTMLAttributes: {
+        class: "vizel-task-list",
+        ...t.HTMLAttributes
+      },
+      itemTypeName: t.itemTypeName ?? "taskItem"
+    }),
+    i.configure({
+      HTMLAttributes: {
+        class: "vizel-task-item",
+        ...e.HTMLAttributes
+      },
+      nested: e.nested ?? !0,
+      ...e.onReadOnlyChecked !== void 0 && {
+        onReadOnlyChecked: e.onReadOnlyChecked
+      }
+    })
+  ];
+}
+export {
+  i as TaskItem,
+  a as TaskList,
+  o as createVizelTaskListExtensions
+};

package/dist/index2.js

@@ -0,0 +1,93 @@
+const i = {
+  enabled: !0,
+  debounceMs: 1e3,
+  storage: "localStorage",
+  key: "vizel-content"
+};
+function d(n, r) {
+  let t = null;
+  const e = (...o) => {
+    t && clearTimeout(t), t = setTimeout(() => {
+      n(...o), t = null;
+    }, r);
+  };
+  return e.cancel = () => {
+    t && (clearTimeout(t), t = null);
+  }, e;
+}
+function f(n, r) {
+  if (n === "localStorage" || n === "sessionStorage") {
+    const t = n === "localStorage" ? localStorage : sessionStorage;
+    return {
+      save: (e) => (t.setItem(r, JSON.stringify(e)), Promise.resolve()),
+      load: () => {
+        const e = t.getItem(r);
+        if (e)
+          try {
+            return Promise.resolve(JSON.parse(e));
+          } catch {
+            return Promise.resolve(null);
+          }
+        return Promise.resolve(null);
+      }
+    };
+  }
+  return {
+    save: async (t) => {
+      await n.save(t);
+    },
+    load: async () => n.load ? await n.load() : null
+  };
+}
+function m(n, r, t) {
+  const e = { ...i, ...r }, o = f(e.storage, e.key), a = async () => {
+    const l = n();
+    if (l) {
+      t({ status: "saving" });
+      try {
+        const s = l.getJSON();
+        await o.save(s), t({
+          status: "saved",
+          hasUnsavedChanges: !1,
+          lastSaved: /* @__PURE__ */ new Date(),
+          error: null
+        }), e.onSave?.(s);
+      } catch (s) {
+        const u = s instanceof Error ? s : new Error(String(s));
+        t({
+          status: "error",
+          error: u
+        }), e.onError?.(u);
+      }
+    }
+  }, c = d(a, e.debounceMs);
+  return {
+    save: c,
+    saveNow: a,
+    restore: async () => {
+      try {
+        const l = await o.load();
+        return e.onRestore?.(l), l;
+      } catch {
+        return null;
+      }
+    },
+    handleUpdate: () => {
+      e.enabled && (t({
+        status: "unsaved",
+        hasUnsavedChanges: !0
+      }), c());
+    },
+    cancel: c.cancel
+  };
+}
+function S(n) {
+  const t = (/* @__PURE__ */ new Date()).getTime() - n.getTime(), e = Math.floor(t / 1e3), o = Math.floor(e / 60), a = Math.floor(o / 60), c = Math.floor(a / 24);
+  return e < 5 ? "Just now" : e < 60 ? `${e}s ago` : o < 60 ? `${o}m ago` : a < 24 ? `${a}h ago` : `${c}d ago`;
+}
+export {
+  i as VIZEL_DEFAULT_AUTO_SAVE_OPTIONS,
+  m as createVizelAutoSaveHandlers,
+  S as formatVizelRelativeTime,
+  f as getVizelStorageBackend
+};