@ekz/lexical-list 0.40.0

package/index.d.ts

@@ -0,0 +1,68 @@
+/**
+ * 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 { SerializedListItemNode } from './LexicalListItemNode';
+import type { ListNodeTagType, ListType, SerializedListNode } from './LexicalListNode';
+import type { LexicalCommand, LexicalEditor, NodeKey } from '@ekz/lexical';
+import { INSERT_CHECK_LIST_COMMAND, registerCheckList } from './checkList';
+import { $handleListInsertParagraph, $insertList, $removeList } from './formatList';
+import { $createListItemNode, $isListItemNode, ListItemNode } from './LexicalListItemNode';
+import { $createListNode, $isListNode, ListNode } from './LexicalListNode';
+import { $getListDepth } from './utils';
+export { $createListItemNode, $createListNode, $getListDepth, $handleListInsertParagraph, $insertList, $isListItemNode, $isListNode, $removeList, INSERT_CHECK_LIST_COMMAND, ListItemNode, ListNode, ListNodeTagType, ListType, registerCheckList, SerializedListItemNode, SerializedListNode, };
+export declare const UPDATE_LIST_START_COMMAND: LexicalCommand<{
+    listNodeKey: NodeKey;
+    newStart: number;
+}>;
+export declare const INSERT_UNORDERED_LIST_COMMAND: LexicalCommand<void>;
+export declare const INSERT_ORDERED_LIST_COMMAND: LexicalCommand<void>;
+export declare const REMOVE_LIST_COMMAND: LexicalCommand<void>;
+export declare function registerList(editor: LexicalEditor): () => void;
+export declare function registerListStrictIndentTransform(editor: LexicalEditor): () => void;
+/**
+ * @deprecated use {@link $insertList} from an update or command listener.
+ *
+ * Inserts a new ListNode. If the selection's anchor node is an empty ListItemNode and is a child of
+ * the root/shadow root, it will replace the ListItemNode with a ListNode and the old ListItemNode.
+ * Otherwise it will replace its parent with a new ListNode and re-insert the ListItemNode and any previous children.
+ * If the selection's anchor node is not an empty ListItemNode, it will add a new ListNode or merge an existing ListNode,
+ * unless the the node is a leaf node, in which case it will attempt to find a ListNode up the branch and replace it with
+ * a new ListNode, or create a new ListNode at the nearest root/shadow root.
+ * @param editor - The lexical editor.
+ * @param listType - The type of list, "number" | "bullet" | "check".
+ */
+export declare function insertList(editor: LexicalEditor, listType: ListType): void;
+/**
+ * @deprecated use {@link $removeList} from an update or command listener.
+ *
+ * Searches for the nearest ancestral ListNode and removes it. If selection is an empty ListItemNode
+ * it will remove the whole list, including the ListItemNode. For each ListItemNode in the ListNode,
+ * removeList will also generate new ParagraphNodes in the removed ListNode's place. Any child node
+ * inside a ListItemNode will be appended to the new ParagraphNodes.
+ * @param editor - The lexical editor.
+ */
+export declare function removeList(editor: LexicalEditor): void;
+export interface ListConfig {
+    /**
+     * When `true`, enforces strict indentation rules for list items, ensuring consistent structure.
+     * When `false` (default), indentation is more flexible.
+     */
+    hasStrictIndent: boolean;
+}
+/**
+ * Configures {@link ListNode}, {@link ListItemNode} and registers
+ * the strict indent transform if `hasStrictIndent` is true (default false).
+ */
+export declare const ListExtension: import("@ekz/lexical").LexicalExtension<ListConfig, "@ekz/lexical-list/List", import("@ekz/lexical-extension").NamedSignalsOutput<ListConfig>, unknown>;
+/**
+ * Registers checklist functionality for {@link ListNode} and
+ * {@link ListItemNode} with a
+ * {@link INSERT_CHECK_LIST_COMMAND} listener and
+ * the expected keyboard and mouse interactions for
+ * checkboxes.
+ */
+export declare const CheckListExtension: import("@ekz/lexical").LexicalExtension<import("@ekz/lexical").ExtensionConfigBase, "@ekz/lexical-list/CheckList", unknown, unknown>;

package/package.json

