@lexical/extension 0.35.1-nightly.20250925.0

package/AutoFocusExtension.d.ts

@@ -0,0 +1,24 @@
+/**
+ * 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.
+ *
+ */
+export type DefaultSelection = 'rootStart' | 'rootEnd';
+export interface AutoFocusConfig {
+    /**
+     * Where to move the selection when the editor is focused and there is no
+     * existing selection. Can be "rootStart" or "rootEnd" (the default).
+     */
+    defaultSelection: DefaultSelection;
+    /**
+     * The initial state of disabled
+     */
+    disabled: boolean;
+}
+/**
+ * An Extension to focus the LexicalEditor when the root element is set
+ * (typically only when the editor is first created).
+ */
+export declare const AutoFocusExtension: import("lexical").LexicalExtension<AutoFocusConfig, "@lexical/extension/AutoFocus", import("./namedSignals").NamedSignalsOutput<AutoFocusConfig>, unknown>;

package/ClearEditorExtension.d.ts

@@ -0,0 +1,16 @@
+/**
+ * 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 { LexicalEditor } from 'lexical';
+export interface ClearEditorConfig {
+    $onClear: () => void;
+}
+export declare function registerClearEditor(editor: LexicalEditor, $onClear?: () => void): () => void;
+/**
+ * An extension to provide an implementation of {@link CLEAR_EDITOR_COMMAND}
+ */
+export declare const ClearEditorExtension: import("lexical").LexicalExtension<ClearEditorConfig, "@lexical/extension/ClearEditor", import("./namedSignals").NamedSignalsOutput<ClearEditorConfig>, unknown>;

package/EditorStateExtension.d.ts

@@ -0,0 +1,4 @@
+/**
+ * An extension to provide the current EditorState as a signal
+ */
+export declare const EditorStateExtension: import("lexical").LexicalExtension<import("lexical").ExtensionConfigBase, "@lexical/extension/EditorState", import("@preact/signals-core").Signal<import("lexical").EditorState>, unknown>;

package/ExtensionRep.d.ts

