@lexical/link 0.1.17

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/LexicalLink.d.ts

@@ -0,0 +1,50 @@
+/**
+ * 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.
+ *
+ * @flow strict
+ */
+import type {
+  DOMConversionMap,
+  DOMConversionOutput,
+  EditorConfig,
+  LexicalNode,
+  NodeKey,
+  RangeSelection,
+  LexicalCommand,
+} from 'lexical';
+
+export declare class LinkNode extends ElementNode {
+  __url: string;
+  static getType(): string;
+  static clone(node: LinkNode): LinkNode;
+  constructor(url: string, key?: NodeKey): void;
+  createDOM<EditorContext>(config: EditorConfig<EditorContext>): HTMLElement;
+  updateDOM<EditorContext>(
+    prevNode: LinkNode,
+    dom: HTMLElement,
+    config: EditorConfig<EditorContext>,
+  ): boolean;
+  static convertDOM(): DOMConversionMap | null;
+  getURL(): string;
+  setURL(url: string): void;
+  insertNewAfter(selection: RangeSelection): null | ElementNode;
+  canInsertTextBefore(): false;
+  canInsertTextAfter(): boolean;
+  canBeEmpty(): false;
+  isInline(): true;
+}
+export function convertAnchorElement(domNode: Node): DOMConversionOutput;
+export function $createLinkNode(url: string): LinkNode;
+export function $isLinkNode(node: ?LexicalNode): boolean;
+export declare class AutoLinkNode extends LinkNode {
+  static getType(): string;
+  static clone(node: AutoLinkNode): AutoLinkNode;
+  insertNewAfter(selection: RangeSelection): null | ElementNode;
+}
+export function $createAutoLinkNode(url: string): AutoLinkNode;
+export function $isAutoLinkNode(node: ?LexicalNode): boolean;
+
+export var TOGGLE_LINK_COMMAND: LexicalCommand<string | null>;

package/LexicalLink.dev.js

@@ -0,0 +1,159 @@
+/**
+ * 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) 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.
+ *
+ * 
+ */
+class LinkNode extends lexical.ElementNode {
+  static getType() {
+    return 'link';
+  }
+
+  static clone(node) {
+    return new LinkNode(node.__url, node.__key);
+  }
+
+  constructor(url, key) {
+    super(key);
+    this.__url = url;
+  }
+
+  createDOM(config) {
+    const element = document.createElement('a');
+    element.href = this.__url;
+    utils.addClassNamesToElement(element, config.theme.link);
+    return element;
+  }
+
+  updateDOM( // $FlowFixMe: not sure how to fix this
+  prevNode, dom, config) {
+    // $FlowFixMe: not sure how to fix this
+    const anchor = dom;
+    const url = this.__url;
+
+    if (url !== prevNode.__url) {
+      anchor.href = url;
+    }
+
+    return false;
+  }
+
+  static convertDOM() {
+    return {
+      a: node => ({
+        conversion: convertAnchorElement,
+        priority: 1
+      })
+    };
+  }
+
+  getURL() {
+    return this.getLatest().__url;
+  }
+
+  setURL(url) {
+    const writable = this.getWritable();
+    writable.__url = url;
+  }
+
+  insertNewAfter(selection) {
+    const element = this.getParentOrThrow().insertNewAfter(selection);
+
+    if (lexical.$isElementNode(element)) {
+      const linkNode = $createLinkNode(this.__url);
+      element.append(linkNode);
+      return linkNode;
+    }
+
+    return null;
+  }
+
+  canInsertTextBefore() {
+    return false;
+  }
+
+  canInsertTextAfter() {
+    return false;
+  }
+
+  canBeEmpty() {
+    return false;
+  }
+
+  isInline() {
+    return true;
+  }
+
+}
+
+function convertAnchorElement(domNode) {
+  let node = null;
+
+  if (domNode instanceof HTMLAnchorElement) {
+    node = $createLinkNode(domNode.href);
+  }
+
+  return {
+    node
+  };
+}
+
+function $createLinkNode(url) {
+  return new LinkNode(url);
+}
+function $isLinkNode(node) {
+  return node instanceof LinkNode;
+} // Custom node type to override `canInsertTextAfter` that will
+// allow typing within the link
+
+class AutoLinkNode extends LinkNode {
+  static getType() {
+    return 'autolink';
+  } // $FlowFixMe[incompatible-extend]
+
+
+  static clone(node) {
+    return new AutoLinkNode(node.__url, node.__key);
+  }
+
+  insertNewAfter(selection) {
+    const element = this.getParentOrThrow().insertNewAfter(selection);
+
+    if (lexical.$isElementNode(element)) {
+      const linkNode = $createAutoLinkNode(this.__url);
+      element.append(linkNode);
+      return linkNode;
+    }
+
+    return null;
+  }
+
+}
+function $createAutoLinkNode(url) {
+  return new AutoLinkNode(url);
+}
+function $isAutoLinkNode(node) {
+  return node instanceof AutoLinkNode;
+}
+const TOGGLE_LINK_COMMAND = lexical.createCommand();
+
+exports.$createAutoLinkNode = $createAutoLinkNode;
+exports.$createLinkNode = $createLinkNode;
+exports.$isAutoLinkNode = $isAutoLinkNode;
+exports.$isLinkNode = $isLinkNode;
+exports.AutoLinkNode = AutoLinkNode;
+exports.LinkNode = LinkNode;
+exports.TOGGLE_LINK_COMMAND = TOGGLE_LINK_COMMAND;

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

