@etrepum/lexical-builder-core 0.0.36-nightly.20250714.0 → 0.0.36

package/README.md

@@ -3,5 +3,5 @@
 **EXPERIMENTAL** Lexical Builder Core
 
 This is the lightweight part of Lexical Builder that should be adopted
-into the lexical package to make it possible to define plans without
+into the lexical package to make it possible to define extensions without
 any overhead of including the builder runtime.

package/dist/defineExtension.d.ts

@@ -0,0 +1,130 @@
+import { AnyLexicalExtension, LexicalExtension, LexicalExtensionConfig, NormalizedLexicalExtensionArgument, NormalizedPeerDependency, ExtensionConfigBase, RegisterCleanup } from './types';
+/**
+ * Define a LexicalExtension from the given object literal. TypeScript will
+ * infer Config and Name in most cases, but you may want to use
+ * {@link safeCast} for config if there are default fields or varying types.
+ *
+ * @param extension - The LexicalExtension
+ * @returns The unmodified extension argument (this is only an inference helper)
+ *
+ * @example Basic example
+ * ```ts
+ * export const MyExtension = defineExtension({
+ *   // Extension names must be unique in an editor
+ *   name: "my",
+ *   nodes: [MyNode],
+ * });
+ * ```
+ *
+ * @example Extension with optional configuration
+ * ```ts
+ * export interface ConfigurableConfig {
+ *   optional?: string;
+ *   required: number;
+ * }
+ * export const ConfigurableExtension = defineExtension({
+ *   name: "configurable",
+ *   // The Extension's config must satisfy the full config type,
+ *   // but using the Extension as a dependency never requires
+ *   // configuration and any partial of the config can be specified
+ *   config: safeCast<ConfigurableConfig>({ required: 1 }),
+ * });
+ * ```
+ */
+export declare function defineExtension<Config extends ExtensionConfigBase, Name extends string, Output, Init>(extension: LexicalExtension<Config, Name, Output, Init>): LexicalExtension<Config, Name, Output, Init>;
+/**
+ * Override a partial of the configuration of an Extension, to be used
+ * in the dependencies array of another extension, or as
+ * an argument to {@link buildEditorFromExtensions}.
+ *
+ * Before building the editor, configurations will be merged using
+ * extension.mergeConfig(extension, config) or {@link shallowMergeConfig} if
+ * this is not directly implemented by the Extension.
+ *
+ * @param args - An extension followed by one or more config partials for that extension
+ * @returns [extension, config, ...configs]
+ *
+ * @example
+ * ```ts
+ * export const ReactDecoratorExtension = defineExtension({
+ *   name: "react-decorator",
+ *   dependencies: [
+ *     configExtension(ReactExtension, {
+ *       decorators: [<ReactDecorator />]
+ *     }),
+ *   ],
+ * });
+ * ```
+ */
+export declare function configExtension<Config extends ExtensionConfigBase, Name extends string, Output, Init>(...args: NormalizedLexicalExtensionArgument<Config, Name, Output, Init>): NormalizedLexicalExtensionArgument<Config, Name, Output, Init>;
+/**
+ * Provide output from the register function of an Extension
+ *
+ * @returns A cleanup function
+ *
+ * @example Provide output with no other cleanup
+ * ```ts
+ * // This is entirely optional and would be inferred correctly, but
+ * // it can be useful for documentation!
+ * export interface RegisteredAtOutput {
+ *   registered_at: number;
+ * }
+ * export const RegisteredAtExtension = defineExtension({
+ *   name: "RegisteredAt",
+ *   register(editor) {
+ *     return provideOutput<RegisteredAtOutput>({ registered_at: Date.now() });
+ *   },
+ * });
+ * ```
+ *
+ * @example Provide output with other cleanup
+ * ```ts
+ * export interface UniqueCommandOutput {
+ *   command: LexicalCommand<unknown>;
+ * }
+ * export const UniqueCommandExtension = defineExtension({
+ *   name: 'UniqueCommand',
+ *   register(editor) {
+ *     const output: UniqueCommnadOutput = {command: createCommand('UNIQUE_COMMAND')};
+ *     const cleanup = registerCommand(
+ *       command,
+ *       (_payload) => {
+ *         console.log('Unique command received!');
+ *         return true;
+ *       }
+ *       COMMAND_PRIORITY_EDITOR
+ *     );
+ *     return provideOutput(output, cleanup);
+ *   },
+ * });
+ * ```
+ *
+ */
+export declare function provideOutput<Output>(output: Output, cleanup?: () => void): RegisterCleanup<Output>;
+/** @internal */
+export declare const PeerDependencyBrand: unique symbol;
+export declare const ConfigTypeId: unique symbol;
+export declare const OutputTypeId: unique symbol;
+/**
+ * Used to declare a peer dependency of an extension in a type-safe way,
+ * requires the type parameter. The most common use case for peer dependencies
+ * is to avoid a direct import dependency, so you would want to use a
+ * type import or the import type (shown in below examples).
+ *
+ * @param name - The extension's name
+ * @param config - An optional config override
+ * @returns NormalizedPeerDependency
+ *
+ * @example
+ * ```ts
+ * export const PeerExtension = defineExtension({
+ *   name: 'PeerExtension',
+ *   peerDependencies: [
+ *     declarePeerDependency<typeof import("foo").FooExtension>("foo"),
+ *     declarePeerDependency<typeof import("bar").BarExtension>("bar", {config: "bar"}),
+ *   ],
+ * });
+ * ```
+ */
+export declare function declarePeerDependency<Extension extends AnyLexicalExtension = never>(name: Extension["name"], config?: Partial<LexicalExtensionConfig<Extension>>): NormalizedPeerDependency<Extension>;
+//# sourceMappingURL=defineExtension.d.ts.map

