impact-ui 4.0.0-alpha.2 → 4.0.0-alpha.4

package/dist/node_modules/@tiptap/extension-link/dist/index.js

@@ -1,360 +0,0 @@
-import { Mark, markPasteRule, mergeAttributes, combineTransactionSteps, getChangedRanges, findChildrenInRange, getMarksBetween, getAttributes } from "../../core/dist/index.js";
-import { registerCustomProtocol, tokenize, find, reset } from "../../../linkifyjs/dist/linkify.js";
-import { Plugin, PluginKey } from "../../../prosemirror-state/dist/index.js";
-const UNICODE_WHITESPACE_PATTERN = "[\0-   ᠎ -\u2029 　]";
-const UNICODE_WHITESPACE_REGEX = new RegExp(UNICODE_WHITESPACE_PATTERN);
-const UNICODE_WHITESPACE_REGEX_END = new RegExp(`${UNICODE_WHITESPACE_PATTERN}$`);
-const UNICODE_WHITESPACE_REGEX_GLOBAL = new RegExp(UNICODE_WHITESPACE_PATTERN, "g");
-function isValidLinkStructure(tokens) {
-  if (tokens.length === 1) {
-    return tokens[0].isLink;
-  }
-  if (tokens.length === 3 && tokens[1].isLink) {
-    return ["()", "[]"].includes(tokens[0].value + tokens[2].value);
-  }
-  return false;
-}
-function autolink(options) {
-  return new Plugin({
-    key: new PluginKey("autolink"),
-    appendTransaction: (transactions, oldState, newState) => {
-      const docChanges = transactions.some((transaction) => transaction.docChanged) && !oldState.doc.eq(newState.doc);
-      const preventAutolink = transactions.some((transaction) => transaction.getMeta("preventAutolink"));
-      if (!docChanges || preventAutolink) {
-        return;
-      }
-      const { tr } = newState;
-      const transform = combineTransactionSteps(oldState.doc, [...transactions]);
-      const changes = getChangedRanges(transform);
-      changes.forEach(({ newRange }) => {
-        const nodesInChangedRanges = findChildrenInRange(newState.doc, newRange, (node) => node.isTextblock);
-        let textBlock;
-        let textBeforeWhitespace;
-        if (nodesInChangedRanges.length > 1) {
-          textBlock = nodesInChangedRanges[0];
-          textBeforeWhitespace = newState.doc.textBetween(textBlock.pos, textBlock.pos + textBlock.node.nodeSize, void 0, " ");
-        } else if (nodesInChangedRanges.length) {
-          const endText = newState.doc.textBetween(newRange.from, newRange.to, " ", " ");
-          if (!UNICODE_WHITESPACE_REGEX_END.test(endText)) {
-            return;
-          }
-          textBlock = nodesInChangedRanges[0];
-          textBeforeWhitespace = newState.doc.textBetween(textBlock.pos, newRange.to, void 0, " ");
-        }
-        if (textBlock && textBeforeWhitespace) {
-          const wordsBeforeWhitespace = textBeforeWhitespace.split(UNICODE_WHITESPACE_REGEX).filter(Boolean);
-          if (wordsBeforeWhitespace.length <= 0) {
-            return false;
-          }
-          const lastWordBeforeSpace = wordsBeforeWhitespace[wordsBeforeWhitespace.length - 1];
-          const lastWordAndBlockOffset = textBlock.pos + textBeforeWhitespace.lastIndexOf(lastWordBeforeSpace);
-          if (!lastWordBeforeSpace) {
-            return false;
-          }
-          const linksBeforeSpace = tokenize(lastWordBeforeSpace).map((t) => t.toObject(options.defaultProtocol));
-          if (!isValidLinkStructure(linksBeforeSpace)) {
-            return false;
-          }
-          linksBeforeSpace.filter((link) => link.isLink).map((link) => ({
-            ...link,
-            from: lastWordAndBlockOffset + link.start + 1,
-            to: lastWordAndBlockOffset + link.end + 1
-          })).filter((link) => {
-            if (!newState.schema.marks.code) {
-              return true;
-            }
-            return !newState.doc.rangeHasMark(link.from, link.to, newState.schema.marks.code);
-          }).filter((link) => options.validate(link.value)).filter((link) => options.shouldAutoLink(link.value)).forEach((link) => {
-            if (getMarksBetween(link.from, link.to, newState.doc).some((item) => item.mark.type === options.type)) {
-              return;
-            }
-            tr.addMark(link.from, link.to, options.type.create({
-              href: link.href
-            }));
-          });
-        }
-      });
-      if (!tr.steps.length) {
-        return;
-      }
-      return tr;
-    }
-  });
-}
-function clickHandler(options) {
-  return new Plugin({
-    key: new PluginKey("handleClickLink"),
-    props: {
-      handleClick: (view, pos, event) => {
-        var _a, _b;
-        if (event.button !== 0) {
-          return false;
-        }
-        if (!view.editable) {
-          return false;
-        }
-        let a = event.target;
-        const els = [];
-        while (a.nodeName !== "DIV") {
-          els.push(a);
-          a = a.parentNode;
-        }
-        if (!els.find((value) => value.nodeName === "A")) {
-          return false;
-        }
-        const attrs = getAttributes(view.state, options.type.name);
-        const link = event.target;
-        const href = (_a = link === null || link === void 0 ? void 0 : link.href) !== null && _a !== void 0 ? _a : attrs.href;
-        const target = (_b = link === null || link === void 0 ? void 0 : link.target) !== null && _b !== void 0 ? _b : attrs.target;
-        if (link && href) {
-          window.open(href, target);
-          return true;
-        }
-        return false;
-      }
-    }
-  });
-}
-function pasteHandler(options) {
-  return new Plugin({
-    key: new PluginKey("handlePasteLink"),
-    props: {
-      handlePaste: (view, event, slice) => {
-        const { state } = view;
-        const { selection } = state;
-        const { empty } = selection;
-        if (empty) {
-          return false;
-        }
-        let textContent = "";
-        slice.content.forEach((node) => {
-          textContent += node.textContent;
-        });
-        const link = find(textContent, { defaultProtocol: options.defaultProtocol }).find((item) => item.isLink && item.value === textContent);
-        if (!textContent || !link) {
-          return false;
-        }
-        return options.editor.commands.setMark(options.type, {
-          href: link.href
-        });
-      }
-    }
-  });
-}
-function isAllowedUri(uri, protocols) {
-  const allowedProtocols = [
-    "http",
-    "https",
-    "ftp",
-    "ftps",
-    "mailto",
-    "tel",
-    "callto",
-    "sms",
-    "cid",
-    "xmpp"
-  ];
-  if (protocols) {
-    protocols.forEach((protocol) => {
-      const nextProtocol = typeof protocol === "string" ? protocol : protocol.scheme;
-      if (nextProtocol) {
-        allowedProtocols.push(nextProtocol);
-      }
-    });
-  }
-  return !uri || uri.replace(UNICODE_WHITESPACE_REGEX_GLOBAL, "").match(new RegExp(
-    // eslint-disable-next-line no-useless-escape
-    `^(?:(?:${allowedProtocols.join("|")}):|[^a-z]|[a-z0-9+.-]+(?:[^a-z+.-:]|$))`,
-    "i"
-  ));
-}
-const Link = Mark.create({
-  name: "link",
-  priority: 1e3,
-  keepOnSplit: false,
-  exitable: true,
-  onCreate() {
-    if (this.options.validate && !this.options.shouldAutoLink) {
-      this.options.shouldAutoLink = this.options.validate;
-      console.warn("The `validate` option is deprecated. Rename to the `shouldAutoLink` option instead.");
-    }
-    this.options.protocols.forEach((protocol) => {
-      if (typeof protocol === "string") {
-        registerCustomProtocol(protocol);
-        return;
-      }
-      registerCustomProtocol(protocol.scheme, protocol.optionalSlashes);
-    });
-  },
-  onDestroy() {
-    reset();
-  },
-  inclusive() {
-    return this.options.autolink;
-  },
-  addOptions() {
-    return {
-      openOnClick: true,
-      linkOnPaste: true,
-      autolink: true,
-      protocols: [],
-      defaultProtocol: "http",
-      HTMLAttributes: {
-        target: "_blank",
-        rel: "noopener noreferrer nofollow",
-        class: null
-      },
-      isAllowedUri: (url, ctx) => !!isAllowedUri(url, ctx.protocols),
-      validate: (url) => !!url,
-      shouldAutoLink: (url) => !!url
-    };
-  },
-  addAttributes() {
-    return {
-      href: {
-        default: null,
-        parseHTML(element) {
-          return element.getAttribute("href");
-        }
-      },
-      target: {
-        default: this.options.HTMLAttributes.target
-      },
-      rel: {
-        default: this.options.HTMLAttributes.rel
-      },
-      class: {
-        default: this.options.HTMLAttributes.class
-      }
-    };
-  },
-  parseHTML() {
-    return [
-      {
-        tag: "a[href]",
-        getAttrs: (dom) => {
-          const href = dom.getAttribute("href");
-          if (!href || !this.options.isAllowedUri(href, {
-            defaultValidate: (url) => !!isAllowedUri(url, this.options.protocols),
-            protocols: this.options.protocols,
-            defaultProtocol: this.options.defaultProtocol
-          })) {
-            return false;
-          }
-          return null;
-        }
-      }
-    ];
-  },
-  renderHTML({ HTMLAttributes }) {
-    if (!this.options.isAllowedUri(HTMLAttributes.href, {
-      defaultValidate: (href) => !!isAllowedUri(href, this.options.protocols),
-      protocols: this.options.protocols,
-      defaultProtocol: this.options.defaultProtocol
-    })) {
-      return [
-        "a",
-        mergeAttributes(this.options.HTMLAttributes, { ...HTMLAttributes, href: "" }),
-        0
-      ];
-    }
-    return ["a", mergeAttributes(this.options.HTMLAttributes, HTMLAttributes), 0];
-  },
-  addCommands() {
-    return {
-      setLink: (attributes) => ({ chain }) => {
-        const { href } = attributes;
-        if (!this.options.isAllowedUri(href, {
-          defaultValidate: (url) => !!isAllowedUri(url, this.options.protocols),
-          protocols: this.options.protocols,
-          defaultProtocol: this.options.defaultProtocol
-        })) {
-          return false;
-        }
-        return chain().setMark(this.name, attributes).setMeta("preventAutolink", true).run();
-      },
-      toggleLink: (attributes) => ({ chain }) => {
-        const { href } = attributes;
-        if (!this.options.isAllowedUri(href, {
-          defaultValidate: (url) => !!isAllowedUri(url, this.options.protocols),
-          protocols: this.options.protocols,
-          defaultProtocol: this.options.defaultProtocol
-        })) {
-          return false;
-        }
-        return chain().toggleMark(this.name, attributes, { extendEmptyMarkRange: true }).setMeta("preventAutolink", true).run();
-      },
-      unsetLink: () => ({ chain }) => {
-        return chain().unsetMark(this.name, { extendEmptyMarkRange: true }).setMeta("preventAutolink", true).run();
-      }
-    };
-  },
-  addPasteRules() {
-    return [
-      markPasteRule({
-        find: (text) => {
-          const foundLinks = [];
-          if (text) {
-            const { protocols, defaultProtocol } = this.options;
-            const links = find(text).filter((item) => item.isLink && this.options.isAllowedUri(item.value, {
-              defaultValidate: (href) => !!isAllowedUri(href, protocols),
-              protocols,
-              defaultProtocol
-            }));
-            if (links.length) {
-              links.forEach((link) => foundLinks.push({
-                text: link.value,
-                data: {
-                  href: link.href
-                },
-                index: link.start
-              }));
-            }
-          }
-          return foundLinks;
-        },
-        type: this.type,
-        getAttributes: (match) => {
-          var _a;
-          return {
-            href: (_a = match.data) === null || _a === void 0 ? void 0 : _a.href
-          };
-        }
-      })
-    ];
-  },
-  addProseMirrorPlugins() {
-    const plugins = [];
-    const { protocols, defaultProtocol } = this.options;
-    if (this.options.autolink) {
-      plugins.push(autolink({
-        type: this.type,
-        defaultProtocol: this.options.defaultProtocol,
-        validate: (url) => this.options.isAllowedUri(url, {
-          defaultValidate: (href) => !!isAllowedUri(href, protocols),
-          protocols,
-          defaultProtocol
-        }),
-        shouldAutoLink: this.options.shouldAutoLink
-      }));
-    }
-    if (this.options.openOnClick === true) {
-      plugins.push(clickHandler({
-        type: this.type
-      }));
-    }
-    if (this.options.linkOnPaste) {
-      plugins.push(pasteHandler({
-        editor: this.editor,
-        defaultProtocol: this.options.defaultProtocol,
-        type: this.type
-      }));
-    }
-    return plugins;
-  }
-});
-export {
-  Link,
-  Link as default,
-  isAllowedUri
-};

