@collabchron/notiq 0.2.0 → 1.0.0

package/dist/chunk-3JVFG7ER.mjs

@@ -0,0 +1,184 @@
+import {
+  __spreadProps,
+  __spreadValues,
+  init_react_shim
+} from "./chunk-77KXU36M.mjs";
+
+// src/components/ui/equation/KatexRenderer.tsx
+init_react_shim();
+import katex from "katex";
+import * as React from "react";
+import { useEffect, useRef } from "react";
+function KatexRenderer({
+  equation,
+  inline,
+  onDoubleClick
+}) {
+  const katexElementRef = useRef(null);
+  useEffect(() => {
+    const katexElement = katexElementRef.current;
+    if (katexElement !== null) {
+      katex.render(equation, katexElement, {
+        displayMode: !inline,
+        // true === block display //
+        errorColor: "#cc0000",
+        output: "html",
+        strict: "warn",
+        throwOnError: false,
+        trust: false
+      });
+    }
+  }, [equation, inline]);
+  return (
+    // We use an empty image tag either side to ensure Android doesn't try and compose from the
+    // inner text from Katex. There didn't seem to be any other way of making this work,
+    // without having a physical space.
+    /* @__PURE__ */ React.createElement(React.Fragment, null, /* @__PURE__ */ React.createElement(
+      "img",
+      {
+        src: "data:image/gif;base64,R0lGODlhAQABAIAAAAAAAP///yH5BAEAAAAALAAAAAABAAEAAAIBRAA7",
+        width: "0",
+        height: "0",
+        alt: ""
+      }
+    ), /* @__PURE__ */ React.createElement(
+      "span",
+      {
+        role: "button",
+        tabIndex: -1,
+        onDoubleClick,
+        ref: katexElementRef
+      }
+    ), /* @__PURE__ */ React.createElement(
+      "img",
+      {
+        src: "data:image/gif;base64,R0lGODlhAQABAIAAAAAAAP///yH5BAEAAAAALAAAAAABAAEAAAIBRAA7",
+        width: "0",
+        height: "0",
+        alt: ""
+      }
+    ))
+  );
+}
+
+// src/components/editor/nodes/EquationNode/EquationNode.tsx
+init_react_shim();
+import katex2 from "katex";
+import { $applyNodeReplacement, DecoratorNode } from "lexical";
+import * as React2 from "react";
+var EquationComponent = React2.lazy(() => import("./EquationComponent-CB6DFIHV.mjs"));
+function $convertEquationElement(domNode) {
+  let equation = domNode.getAttribute("data-lexical-equation");
+  const inline = domNode.getAttribute("data-lexical-inline") === "true";
+  equation = atob(equation || "");
+  if (equation) {
+    const node = $createEquationNode(equation, inline);
+    return { node };
+  }
+  return null;
+}
+var EquationNode = class _EquationNode extends DecoratorNode {
+  static getType() {
+    return "equation";
+  }
+  static clone(node) {
+    return new _EquationNode(node.__equation, node.__inline, node.__key);
+  }
+  constructor(equation, inline, key) {
+    super(key);
+    this.__equation = equation;
+    this.__inline = inline != null ? inline : false;
+  }
+  static importJSON(serializedNode) {
+    return $createEquationNode(
+      serializedNode.equation,
+      serializedNode.inline
+    ).updateFromJSON(serializedNode);
+  }
+  exportJSON() {
+    return __spreadProps(__spreadValues({}, super.exportJSON()), {
+      equation: this.getEquation(),
+      inline: this.__inline
+    });
+  }
+  createDOM(_config) {
+    const element = document.createElement(this.__inline ? "span" : "div");
+    element.className = "editor-equation";
+    return element;
+  }
+  exportDOM() {
+    const element = document.createElement(this.__inline ? "span" : "div");
+    const equation = btoa(this.__equation);
+    element.setAttribute("data-lexical-equation", equation);
+    element.setAttribute("data-lexical-inline", `${this.__inline}`);
+    katex2.render(this.__equation, element, {
+      displayMode: !this.__inline,
+      // true === block display //
+      errorColor: "#cc0000",
+      output: "html",
+      strict: "warn",
+      throwOnError: false,
+      trust: false
+    });
+    return { element };
+  }
+  static importDOM() {
+    return {
+      div: (domNode) => {
+        if (!domNode.hasAttribute("data-lexical-equation")) {
+          return null;
+        }
+        return {
+          conversion: $convertEquationElement,
+          priority: 2
+        };
+      },
+      span: (domNode) => {
+        if (!domNode.hasAttribute("data-lexical-equation")) {
+          return null;
+        }
+        return {
+          conversion: $convertEquationElement,
+          priority: 1
+        };
+      }
+    };
+  }
+  updateDOM(prevNode) {
+    return this.__inline !== prevNode.__inline;
+  }
+  getTextContent() {
+    return this.__equation;
+  }
+  getEquation() {
+    return this.__equation;
+  }
+  setEquation(equation) {
+    const writable = this.getWritable();
+    writable.__equation = equation;
+  }
+  decorate() {
+    return /* @__PURE__ */ React2.createElement(
+      EquationComponent,
+      {
+        equation: this.__equation,
+        inline: this.__inline,
+        nodeKey: this.__key
+      }
+    );
+  }
+};
+function $createEquationNode(equation = "", inline = false) {
+  const equationNode = new EquationNode(equation, inline);
+  return $applyNodeReplacement(equationNode);
+}
+function $isEquationNode(node) {
+  return node instanceof EquationNode;
+}
+
+export {
+  KatexRenderer,
+  EquationNode,
+  $createEquationNode,
+  $isEquationNode
+};

