@etrepum/lexical-builder 0.0.0

package/README.md

@@ -0,0 +1,3 @@
+# `@etrepum/lexical-builder`
+
+**EXPERIMENTAL** A high-level way to manage Lexical config and plug-ins for any framework

package/dist/index.d.mts

@@ -0,0 +1,247 @@
+/// <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;
+    setComponent: (component: undefined | EditorComponentType, context: LexicalComposerContextWithEditor) => void;
+    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

@@ -0,0 +1 @@
+{"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"}