@vizel/core 0.0.1-alpha.1 → 0.0.1-alpha.3

package/dist/index31.js

@@ -1,26 +1,150 @@
-const r = "50";
-function c() {
-  const e = document.createElement("div");
-  e.style.position = "absolute", e.style.zIndex = "50", document.body.appendChild(e);
-  const n = document.createElement("div");
-  return e.appendChild(n), {
-    container: e,
-    menuContainer: n,
-    updatePosition: (o) => {
-      if (!o) return;
-      const t = o();
-      t && (e.style.top = `${t.bottom + window.scrollY}px`, e.style.left = `${t.left + window.scrollX}px`);
+import { PluginKey as S, Plugin as A } from "./index38.js";
+import { DecorationSet as E, Decoration as M } from "./index50.js";
+import { VIZEL_DEFAULT_IMAGE_MAX_FILE_SIZE as _, VIZEL_DEFAULT_FILE_MIME_TYPES as P } from "./index10.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;
+      }
     },
-    destroy: () => {
-      e.remove();
+    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 d(e) {
-  return e.key === "Escape";
+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 {
-  r as VIZEL_SUGGESTION_Z_INDEX,
-  c as createVizelSuggestionContainer,
-  d as handleVizelSuggestionEscape
+  T as createVizelImageUploadPlugin,
+  v as createVizelImageUploader,
+  C as getVizelImageUploadPluginKey,
+  B as handleVizelImageDrop,
+  b as handleVizelImagePaste,
+  x as validateVizelImageFile
 };

package/dist/index32.js

@@ -1,15 +1,268 @@
-function s(t) {
-  return /^#([A-Fa-f0-9]{6}|[A-Fa-f0-9]{3})$/.test(t);
-}
-function a(t) {
-  const e = t.trim(), r = e.startsWith("#") ? e : `#${e}`;
-  if (r.length === 4) {
-    const [, o, i, n] = r;
-    return `#${o}${o}${i}${i}${n}${n}`.toUpperCase();
+import l from "fuse.js";
+const h = [
+  // Text group
+  {
+    title: "Heading 1",
+    description: "Large section heading",
+    icon: "heading1",
+    group: "Text",
+    keywords: ["h1", "title", "header", "big"],
+    shortcut: "⌘⌥1",
+    command: ({ editor: e, range: t }) => {
+      e.chain().focus().deleteRange(t).setNode("heading", { level: 1 }).run();
+    }
+  },
+  {
+    title: "Heading 2",
+    description: "Medium section heading",
+    icon: "heading2",
+    group: "Text",
+    keywords: ["h2", "subtitle", "header"],
+    shortcut: "⌘⌥2",
+    command: ({ editor: e, range: t }) => {
+      e.chain().focus().deleteRange(t).setNode("heading", { level: 2 }).run();
+    }
+  },
+  {
+    title: "Heading 3",
+    description: "Small section heading",
+    icon: "heading3",
+    group: "Text",
+    keywords: ["h3", "header", "section"],
+    shortcut: "⌘⌥3",
+    command: ({ editor: e, range: t }) => {
+      e.chain().focus().deleteRange(t).setNode("heading", { level: 3 }).run();
+    }
+  },
+  // Lists group
+  {
+    title: "Bullet List",
+    description: "Create a simple bullet list",
+    icon: "bulletList",
+    group: "Lists",
+    keywords: ["ul", "unordered", "bullets", "points"],
+    shortcut: "⌘⇧8",
+    command: ({ editor: e, range: t }) => {
+      e.chain().focus().deleteRange(t).toggleBulletList().run();
+    }
+  },
+  {
+    title: "Numbered List",
+    description: "Create a numbered list",
+    icon: "orderedList",
+    group: "Lists",
+    keywords: ["ol", "ordered", "numbers", "steps"],
+    shortcut: "⌘⇧7",
+    command: ({ editor: e, range: t }) => {
+      e.chain().focus().deleteRange(t).toggleOrderedList().run();
+    }
+  },
+  {
+    title: "Task List",
+    description: "Create a task list with checkboxes",
+    icon: "taskList",
+    group: "Lists",
+    keywords: ["todo", "checkbox", "checklist", "tasks"],
+    command: ({ editor: e, range: t }) => {
+      e.chain().focus().deleteRange(t).toggleTaskList().run();
+    }
+  },
+  // Blocks group
+  {
+    title: "Quote",
+    description: "Capture a quote",
+    icon: "blockquote",
+    group: "Blocks",
+    keywords: ["blockquote", "citation", "cite"],
+    shortcut: "⌘⇧B",
+    command: ({ editor: e, range: t }) => {
+      e.chain().focus().deleteRange(t).toggleBlockquote().run();
+    }
+  },
+  {
+    title: "Divider",
+    description: "Insert a horizontal divider",
+    icon: "horizontalRule",
+    group: "Blocks",
+    keywords: ["hr", "horizontal", "line", "separator", "break"],
+    command: ({ editor: e, range: t }) => {
+      e.chain().focus().deleteRange(t).setHorizontalRule().run();
+    }
+  },
+  {
+    title: "Details",
+    description: "Collapsible content block",
+    icon: "details",
+    group: "Blocks",
+    keywords: ["accordion", "toggle", "collapse", "expand", "summary", "details"],
+    command: ({ editor: e, range: t }) => {
+      e.can().setDetails?.() && e.chain().focus().deleteRange(t).setDetails().run();
+    }
+  },
+  {
+    title: "Code Block",
+    description: "Insert a code snippet",
+    icon: "codeBlock",
+    group: "Blocks",
+    keywords: ["pre", "code", "programming", "syntax", "snippet"],
+    shortcut: "⌘⌥C",
+    command: ({ editor: e, range: t }) => {
+      e.chain().focus().deleteRange(t).toggleCodeBlock().run();
+    }
+  },
+  {
+    title: "Table",
+    description: "Insert a table",
+    icon: "table",
+    group: "Blocks",
+    keywords: ["grid", "spreadsheet", "columns", "rows"],
+    command: ({ editor: e, range: t }) => {
+      e.chain().focus().deleteRange(t).insertTable({ rows: 3, cols: 3, withHeaderRow: !0 }).run();
+    }
+  },
+  // Media group
+  {
+    title: "Image",
+    description: "Insert an image from URL",
+    icon: "image",
+    group: "Media",
+    keywords: ["picture", "photo", "img", "url"],
+    command: ({ editor: e, range: t }) => {
+      const o = window.prompt("Enter image URL:");
+      o && e.chain().focus().deleteRange(t).setImage({ src: o }).run();
+    }
+  },
+  {
+    title: "Upload Image",
+    description: "Upload an image from your device",
+    icon: "imageUpload",
+    group: "Media",
+    keywords: ["picture", "photo", "upload", "file"],
+    command: ({ editor: e, range: t }) => {
+      try {
+        e.chain().focus().deleteRange(t).run();
+      } catch {
+      }
+      const o = document.createElement("input");
+      o.type = "file", o.accept = "image/*", o.onchange = () => {
+        const i = o.files?.[0];
+        if (i) {
+          const n = new CustomEvent("vizel:upload-image", {
+            detail: { file: i, editor: e }
+          });
+          document.dispatchEvent(n);
+        }
+      }, o.click();
+    }
+  },
+  {
+    title: "Embed",
+    description: "Embed a URL (YouTube, Twitter, etc.)",
+    icon: "embed",
+    group: "Media",
+    keywords: ["link", "url", "youtube", "video", "twitter", "embed", "iframe", "oembed"],
+    command: ({ editor: e, range: t }) => {
+      if (!(typeof e.commands.setEmbed == "function")) {
+        const n = window.prompt("Enter URL:");
+        n && e.chain().focus().deleteRange(t).setLink({ href: n }).run();
+        return;
+      }
+      const i = window.prompt("Enter URL to embed:");
+      i && e.chain().focus().deleteRange(t).setEmbed({ url: i }).run();
+    }
+  },
+  // Advanced group
+  {
+    title: "Math Equation",
+    description: "Insert a mathematical expression",
+    icon: "mathBlock",
+    group: "Advanced",
+    keywords: ["latex", "formula", "equation", "katex", "math"],
+    command: ({ editor: e, range: t }) => {
+      e.can().insertMathBlock?.({ latex: "" }) && e.chain().focus().deleteRange(t).insertMathBlock({ latex: "" }).run();
+    }
+  },
+  {
+    title: "Inline Math",
+    description: "Insert an inline math expression",
+    icon: "mathInline",
+    group: "Advanced",
+    keywords: ["latex", "formula", "inline", "katex", "math"],
+    command: ({ editor: e, range: t }) => {
+      e.can().insertMath?.({ latex: "" }) && e.chain().focus().deleteRange(t).insertMath({ latex: "" }).run();
+    }
+  },
+  {
+    title: "Mermaid Diagram",
+    description: "Insert a Mermaid diagram",
+    icon: "mermaid",
+    group: "Advanced",
+    keywords: ["diagram", "chart", "flowchart", "mermaid", "sequence", "graph", "uml"],
+    command: ({ editor: e, range: t }) => {
+      e.can().insertDiagram?.({ code: "" }) && e.chain().focus().deleteRange(t).insertDiagram({ code: "", type: "mermaid" }).run();
+    }
+  },
+  {
+    title: "GraphViz Diagram",
+    description: "Insert a GraphViz (DOT) diagram",
+    icon: "graphviz",
+    group: "Advanced",
+    keywords: ["diagram", "graphviz", "dot", "graph", "network", "nodes", "edges"],
+    command: ({ editor: e, range: t }) => {
+      e.can().insertDiagram?.({ code: "" }) && e.chain().focus().deleteRange(t).insertDiagram({ code: "", type: "graphviz" }).run();
+    }
   }
-  return r.toUpperCase();
+], u = ["Text", "Lists", "Blocks", "Media", "Advanced"], m = {
+  keys: [
+    { name: "title", weight: 0.4 },
+    { name: "description", weight: 0.2 },
+    { name: "keywords", weight: 0.4 }
+  ],
+  threshold: 0.4,
+  includeScore: !0,
+  includeMatches: !0,
+  minMatchCharLength: 1
+}, s = /* @__PURE__ */ new WeakMap();
+function c(e) {
+  let t = s.get(e);
+  return t || (t = new l(e, m), s.set(e, t)), t;
+}
+function p(e, t) {
+  return t.trim() ? c(e).search(t).map((n) => n.item) : e;
+}
+function f(e, t) {
+  return t.trim() ? c(e).search(t).map((n) => {
+    const r = n.matches?.find((d) => d.key === "title")?.indices;
+    return {
+      item: n.item,
+      score: n.score ?? 0,
+      titleMatches: r
+    };
+  }) : e.map((n) => ({ item: n, score: 0 }));
+}
+function k(e, t = u) {
+  const o = /* @__PURE__ */ new Map();
+  for (const n of e) {
+    const a = n.group ?? "Other", r = o.get(a) ?? [];
+    r.push(n), o.set(a, r);
+  }
+  const i = [];
+  for (const n of t) {
+    const a = o.get(n);
+    a && a.length > 0 && (i.push({ name: n, items: a }), o.delete(n));
+  }
+  for (const [n, a] of o)
+    a.length > 0 && i.push({ name: n, items: a });
+  return i;
+}
+function w(e) {
+  return e.flatMap((t) => t.items);
 }
 export {
-  s as isVizelValidHexColor,
-  a as normalizeVizelHexColor
+  u as defaultGroupOrder,
+  h as defaultSlashCommands,
+  p as filterSlashCommands,
+  w as flattenSlashCommandGroups,
+  k as groupSlashCommands,
+  f as searchSlashCommands
 };

package/dist/index33.js

@@ -1,12 +1,95 @@
-function g(i, e) {
-  if (!e || e.length === 0)
-    return [{ text: i, highlight: !1 }];
-  const t = [];
-  let l = 0;
-  for (const [h, s] of e)
-    h > l && t.push({ text: i.slice(l, h), highlight: !1 }), t.push({ text: i.slice(h, s + 1), highlight: !0 }), l = s + 1;
-  return l < i.length && t.push({ text: i.slice(l), highlight: !1 }), t;
+import { Table as w, TableCell as A, TableHeader as T } from "@tiptap/extension-table";
+function g(t, e) {
+  return t.tokens ? e.parseInline(t.tokens) : t.text ? [e.createTextNode(t.text)] : [];
 }
+function f(t, e) {
+  return t.length > 0 ? [e.createNode("paragraph", void 0, t)] : [e.createNode("paragraph")];
+}
+function x(t, e) {
+  const { header: l, align: r, rows: s } = t, a = l.map((n, i) => {
+    const o = g(n, e), c = r[i] ? { textAlign: r[i] } : void 0;
+    return e.createNode("tableHeader", c, f(o, e));
+  }), d = e.createNode("tableRow", void 0, a), u = s.map((n) => {
+    const i = n.map((o, c) => {
+      const m = g(o, e), p = r[c] ? { textAlign: r[c] } : void 0;
+      return e.createNode("tableCell", p, f(m, e));
+    });
+    return e.createNode("tableRow", void 0, i);
+  });
+  return e.createNode("table", void 0, [d, ...u]);
+}
+function b(t, e) {
+  if (!t.content || t.content.length === 0)
+    return "";
+  const l = t.content, r = l[0];
+  if (!r?.content)
+    return "";
+  const s = r.content.map(
+    (n) => n.attrs?.textAlign || null
+  ), a = l.map((n) => n.content ? `| ${n.content.map((o) => (o.content ? e.renderChildren(o.content, "") : "").replace(/\n/g, " ").trim()).join(" | ")} |` : "|"), u = `| ${s.map((n) => {
+    switch (n) {
+      case "left":
+        return ":---";
+      case "center":
+        return ":---:";
+      case "right":
+        return "---:";
+      default:
+        return "---";
+    }
+  }).join(" | ")} |`;
+  return a.length > 0 ? [a[0], u, ...a.slice(1)].join(`
+`) : a.join(`
+`);
+}
+const C = w.extend({
+  // Register markdown name for token matching
+  name: "table",
+  addStorage() {
+    return {
+      ...this.parent?.(),
+      // Mark this extension as markdown-aware
+      markdown: {
+        parse: x,
+        serialize: b
+      }
+    };
+  },
+  // Add markdown parsing support
+  // @ts-expect-error - parseMarkdown is a @tiptap/markdown extension point
+  parseMarkdown(t, e) {
+    return t.type !== "table" ? null : x(t, e);
+  },
+  // Add markdown rendering support
+  // @ts-expect-error - renderMarkdown is a @tiptap/markdown extension point
+  renderMarkdown(t, e, l) {
+    return b(t, e);
+  }
+}), M = A.extend({
+  addAttributes() {
+    return {
+      ...this.parent?.(),
+      textAlign: {
+        default: null,
+        parseHTML: (t) => t.style.textAlign || null,
+        renderHTML: (t) => t.textAlign ? { style: `text-align: ${t.textAlign}` } : {}
+      }
+    };
+  }
+}), N = T.extend({
+  addAttributes() {
+    return {
+      ...this.parent?.(),
+      textAlign: {
+        default: null,
+        parseHTML: (t) => t.style.textAlign || null,
+        renderHTML: (t) => t.textAlign ? { style: `text-align: ${t.textAlign}` } : {}
+      }
+    };
+  }
+});
 export {
-  g as splitVizelTextByMatches
+  C as VizelTable,
+  M as VizelTableCell,
+  N as VizelTableHeader
 };

package/dist/index34.js

@@ -1,19 +1,66 @@
-import { mergeIconData as s } from "./index57.js";
-import { getIconsTree as f } from "./index58.js";
-function i(r, o, n) {
-  const u = r.icons, l = r.aliases || /* @__PURE__ */ Object.create(null);
-  let t = {};
-  function c(e) {
-    t = s(u[e] || l[e], t);
+import { Mark as d, mergeAttributes as a } from "@tiptap/core";
+var s = d.create({
+  name: "underline",
+  addOptions() {
+    return {
+      HTMLAttributes: {}
+    };
+  },
+  parseHTML() {
+    return [
+      {
+        tag: "u"
+      },
+      {
+        style: "text-decoration",
+        consuming: !1,
+        getAttrs: (e) => e.includes("underline") ? {} : !1
+      }
+    ];
+  },
+  renderHTML({ HTMLAttributes: e }) {
+    return ["u", a(this.options.HTMLAttributes, e), 0];
+  },
+  parseMarkdown(e, n) {
+    return n.applyMark(this.name || "underline", n.parseInline(e.tokens || []));
+  },
+  renderMarkdown(e, n) {
+    return `++${n.renderChildren(e)}++`;
+  },
+  markdownTokenizer: {
+    name: "underline",
+    level: "inline",
+    start(e) {
+      return e.indexOf("++");
+    },
+    tokenize(e, n, i) {
+      const r = /^(\+\+)([\s\S]+?)(\+\+)/.exec(e);
+      if (!r)
+        return;
+      const t = r[2].trim();
+      return {
+        type: "underline",
+        raw: r[0],
+        text: t,
+        tokens: i.inlineTokens(t)
+      };
+    }
+  },
+  addCommands() {
+    return {
+      setUnderline: () => ({ commands: e }) => e.setMark(this.name),
+      toggleUnderline: () => ({ commands: e }) => e.toggleMark(this.name),
+      unsetUnderline: () => ({ commands: e }) => e.unsetMark(this.name)
+    };
+  },
+  addKeyboardShortcuts() {
+    return {
+      "Mod-u": () => this.editor.commands.toggleUnderline(),
+      "Mod-U": () => this.editor.commands.toggleUnderline()
+    };
   }
-  return c(o), n.forEach(c), s(r, t);
-}
-function g(r, o) {
-  if (r.icons[o]) return i(r, o, []);
-  const n = f(r, [o])[o];
-  return n ? i(r, o, n) : null;
-}
+}), l = s;
 export {
-  g as getIconData,
-  i as internalGetIconData
+  s as Underline,
+  l as default
 };