package/dist/chunk-456TN7IM.mjs

@@ -0,0 +1,110 @@
+import {
+  DropDown
+} from "./chunk-EGMI62PP.mjs";
+import {
+  SHORTCUTS
+} from "./chunk-ZB5LZQKC.mjs";
+import {
+  clearFormatting
+} from "./chunk-PZSUSXQG.mjs";
+import {
+  __spreadProps,
+  __spreadValues,
+  init_react_shim
+} from "./chunk-77KXU36M.mjs";
+
+// src/components/ui/drop-downs/text-format.tsx
+init_react_shim();
+import { FORMAT_TEXT_COMMAND } from "lexical";
+import {
+  CaseSensitive,
+  CaseUpper,
+  HighlighterIcon,
+  LucideRemoveFormatting,
+  Strikethrough,
+  Subscript,
+  Superscript,
+  Trash
+} from "lucide-react";
+import React, { useMemo } from "react";
+function TextFormat({
+  disabled = false,
+  editor,
+  toolbarState,
+  style,
+  ShowChevronsUpDown,
+  side,
+  sideOffset
+}) {
+  const items = useMemo(
+    () => [
+      {
+        label: "Lowercase",
+        icon: /* @__PURE__ */ React.createElement(CaseSensitive, { className: "w-4 h-4" }),
+        func: () => editor.dispatchCommand(FORMAT_TEXT_COMMAND, "lowercase"),
+        shortcuts: SHORTCUTS.LOWERCASE,
+        selected: toolbarState.isLowercase
+      },
+      {
+        label: "Uppercase",
+        icon: /* @__PURE__ */ React.createElement(CaseUpper, { className: "w-4 h-4" }),
+        func: () => editor.dispatchCommand(FORMAT_TEXT_COMMAND, "uppercase"),
+        shortcuts: SHORTCUTS.UPPERCASE,
+        selected: toolbarState.isUppercase
+      },
+      {
+        label: "Strikethrough",
+        icon: /* @__PURE__ */ React.createElement(Strikethrough, { className: "w-4 h-4" }),
+        func: () => editor.dispatchCommand(FORMAT_TEXT_COMMAND, "strikethrough"),
+        shortcuts: SHORTCUTS.STRIKETHROUGH,
+        selected: toolbarState.isStrikethrough
+      },
+      {
+        label: "Subscript",
+        icon: /* @__PURE__ */ React.createElement(Subscript, { className: "w-4 h-4" }),
+        func: () => editor.dispatchCommand(FORMAT_TEXT_COMMAND, "subscript"),
+        shortcuts: SHORTCUTS.SUBSCRIPT,
+        selected: toolbarState.isSubscript
+      },
+      {
+        label: "Superscript",
+        icon: /* @__PURE__ */ React.createElement(Superscript, { className: "w-4 h-4" }),
+        func: () => editor.dispatchCommand(FORMAT_TEXT_COMMAND, "superscript"),
+        shortcuts: SHORTCUTS.SUPERSCRIPT,
+        selected: toolbarState.isSuperscript
+      },
+      {
+        label: "Highlight",
+        icon: /* @__PURE__ */ React.createElement(HighlighterIcon, { className: "w-4 h-4" }),
+        func: () => editor.dispatchCommand(FORMAT_TEXT_COMMAND, "highlight"),
+        selected: toolbarState.isHighlight
+      },
+      {
+        label: "Clear Formatting",
+        icon: /* @__PURE__ */ React.createElement(Trash, { className: "w-4 h-4" }),
+        func: () => clearFormatting(editor),
+        shortcuts: SHORTCUTS.CLEAR_FORMATTING,
+        selected: false
+      }
+    ],
+    [editor, toolbarState]
+  );
+  return /* @__PURE__ */ React.createElement(
+    DropDown,
+    {
+      PopoverContentClassName: { width: "100%" },
+      TriggerClassName: __spreadProps(__spreadValues({}, style), { width: "100%", border: "none" }),
+      disabled,
+      sideOffset,
+      side,
+      className: "cursor-pointer",
+      ShowChevronsUpDown,
+      TriggerLabel: /* @__PURE__ */ React.createElement(LucideRemoveFormatting, null),
+      values: items
+    }
+  );
+}
+
+export {
+  TextFormat
+};

