@lexical/hashtag 0.1.15

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2020 Dominic Gannaway
+
+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/LexicalHashtag.d.ts

@@ -0,0 +1,23 @@
+/**
+ * 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 type {EditorConfig, LexicalNode, NodeKey} from 'lexical';
+import {TextNode} from 'lexical';
+
+export declare class HashtagNode extends TextNode {
+  getType(): string;
+  clone(node: HashtagNode): HashtagNode;
+  constructor(text: string, key?: NodeKey);
+  createDOM<EditorContext>(config: EditorConfig<EditorContext>): HTMLElement;
+  setTextContent(text: string): TextNode;
+  canInsertTextBefore(): boolean;
+  canInsertTextAfter(): boolean;
+}
+export function $toggleHashtag(node: TextNode): TextNode;
+export function $createHashtagNode(text?: string): TextNode;
+export function $isHashtagNode(node: LexicalNode | null | undefined): boolean;

package/LexicalHashtag.dev.js

@@ -0,0 +1,96 @@
+/**
+ * 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 utils = require('@lexical/utils');
+var lexical = require('lexical');
+
+/**
+ * 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 HashtagNode extends lexical.TextNode {
+  static getType() {
+    return 'hashtag';
+  }
+
+  static clone(node) {
+    return new HashtagNode(node.__text, node.__key);
+  }
+
+  constructor(text, key) {
+    super(text, key);
+  }
+
+  createDOM(config) {
+    const element = super.createDOM(config);
+    utils.addClassNamesToElement(element, config.theme.hashtag);
+    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() {
+    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);
+}
+function $isHashtagNode(node) {
+  return node instanceof HashtagNode;
+}
+
+exports.$createHashtagNode = $createHashtagNode;
+exports.$isHashtagNode = $isHashtagNode;
+exports.$toggleHashtag = $toggleHashtag;
+exports.HashtagNode = HashtagNode;

package/LexicalHashtag.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 LexicalHashtag = process.env.NODE_ENV === 'development' ? require('./LexicalHashtag.dev.js') : require('./LexicalHashtag.prod.js')
+module.exports = LexicalHashtag;

package/LexicalHashtag.prod.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.
+ */
+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;

package/README.md

@@ -0,0 +1,5 @@
+# `@lexical/hashtag`
+
+This package contains the functionality for Lexical hashtags.
+
+More documentation coming soon.

package/package.json

@@ -0,0 +1,29 @@
+{
+  "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.15",
+  "main": "LexicalHashtag.js",
+  "peerDependencies": {
+    "lexical": "0.1.15"
+  },
+  "dependencies": {
+    "@lexical/utils": "0.1.15"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/facebook/lexical",
+    "directory": "packages/lexical-hashtag"
+  }
+}