@lexical/mark 0.2.6

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) Meta Platforms, Inc. and affiliates.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/LexicalMark.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ */
+import type {NodeKey, RangeSelection, TextNode} from 'lexical';
+import {ElementNode, LexicalNode} from 'lexical';
+export declare class MarkNode extends ElementNode {
+  __ids: Array<string>;
+  clone(node: MarkNode): MarkNode;
+  constructor(ids: Array<string>, key?: NodeKey): void;
+  hasID(id: string): boolean;
+  getIDs(): Array<string>;
+  addID(id: string): void;
+  deleteID(id: string): void;
+  canInsertTextBefore(): false;
+  canInsertTextAfter(): false;
+  isInline(): true;
+}
+export function $isMarkNode(node: LexicalNode | null | undefined): boolean;
+export function $createMarkNode(ids: Array<string>): MarkNode;
+export function $getMarkIDs(
+  node: TextNode,
+  offset: number,
+): null | Array<string>;
+export function $wrapSelectionInMarkNode(
+  selection: RangeSelection,
+  isBackward: boolean,
+  id: string,
+): void;
+export function $unwrapMarkNode(node: MarkNode): void;

package/LexicalMark.dev.js

@@ -0,0 +1,279 @@
+/**
+ * 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.
+ */
+'use strict';
+
+var lexical = require('lexical');
+var utils = require('@lexical/utils');
+
+/**
+ * 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.
+ *
+ * 
+ */
+class MarkNode extends lexical.ElementNode {
+  static getType() {
+    return 'mark';
+  }
+
+  static clone(node) {
+    return new MarkNode(Array.from(node.__ids), node.__key);
+  }
+
+  constructor(ids, key) {
+    super(key);
+    this.__ids = ids || [];
+  }
+
+  createDOM(config) {
+    const element = document.createElement('mark');
+    utils.addClassNamesToElement(element, config.theme.mark);
+
+    if (this.__ids.length > 1) {
+      utils.addClassNamesToElement(element, config.theme.markOverlap);
+    }
+
+    return element;
+  }
+
+  updateDOM(prevNode, element, config) {
+    const prevIDs = prevNode.__ids;
+    const nextIDs = this.__ids;
+    const prevIDsCount = prevIDs.length;
+    const nextIDsCount = nextIDs.length;
+    const overlapTheme = config.theme.markOverlap;
+
+    if (prevIDsCount !== nextIDsCount) {
+      if (prevIDsCount === 1) {
+        if (nextIDsCount === 2) {
+          utils.addClassNamesToElement(element, overlapTheme);
+        }
+      } else if (nextIDsCount === 1) {
+        utils.removeClassNamesFromElement(element, overlapTheme);
+      }
+    }
+
+    return false;
+  }
+
+  hasID(id) {
+    const ids = this.getIDs();
+
+    for (let i = 0; i < ids.length; i++) {
+      if (id === ids[i]) {
+        return true;
+      }
+    }
+
+    return false;
+  }
+
+  getIDs() {
+    const self = this.getLatest();
+    return self.__ids;
+  }
+
+  addID(id) {
+    const self = this.getWritable();
+    const ids = self.__ids;
+    self.__ids = ids;
+
+    for (let i = 0; i < ids.length; i++) {
+      // If we already have it, don't add again
+      if (id === ids[i]) {
+        return;
+      }
+    }
+
+    ids.push(id);
+  }
+
+  deleteID(id) {
+    const self = this.getWritable();
+    const ids = self.__ids;
+    self.__ids = ids;
+
+    for (let i = 0; i < ids.length; i++) {
+      if (id === ids[i]) {
+        ids.splice(i, 1);
+        return;
+      }
+    }
+  }
+
+  insertNewAfter(selection) {
+    const element = this.getParentOrThrow().insertNewAfter(selection);
+
+    if (lexical.$isElementNode(element)) {
+      const linkNode = $createMarkNode(this.__ids);
+      element.append(linkNode);
+      return linkNode;
+    }
+
+    return null;
+  }
+
+  canInsertTextBefore() {
+    return false;
+  }
+
+  canInsertTextAfter() {
+    return false;
+  }
+
+  canBeEmpty() {
+    return false;
+  }
+
+  isInline() {
+    return true;
+  }
+
+  extractWithChild(child, selection, destination) {
+    if (!lexical.$isRangeSelection(selection) || destination === 'html') {
+      return false;
+    }
+
+    const anchor = selection.anchor;
+    const focus = selection.focus;
+    const anchorNode = anchor.getNode();
+    const focusNode = focus.getNode();
+    const isBackward = selection.isBackward();
+    const selectionLength = isBackward ? anchor.offset - focus.offset : focus.offset - anchor.offset;
+    return this.isParentOf(anchorNode) && this.isParentOf(focusNode) && this.getTextContent().length === selectionLength;
+  }
+
+  excludeFromCopy(destination) {
+    return destination !== 'clone';
+  }
+
+}
+function $createMarkNode(ids) {
+  return new MarkNode(ids);
+}
+function $isMarkNode(node) {
+  return node instanceof MarkNode;
+}
+
+/**
+ * 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.
+ *
+ * 
+ */
+function $unwrapMarkNode(node) {
+  const children = node.getChildren();
+  let target = null;
+
+  for (let i = 0; i < children.length; i++) {
+    const child = children[i];
+
+    if (target === null) {
+      node.insertBefore(child);
+    } else {
+      target.insertAfter(child);
+    }
+
+    target = child;
+  }
+
+  node.remove();
+}
+function $wrapSelectionInMarkNode(selection, isBackward, id) {
+  const nodes = selection.getNodes();
+  const anchorOffset = selection.anchor.offset;
+  const focusOffset = selection.focus.offset;
+  const nodesLength = nodes.length;
+  const startOffset = isBackward ? focusOffset : anchorOffset;
+  const endOffset = isBackward ? anchorOffset : focusOffset;
+  let currentNodeParent;
+  let currentMarkNode; // We only want wrap adjacent text nodes, line break nodes
+  // and inline element nodes. For decorator nodes and block
+  // element nodes, we stop out their boundary and start again
+  // after, if there are more nodes.
+
+  for (let i = 0; i < nodesLength; i++) {
+    const node = nodes[i];
+
+    if (lexical.$isElementNode(currentMarkNode) && currentMarkNode.isParentOf(node)) {
+      continue;
+    }
+
+    const isFirstNode = i === 0;
+    const isLastNode = i === nodesLength - 1;
+    let targetNode;
+
+    if (lexical.$isTextNode(node)) {
+      const textContentSize = node.getTextContentSize();
+      const startTextOffset = isFirstNode ? startOffset : 0;
+      const endTextOffset = isLastNode ? endOffset : textContentSize;
+
+      if (startTextOffset === 0 && endTextOffset === 0) {
+        continue;
+      }
+
+      const splitNodes = node.splitText(startTextOffset, endTextOffset);
+      targetNode = splitNodes.length > 1 && (splitNodes.length === 3 || isFirstNode && !isLastNode || endTextOffset === textContentSize) ? splitNodes[1] : splitNodes[0];
+    } else if (lexical.$isElementNode(node) && node.isInline()) {
+      targetNode = node;
+    }
+
+    if (targetNode !== undefined) {
+      if (targetNode && targetNode.is(currentNodeParent)) {
+        continue;
+      }
+
+      const parentNode = targetNode.getParent();
+
+      if (parentNode == null || !parentNode.is(currentNodeParent)) {
+        currentMarkNode = undefined;
+      }
+
+      currentNodeParent = parentNode;
+
+      if (currentMarkNode === undefined) {
+        currentMarkNode = $createMarkNode([id]);
+        targetNode.insertBefore(currentMarkNode);
+      }
+
+      currentMarkNode.append(targetNode);
+    } else {
+      currentNodeParent = undefined;
+      currentMarkNode = undefined;
+    }
+  }
+}
+function $getMarkIDs(node, offset) {
+  let currentNode = node;
+
+  while (currentNode !== null) {
+    if ($isMarkNode(currentNode)) {
+      return currentNode.getIDs();
+    } else if (lexical.$isTextNode(currentNode) && offset === currentNode.getTextContentSize()) {
+      const nextSibling = currentNode.getNextSibling();
+
+      if ($isMarkNode(nextSibling)) {
+        return nextSibling.getIDs();
+      }
+    }
+
+    currentNode = currentNode.getParent();
+  }
+
+  return null;
+}
+
+exports.$createMarkNode = $createMarkNode;
+exports.$getMarkIDs = $getMarkIDs;
+exports.$isMarkNode = $isMarkNode;
+exports.$unwrapMarkNode = $unwrapMarkNode;
+exports.$wrapSelectionInMarkNode = $wrapSelectionInMarkNode;
+exports.MarkNode = MarkNode;