package/dist/chunk-4EXYCTGJ.mjs

@@ -0,0 +1,27 @@
+import {
+  init_react_shim
+} from "./chunk-77KXU36M.mjs";
+
+// src/components/providers/SharedHistoryContext.tsx
+init_react_shim();
+import { createEmptyHistoryState } from "@lexical/react/LexicalHistoryPlugin";
+import * as React from "react";
+import { createContext, useContext, useMemo } from "react";
+var Context = createContext({});
+var SharedHistoryContext = ({
+  children
+}) => {
+  const historyContext = useMemo(
+    () => ({ historyState: createEmptyHistoryState() }),
+    []
+  );
+  return /* @__PURE__ */ React.createElement(Context.Provider, { value: historyContext }, children);
+};
+var useSharedHistoryContext = () => {
+  return useContext(Context);
+};
+
+export {
+  SharedHistoryContext,
+  useSharedHistoryContext
+};

package/{src/utils/getSelectedNode.ts → dist/chunk-4HBCVSE6.mjs}

@@ -1,27 +1,26 @@
-/**
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- *
- * This source code is licensed under the MIT license found in the
- * LICENSE file in the root directory of this source tree.
- *
- */
-import {$isAtNodeEnd} from '@lexical/selection';
-import {ElementNode, RangeSelection, TextNode} from 'lexical';
-
-export function getSelectedNode(
-  selection: RangeSelection,
-): TextNode | ElementNode {
-  const anchor = selection.anchor;
-  const focus = selection.focus;
-  const anchorNode = selection.anchor.getNode();
-  const focusNode = selection.focus.getNode();
-  if (anchorNode === focusNode) {
-    return anchorNode;
-  }
-  const isBackward = selection.isBackward();
-  if (isBackward) {
-    return $isAtNodeEnd(focus) ? anchorNode : focusNode;
-  } else {
-    return $isAtNodeEnd(anchor) ? anchorNode : focusNode;
-  }
-}
+import {
+  init_react_shim
+} from "./chunk-77KXU36M.mjs";
+
+// src/components/editor/utils/getSelectedNode.ts
+init_react_shim();
+import { $isAtNodeEnd } from "@lexical/selection";
+function getSelectedNode(selection) {
+  const anchor = selection.anchor;
+  const focus = selection.focus;
+  const anchorNode = selection.anchor.getNode();
+  const focusNode = selection.focus.getNode();
+  if (anchorNode === focusNode) {
+    return anchorNode;
+  }
+  const isBackward = selection.isBackward();
+  if (isBackward) {
+    return $isAtNodeEnd(focus) ? anchorNode : focusNode;
+  } else {
+    return $isAtNodeEnd(anchor) ? anchorNode : focusNode;
+  }
+}
+
+export {
+  getSelectedNode
+};