@@ -0,0 +1,91 @@
+/**
+ * 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 { LexicalBuilder } from './LexicalBuilder';
+import type { AnyLexicalExtension, ExtensionBuildState, ExtensionInitState, ExtensionRegisterState, InitialEditorConfig, LexicalEditor, LexicalExtensionConfig, LexicalExtensionDependency, LexicalExtensionInit, LexicalExtensionOutput } from 'lexical';
+export declare const ExtensionRepStateIds: {
+    readonly unmarked: 0;
+    readonly temporary: 1;
+    readonly permanent: 2;
+    readonly configured: 3;
+    readonly initialized: 4;
+    readonly built: 5;
+    readonly registered: 6;
+    readonly afterRegistration: 7;
+};
+interface UnmarkedState {
+    id: (typeof ExtensionRepStateIds)['unmarked'];
+}
+interface TemporaryState {
+    id: (typeof ExtensionRepStateIds)['temporary'];
+}
+interface PermanentState {
+    id: (typeof ExtensionRepStateIds)['permanent'];
+}
+interface ConfiguredState<Extension extends AnyLexicalExtension> {
+    id: (typeof ExtensionRepStateIds)['configured'];
+    config: LexicalExtensionConfig<Extension>;
+    registerState: ExtensionInitState;
+}
+interface InitializedState<Extension extends AnyLexicalExtension> extends Omit<ConfiguredState<Extension>, 'id' | 'registerState'> {
+    id: (typeof ExtensionRepStateIds)['initialized'];
+    initResult: LexicalExtensionInit<Extension>;
+    registerState: ExtensionBuildState<LexicalExtensionInit<Extension>>;
+}
+interface BuiltState<Extension extends AnyLexicalExtension> extends Omit<ConfiguredState<Extension>, 'id' | 'registerState'> {
+    id: (typeof ExtensionRepStateIds)['built'];
+    initResult: LexicalExtensionInit<Extension>;
+    output: LexicalExtensionOutput<Extension>;
+    registerState: ExtensionRegisterState<LexicalExtensionInit<Extension>, LexicalExtensionOutput<Extension>>;
+}
+interface RegisteredState<Extension extends AnyLexicalExtension> extends Omit<BuiltState<Extension>, 'id'> {
+    id: (typeof ExtensionRepStateIds)['registered'];
+}
+interface AfterRegistrationState<Extension extends AnyLexicalExtension> extends Omit<RegisteredState<Extension>, 'id'> {
+    id: (typeof ExtensionRepStateIds)['afterRegistration'];
+}
+export type ExtensionRepState<Extension extends AnyLexicalExtension> = UnmarkedState | TemporaryState | PermanentState | ConfiguredState<Extension> | InitializedState<Extension> | BuiltState<Extension> | RegisteredState<Extension> | AfterRegistrationState<Extension>;
+export declare function isExactlyUnmarkedExtensionRepState<Extension extends AnyLexicalExtension>(state: ExtensionRepState<Extension>): state is UnmarkedState;
+export declare function isExactlyPermanentExtensionRepState<Extension extends AnyLexicalExtension>(state: ExtensionRepState<Extension>): state is PermanentState;
+export declare function applyTemporaryMark<Extension extends AnyLexicalExtension>(state: ExtensionRepState<Extension>): TemporaryState;
+export declare function applyPermanentMark<Extension extends AnyLexicalExtension>(state: ExtensionRepState<Extension>): PermanentState;
+export declare function applyConfiguredState<Extension extends AnyLexicalExtension>(state: PermanentState, config: LexicalExtensionConfig<Extension>, registerState: ExtensionInitState): ConfiguredState<Extension>;
+export declare function applyInitializedState<Extension extends AnyLexicalExtension>(state: ConfiguredState<Extension>, initResult: LexicalExtensionInit<Extension>, registerState: ExtensionBuildState<LexicalExtensionInit<Extension>>): InitializedState<Extension>;
+export declare function applyBuiltState<Extension extends AnyLexicalExtension>(state: InitializedState<Extension>, output: LexicalExtensionOutput<Extension>, registerState: ExtensionRegisterState<LexicalExtensionInit<Extension>, LexicalExtensionOutput<Extension>>): BuiltState<Extension>;
+export declare function applyRegisteredState<Extension extends AnyLexicalExtension>(state: BuiltState<Extension>): never;
+export declare function applyAfterRegistrationState<Extension extends AnyLexicalExtension>(state: RegisteredState<Extension>): AfterRegistrationState<Extension>;
+export declare function rollbackToBuiltState<Extension extends AnyLexicalExtension>(state: AfterRegistrationState<Extension>): BuiltState<Extension>;
+/**
+ * @internal
+ */
+export declare class ExtensionRep<Extension extends AnyLexicalExtension> {
+    builder: LexicalBuilder;
+    configs: Set<Partial<LexicalExtensionConfig<Extension>>>;
+    _dependency?: LexicalExtensionDependency<Extension>;
+    _peerNameSet?: Set<string>;
+    extension: Extension;
+    state: ExtensionRepState<Extension>;
+    _signal?: AbortSignal;
+    constructor(builder: LexicalBuilder, extension: Extension);
+    mergeConfigs(): LexicalExtensionConfig<Extension>;
+    init(editorConfig: InitialEditorConfig): void;
+    build(editor: LexicalEditor): void;
+    register(editor: LexicalEditor, signal: AbortSignal): undefined | (() => void);
+    afterRegistration(editor: LexicalEditor): undefined | (() => void);
+    getSignal(): AbortSignal;
+    getInitResult(): LexicalExtensionInit<Extension>;
+    getInitPeer<PeerExtension extends AnyLexicalExtension = never>(name: PeerExtension['name']): undefined | Omit<LexicalExtensionDependency<PeerExtension>, 'output' | 'init'>;
+    getExtensionInitDependency(): Omit<LexicalExtensionDependency<Extension>, 'output' | 'init'>;
+    getPeer<PeerExtension extends AnyLexicalExtension = never>(name: PeerExtension['name']): undefined | LexicalExtensionDependency<PeerExtension>;
+    getInitDependency<Dependency extends AnyLexicalExtension>(dep: Dependency): Omit<LexicalExtensionDependency<Dependency>, 'output' | 'init'>;
+    getDependency<Dependency extends AnyLexicalExtension>(dep: Dependency): LexicalExtensionDependency<Dependency>;
+    getState(): AfterRegistrationState<Extension>;
+    getDirectDependentNames(): ReadonlySet<string>;
+    getPeerNameSet(): ReadonlySet<string>;
+    getExtensionDependency(): LexicalExtensionDependency<Extension>;
+}
+export {};

package/HorizontalRuleExtension.d.ts

@@ -0,0 +1,29 @@
+/**
+ * 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 { DOMConversionMap, DOMExportOutput, EditorConfig, LexicalCommand, LexicalNode, SerializedLexicalNode } from 'lexical';
+import { DecoratorNode } from 'lexical';
+export type SerializedHorizontalRuleNode = SerializedLexicalNode;
+export declare const INSERT_HORIZONTAL_RULE_COMMAND: LexicalCommand<void>;
+export declare class HorizontalRuleNode extends DecoratorNode<unknown> {
+    static getType(): string;
+    static clone(node: HorizontalRuleNode): HorizontalRuleNode;
+    static importJSON(serializedNode: SerializedHorizontalRuleNode): HorizontalRuleNode;
+    static importDOM(): DOMConversionMap | null;
+    exportDOM(): DOMExportOutput;
+    createDOM(config: EditorConfig): HTMLElement;
+    getTextContent(): string;
+    isInline(): false;
+    updateDOM(): boolean;
+}
+export declare function $createHorizontalRuleNode(): HorizontalRuleNode;
+export declare function $isHorizontalRuleNode(node: LexicalNode | null | undefined): node is HorizontalRuleNode;
+/**
+ * An extension for HorizontalRuleNode that provides an implementation that
+ * works without any React dependency.
+ */
+export declare const HorizontalRuleExtension: import("lexical").LexicalExtension<import("lexical").ExtensionConfigBase, "@lexical/extension/HorizontalRule", unknown, unknown>;