package/LexicalLink.js.flow

@@ -0,0 +1,54 @@
+/**
+ * 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.
+ *
+ * @flow strict
+ */
+import type {
+  DOMConversionMap,
+  EditorConfig,
+  LexicalNode,
+  NodeKey,
+  RangeSelection,
+  LexicalCommand,
+} from 'lexical';
+import {addClassNamesToElement} from '@lexical/utils';
+import {$isElementNode, ElementNode} from 'lexical';
+declare export class LinkNode extends ElementNode {
+  __url: string;
+  static getType(): string;
+  static clone(node: LinkNode): LinkNode;
+  constructor(url: string, key?: NodeKey): void;
+  createDOM<EditorContext>(config: EditorConfig<EditorContext>): HTMLElement;
+  updateDOM<EditorContext>(
+    prevNode: LinkNode,
+    dom: HTMLElement,
+    config: EditorConfig<EditorContext>,
+  ): boolean;
+  static convertDOM(): DOMConversionMap | null;
+  getURL(): string;
+  setURL(url: string): void;
+  insertNewAfter(selection: RangeSelection): null | ElementNode;
+  canInsertTextBefore(): false;
+  canInsertTextAfter(): boolean;
+  canBeEmpty(): false;
+  isInline(): true;
+}
+declare export function $createLinkNode(url: string): LinkNode;
+declare export function $isLinkNode(
+  node: ?LexicalNode,
+): boolean %checks(node instanceof LinkNode);
+declare export class AutoLinkNode extends LinkNode {
+  static getType(): string;
+  // $FlowFixMe clone method inheritance
+  static clone(node: AutoLinkNode): AutoLinkNode;
+  insertNewAfter(selection: RangeSelection): null | ElementNode;
+}
+declare export function $createAutoLinkNode(url: string): AutoLinkNode;
+declare export function $isAutoLinkNode(
+  node: ?LexicalNode,
+): boolean %checks(node instanceof AutoLinkNode);
+
+declare export var TOGGLE_LINK_COMMAND: LexicalCommand<string | null>;

package/LexicalLink.prod.js

@@ -0,0 +1,11 @@
+/**
+ * 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.ElementNode{static getType(){return"link"}static clone(a){return new e(a.__url,a.__key)}constructor(a,b){super(b);this.__url=a}createDOM(a){const b=document.createElement("a");b.href=this.__url;c.addClassNamesToElement(b,a.theme.link);return b}updateDOM(a,b){const g=this.__url;g!==a.__url&&(b.href=g);return!1}static convertDOM(){return{a:()=>({conversion:f,priority:1})}}getURL(){return this.getLatest().__url}setURL(a){this.getWritable().__url=a}insertNewAfter(a){a=this.getParentOrThrow().insertNewAfter(a);
+if(d.$isElementNode(a)){const b=h(this.__url);a.append(b);return b}return null}canInsertTextBefore(){return!1}canInsertTextAfter(){return!1}canBeEmpty(){return!1}isInline(){return!0}}function f(a){let b=null;a instanceof HTMLAnchorElement&&(b=h(a.href));return{node:b}}function h(a){return new e(a)}
+class k extends e{static getType(){return"autolink"}static clone(a){return new k(a.__url,a.__key)}insertNewAfter(a){a=this.getParentOrThrow().insertNewAfter(a);if(d.$isElementNode(a)){const b=l(this.__url);a.append(b);return b}return null}}function l(a){return new k(a)}const m=d.createCommand();exports.$createAutoLinkNode=l;exports.$createLinkNode=h;exports.$isAutoLinkNode=function(a){return a instanceof k};exports.$isLinkNode=function(a){return a instanceof e};exports.AutoLinkNode=k;
+exports.LinkNode=e;exports.TOGGLE_LINK_COMMAND=m;

package/README.md

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

package/package.json

@@ -0,0 +1,24 @@
+{
+  "name": "@lexical/link",
+  "description": "This package contains the functionality for Lexical links.",
+  "keywords": [
+    "lexical",
+    "editor",
+    "rich-text",
+    "link"
+  ],
+  "license": "MIT",
+  "version": "0.1.17",
+  "main": "LexicalLink.js",
+  "peerDependencies": {
+    "lexical": "0.1.17"
+  },
+  "dependencies": {
+    "@lexical/utils": "0.1.17"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/facebook/lexical",
+    "directory": "packages/lexical-link"
+  }
+}