package/dist/chunk-4MEDW3T6.mjs

@@ -0,0 +1,125 @@
+import {
+  init_react_shim
+} from "./chunk-77KXU36M.mjs";
+
+// src/components/editor/nodes/StoryBuilderNode/StoryBuilderNode.tsx
+init_react_shim();
+import { $applyNodeReplacement, DecoratorNode } from "lexical";
+import * as React from "react";
+import { Suspense } from "react";
+var StoryBuilderComponent = React.lazy(() => import("./StoryBuilderComponent-JGDBM5JU.mjs"));
+function convertStoryBuilderElement(domNode) {
+  const textContent = domNode.textContent;
+  if (textContent) {
+    const node = $createStoryBuilderNode({
+      nodes: [],
+      currentNodeId: "",
+      title: "Interactive Story"
+    });
+    return {
+      node
+    };
+  }
+  return null;
+}
+var StoryBuilderNode = class _StoryBuilderNode extends DecoratorNode {
+  static getType() {
+    return "story-builder";
+  }
+  static clone(node) {
+    return new _StoryBuilderNode(node.__nodes, node.__currentNodeId, node.__title, node.__key);
+  }
+  static importJSON(serializedNode) {
+    const { nodes, currentNodeId, title } = serializedNode;
+    const node = $createStoryBuilderNode({
+      nodes,
+      currentNodeId,
+      title
+    });
+    return node;
+  }
+  exportJSON() {
+    return {
+      nodes: this.__nodes,
+      currentNodeId: this.__currentNodeId,
+      title: this.__title,
+      type: "story-builder",
+      version: 1
+    };
+  }
+  constructor(nodes, currentNodeId, title, key) {
+    super(key);
+    this.__nodes = nodes;
+    this.__currentNodeId = currentNodeId;
+    this.__title = title;
+  }
+  exportDOM() {
+    const element = document.createElement("div");
+    element.setAttribute("data-lexical-story-builder", "true");
+    element.textContent = this.__title;
+    return { element };
+  }
+  static importDOM() {
+    return {
+      div: (domNode) => {
+        if (!domNode.hasAttribute("data-lexical-story-builder")) {
+          return null;
+        }
+        return {
+          conversion: convertStoryBuilderElement,
+          priority: 1
+        };
+      }
+    };
+  }
+  updateStory(payload) {
+    const writable = this.getWritable();
+    writable.__nodes = payload.nodes;
+    writable.__currentNodeId = payload.currentNodeId;
+    writable.__title = payload.title;
+  }
+  setTitle(title) {
+    const writable = this.getWritable();
+    writable.__title = title;
+  }
+  getNodes() {
+    return this.__nodes;
+  }
+  getCurrentNodeId() {
+    return this.__currentNodeId;
+  }
+  getTitle() {
+    return this.__title;
+  }
+  createDOM(config) {
+    const div = document.createElement("div");
+    div.style.display = "contents";
+    return div;
+  }
+  updateDOM() {
+    return false;
+  }
+  decorate() {
+    return /* @__PURE__ */ React.createElement(Suspense, { fallback: null }, /* @__PURE__ */ React.createElement(
+      StoryBuilderComponent,
+      {
+        nodes: this.__nodes,
+        currentNodeId: this.__currentNodeId,
+        title: this.__title,
+        nodeKey: this.getKey()
+      }
+    ));
+  }
+};
+function $createStoryBuilderNode(payload) {
+  return $applyNodeReplacement(new StoryBuilderNode(payload.nodes, payload.currentNodeId, payload.title));
+}
+function $isStoryBuilderNode(node) {
+  return node instanceof StoryBuilderNode;
+}
+
+export {
+  StoryBuilderNode,
+  $createStoryBuilderNode,
+  $isStoryBuilderNode
+};

package/dist/chunk-4VWFVWYP.mjs