package/dist/node_modules/@tiptap/extension-list-item/dist/index.js

@@ -1,34 +0,0 @@
-import { Node, mergeAttributes } from "../../core/dist/index.js";
-const ListItem = Node.create({
-  name: "listItem",
-  addOptions() {
-    return {
-      HTMLAttributes: {},
-      bulletListTypeName: "bulletList",
-      orderedListTypeName: "orderedList"
-    };
-  },
-  content: "paragraph block*",
-  defining: true,
-  parseHTML() {
-    return [
-      {
-        tag: "li"
-      }
-    ];
-  },
-  renderHTML({ HTMLAttributes }) {
-    return ["li", mergeAttributes(this.options.HTMLAttributes, HTMLAttributes), 0];
-  },
-  addKeyboardShortcuts() {
-    return {
-      Enter: () => this.editor.commands.splitListItem(this.name),
-      Tab: () => this.editor.commands.sinkListItem(this.name),
-      "Shift-Tab": () => this.editor.commands.liftListItem(this.name)
-    };
-  }
-});
-export {
-  ListItem,
-  ListItem as default
-};

package/dist/node_modules/@tiptap/extension-mention/dist/index.js

@@ -1,213 +0,0 @@
-import { Node, mergeAttributes } from "../../core/dist/index.js";
-import { Node as Node$1 } from "../../../prosemirror-model/dist/index.js";
-import { Suggestion } from "../../suggestion/dist/index.js";
-import { PluginKey } from "../../../prosemirror-state/dist/index.js";
-function getSuggestionOptions({ editor: tiptapEditor, overrideSuggestionOptions, extensionName, char = "@" }) {
-  const pluginKey = new PluginKey();
-  return {
-    editor: tiptapEditor,
-    char,
-    pluginKey,
-    command: ({ editor, range, props }) => {
-      var _a, _b, _c;
-      const nodeAfter = editor.view.state.selection.$to.nodeAfter;
-      const overrideSpace = (_a = nodeAfter === null || nodeAfter === void 0 ? void 0 : nodeAfter.text) === null || _a === void 0 ? void 0 : _a.startsWith(" ");
-      if (overrideSpace) {
-        range.to += 1;
-      }
-      editor.chain().focus().insertContentAt(range, [
-        {
-          type: extensionName,
-          attrs: { ...props, mentionSuggestionChar: char }
-        },
-        {
-          type: "text",
-          text: " "
-        }
-      ]).run();
-      (_c = (_b = editor.view.dom.ownerDocument.defaultView) === null || _b === void 0 ? void 0 : _b.getSelection()) === null || _c === void 0 ? void 0 : _c.collapseToEnd();
-    },
-    allow: ({ state, range }) => {
-      const $from = state.doc.resolve(range.from);
-      const type = state.schema.nodes[extensionName];
-      const allow = !!$from.parent.type.contentMatch.matchType(type);
-      return allow;
-    },
-    ...overrideSuggestionOptions
-  };
-}
-function getSuggestions(options) {
-  return (options.options.suggestions.length ? options.options.suggestions : [options.options.suggestion]).map((suggestion) => getSuggestionOptions({
-    // @ts-ignore `editor` can be `undefined` when converting the document to HTML with the HTML utility
-    editor: options.editor,
-    overrideSuggestionOptions: suggestion,
-    extensionName: options.name,
-    char: suggestion.char
-  }));
-}
-function getSuggestionFromChar(options, char) {
-  const suggestions = getSuggestions(options);
-  const suggestion = suggestions.find((s) => s.char === char);
-  if (suggestion) {
-    return suggestion;
-  }
-  if (suggestions.length) {
-    return suggestions[0];
-  }
-  return null;
-}
-const Mention = Node.create({
-  name: "mention",
-  priority: 101,
-  addOptions() {
-    return {
-      HTMLAttributes: {},
-      renderText({ node, suggestion }) {
-        var _a, _b;
-        return `${(_a = suggestion === null || suggestion === void 0 ? void 0 : suggestion.char) !== null && _a !== void 0 ? _a : "@"}${(_b = node.attrs.label) !== null && _b !== void 0 ? _b : node.attrs.id}`;
-      },
-      deleteTriggerWithBackspace: false,
-      renderHTML({ options, node, suggestion }) {
-        var _a, _b;
-        return [
-          "span",
-          mergeAttributes(this.HTMLAttributes, options.HTMLAttributes),
-          `${(_a = suggestion === null || suggestion === void 0 ? void 0 : suggestion.char) !== null && _a !== void 0 ? _a : "@"}${(_b = node.attrs.label) !== null && _b !== void 0 ? _b : node.attrs.id}`
-        ];
-      },
-      suggestions: [],
-      suggestion: {}
-    };
-  },
-  group: "inline",
-  inline: true,
-  selectable: false,
-  atom: true,
-  addAttributes() {
-    return {
-      id: {
-        default: null,
-        parseHTML: (element) => element.getAttribute("data-id"),
-        renderHTML: (attributes) => {
-          if (!attributes.id) {
-            return {};
-          }
-          return {
-            "data-id": attributes.id
-          };
-        }
-      },
-      label: {
-        default: null,
-        parseHTML: (element) => element.getAttribute("data-label"),
-        renderHTML: (attributes) => {
-          if (!attributes.label) {
-            return {};
-          }
-          return {
-            "data-label": attributes.label
-          };
-        }
-      },
-      // When there are multiple types of mentions, this attribute helps distinguish them
-      mentionSuggestionChar: {
-        default: "@",
-        parseHTML: (element) => element.getAttribute("data-mention-suggestion-char"),
-        renderHTML: (attributes) => {
-          return {
-            "data-mention-suggestion-char": attributes.mentionSuggestionChar
-          };
-        }
-      }
-    };
-  },
-  parseHTML() {
-    return [
-      {
-        tag: `span[data-type="${this.name}"]`
-      }
-    ];
-  },
-  renderHTML({ node, HTMLAttributes }) {
-    const suggestion = getSuggestionFromChar(this, node.attrs.mentionSuggestionChar);
-    if (this.options.renderLabel !== void 0) {
-      console.warn("renderLabel is deprecated use renderText and renderHTML instead");
-      return [
-        "span",
-        mergeAttributes({ "data-type": this.name }, this.options.HTMLAttributes, HTMLAttributes),
-        this.options.renderLabel({
-          options: this.options,
-          node,
-          suggestion
-        })
-      ];
-    }
-    const mergedOptions = { ...this.options };
-    mergedOptions.HTMLAttributes = mergeAttributes({ "data-type": this.name }, this.options.HTMLAttributes, HTMLAttributes);
-    const html = this.options.renderHTML({
-      options: mergedOptions,
-      node,
-      suggestion
-    });
-    if (typeof html === "string") {
-      return [
-        "span",
-        mergeAttributes({ "data-type": this.name }, this.options.HTMLAttributes, HTMLAttributes),
-        html
-      ];
-    }
-    return html;
-  },
-  renderText({ node }) {
-    const args = {
-      options: this.options,
-      node,
-      suggestion: getSuggestionFromChar(this, node.attrs.mentionSuggestionChar)
-    };
-    if (this.options.renderLabel !== void 0) {
-      console.warn("renderLabel is deprecated use renderText and renderHTML instead");
-      return this.options.renderLabel(args);
-    }
-    return this.options.renderText(args);
-  },
-  addKeyboardShortcuts() {
-    return {
-      Backspace: () => this.editor.commands.command(({ tr, state }) => {
-        let isMention = false;
-        const { selection } = state;
-        const { empty, anchor } = selection;
-        if (!empty) {
-          return false;
-        }
-        state.doc.nodesBetween(anchor - 1, anchor, (node, pos) => {
-          if (node.type.name === this.name) {
-            isMention = true;
-            tr.insertText(this.options.deleteTriggerWithBackspace ? "" : this.options.suggestion.char || "", pos, pos + node.nodeSize);
-            return false;
-          }
-        });
-        let mentionNode = new Node$1();
-        let mentionPos = 0;
-        state.doc.nodesBetween(anchor - 1, anchor, (node, pos) => {
-          if (node.type.name === this.name) {
-            isMention = true;
-            mentionNode = node;
-            mentionPos = pos;
-            return false;
-          }
-        });
-        if (isMention) {
-          tr.insertText(this.options.deleteTriggerWithBackspace ? "" : mentionNode.attrs.mentionSuggestionChar, mentionPos, mentionPos + mentionNode.nodeSize);
-        }
-        return isMention;
-      })
-    };
-  },
-  addProseMirrorPlugins() {
-    return getSuggestions(this).map(Suggestion);
-  }
-});
-export {
-  Mention,
-  Mention as default
-};