@@ -0,0 +1,44 @@
+{
+  "name": "@ekz/lexical-list",
+  "description": "This package provides the list feature for Lexical.",
+  "keywords": [
+    "lexical",
+    "editor",
+    "rich-text",
+    "list"
+  ],
+  "license": "MIT",
+  "version": "0.40.0",
+  "main": "LexicalList.js",
+  "types": "index.d.ts",
+  "dependencies": {
+    "@ekz/lexical-extension": "0.40.0",
+    "@ekz/lexical-selection": "0.40.0",
+    "@ekz/lexical-utils": "0.40.0",
+    "@ekz/lexical": "0.40.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/facebook/lexical.git",
+    "directory": "packages/lexical-list"
+  },
+  "module": "LexicalList.mjs",
+  "sideEffects": false,
+  "exports": {
+    ".": {
+      "import": {
+        "types": "./index.d.ts",
+        "development": "./LexicalList.dev.mjs",
+        "production": "./LexicalList.prod.mjs",
+        "node": "./LexicalList.node.mjs",
+        "default": "./LexicalList.mjs"
+      },
+      "require": {
+        "types": "./index.d.ts",
+        "development": "./LexicalList.dev.js",
+        "production": "./LexicalList.prod.js",
+        "default": "./LexicalList.js"
+      }
+    }
+  }
+}

package/utils.d.ts

@@ -0,0 +1,65 @@
+/**
+ * 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 { LexicalNode, Spread } from '@ekz/lexical';
+import { ListItemNode, ListNode } from './';
+/**
+ * Checks the depth of listNode from the root node.
+ * @param listNode - The ListNode to be checked.
+ * @returns The depth of the ListNode.
+ */
+export declare function $getListDepth(listNode: ListNode): number;
+/**
+ * Finds the nearest ancestral ListNode and returns it, throws an invariant if listItem is not a ListItemNode.
+ * @param listItem - The node to be checked.
+ * @returns The ListNode found.
+ */
+export declare function $getTopListNode(listItem: LexicalNode): ListNode;
+/**
+ * Checks if listItem has no child ListNodes and has no ListItemNode ancestors with siblings.
+ * @param listItem - the ListItemNode to be checked.
+ * @returns true if listItem has no child ListNode and no ListItemNode ancestors with siblings, false otherwise.
+ */
+export declare function $isLastItemInList(listItem: ListItemNode): boolean;
+/**
+ * A recursive Depth-First Search (Postorder Traversal) that finds all of a node's children
+ * that are of type ListItemNode and returns them in an array.
+ * @param node - The ListNode to start the search.
+ * @returns An array containing all nodes of type ListItemNode found.
+ */
+export declare function $getAllListItems(node: ListNode): Array<ListItemNode>;
+declare const NestedListNodeBrand: unique symbol;
+/**
+ * Checks to see if the passed node is a ListItemNode and has a ListNode as a child.
+ * @param node - The node to be checked.
+ * @returns true if the node is a ListItemNode and has a ListNode child, false otherwise.
+ */
+export declare function isNestedListNode(node: LexicalNode | null | undefined): node is Spread<{
+    getFirstChild(): ListNode;
+    [NestedListNodeBrand]: never;
+}, ListItemNode>;
+/**
+ * Traverses up the tree and returns the first ListItemNode found.
+ * @param node - Node to start the search.
+ * @returns The first ListItemNode found, or null if none exist.
+ */
+export declare function $findNearestListItemNode(node: LexicalNode): ListItemNode | null;
+/**
+ * Takes a deeply nested ListNode or ListItemNode and traverses up the branch to delete the first
+ * ancestral ListNode (which could be the root ListNode) or ListItemNode with siblings, essentially
+ * bringing the deeply nested node up the branch once. Would remove sublist if it has siblings.
+ * Should not break ListItem -> List -> ListItem chain as empty List/ItemNodes should be removed on .remove().
+ * @param sublist - The nested ListNode or ListItemNode to be brought up the branch.
+ */
+export declare function $removeHighestEmptyListParent(sublist: ListItemNode | ListNode): void;
+/**
+ * Wraps a node into a ListItemNode.
+ * @param node - The node to be wrapped into a ListItemNode
+ * @returns The ListItemNode which the passed node is wrapped in.
+ */
+export declare function $wrapInListItem(node: LexicalNode): ListItemNode;
+export {};