package/dist/defineExtension.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"defineExtension.d.ts","sourceRoot":"","sources":["../src/defineExtension.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,EACV,mBAAmB,EACnB,gBAAgB,EAChB,sBAAsB,EACtB,kCAAkC,EAClC,wBAAwB,EACxB,mBAAmB,EACnB,eAAe,EAChB,MAAM,SAAS,CAAC;AAEjB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,wBAAgB,eAAe,CAC7B,MAAM,SAAS,mBAAmB,EAClC,IAAI,SAAS,MAAM,EACnB,MAAM,EACN,IAAI,EAEJ,SAAS,EAAE,gBAAgB,CAAC,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,CAAC,GACtD,gBAAgB,CAAC,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,CAAC,CAE9C;AAED;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAgB,eAAe,CAC7B,MAAM,SAAS,mBAAmB,EAClC,IAAI,SAAS,MAAM,EACnB,MAAM,EACN,IAAI,EAEJ,GAAG,IAAI,EAAE,kCAAkC,CAAC,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,CAAC,GACtE,kCAAkC,CAAC,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,CAAC,CAEhE;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0CG;AACH,wBAAgB,aAAa,CAAC,MAAM,EAClC,MAAM,EAAE,MAAM,EACd,OAAO,CAAC,EAAE,MAAM,IAAI,GACnB,eAAe,CAAC,MAAM,CAAC,CAOzB;AAED,gBAAgB;AAChB,eAAO,MAAM,mBAAmB,EAAE,OAAO,MAExC,CAAC;AACF,eAAO,MAAM,YAAY,EAAE,OAAO,MAEjC,CAAC;AACF,eAAO,MAAM,YAAY,EAAE,OAAO,MAEjC,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,qBAAqB,CAAC,SAAS,SAAS,mBAAmB,GAAG,KAAK,EACjF,IAAI,EAAE,SAAS,CAAC,MAAM,CAAC,EACvB,MAAM,CAAC,EAAE,OAAO,CAAC,sBAAsB,CAAC,SAAS,CAAC,CAAC,GAClD,wBAAwB,CAAC,SAAS,CAAC,CAErC"}

package/dist/index.d.ts

@@ -6,9 +6,9 @@
  *
  */
 export declare const PACKAGE_VERSION: string;
-export { configPlan, definePlan, provideOutput, declarePeerDependency, } from './definePlan';
-export { type AnyLexicalPlan, type AnyLexicalPlanArgument, type AnyNormalizedLexicalPlanArgument, type LexicalEditorWithDispose, type InitialEditorConfig, type InitialEditorStateType, type LexicalPlan, type LexicalPlanArgument, type LexicalPlanConfig, type LexicalPlanInit, type LexicalPlanName, type LexicalPlanOutput, type OutputComponentPlan, type LexicalPlanDependency, type NormalizedLexicalPlanArgument, type PlanConfigBase, type PlanInitState, type PlanRegisterState, type RegisterCleanup, type NormalizedPeerDependency, } from './types';
-export { type LexicalPlanInternal, type initTypeSymbol, type configTypeSymbol, type outputTypeSymbol, } from './internal';
+export { configExtension, defineExtension, provideOutput, declarePeerDependency, } from './defineExtension';
+export { type AnyLexicalExtension, type AnyLexicalExtensionArgument, type AnyNormalizedLexicalExtensionArgument, type LexicalEditorWithDispose, type InitialEditorConfig, type InitialEditorStateType, type LexicalExtension, type LexicalExtensionArgument, type LexicalExtensionConfig, type LexicalExtensionInit, type LexicalExtensionName, type LexicalExtensionOutput, type OutputComponentExtension, type LexicalExtensionDependency, type NormalizedLexicalExtensionArgument, type ExtensionConfigBase, type ExtensionInitState, type ExtensionRegisterState, type RegisterCleanup, type NormalizedPeerDependency, } from './types';
+export { type LexicalExtensionInternal, type initTypeSymbol, type configTypeSymbol, type outputTypeSymbol, } from './internal';
 export { safeCast } from './safeCast';
 export { shallowMergeConfig } from './shallowMergeConfig';
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,eAAO,MAAM,eAAe,EAAE,MAAwC,CAAC;AAEvE,OAAO,EACL,UAAU,EACV,UAAU,EACV,aAAa,EACb,qBAAqB,GACtB,MAAM,cAAc,CAAC;AACtB,OAAO,EACL,KAAK,cAAc,EACnB,KAAK,sBAAsB,EAC3B,KAAK,gCAAgC,EACrC,KAAK,wBAAwB,EAC7B,KAAK,mBAAmB,EACxB,KAAK,sBAAsB,EAC3B,KAAK,WAAW,EAChB,KAAK,mBAAmB,EACxB,KAAK,iBAAiB,EACtB,KAAK,eAAe,EACpB,KAAK,eAAe,EACpB,KAAK,iBAAiB,EACtB,KAAK,mBAAmB,EACxB,KAAK,qBAAqB,EAC1B,KAAK,6BAA6B,EAClC,KAAK,cAAc,EACnB,KAAK,aAAa,EAClB,KAAK,iBAAiB,EACtB,KAAK,eAAe,EACpB,KAAK,wBAAwB,GAC9B,MAAM,SAAS,CAAC;AACjB,OAAO,EACL,KAAK,mBAAmB,EACxB,KAAK,cAAc,EACnB,KAAK,gBAAgB,EACrB,KAAK,gBAAgB,GACtB,MAAM,YAAY,CAAC;AACpB,OAAO,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AACtC,OAAO,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,eAAO,MAAM,eAAe,EAAE,MAAwC,CAAC;AAEvE,OAAO,EACL,eAAe,EACf,eAAe,EACf,aAAa,EACb,qBAAqB,GACtB,MAAM,mBAAmB,CAAC;AAC3B,OAAO,EACL,KAAK,mBAAmB,EACxB,KAAK,2BAA2B,EAChC,KAAK,qCAAqC,EAC1C,KAAK,wBAAwB,EAC7B,KAAK,mBAAmB,EACxB,KAAK,sBAAsB,EAC3B,KAAK,gBAAgB,EACrB,KAAK,wBAAwB,EAC7B,KAAK,sBAAsB,EAC3B,KAAK,oBAAoB,EACzB,KAAK,oBAAoB,EACzB,KAAK,sBAAsB,EAC3B,KAAK,wBAAwB,EAC7B,KAAK,0BAA0B,EAC/B,KAAK,kCAAkC,EACvC,KAAK,mBAAmB,EACxB,KAAK,kBAAkB,EACvB,KAAK,sBAAsB,EAC3B,KAAK,eAAe,EACpB,KAAK,wBAAwB,GAC9B,MAAM,SAAS,CAAC;AACjB,OAAO,EACL,KAAK,wBAAwB,EAC7B,KAAK,cAAc,EACnB,KAAK,gBAAgB,EACrB,KAAK,gBAAgB,GACtB,MAAM,YAAY,CAAC;AACpB,OAAO,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AACtC,OAAO,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,CAAC"}

package/dist/index.js

