@etrepum/lexical-builder 0.0.4 → 0.0.5

package/dist/index.d.mts

@@ -1,248 +0,0 @@
-/// <reference types="react" />
-/// <reference types="react-dom" />
-/**
- * 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 { CreateEditorArgs, EditorState, LexicalEditor } from "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.
- *
- */
-import { HistoryState } from "@lexical/history";
-import { LexicalComposerContextWithEditor } from "@lexical/react/LexicalComposerContext";
-import * as React from "react";
-import { Root } from "react-dom/client";
-interface AutoFocusConfig {
-    defaultSelection?: "rootStart" | "rootEnd";
-}
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-type AnyLexicalPlan = LexicalPlan<any, string>;
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-type AnyLexicalPlanArgument = LexicalPlanArgument<any, string>;
-type PlanConfigBase = Record<never, never>;
-type NormalizedLexicalPlanArgument<Config extends PlanConfigBase, Name extends string> = [
-    LexicalPlan<Config, Name>,
-    Config,
-    ...Config[]
-];
-interface LexicalPlanRegistry {
-}
-interface RegisterState {
-    signal: AbortSignal;
-    getPeerConfig<Name extends keyof LexicalPlanRegistry>(name: string): undefined | LexicalPlanConfig<LexicalPlanRegistry[Name]>;
-    getDependencyConfig<Dependency extends AnyLexicalPlan>(dep: Dependency): LexicalPlanConfig<Dependency>;
-}
-type LexicalPlanArgument<Config extends PlanConfigBase, Name extends string> = LexicalPlan<Config, Name> | NormalizedLexicalPlanArgument<Config, Name>;
-interface LexicalPlan<Config extends PlanConfigBase = PlanConfigBase, Name extends string = string> {
-    /** The name of the Plan, must be unique */
-    name: Name;
-    /** Plan names that must not be loaded with this Plan */
-    conflictsWith?: string[];
-    /** Other Plans that this Plan depends on, can also be used to configure them */
-    dependencies?: AnyLexicalPlanArgument[];
-    /**
-     * Other Plans, by name, that this Plan can optionally depend on or
-     * configure, if they are directly depended on by another Plan
-     */
-    peerDependencies?: {
-        [k in keyof LexicalPlanRegistry]?: LexicalPeerConfig<k>;
-    };
-    /**
-     * @internal Disable root element events (for internal Meta use)
-     */
-    disableEvents?: CreateEditorArgs["disableEvents"];
-    /**
-     * Used when this editor is nested inside of another editor
-     */
-    parentEditor?: CreateEditorArgs["parentEditor"];
-    /**
-     * The namespace of this Editor. If two editors share the same
-     * namespace, JSON will be the clipboard interchange format.
-     * Otherwise HTML will be used.
-     */
-    namespace?: CreateEditorArgs["namespace"];
-    /**
-     * The nodes that this Plan adds to the Editor configuration, will be merged with other Plans
-     */
-    nodes?: CreateEditorArgs["nodes"];
-    /**
-     * EditorThemeClasses that will be deep merged with other Plans
-     */
-    theme?: CreateEditorArgs["theme"];
-    /**
-     * Overrides for HTML serialization (exportDOM) and
-     * deserialization (importDOM) that does not require subclassing and node
-     * replacement
-     */
-    html?: CreateEditorArgs["html"];
-    /**
-     * Whether the initial state of the editor is editable or not
-     */
-    editable?: CreateEditorArgs["editable"];
-    /**
-     * The editor will catch errors that happen during updates and
-     * reconciliation and call this. It defaults to
-     * `(error) => console.error(error)`.
-     *
-     * @param error The Error object
-     * @param editor The editor that this error came from
-     */
-    onError?: (error: Error, editor: LexicalEditor) => void;
-    /**
-     * The initial EditorState as a JSON string, an EditorState, or a function
-     * to update the editor once.
-     */
-    $initialEditorState?: InitialEditorStateType;
-    /**
-     * The default configuration specific to this Plan
-     */
-    config: Config;
-    /**
-     * By default, Config is shallow merged `{...a, ...b}`, if your Plan
-     * requires other strategies (such as concatenating an Array) you can
-     * implement it here.
-     *
-     * @param a The current configuration
-     * @param b The partial configuration to merge
-     * @returns The merged configuration
-     */
-    mergeConfig?: (a: Config, b?: Partial<Config>) => Config;
-    /**
-     * Add behavior to the editor (register transforms, listeners, etc.) after
-     * the Editor is created.
-     *
-     * @param editor The editor this Plan is being registered with
-     * @param config The merged configuration specific to this Plan
-     * @param state An object containing an AbortSignal that can be
-     *   used, and methods for accessing the merged configuration of
-     *   dependencies and peerDependencies
-     * @returns A clean-up function
-     */
-    register?: (editor: LexicalEditor, config: Config, state: RegisterState) => () => void;
-}
-type LexicalPeerConfig<Name extends keyof LexicalPlanRegistry | string> = [
-    Name
-] extends [
-    keyof LexicalPlanRegistry
-] ? LexicalPlanRegistry[Name] : PlanConfigBase;
-type LexicalPlanConfig<Plan extends AnyLexicalPlan> = Plan["config"];
-type LexicalPlanName<Plan extends AnyLexicalPlan> = Plan["name"];
-interface EditorHandle {
-    editor: LexicalEditor;
-    dispose: () => void;
-}
-type InitialEditorStateType = null | string | EditorState | ((editor: LexicalEditor) => void);
-declare const AutoFocusPlan: LexicalPlan<AutoFocusConfig, "@etrepum/lexical-builder/AutoFocusPlan">;
-declare function definePlan<Config extends PlanConfigBase, Name extends string>(plan: LexicalPlan<Config, Name>): LexicalPlan<Config, Name>;
-declare function configPlan<Plan extends AnyLexicalPlan>(plan: Plan, config: Partial<LexicalPlanConfig<Plan>>): [
-    Plan,
-    Partial<LexicalPlanConfig<Plan>>
-];
-declare const DragonPlan: LexicalPlan<{}, "@lexical/dragon">;
-interface HistoryConfig {
-    delay: number;
-    createInitialHistoryState: () => HistoryState;
-}
-declare const HistoryPlan: LexicalPlan<HistoryConfig, "@etrepum/lexical-builder/HistoryPlan">;
-declare class PlanRep<Plan extends AnyLexicalPlan> {
-    builder: LexicalBuilder;
-    configs: Set<LexicalPlanConfig<Plan>>;
-    _config?: LexicalPlanConfig<Plan>;
-    plan: Plan;
-    constructor(builder: LexicalBuilder, plan: Plan);
-    getPeerConfig<Name extends keyof LexicalPlanRegistry>(name: string): undefined | LexicalPlanConfig<LexicalPlanRegistry[Name]>;
-    getDependencyConfig<Dependency extends AnyLexicalPlan>(dep: Dependency): LexicalPlanConfig<Dependency>;
-    getConfig(): LexicalPlanConfig<Plan>;
-}
-/** @experimental */
-declare class LexicalBuilder {
-    phases: Map<AnyLexicalPlan, PlanRep<AnyLexicalPlan>>[];
-    planMap: Map<AnyLexicalPlan, [
-        number,
-        PlanRep<AnyLexicalPlan>
-    ]>;
-    planNameMap: Map<string, PlanRep<AnyLexicalPlan>>;
-    conflicts: Map<string, string>;
-    constructor();
-    static fromPlans(...args: AnyLexicalPlanArgument[]): LexicalBuilder;
-    buildEditor(): EditorHandle;
-    addPlan(arg: AnyLexicalPlanArgument): number;
-    sortedPlanReps(): Generator<PlanRep<AnyLexicalPlan>, void, undefined>;
-    registerEditor(editor: LexicalEditor): () => void;
-    buildCreateEditorArgs(): Pick<CreateEditorArgs, "disableEvents" | "namespace" | "nodes" | "theme" | "html" | "editable"> & Pick<AnyLexicalPlan, "onError" | "$initialEditorState">;
-}
-declare const PlainTextPlan: LexicalPlan<{}, "@lexical/plain-text">;
-type ErrorBoundaryProps = {
-    children: JSX.Element;
-    onError: (error: Error) => void;
-};
-type ErrorBoundaryType = React.ComponentClass<ErrorBoundaryProps> | React.FC<ErrorBoundaryProps>;
-interface EditorChildrenComponentProps {
-    context: LexicalComposerContextWithEditor;
-    placeholder: null | JSX.Element;
-    contentEditable: null | JSX.Element;
-    children?: React.ReactNode;
-}
-type EditorChildrenComponentType = (props: EditorChildrenComponentProps) => JSX.Element | null;
-interface DecoratorComponentProps {
-    context: LexicalComposerContextWithEditor;
-}
-type DecoratorComponentType = JSX.Element | ((props: DecoratorComponentProps) => JSX.Element | null);
-interface EditorComponentProps {
-    EditorChildrenComponent: EditorChildrenComponentType;
-    children?: React.ReactNode;
-    placeholder: ((isEditable: boolean) => null | JSX.Element) | null | JSX.Element;
-    contentEditable: JSX.Element | null;
-    ErrorBoundary: ErrorBoundaryType;
-}
-type EditorComponentType = (props: Partial<EditorComponentProps>) => JSX.Element;
-interface ReactConfig {
-    contentEditable: JSX.Element | null;
-    placeholder: ((isEditable: boolean) => null | JSX.Element) | null | JSX.Element;
-    ErrorBoundary: ErrorBoundaryType;
-    EditorChildrenComponent: EditorChildrenComponentType;
-    Component: EditorComponentType;
-    getContext: () => LexicalComposerContextWithEditor;
-    decorators: readonly DecoratorComponentType[];
-}
-interface LexicalPlanComposerProps {
-    plan: AnyLexicalPlanArgument;
-    children: React.ReactNode;
-}
-declare function LexicalPlanComposer({ plan, children }: LexicalPlanComposerProps): import("react/jsx-runtime").JSX.Element | null;
-declare const ReactPlan: LexicalPlan<ReactConfig, "@etrepum/lexical-builder/ReactPlan">;
-interface HostMountCommandArg {
-    root: Root;
-}
-type Container = Element | DocumentFragment;
-interface MountPluginCommandArg {
-    key: string;
-    element: JSX.Element | null;
-    domNode?: Container | null;
-}
-declare function mountReactPluginComponent<P extends Record<never, never> = Record<never, never>>(editor: LexicalEditor, opts: {
-    Component: null | React.ComponentType<P>;
-    props: (P & React.Attributes) | null;
-} & Omit<MountPluginCommandArg, "element">): void;
-declare function mountReactPluginElement(editor: LexicalEditor, opts: MountPluginCommandArg): void;
-declare function mountReactPluginHost(editor: LexicalEditor, container: Container): void;
-declare const REACT_PLUGIN_HOST_MOUNT_COMMAND: import("lexical").LexicalCommand<HostMountCommandArg>;
-declare const REACT_MOUNT_PLUGIN_COMMAND: import("lexical").LexicalCommand<MountPluginCommandArg>;
-declare const ReactPluginHostPlan: LexicalPlan<{}, "@etrepum/lexical-builder/ReactPluginHostPlan">;
-declare const RichTextPlan: LexicalPlan<{}, "@lexical/rich-text">;
-/**
- * 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 { AutoFocusConfig, AutoFocusPlan, configPlan, definePlan, DragonPlan, HistoryConfig, HistoryPlan, LexicalBuilder, PlainTextPlan, DecoratorComponentProps, DecoratorComponentType, EditorChildrenComponentProps, EditorChildrenComponentType, EditorComponentProps, EditorComponentType, LexicalPlanComposer, LexicalPlanComposerProps, ReactConfig, ReactPlan, HostMountCommandArg, MountPluginCommandArg, mountReactPluginComponent, mountReactPluginElement, mountReactPluginHost, REACT_MOUNT_PLUGIN_COMMAND, REACT_PLUGIN_HOST_MOUNT_COMMAND, ReactPluginHostPlan, RichTextPlan, AnyLexicalPlan, AnyLexicalPlanArgument, EditorHandle, InitialEditorStateType, LexicalPeerConfig, LexicalPlan, LexicalPlanArgument, LexicalPlanConfig, LexicalPlanName, LexicalPlanRegistry, NormalizedLexicalPlanArgument, PlanConfigBase, RegisterState, ErrorBoundaryType };
-//# sourceMappingURL=index.d.mts.map

package/dist/index.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.mts","sourceRoot":"","sources":["../src/index.ts","../src/types.ts","../src/definePlan.ts","../src/safeCast.ts","../src/AutoFocusPlan.ts","../src/DragonPlan.ts","../src/HistoryPlan.ts","../src/shared/invariant.ts","../src/deepThemeMergeInPlace.ts","../src/initializeEditor.ts","../src/shallowMergeConfig.ts","../src/PlanRep.ts","../src/LexicalBuilder.ts","../src/PlainTextPlan.ts","../src/registerSubscription.ts","../src/registerShowPlaceholder.ts","../src/shared/useLayoutEffect.ts","../src/useReactDecorators.tsx","../src/useRegisterSubscription.ts","../src/ReactPlan.tsx","../src/ReactPluginHostPlan.tsx","../src/RichTextPlan.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;;;;;;GAMG;AAEH,OAAO,k0BAAuC,CAAwB"}