@@ -0,0 +1,36 @@
+import {
+  init_react_shim
+} from "./chunk-77KXU36M.mjs";
+
+// src/components/editor/utils/url.ts
+init_react_shim();
+var SUPPORTED_URL_PROTOCOLS = /* @__PURE__ */ new Set([
+  "http:",
+  "https:",
+  "mailto:",
+  "sms:",
+  "tel:",
+  "ftp:"
+]);
+function sanitizeUrl(url) {
+  try {
+    const parsedUrl = new URL(url);
+    if (!SUPPORTED_URL_PROTOCOLS.has(parsedUrl.protocol)) {
+      return "about:blank";
+    }
+  } catch (e) {
+    return url;
+  }
+  return url;
+}
+var urlRegExp = new RegExp(
+  /((([A-Za-z]{3,9}:(?:\/\/)?)(?:[-;:&=+$,\w]+@)?[A-Za-z0-9.-]+|(?:www.|[-;:&=+$,\w]+@)[A-Za-z0-9.-]+)((?:\/[+~%/.\w-_]*)?\??(?:[-+=&;%@.\w_]*)#?(?:[\w]*))?)/
+);
+function validateUrl(url) {
+  return url === "https://" || urlRegExp.test(url);
+}
+
+export {
+  sanitizeUrl,
+  validateUrl
+};

package/dist/chunk-5BAKY5KN.mjs

@@ -0,0 +1,84 @@
+import {
+  __spreadProps,
+  __spreadValues,
+  init_react_shim
+} from "./chunk-77KXU36M.mjs";
+
+// src/components/editor/nodes/DynamicBlockNode/DynamicBlockNode.tsx
+init_react_shim();
+import { DecoratorBlockNode } from "@lexical/react/LexicalDecoratorBlockNode";
+import * as React from "react";
+function convertDynamicBlockElement(domNode) {
+  const element = domNode;
+  const payload = element.getAttribute("data-lexical-dynamic-block");
+  if (payload) {
+    const node = $createDynamicBlockNode(JSON.parse(payload));
+    return { node };
+  }
+  return null;
+}
+var DynamicBlockNode = class _DynamicBlockNode extends DecoratorBlockNode {
+  static getType() {
+    return "dynamic-block";
+  }
+  static clone(node) {
+    return new _DynamicBlockNode(node.__payload, node.__format, node.__key);
+  }
+  static importJSON(serializedNode) {
+    const { payload } = serializedNode;
+    const node = $createDynamicBlockNode(payload);
+    node.setFormat(serializedNode.format);
+    return node;
+  }
+  exportJSON() {
+    return __spreadProps(__spreadValues({}, super.exportJSON()), {
+      payload: this.__payload,
+      type: "dynamic-block",
+      version: 1
+    });
+  }
+  static importDOM() {
+    return {
+      div: (node) => ({
+        conversion: convertDynamicBlockElement,
+        priority: 1
+      })
+    };
+  }
+  exportDOM() {
+    const element = document.createElement("div");
+    element.setAttribute("data-lexical-dynamic-block", JSON.stringify(this.__payload));
+    element.className = "dynamic-block-container";
+    return { element };
+  }
+  constructor(payload, format, key) {
+    super(format, key);
+    this.__payload = payload;
+  }
+  updatePayload(payload) {
+    const writable = this.getWritable();
+    writable.__payload = payload;
+  }
+  getPayload() {
+    return this.getLatest().__payload;
+  }
+  getTextContent() {
+    return `Dynamic Block: ${this.__payload.title}`;
+  }
+  decorate() {
+    return /* @__PURE__ */ React.createElement(DynamicBlockComponent, { nodeKey: this.getKey(), payload: this.__payload });
+  }
+};
+function $createDynamicBlockNode(payload) {
+  return new DynamicBlockNode(payload);
+}
+function $isDynamicBlockNode(node) {
+  return node instanceof DynamicBlockNode;
+}
+var DynamicBlockComponent = React.lazy(() => import("./DynamicBlockComponent-NRQJ4WW4.mjs"));
+
+export {
+  DynamicBlockNode,
+  $createDynamicBlockNode,
+  $isDynamicBlockNode
+};