@@ -1,4 +1,4 @@
-function e(n) {
+function u(n) {
   return n;
 }
 function r(...n) {
@@ -12,27 +12,27 @@ function f(n, t) {
     { output: n }
   );
 }
-function c(n, t) {
+function i(n, t) {
   return [n, t];
 }
-function i(n) {
+function o(n) {
   return n;
 }
-function a(n, t) {
+function c(n, t) {
   if (!t || n === t)
     return n;
-  for (const u in t)
-    if (n[u] !== t[u])
+  for (const e in t)
+    if (n[e] !== t[e])
       return { ...n, ...t };
   return n;
 }
-const o = "0.0.36-nightly.20250714.0";
+const s = "0.0.36";
 export {
-  o as PACKAGE_VERSION,
-  r as configPlan,
-  c as declarePeerDependency,
-  e as definePlan,
+  s as PACKAGE_VERSION,
+  r as configExtension,
+  i as declarePeerDependency,
+  u as defineExtension,
   f as provideOutput,
-  i as safeCast,
-  a as shallowMergeConfig
+  o as safeCast,
+  c as shallowMergeConfig
 };

package/dist/internal.d.ts

@@ -15,7 +15,7 @@ export declare const initTypeSymbol: unique symbol;
 /** @internal */
 export type initTypeSymbol = typeof initTypeSymbol;
 /** @internal */
-export interface LexicalPlanInternal<out Config, out Output, out Init> {
+export interface LexicalExtensionInternal<out Config, out Output, out Init> {
     /** @internal */
     readonly [configTypeSymbol]?: Config;
     /** @internal */

package/dist/internal.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"internal.d.ts","sourceRoot":"","sources":["../src/internal.ts"],"names":[],"mappings":"AACA,gBAAgB;AAChB,MAAM,CAAC,OAAO,CAAC,MAAM,oBAAoB,EAAE,OAAO,MAAM,CAAC;AACzD,gBAAgB;AAChB,MAAM,MAAM,oBAAoB,GAAG,OAAO,oBAAoB,CAAC;AAC/D,gBAAgB;AAChB,MAAM,CAAC,OAAO,CAAC,MAAM,gBAAgB,EAAE,OAAO,MAAM,CAAC;AACrD,gBAAgB;AAChB,MAAM,MAAM,gBAAgB,GAAG,OAAO,gBAAgB,CAAC;AACvD,gBAAgB;AAChB,MAAM,CAAC,OAAO,CAAC,MAAM,gBAAgB,EAAE,OAAO,MAAM,CAAC;AACrD,gBAAgB;AAChB,MAAM,MAAM,gBAAgB,GAAG,OAAO,gBAAgB,CAAC;AACvD,gBAAgB;AAChB,MAAM,CAAC,OAAO,CAAC,MAAM,cAAc,EAAE,OAAO,MAAM,CAAC;AACnD,gBAAgB;AAChB,MAAM,MAAM,cAAc,GAAG,OAAO,cAAc,CAAC;AAEnD,gBAAgB;AAChB,MAAM,WAAW,mBAAmB,CAAC,GAAG,CAAC,MAAM,EAAE,GAAG,CAAC,MAAM,EAAE,GAAG,CAAC,IAAI;IACnE,gBAAgB;IAChB,QAAQ,CAAC,CAAC,gBAAgB,CAAC,CAAC,EAAE,MAAM,CAAC;IACrC,gBAAgB;IAChB,QAAQ,CAAC,CAAC,gBAAgB,CAAC,CAAC,EAAE,MAAM,CAAC;IACrC,gBAAgB;IAChB,QAAQ,CAAC,CAAC,cAAc,CAAC,CAAC,EAAE,IAAI,CAAC;CAClC"}
+{"version":3,"file":"internal.d.ts","sourceRoot":"","sources":["../src/internal.ts"],"names":[],"mappings":"AACA,gBAAgB;AAChB,MAAM,CAAC,OAAO,CAAC,MAAM,oBAAoB,EAAE,OAAO,MAAM,CAAC;AACzD,gBAAgB;AAChB,MAAM,MAAM,oBAAoB,GAAG,OAAO,oBAAoB,CAAC;AAC/D,gBAAgB;AAChB,MAAM,CAAC,OAAO,CAAC,MAAM,gBAAgB,EAAE,OAAO,MAAM,CAAC;AACrD,gBAAgB;AAChB,MAAM,MAAM,gBAAgB,GAAG,OAAO,gBAAgB,CAAC;AACvD,gBAAgB;AAChB,MAAM,CAAC,OAAO,CAAC,MAAM,gBAAgB,EAAE,OAAO,MAAM,CAAC;AACrD,gBAAgB;AAChB,MAAM,MAAM,gBAAgB,GAAG,OAAO,gBAAgB,CAAC;AACvD,gBAAgB;AAChB,MAAM,CAAC,OAAO,CAAC,MAAM,cAAc,EAAE,OAAO,MAAM,CAAC;AACnD,gBAAgB;AAChB,MAAM,MAAM,cAAc,GAAG,OAAO,cAAc,CAAC;AAEnD,gBAAgB;AAChB,MAAM,WAAW,wBAAwB,CAAC,GAAG,CAAC,MAAM,EAAE,GAAG,CAAC,MAAM,EAAE,GAAG,CAAC,IAAI;IACxE,gBAAgB;IAChB,QAAQ,CAAC,CAAC,gBAAgB,CAAC,CAAC,EAAE,MAAM,CAAC;IACrC,gBAAgB;IAChB,QAAQ,CAAC,CAAC,gBAAgB,CAAC,CAAC,EAAE,MAAM,CAAC;IACrC,gBAAgB;IAChB,QAAQ,CAAC,CAAC,cAAc,CAAC,CAAC,EAAE,IAAI,CAAC;CAClC"}

package/dist/safeCast.d.ts

@@ -8,7 +8,7 @@
 /**
  * Explicitly and safely cast a value to a specific type when inference or
  * satisfies isn't going to work as expected (often useful for the config
- * property with definePlan)
+ * property with defineExtension)
  */
 export declare function safeCast<T>(value: T): T;
 //# sourceMappingURL=safeCast.d.ts.map

package/dist/shallowMergeConfig.d.ts

@@ -1,10 +1,10 @@
-import { PlanConfigBase } from './types';
+import { ExtensionConfigBase } from './types';
 /**
- * The default merge strategy for plan configuration is a shallow merge.
+ * The default merge strategy for extension configuration is a shallow merge.
  *
  * @param config - A full config
  * @param overrides - A partial config of overrides
  * @returns config if there are no overrides, otherwise `{...config, ...overrides}`
  */
-export declare function shallowMergeConfig<T extends PlanConfigBase>(config: T, overrides?: Partial<T>): T;
+export declare function shallowMergeConfig<T extends ExtensionConfigBase>(config: T, overrides?: Partial<T>): T;
 //# sourceMappingURL=shallowMergeConfig.d.ts.map

package/dist/shallowMergeConfig.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shallowMergeConfig.d.ts","sourceRoot":"","sources":["../src/shallowMergeConfig.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,SAAS,CAAC;AAE9C;;;;;;GAMG;AACH,wBAAgB,kBAAkB,CAAC,CAAC,SAAS,cAAc,EACzD,MAAM,EAAE,CAAC,EACT,SAAS,CAAC,EAAE,OAAO,CAAC,CAAC,CAAC,GACrB,CAAC,CAUH"}
+{"version":3,"file":"shallowMergeConfig.d.ts","sourceRoot":"","sources":["../src/shallowMergeConfig.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,SAAS,CAAC;AAEnD;;;;;;GAMG;AACH,wBAAgB,kBAAkB,CAAC,CAAC,SAAS,mBAAmB,EAC9D,MAAM,EAAE,CAAC,EACT,SAAS,CAAC,EAAE,OAAO,CAAC,CAAC,CAAC,GACrB,CAAC,CAUH"}

package/dist/types.d.ts

@@ -1,87 +1,87 @@
 import { CreateEditorArgs, EditorState, LexicalEditor } from 'lexical';
-import { LexicalPlanInternal, peerDependencySymbol, configTypeSymbol, outputTypeSymbol, initTypeSymbol } from './internal';
+import { LexicalExtensionInternal, peerDependencySymbol, configTypeSymbol, outputTypeSymbol, initTypeSymbol } from './internal';
 /**
- * Any concrete {@link LexicalPlan}
+ * Any concrete {@link LexicalExtension}
  */
-export type AnyLexicalPlan = LexicalPlan<any, string, any, any>;
+export type AnyLexicalExtension = LexicalExtension<any, string, any, any>;
 /**
- * Any {@link LexicalPlan} or {@link NormalizedLexicalPlanArgument}
+ * Any {@link LexicalExtension} or {@link NormalizedLexicalExtensionArgument}
  */
-export type AnyLexicalPlanArgument = AnyLexicalPlan | AnyNormalizedLexicalPlanArgument;
+export type AnyLexicalExtensionArgument = AnyLexicalExtension | AnyNormalizedLexicalExtensionArgument;
 /**
- * The default plan configuration of an empty object
+ * The default extension configuration of an empty object
  */
-export type PlanConfigBase = Record<never, never>;
-export type NormalizedPeerDependency<Plan extends AnyLexicalPlan> = [
-    Plan["name"],
-    Partial<LexicalPlanConfig<Plan>> | undefined
+export type ExtensionConfigBase = Record<never, never>;
+export type NormalizedPeerDependency<Extension extends AnyLexicalExtension> = [
+    Extension["name"],
+    Partial<LexicalExtensionConfig<Extension>> | undefined
 ] & {
-    readonly [peerDependencySymbol]: Plan;
+    readonly [peerDependencySymbol]: Extension;
 };
 /**
- * Any {@link NormalizedLexicalPlanArgument}
+ * Any {@link NormalizedLexicalExtensionArgument}
  */
-export type NormalizedLexicalPlanArgument<in out Config extends PlanConfigBase, out Name extends string, in out Output, in out Init> = [LexicalPlan<Config, Name, Output, Init>, ...Partial<Config>[]];
+export type NormalizedLexicalExtensionArgument<in out Config extends ExtensionConfigBase, out Name extends string, in out Output, in out Init> = [LexicalExtension<Config, Name, Output, Init>, ...Partial<Config>[]];
 /**
- * A tuple of [plan, ...configOverrides]
+ * A tuple of [extension, ...configOverrides]
  */
-export type AnyNormalizedLexicalPlanArgument = NormalizedLexicalPlanArgument<any, string, any, any>;
+export type AnyNormalizedLexicalExtensionArgument = NormalizedLexicalExtensionArgument<any, string, any, any>;
 /**
  * An object that the register method can use to detect unmount and access the
- * configuration for plan dependencies
+ * configuration for extension dependencies
  */
-export interface PlanInitState {
+export interface ExtensionInitState {
     /** An AbortSignal that is aborted when the LexicalEditor is disposed */
     signal: AbortSignal;
     /**
      * Get the result of a peerDependency by name, if it exists
-     * (must be a peerDependency of this plan)
+     * (must be a peerDependency of this extension)
      */
-    getPeer: <Dependency extends AnyLexicalPlan = never>(name: Dependency["name"]) => undefined | Omit<LexicalPlanDependency<Dependency>, "output">;
+    getPeer: <Dependency extends AnyLexicalExtension = never>(name: Dependency["name"]) => undefined | Omit<LexicalExtensionDependency<Dependency>, "output">;
     /**
-     * Get the configuration of a dependency by plan
-     * (must be a direct dependency of this plan)
+     * Get the configuration of a dependency by extension
+     * (must be a direct dependency of this extension)
      */
-    getDependency: <Dependency extends AnyLexicalPlan>(dep: Dependency) => Omit<LexicalPlanDependency<Dependency>, "output">;
+    getDependency: <Dependency extends AnyLexicalExtension>(dep: Dependency) => Omit<LexicalExtensionDependency<Dependency>, "output">;
     /**
      * Get the names of any direct dependents of this
-     * Plan, typically only used for error messages.
+     * Extension, typically only used for error messages.
      */
     getDirectDependentNames: () => ReadonlySet<string>;
     /**
      * Get the names of all peer dependencies of this
-     * Plan, even if they do not exist in the builder,
+     * Extension, even if they do not exist in the builder,
      * typically only used for devtools.
      */
     getPeerNameSet: () => ReadonlySet<string>;
 }
 /**
  * An object that the register method can use to detect unmount and access the
- * configuration for plan dependencies
+ * configuration for extension dependencies
  */
-export interface PlanRegisterState<Init> extends Omit<PlanInitState, "getPeer" | "getDependency"> {
+export interface ExtensionRegisterState<Init> extends Omit<ExtensionInitState, "getPeer" | "getDependency"> {
     /**
      * Get the result of a peerDependency by name, if it exists
-     * (must be a peerDependency of this plan)
+     * (must be a peerDependency of this extension)
      */
-    getPeer: <Dependency extends AnyLexicalPlan = never>(name: Dependency["name"]) => undefined | LexicalPlanDependency<Dependency>;
+    getPeer: <Dependency extends AnyLexicalExtension = never>(name: Dependency["name"]) => undefined | LexicalExtensionDependency<Dependency>;
     /**
-     * Get the configuration of a dependency by plan
-     * (must be a direct dependency of this plan)
+     * Get the configuration of a dependency by extension
+     * (must be a direct dependency of this extension)
      */
-    getDependency: <Dependency extends AnyLexicalPlan>(dep: Dependency) => LexicalPlanDependency<Dependency>;
+    getDependency: <Dependency extends AnyLexicalExtension>(dep: Dependency) => LexicalExtensionDependency<Dependency>;
     /**
      * The result of the init function
      */
     getInitResult: () => Init;
 }
 /**
- * A {@link LexicalPlan} or {@link NormalizedLexicalPlanArgument} (plan with config overrides)
+ * A {@link LexicalExtension} or {@link NormalizedLexicalExtensionArgument} (extension with config overrides)
  */
-export type LexicalPlanArgument<Config extends PlanConfigBase, Name extends string, Output, Init> = LexicalPlan<Config, Name, Output, Init> | NormalizedLexicalPlanArgument<Config, Name, Output, Init>;
-export interface LexicalPlanDependency<out Dependency extends AnyLexicalPlan> {
-    config: LexicalPlanConfig<Dependency>;
-    output: LexicalPlanOutput<Dependency>;
+export type LexicalExtensionArgument<Config extends ExtensionConfigBase, Name extends string, Output, Init> = LexicalExtension<Config, Name, Output, Init> | NormalizedLexicalExtensionArgument<Config, Name, Output, Init>;
+export interface LexicalExtensionDependency<out Dependency extends AnyLexicalExtension> {
+    config: LexicalExtensionConfig<Dependency>;
+    output: LexicalExtensionOutput<Dependency>;
 }
 export type RegisterCleanup<Output> = (() => void) & (unknown extends Output ? {
     output?: Output;
@@ -89,41 +89,41 @@ export type RegisterCleanup<Output> = (() => void) & (unknown extends Output ? {
     output: Output;
 });
 /**
- * A Plan is a composable unit of LexicalEditor configuration
+ * An Extension is a composable unit of LexicalEditor configuration
  * (nodes, theme, etc) used to create an editor, plus runtime behavior
  * that is registered after the editor is created.
  *
- * A Plan may depend on other Plans, and provide functionality to other
- * plans through its config.
+ * An Extension may depend on other Extensions, and provide functionality to other
+ * extensions through its config.
  */
-export interface LexicalPlan<in out Config extends PlanConfigBase, out Name extends string, in out Output, in out Init> extends InitialEditorConfig, LexicalPlanInternal<Config, Output, Init> {
-    /** The name of the Plan, must be unique */
+export interface LexicalExtension<in out Config extends ExtensionConfigBase, out Name extends string, in out Output, in out Init> extends InitialEditorConfig, LexicalExtensionInternal<Config, Output, Init> {
+    /** The name of the Extension, must be unique */
     readonly name: Name;
-    /** Plan names that must not be loaded with this Plan */
+    /** Extension names that must not be loaded with this Extension */
     conflictsWith?: string[];
-    /** Other Plans that this Plan depends on, can also be used to configure them */
-    dependencies?: AnyLexicalPlanArgument[];
+    /** Other Extensions that this Extension depends on, can also be used to configure them */
+    dependencies?: AnyLexicalExtensionArgument[];
     /**
-     * Other Plans, by name, that this Plan can optionally depend on or
-     * configure, if they are directly depended on by another Plan
+     * Other Extensions, by name, that this Extension can optionally depend on or
+     * configure, if they are directly depended on by another Extension
      */
-    peerDependencies?: NormalizedPeerDependency<AnyLexicalPlan>[];
+    peerDependencies?: NormalizedPeerDependency<AnyLexicalExtension>[];
     /**
-     * The default configuration specific to this Plan. This Config may be
-     * seen by this Plan, or any Plan that uses it as a dependency.
+     * The default configuration specific to this Extension. This Config may be
+     * seen by this Extension, or any Extension that uses it as a dependency.
      *
      * The config may be mutated on register, this is particularly useful
-     * for vending functionality to other Plans that depend on this Plan.
+     * for vending functionality to other Extensions that depend on this Extension.
      */
     config?: Config;
     /**
      * By default, Config is shallow merged `{...a, ...b}` with
-     * {@link shallowMergeConfig}, if your Plan requires other strategies
+     * {@link shallowMergeConfig}, if your Extension requires other strategies
      * (such as concatenating an Array) you can implement it here.
      *
      * @example Merging an array
      * ```js
-     * const plan = definePlan({
+     * const extension = defineExtension({
      *   // ...
      *   mergeConfig(config, overrides) {
      *     const merged = shallowMergeConfig(config, overrides);
@@ -143,63 +143,63 @@ export interface LexicalPlan<in out Config extends PlanConfigBase, out Name exte
     /**
      * Perform any necessary initialization before the editor is created,
      * this runs after all configuration overrides for both the editor this
-     * this plan have been merged. May be used validate the editor
+     * this extension have been merged. May be used validate the editor
      * configuration.
      *
      * @param editorConfig - The in-progress editor configuration (mutable)
-     * @param config - The merged configuration specific to this plan (mutable)
+     * @param config - The merged configuration specific to this extension (mutable)
      * @param state - An object containing an AbortSignal that can be
      *   used, and methods for accessing the merged configuration of
      *   dependencies and peerDependencies
      */
-    init?: (editorConfig: InitialEditorConfig, config: Config, state: PlanInitState) => Init;
+    init?: (editorConfig: InitialEditorConfig, config: Config, state: ExtensionInitState) => Init;
     /**
      * Add behavior to the editor (register transforms, listeners, etc.) after
      * the Editor is created, but before its initial state is set.
      * The register function may also mutate the config
-     * in-place to expose data to other plans that use it as a dependency.
+     * in-place to expose data to other extensions that use it as a dependency.
      *
-     * @param editor - The editor this Plan is being registered with
-     * @param config - The merged configuration specific to this Plan
+     * @param editor - The editor this Extension is being registered with
+     * @param config - The merged configuration specific to this Extension
      * @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: PlanRegisterState<Init>) => RegisterCleanup<Output>;
+    register?: (editor: LexicalEditor, config: Config, state: ExtensionRegisterState<Init>) => RegisterCleanup<Output>;
     /**
      * Run any code that must happen after initialization of the
      * editor state (which happens after all register calls).
      *
-     * @param editor - The editor this Plan is being registered with
-     * @param config - The merged configuration specific to this Plan
+     * @param editor - The editor this Extension is being registered with
+     * @param config - The merged configuration specific to this Extension
      * @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
      */
-    afterInitialization?: (editor: LexicalEditor, config: Config, state: PlanRegisterState<Init>) => () => void;
+    afterInitialization?: (editor: LexicalEditor, config: Config, state: ExtensionRegisterState<Init>) => () => void;
 }
 /**
- * Extract the Config type from a Plan
+ * Extract the Config type from an Extension
  */
-export type LexicalPlanConfig<Plan extends AnyLexicalPlan> = NonNullable<Plan[configTypeSymbol]>;
+export type LexicalExtensionConfig<Extension extends AnyLexicalExtension> = NonNullable<Extension[configTypeSymbol]>;
 /**
- * Extract the Name type from a Plan
+ * Extract the Name type from an Extension
  */
-export type LexicalPlanName<Plan extends AnyLexicalPlan> = Plan["name"];
+export type LexicalExtensionName<Extension extends AnyLexicalExtension> = Extension["name"];
 /**
- * Extract the Output type from a Plan
+ * Extract the Output type from an Extension
  */
-export type LexicalPlanOutput<Plan extends AnyLexicalPlan> = NonNullable<Plan[outputTypeSymbol]>;
+export type LexicalExtensionOutput<Extension extends AnyLexicalExtension> = NonNullable<Extension[outputTypeSymbol]>;
 /**
- * Extract the Init type from a Plan
+ * Extract the Init type from an Extension
  */
-export type LexicalPlanInit<Plan extends AnyLexicalPlan> = NonNullable<Plan[initTypeSymbol]>;
+export type LexicalExtensionInit<Extension extends AnyLexicalExtension> = NonNullable<Extension[initTypeSymbol]>;
 /**
- * A Plan that has an OutputComponent of the given type (e.g. React.ComponentType)
+ * An Extension that has an OutputComponent of the given type (e.g. React.ComponentType)
  */
-export type OutputComponentPlan<ComponentType> = LexicalPlan<any, any, {
+export type OutputComponentExtension<ComponentType> = LexicalExtension<any, any, {
     Component: ComponentType;
 }, any>;
 /**
@@ -236,11 +236,11 @@ export interface InitialEditorConfig {
      */
     namespace?: CreateEditorArgs["namespace"];
     /**
-     * The nodes that this Plan adds to the Editor configuration, will be merged with other Plans
+     * The nodes that this Extension adds to the Editor configuration, will be merged with other Extensions
      */
     nodes?: CreateEditorArgs["nodes"];
     /**
-     * EditorThemeClasses that will be deep merged with other Plans
+     * EditorThemeClasses that will be deep merged with other Extensions
      */
     theme?: CreateEditorArgs["theme"];
     /**

package/dist/types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,EAAE,gBAAgB,EAAE,WAAW,EAAE,aAAa,EAAE,MAAM,SAAS,CAAC;AAC5E,OAAO,KAAK,EACV,mBAAmB,EACnB,oBAAoB,EACpB,gBAAgB,EAChB,gBAAgB,EAChB,cAAc,EACf,MAAM,YAAY,CAAC;AAEpB;;GAEG;AAEH,MAAM,MAAM,cAAc,GAAG,WAAW,CAAC,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,GAAG,CAAC,CAAC;AAChE;;GAEG;AACH,MAAM,MAAM,sBAAsB,GAC9B,cAAc,GACd,gCAAgC,CAAC;AACrC;;GAEG;AACH,MAAM,MAAM,cAAc,GAAG,MAAM,CAAC,KAAK,EAAE,KAAK,CAAC,CAAC;AAElD,MAAM,MAAM,wBAAwB,CAAC,IAAI,SAAS,cAAc,IAAI;IAClE,IAAI,CAAC,MAAM,CAAC;IACZ,OAAO,CAAC,iBAAiB,CAAC,IAAI,CAAC,CAAC,GAAG,SAAS;CAC7C,GAAG;IAAE,QAAQ,CAAC,CAAC,oBAAoB,CAAC,EAAE,IAAI,CAAA;CAAE,CAAC;AAE9C;;GAEG;AACH,MAAM,MAAM,6BAA6B,CACvC,EAAE,CAAC,GAAG,CAAC,MAAM,SAAS,cAAc,EACpC,GAAG,CAAC,IAAI,SAAS,MAAM,EACvB,EAAE,CAAC,GAAG,CAAC,MAAM,EACb,EAAE,CAAC,GAAG,CAAC,IAAI,IACT,CAAC,WAAW,CAAC,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,GAAG,OAAO,CAAC,MAAM,CAAC,EAAE,CAAC,CAAC;AAEpE;;GAEG;AACH,MAAM,MAAM,gCAAgC,GAAG,6BAA6B,CAE1E,GAAG,EACH,MAAM,EAEN,GAAG,EAEH,GAAG,CACJ,CAAC;AAEF;;;GAGG;AACH,MAAM,WAAW,aAAa;IAC5B,wEAAwE;IACxE,MAAM,EAAE,WAAW,CAAC;IACpB;;;OAGG;IACH,OAAO,EAAE,CAAC,UAAU,SAAS,cAAc,GAAG,KAAK,EACjD,IAAI,EAAE,UAAU,CAAC,MAAM,CAAC,KACrB,SAAS,GAAG,IAAI,CAAC,qBAAqB,CAAC,UAAU,CAAC,EAAE,QAAQ,CAAC,CAAC;IACnE;;;OAGG;IACH,aAAa,EAAE,CAAC,UAAU,SAAS,cAAc,EAC/C,GAAG,EAAE,UAAU,KACZ,IAAI,CAAC,qBAAqB,CAAC,UAAU,CAAC,EAAE,QAAQ,CAAC,CAAC;IACvD;;;OAGG;IACH,uBAAuB,EAAE,MAAM,WAAW,CAAC,MAAM,CAAC,CAAC;IACnD;;;;OAIG;IACH,cAAc,EAAE,MAAM,WAAW,CAAC,MAAM,CAAC,CAAC;CAC3C;AAED;;;GAGG;AACH,MAAM,WAAW,iBAAiB,CAAC,IAAI,CACrC,SAAQ,IAAI,CAAC,aAAa,EAAE,SAAS,GAAG,eAAe,CAAC;IACxD;;;OAGG;IACH,OAAO,EAAE,CAAC,UAAU,SAAS,cAAc,GAAG,KAAK,EACjD,IAAI,EAAE,UAAU,CAAC,MAAM,CAAC,KACrB,SAAS,GAAG,qBAAqB,CAAC,UAAU,CAAC,CAAC;IACnD;;;OAGG;IACH,aAAa,EAAE,CAAC,UAAU,SAAS,cAAc,EAC/C,GAAG,EAAE,UAAU,KACZ,qBAAqB,CAAC,UAAU,CAAC,CAAC;IACvC;;OAEG;IACH,aAAa,EAAE,MAAM,IAAI,CAAC;CAC3B;AAED;;GAEG;AACH,MAAM,MAAM,mBAAmB,CAC7B,MAAM,SAAS,cAAc,EAC7B,IAAI,SAAS,MAAM,EACnB,MAAM,EACN,IAAI,IAEF,WAAW,CAAC,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,CAAC,GACvC,6BAA6B,CAAC,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,CAAC,CAAC;AAE9D,MAAM,WAAW,qBAAqB,CAAC,GAAG,CAAC,UAAU,SAAS,cAAc;IAC1E,MAAM,EAAE,iBAAiB,CAAC,UAAU,CAAC,CAAC;IACtC,MAAM,EAAE,iBAAiB,CAAC,UAAU,CAAC,CAAC;CACvC;AAED,MAAM,MAAM,eAAe,CAAC,MAAM,IAAI,CAAC,MAAM,IAAI,CAAC,GAChD,CAAC,OAAO,SAAS,MAAM,GAAG;IAAE,MAAM,CAAC,EAAE,MAAM,CAAA;CAAE,GAAG;IAAE,MAAM,EAAE,MAAM,CAAA;CAAE,CAAC,CAAC;AAEtE;;;;;;;GAOG;AACH,MAAM,WAAW,WAAW,CAC1B,EAAE,CAAC,GAAG,CAAC,MAAM,SAAS,cAAc,EACpC,GAAG,CAAC,IAAI,SAAS,MAAM,EACvB,EAAE,CAAC,GAAG,CAAC,MAAM,EACb,EAAE,CAAC,GAAG,CAAC,IAAI,CACX,SAAQ,mBAAmB,EACzB,mBAAmB,CAAC,MAAM,EAAE,MAAM,EAAE,IAAI,CAAC;IAC3C,2CAA2C;IAC3C,QAAQ,CAAC,IAAI,EAAE,IAAI,CAAC;IACpB,wDAAwD;IACxD,aAAa,CAAC,EAAE,MAAM,EAAE,CAAC;IACzB,gFAAgF;IAChF,YAAY,CAAC,EAAE,sBAAsB,EAAE,CAAC;IACxC;;;OAGG;IACH,gBAAgB,CAAC,EAAE,wBAAwB,CAAC,cAAc,CAAC,EAAE,CAAC;IAE9D;;;;;;OAMG;IACH,MAAM,CAAC,EAAE,MAAM,CAAC;IAEhB;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACH,WAAW,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,SAAS,EAAE,OAAO,CAAC,MAAM,CAAC,KAAK,MAAM,CAAC;IACrE;;;;;;;;;;;OAWG;IACH,IAAI,CAAC,EAAE,CACL,YAAY,EAAE,mBAAmB,EACjC,MAAM,EAAE,MAAM,EACd,KAAK,EAAE,aAAa,KACjB,IAAI,CAAC;IACV;;;;;;;;;;;;OAYG;IACH,QAAQ,CAAC,EAAE,CACT,MAAM,EAAE,aAAa,EACrB,MAAM,EAAE,MAAM,EACd,KAAK,EAAE,iBAAiB,CAAC,IAAI,CAAC,KAC3B,eAAe,CAAC,MAAM,CAAC,CAAC;IAE7B;;;;;;;;;;OAUG;IACH,mBAAmB,CAAC,EAAE,CACpB,MAAM,EAAE,aAAa,EACrB,MAAM,EAAE,MAAM,EACd,KAAK,EAAE,iBAAiB,CAAC,IAAI,CAAC,KAC3B,MAAM,IAAI,CAAC;CACjB;AAED;;GAEG;AACH,MAAM,MAAM,iBAAiB,CAAC,IAAI,SAAS,cAAc,IAAI,WAAW,CACtE,IAAI,CAAC,gBAAgB,CAAC,CACvB,CAAC;AAEF;;GAEG;AACH,MAAM,MAAM,eAAe,CAAC,IAAI,SAAS,cAAc,IAAI,IAAI,CAAC,MAAM,CAAC,CAAC;AAExE;;GAEG;AACH,MAAM,MAAM,iBAAiB,CAAC,IAAI,SAAS,cAAc,IAAI,WAAW,CACtE,IAAI,CAAC,gBAAgB,CAAC,CACvB,CAAC;AAEF;;GAEG;AACH,MAAM,MAAM,eAAe,CAAC,IAAI,SAAS,cAAc,IAAI,WAAW,CACpE,IAAI,CAAC,cAAc,CAAC,CACrB,CAAC;AAEF;;GAEG;AACH,MAAM,MAAM,mBAAmB,CAAC,aAAa,IAAI,WAAW,CAE1D,GAAG,EAEH,GAAG,EACH;IAAE,SAAS,EAAE,aAAa,CAAA;CAAE,EAE5B,GAAG,CACJ,CAAC;AAEF;;GAEG;AACH,MAAM,WAAW,wBAAyB,SAAQ,aAAa,EAAE,UAAU;IACzE;;;OAGG;IACH,OAAO,EAAE,MAAM,IAAI,CAAC;CACrB;AAED;;;;;;GAMG;AACH,MAAM,MAAM,sBAAsB,GAC9B,IAAI,GACJ,MAAM,GACN,WAAW,GACX,CAAC,CAAC,MAAM,EAAE,aAAa,KAAK,IAAI,CAAC,CAAC;AAEtC,MAAM,WAAW,mBAAmB;IAClC;;OAEG;IACH,aAAa,CAAC,EAAE,gBAAgB,CAAC,eAAe,CAAC,CAAC;IAClD;;OAEG;IACH,YAAY,CAAC,EAAE,gBAAgB,CAAC,cAAc,CAAC,CAAC;IAChD;;;;OAIG;IACH,SAAS,CAAC,EAAE,gBAAgB,CAAC,WAAW,CAAC,CAAC;IAC1C;;OAEG;IACH,KAAK,CAAC,EAAE,gBAAgB,CAAC,OAAO,CAAC,CAAC;IAClC;;OAEG;IACH,KAAK,CAAC,EAAE,gBAAgB,CAAC,OAAO,CAAC,CAAC;IAClC;;;;OAIG;IACH,IAAI,CAAC,EAAE,gBAAgB,CAAC,MAAM,CAAC,CAAC;IAChC;;OAEG;IACH,QAAQ,CAAC,EAAE,gBAAgB,CAAC,UAAU,CAAC,CAAC;IACxC;;;;;;;OAOG;IACH,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,KAAK,EAAE,MAAM,EAAE,aAAa,KAAK,IAAI,CAAC;IACxD;;;OAGG;IACH,mBAAmB,CAAC,EAAE,sBAAsB,CAAC;CAC9C"}
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"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"}

package/package.json

@@ -6,7 +6,7 @@
     "lexical",
     "lexical-builder",
     "plug-in",
-    "plan"
+    "extension"
   ],
   "scripts": {
     "build": "tsc --noEmit && vite build",
@@ -15,7 +15,7 @@
     "test": "vitest run --typecheck",
     "test:watch": "vitest"
   },
-  "version": "0.0.36-nightly.20250714.0",
+  "version": "0.0.36",
   "license": "MIT",
   "repository": {
     "type": "git",
@@ -27,7 +27,7 @@
   },
   "homepage": "https://github.com/etrepum/lexical-builder",
   "peerDependencies": {
-    "lexical": ">=0.31.0 || >=0.31.1-nightly.0"
+    "lexical": ">=0.33.1 || >=0.33.2-nightly.0"
   },
   "sideEffects": false,
   "devDependencies": {

package/dist/definePlan.d.ts

@@ -1,130 +0,0 @@
-import { AnyLexicalPlan, LexicalPlan, LexicalPlanConfig, NormalizedLexicalPlanArgument, NormalizedPeerDependency, PlanConfigBase, RegisterCleanup } from './types';
-/**
- * Define a LexicalPlan from the given object literal. TypeScript will
- * infer Config and Name in most cases, but you may want to use
- * {@link safeCast} for config if there are default fields or varying types.
- *
- * @param plan - The LexicalPlan
- * @returns The unmodified plan argument (this is only an inference helper)
- *
- * @example Basic example
- * ```ts
- * export const MyPlan = definePlan({
- *   // Plan names must be unique in an editor
- *   name: "my",
- *   nodes: [MyNode],
- * });
- * ```
- *
- * @example Plan with optional configuration
- * ```ts
- * export interface ConfigurableConfig {
- *   optional?: string;
- *   required: number;
- * }
- * export const ConfigurablePlan = definePlan({
- *   name: "configurable",
- *   // The Plan's config must satisfy the full config type,
- *   // but using the Plan as a dependency never requires
- *   // configuration and any partial of the config can be specified
- *   config: safeCast<ConfigurableConfig>({ required: 1 }),
- * });
- * ```
- */
-export declare function definePlan<Config extends PlanConfigBase, Name extends string, Output, Init>(plan: LexicalPlan<Config, Name, Output, Init>): LexicalPlan<Config, Name, Output, Init>;
-/**
- * Override a partial of the configuration of a Plan, to be used
- * in the dependencies array of another plan, or as
- * an argument to {@link buildEditorFromPlans}.
- *
- * Before building the editor, configurations will be merged using
- * plan.mergeConfig(plan, config) or {@link shallowMergeConfig} if
- * this is not directly implemented by the Plan.
- *
- * @param args - A plan followed by one or more config partials for that plan
- * @returns [plan, config, ...configs]
- *
- * @example
- * ```ts
- * export const ReactDecoratorPlan = definePlan({
- *   name: "react-decorator",
- *   dependencies: [
- *     configPlan(ReactPlan, {
- *       decorators: [<ReactDecorator />]
- *     }),
- *   ],
- * });
- * ```
- */
-export declare function configPlan<Config extends PlanConfigBase, Name extends string, Output, Init>(...args: NormalizedLexicalPlanArgument<Config, Name, Output, Init>): NormalizedLexicalPlanArgument<Config, Name, Output, Init>;
-/**
- * Provide output from the register function of a Plan
- *
- * @returns A cleanup function
- *
- * @example Provide output with no other cleanup
- * ```ts
- * // This is entirely optional and would be inferred correctly, but
- * // it can be useful for documentation!
- * export interface RegisteredAtOutput {
- *   registered_at: number;
- * }
- * export const RegisteredAtPlan = definePlan({
- *   name: "RegisteredAt",
- *   register(editor) {
- *     return provideOutput<RegisteredAtOutput>({ registered_at: Date.now() });
- *   },
- * });
- * ```
- *
- * @example Provide output with other cleanup
- * ```ts
- * export interface UniqueCommandOutput {
- *   command: LexicalCommand<unknown>;
- * }
- * export const UniqueCommandPlan = definePlan({
- *   name: 'UniqueCommand',
- *   register(editor) {
- *     const output: UniqueCommnadOutput = {command: createCommand('UNIQUE_COMMAND')};
- *     const cleanup = registerCommand(
- *       command,
- *       (_payload) => {
- *         console.log('Unique command received!');
- *         return true;
- *       }
- *       COMMAND_PRIORITY_EDITOR
- *     );
- *     return provideOutput(output, cleanup);
- *   },
- * });
- * ```
- *
- */
-export declare function provideOutput<Output>(output: Output, cleanup?: () => void): RegisterCleanup<Output>;
-/** @internal */
-export declare const PeerDependencyBrand: unique symbol;
-export declare const ConfigTypeId: unique symbol;
-export declare const OutputTypeId: unique symbol;
-/**
- * Used to declare a peer dependency of a plan in a type-safe way,
- * requires the type parameter. The most common use case for peer dependencies
- * is to avoid a direct import dependency, so you would want to use a
- * type import or the import type (shown in below examples).
- *
- * @param name - The plan's name
- * @param config - An optional config override
- * @returns NormalizedPeerDependency
- *
- * @example
- * ```ts
- * export const PeerPlan = definePlan({
- *   name: 'PeerPlan',
- *   peerDependencies: [
- *     declarePeerDependency<typeof import("foo").FooPlan>("foo"),
- *     declarePeerDependency<typeof import("bar").BarPlan>("bar", {config: "bar"}),
- *   ],
- * });
- * ```
- */
-export declare function declarePeerDependency<Plan extends AnyLexicalPlan = never>(name: Plan["name"], config?: Partial<LexicalPlanConfig<Plan>>): NormalizedPeerDependency<Plan>;
-//# sourceMappingURL=definePlan.d.ts.map

package/dist/definePlan.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"definePlan.d.ts","sourceRoot":"","sources":["../src/definePlan.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,EACV,cAAc,EACd,WAAW,EACX,iBAAiB,EACjB,6BAA6B,EAC7B,wBAAwB,EACxB,cAAc,EACd,eAAe,EAChB,MAAM,SAAS,CAAC;AAEjB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,wBAAgB,UAAU,CACxB,MAAM,SAAS,cAAc,EAC7B,IAAI,SAAS,MAAM,EACnB,MAAM,EACN,IAAI,EAEJ,IAAI,EAAE,WAAW,CAAC,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,CAAC,GAC5C,WAAW,CAAC,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,CAAC,CAEzC;AAED;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAgB,UAAU,CACxB,MAAM,SAAS,cAAc,EAC7B,IAAI,SAAS,MAAM,EACnB,MAAM,EACN,IAAI,EAEJ,GAAG,IAAI,EAAE,6BAA6B,CAAC,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,CAAC,GACjE,6BAA6B,CAAC,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,CAAC,CAE3D;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0CG;AACH,wBAAgB,aAAa,CAAC,MAAM,EAClC,MAAM,EAAE,MAAM,EACd,OAAO,CAAC,EAAE,MAAM,IAAI,GACnB,eAAe,CAAC,MAAM,CAAC,CAOzB;AAED,gBAAgB;AAChB,eAAO,MAAM,mBAAmB,EAAE,OAAO,MAExC,CAAC;AACF,eAAO,MAAM,YAAY,EAAE,OAAO,MAEjC,CAAC;AACF,eAAO,MAAM,YAAY,EAAE,OAAO,MAEjC,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,qBAAqB,CAAC,IAAI,SAAS,cAAc,GAAG,KAAK,EACvE,IAAI,EAAE,IAAI,CAAC,MAAM,CAAC,EAClB,MAAM,CAAC,EAAE,OAAO,CAAC,iBAAiB,CAAC,IAAI,CAAC,CAAC,GACxC,wBAAwB,CAAC,IAAI,CAAC,CAEhC"}