package/LexicalMark.js

@@ -0,0 +1,9 @@
+/**
+ * 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.
+ */
+'use strict'
+const LexicalMark = process.env.NODE_ENV === 'development' ? require('./LexicalMark.dev.js') : require('./LexicalMark.prod.js')
+module.exports = LexicalMark;

package/LexicalMark.js.flow

@@ -0,0 +1,45 @@
+/**
+ * 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.
+ *
+ * @flow strict
+ */
+
+import type {NodeKey, RangeSelection, TextNode} from 'lexical';
+import {ElementNode, LexicalNode} from 'lexical';
+
+declare export class MarkNode extends ElementNode {
+  __ids: Array<string>;
+
+  static clone(node: MarkNode): MarkNode;
+  constructor(ids: Array<string>, key?: NodeKey): void;
+
+  hasID(id: string): boolean;
+  getIDs(): Array<string>;
+  addID(id: string): void;
+  deleteID(id: string): void;
+  canInsertTextBefore(): false;
+  canInsertTextAfter(): false;
+  isInline(): true;
+}
+
+declare export function $isMarkNode(
+  node: ?LexicalNode,
+): boolean %checks(node instanceof MarkNode);
+
+declare export function $createMarkNode(ids: Array<string>): MarkNode;
+
+declare export function $getMarkIDs(
+  node: TextNode,
+  offset: number,
+): null | Array<string>;
+
+declare export function $wrapSelectionInMarkNode(
+  selection: RangeSelection,
+  isBackward: boolean,
+  id: string,
+): void;
+
+declare export function $unwrapMarkNode(node: MarkNode): void;

