@lexical/hashtag 0.1.16 → 0.1.17

package/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2020 Dominic Gannaway
+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

package/LexicalHashtag.d.ts

@@ -14,10 +14,8 @@ export declare class HashtagNode extends TextNode {
   clone(node: HashtagNode): HashtagNode;
   constructor(text: string, key?: NodeKey);
   createDOM<EditorContext>(config: EditorConfig<EditorContext>): HTMLElement;
-  setTextContent(text: string): TextNode;
   canInsertTextBefore(): boolean;
-  canInsertTextAfter(): boolean;
+  isTextEntity(): true;
 }
-export function $toggleHashtag(node: TextNode): TextNode;
 export function $createHashtagNode(text?: string): TextNode;
 export function $isHashtagNode(node: LexicalNode | null | undefined): boolean;

package/LexicalHashtag.dev.js

@@ -36,53 +36,15 @@ class HashtagNode extends lexical.TextNode {
     return element;
   }
 
-  setTextContent(text) {
-    let targetNode = super.setTextContent(text); // Handle hashtags
-
-    if (targetNode.getParent() !== null && !targetNode.isComposing()) {
-      const indexOfHash = text.indexOf('#');
-
-      if (indexOfHash === -1 || targetNode.getTextContent() === '#') {
-        targetNode = $toggleHashtag(targetNode);
-      } else if (indexOfHash > 0) {
-        [targetNode] = targetNode.splitText(indexOfHash);
-        targetNode = $toggleHashtag(targetNode);
-      } // Check for invalid characters
-
-
-      if (lexical.$isTextNode(targetNode) && targetNode.isAttached()) {
-        const targetTextContent = targetNode.getTextContent().slice(1);
-        const indexOfInvalidChar = targetTextContent.search(/[\s.,\\\/#!$%\^&\*;:{}=\-`~()@]/);
-
-        if (indexOfInvalidChar === 0) {
-          targetNode = $toggleHashtag(targetNode);
-        } else if (indexOfInvalidChar > 0) {
-          [, targetNode] = targetNode.splitText(indexOfInvalidChar + 1);
-          targetNode = $toggleHashtag(targetNode);
-        }
-      }
-
-      return targetNode;
-    }
-
-    return this;
-  }
-
   canInsertTextBefore() {
     return false;
   }
 
-  canInsertTextAfter() {
+  isTextEntity() {
     return true;
   }
 
 }
-function $toggleHashtag(node) {
-  const text = node.getTextContent();
-  const replacement = !$isHashtagNode(node) ? $createHashtagNode(text) : lexical.$createTextNode(text);
-  node.replace(replacement);
-  return replacement;
-}
 function $createHashtagNode(text = '') {
   return new HashtagNode(text);
 }
@@ -92,5 +54,4 @@ function $isHashtagNode(node) {
 
 exports.$createHashtagNode = $createHashtagNode;
 exports.$isHashtagNode = $isHashtagNode;
-exports.$toggleHashtag = $toggleHashtag;
 exports.HashtagNode = HashtagNode;

package/LexicalHashtag.js.flow

@@ -0,0 +1,25 @@
+/**
+ * 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 {EditorConfig, LexicalNode, NodeKey} from 'lexical';
+
+import {TextNode} from 'lexical';
+
+declare export class HashtagNode extends TextNode {
+  static getType(): string;
+  static clone(node: HashtagNode): HashtagNode;
+  constructor(text: string, key?: NodeKey): void;
+  createDOM<EditorContext>(config: EditorConfig<EditorContext>): HTMLElement;
+  canInsertTextBefore(): boolean;
+  isTextEntity(): true;
+}
+declare export function $createHashtagNode(text?: string): HashtagNode;
+declare export function $isHashtagNode(
+  node: ?LexicalNode,
+): boolean %checks(node instanceof HashtagNode);

package/LexicalHashtag.prod.js

@@ -4,6 +4,4 @@
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
  */
-var c=require("@lexical/utils"),d=require("lexical");
-class e extends d.TextNode{static getType(){return"hashtag"}static clone(b){return new e(b.__text,b.__key)}constructor(b,a){super(b,a)}createDOM(b){const a=super.createDOM(b);c.addClassNamesToElement(a,b.theme.hashtag);return a}setTextContent(b){let a=super.setTextContent(b);return null===a.getParent()||a.isComposing()?this:(b=b.indexOf("#"),-1===b||"#"===a.getTextContent()?a=f(a):0<b&&([a]=a.splitText(b),a=f(a)),d.$isTextNode(a)&&a.isAttached()&&(b=a.getTextContent().slice(1).search(/[\s.,\\\/#!$%\^&\*;:{}=\-`~()@]/),
-0===b?a=f(a):0<b&&([,a]=a.splitText(b+1),a=f(a))),a)}canInsertTextBefore(){return!1}canInsertTextAfter(){return!0}}function f(b){var a=b.getTextContent();a=g(b)?d.$createTextNode(a):h(a);b.replace(a);return a}function h(b=""){return new e(b)}function g(b){return b instanceof e}exports.$createHashtagNode=h;exports.$isHashtagNode=g;exports.$toggleHashtag=f;exports.HashtagNode=e;
+var b=require("@lexical/utils"),d=require("lexical");class e extends d.TextNode{static getType(){return"hashtag"}static clone(a){return new e(a.__text,a.__key)}constructor(a,c){super(a,c)}createDOM(a){const c=super.createDOM(a);b.addClassNamesToElement(c,a.theme.hashtag);return c}canInsertTextBefore(){return!1}isTextEntity(){return!0}}exports.$createHashtagNode=function(a=""){return new e(a)};exports.$isHashtagNode=function(a){return a instanceof e};exports.HashtagNode=e;

package/package.json

@@ -1,25 +1,20 @@
 {
   "name": "@lexical/hashtag",
-  "author": {
-    "name": "Dominic Gannaway",
-    "email": "dg@domgan.com"
-  },
   "description": "This package contains the functionality for Lexical hashtags.",
   "keywords": [
     "lexical",
     "editor",
     "rich-text",
-    "table",
     "hashtag"
   ],
   "license": "MIT",
-  "version": "0.1.16",
+  "version": "0.1.17",
   "main": "LexicalHashtag.js",
   "peerDependencies": {
-    "lexical": "0.1.16"
+    "lexical": "0.1.17"
   },
   "dependencies": {
-    "@lexical/utils": "0.1.16"
+    "@lexical/utils": "0.1.17"
   },
   "repository": {
     "type": "git",