package/InitialStateExtension.d.ts

@@ -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.
+ *
+ */
+import { type EditorSetOptions, type EditorUpdateOptions } from 'lexical';
+export interface InitialStateConfig {
+    updateOptions: EditorUpdateOptions;
+    setOptions: EditorSetOptions;
+}
+/**
+ * An extension to set the initial state of the editor from
+ * a function or serialized JSON EditorState. This is
+ * implicitly included with all editors built with
+ * Lexical Extension. This happens in the `afterRegistration`
+ * phase so your initial state may depend on registered commands,
+ * but you should not call `editor.setRootElement` earlier than
+ * this phase to avoid rendering an empty editor first.
+ */
+export declare const InitialStateExtension: import("lexical").LexicalExtension<InitialStateConfig, "@lexical/extension/InitialState", unknown, {
+    $initialEditorState: import("lexical").InitialEditorStateType;
+    initialized: boolean;
+}>;

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

@@ -0,0 +1,76 @@
+/**
+ * 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 AnyLexicalExtension, type AnyLexicalExtensionArgument, type AnyNormalizedLexicalExtensionArgument, type InitialEditorConfig, type LexicalEditor, type LexicalEditorWithDispose, type LexicalExtensionConfig } from 'lexical';
+import { ExtensionRep } from './ExtensionRep';
+/** @internal Use a well-known symbol for dev tools purposes */
+export declare const builderSymbol: unique symbol;
+/**
+ * Build a LexicalEditor by combining together one or more extensions, optionally
+ * overriding some of their configuration.
+ *
+ * @param extensions - Extension arguments (extensions or extensions with config overrides)
+ * @returns An editor handle
+ *
+ * @example
+ * A single root extension with multiple dependencies
+ *
+ * ```ts
+ * const editor = buildEditorFromExtensions(
+ *   defineExtension({
+ *     name: "[root]",
+ *     dependencies: [
+ *       RichTextExtension,
+ *       configExtension(EmojiExtension, { emojiBaseUrl: "/assets/emoji" }),
+ *     ],
+ *     register: (editor: LexicalEditor) => {
+ *       console.log("Editor Created");
+ *       return () => console.log("Editor Disposed");
+ *     },
+ *   }),
+ * );
+ * ```
+ *
+ * @example
+ * A very similar minimal configuration without the register hook
+ *
+ * ```ts
+ * const editor = buildEditorFromExtensions(
+ *   RichTextExtension,
+ *   configExtension(EmojiExtension, { emojiBaseUrl: "/assets/emoji" }),
+ * );
+ * ```
+ */
+export declare function buildEditorFromExtensions(...extensions: AnyLexicalExtensionArgument[]): LexicalEditorWithDispose;
+interface WithBuilder {
+    [builderSymbol]?: LexicalBuilder | undefined;
+}
+/** @internal */
+export declare class LexicalBuilder {
+    roots: readonly AnyNormalizedLexicalExtensionArgument[];
+    extensionNameMap: Map<string, ExtensionRep<AnyLexicalExtension>>;
+    outgoingConfigEdges: Map<string, Map<string, LexicalExtensionConfig<AnyLexicalExtension>[]>>;
+    incomingEdges: Map<string, Set<string>>;
+    conflicts: Map<string, string>;
+    _sortedExtensionReps?: readonly ExtensionRep<AnyLexicalExtension>[];
+    PACKAGE_VERSION: string;
+    constructor(roots: AnyNormalizedLexicalExtensionArgument[]);
+    static fromExtensions(extensions: AnyLexicalExtensionArgument[]): LexicalBuilder;
+    static maybeFromEditor(editor: LexicalEditor): undefined | LexicalBuilder;
+    /** Look up the editor that was created by this LexicalBuilder or throw */
+    static fromEditor(editor: LexicalEditor): LexicalBuilder;
+    constructEditor(): LexicalEditor & WithBuilder;
+    buildEditor(): LexicalEditorWithDispose;
+    hasExtensionByName(name: string): boolean;
+    getExtensionRep<Extension extends AnyLexicalExtension>(extension: Extension): ExtensionRep<Extension> | undefined;
+    addEdge(fromExtensionName: string, toExtensionName: string, configs: LexicalExtensionConfig<AnyLexicalExtension>[]): void;
+    addExtension(arg: AnyLexicalExtensionArgument): void;
+    sortedExtensionReps(): readonly ExtensionRep<AnyLexicalExtension>[];
+    registerEditor(editor: LexicalEditor): () => void;
+    buildCreateEditorArgs(): InitialEditorConfig;
+}
+export {};