package/LexicalMark.prod.js

@@ -0,0 +1,13 @@
+/**
+ * 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.
+ */
+var k=require("lexical"),m=require("@lexical/utils");
+class n extends k.ElementNode{static getType(){return"mark"}static clone(a){return new n(Array.from(a.__ids),a.__key)}constructor(a,b){super(b);this.__ids=a||[]}createDOM(a){const b=document.createElement("mark");m.addClassNamesToElement(b,a.theme.mark);1<this.__ids.length&&m.addClassNamesToElement(b,a.theme.markOverlap);return b}updateDOM(a,b,c){a=a.__ids.length;const e=this.__ids.length;c=c.theme.markOverlap;a!==e&&(1===a?2===e&&m.addClassNamesToElement(b,c):1===e&&m.removeClassNamesFromElement(b,
+c));return!1}hasID(a){const b=this.getIDs();for(let c=0;c<b.length;c++)if(a===b[c])return!0;return!1}getIDs(){return this.getLatest().__ids}addID(a){var b=this.getWritable();const c=b.__ids;b.__ids=c;for(b=0;b<c.length;b++)if(a===c[b])return;c.push(a)}deleteID(a){var b=this.getWritable();const c=b.__ids;b.__ids=c;for(b=0;b<c.length;b++)if(a===c[b]){c.splice(b,1);break}}insertNewAfter(a){a=this.getParentOrThrow().insertNewAfter(a);if(k.$isElementNode(a)){const b=q(this.__ids);a.append(b);return b}return null}canInsertTextBefore(){return!1}canInsertTextAfter(){return!1}canBeEmpty(){return!1}isInline(){return!0}extractWithChild(a,
+b,c){if(!k.$isRangeSelection(b)||"html"===c)return!1;const e=b.anchor,d=b.focus;a=e.getNode();c=d.getNode();b=b.isBackward()?e.offset-d.offset:d.offset-e.offset;return this.isParentOf(a)&&this.isParentOf(c)&&this.getTextContent().length===b}excludeFromCopy(a){return"clone"!==a}}function q(a){return new n(a)}function r(a){return a instanceof n}exports.$createMarkNode=q;
+exports.$getMarkIDs=function(a,b){for(;null!==a;){if(r(a))return a.getIDs();if(k.$isTextNode(a)&&b===a.getTextContentSize()){const c=a.getNextSibling();if(r(c))return c.getIDs()}a=a.getParent()}return null};exports.$isMarkNode=r;exports.$unwrapMarkNode=function(a){const b=a.getChildren();let c=null;for(let e=0;e<b.length;e++){const d=b[e];null===c?a.insertBefore(d):c.insertAfter(d);c=d}a.remove()};
+exports.$wrapSelectionInMarkNode=function(a,b,c){const e=a.getNodes();var d=a.anchor.offset,g=a.focus.offset;a=e.length;const x=b?g:d;b=b?d:g;let p,h;for(d=0;d<a;d++){const l=e[d];if(k.$isElementNode(h)&&h.isParentOf(l))continue;g=0===d;const u=d===a-1;var f=void 0;if(k.$isTextNode(l)){const v=l.getTextContentSize(),w=g?x:0,t=u?b:v;if(0===w&&0===t)continue;f=l.splitText(w,t);f=1<f.length&&(3===f.length||g&&!u||t===v)?f[1]:f[0]}else k.$isElementNode(l)&&l.isInline()&&(f=l);void 0!==f?f&&f.is(p)||(g=
+f.getParent(),null!=g&&g.is(p)||(h=void 0),p=g,void 0===h&&(h=q([c]),f.insertBefore(h)),h.append(f)):h=p=void 0}};exports.MarkNode=n;

package/README.md

@@ -0,0 +1,3 @@
+# `@lexical/mark`
+
+This package contains helpers and nodes for wrapping content in marks for Lexical.

package/package.json

@@ -0,0 +1,24 @@
+{
+  "name": "@lexical/mark",
+  "description": "This package contains helpers and nodes for wrapping content in marks for Lexical.",
+  "keywords": [
+    "lexical",
+    "editor",
+    "rich-text",
+    "mark"
+  ],
+  "license": "MIT",
+  "version": "0.2.6",
+  "main": "LexicalMark.js",
+  "peerDependencies": {
+    "lexical": "0.2.6"
+  },
+  "dependencies": {
+    "@lexical/utils": "0.2.6"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/facebook/lexical",
+    "directory": "packages/lexical-mark"
+  }
+}