package/dist/node_modules/@tiptap/extension-ordered-list/dist/index.js

@@ -1,86 +0,0 @@
-import { Node, wrappingInputRule, mergeAttributes } from "../../core/dist/index.js";
-const ListItemName = "listItem";
-const TextStyleName = "textStyle";
-const inputRegex = /^(\d+)\.\s$/;
-const OrderedList = Node.create({
-  name: "orderedList",
-  addOptions() {
-    return {
-      itemTypeName: "listItem",
-      HTMLAttributes: {},
-      keepMarks: false,
-      keepAttributes: false
-    };
-  },
-  group: "block list",
-  content() {
-    return `${this.options.itemTypeName}+`;
-  },
-  addAttributes() {
-    return {
-      start: {
-        default: 1,
-        parseHTML: (element) => {
-          return element.hasAttribute("start") ? parseInt(element.getAttribute("start") || "", 10) : 1;
-        }
-      },
-      type: {
-        default: null,
-        parseHTML: (element) => element.getAttribute("type")
-      }
-    };
-  },
-  parseHTML() {
-    return [
-      {
-        tag: "ol"
-      }
-    ];
-  },
-  renderHTML({ HTMLAttributes }) {
-    const { start, ...attributesWithoutStart } = HTMLAttributes;
-    return start === 1 ? ["ol", mergeAttributes(this.options.HTMLAttributes, attributesWithoutStart), 0] : ["ol", mergeAttributes(this.options.HTMLAttributes, HTMLAttributes), 0];
-  },
-  addCommands() {
-    return {
-      toggleOrderedList: () => ({ commands, chain }) => {
-        if (this.options.keepAttributes) {
-          return chain().toggleList(this.name, this.options.itemTypeName, this.options.keepMarks).updateAttributes(ListItemName, this.editor.getAttributes(TextStyleName)).run();
-        }
-        return commands.toggleList(this.name, this.options.itemTypeName, this.options.keepMarks);
-      }
-    };
-  },
-  addKeyboardShortcuts() {
-    return {
-      "Mod-Shift-7": () => this.editor.commands.toggleOrderedList()
-    };
-  },
-  addInputRules() {
-    let inputRule = wrappingInputRule({
-      find: inputRegex,
-      type: this.type,
-      getAttributes: (match) => ({ start: +match[1] }),
-      joinPredicate: (match, node) => node.childCount + node.attrs.start === +match[1]
-    });
-    if (this.options.keepMarks || this.options.keepAttributes) {
-      inputRule = wrappingInputRule({
-        find: inputRegex,
-        type: this.type,
-        keepMarks: this.options.keepMarks,
-        keepAttributes: this.options.keepAttributes,
-        getAttributes: (match) => ({ start: +match[1], ...this.editor.getAttributes(TextStyleName) }),
-        joinPredicate: (match, node) => node.childCount + node.attrs.start === +match[1],
-        editor: this.editor
-      });
-    }
-    return [
-      inputRule
-    ];
-  }
-});
-export {
-  OrderedList,
-  OrderedList as default,
-  inputRegex
-};