@byline/richtext-lexical 3.0.2 → 3.1.1

package/dist/config.d.ts

@@ -0,0 +1,45 @@
+/**
+ * This Source Code is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * Copyright (c) Infonomic Company Limited
+ */
+/**
+ * Config-only surface for `@byline/richtext-lexical`.
+ *
+ * This entry is intentionally **light**: it carries the `lexicalEditor`
+ * registration factory (which dynamic-imports the editor runtime on first
+ * mount), the config types, the built-in extension **names**, and the
+ * light toolbar-authoring primitives — but NOT `RichTextField` /
+ * `EditorField` / `Nodes` or the heavy *content* extension classes
+ * (Table, InlineImage, Admonition, …), all of which statically pull React
+ * plugins, nodes, and the Lexical core. Import from here at registration
+ * sites (e.g. an admin/client config that you want to evaluate eagerly)
+ * so referencing the editor doesn't drag the editor module graph into the
+ * importing bundle.
+ *
+ * To toggle a built-in extension without importing its heavy class, use
+ * the name-based form of `extensions.remove/has/replace` with
+ * `builtInExtensions.*`:
+ *
+ * ```ts
+ * import { builtInExtensions, lexicalEditor } from '@byline/richtext-lexical/config'
+ *
+ * lexicalEditor((c) => {
+ *   c.extensions.remove(builtInExtensions.FloatingTextFormat)
+ *   return c
+ * })
+ * ```
+ *
+ * Need an actual extension class (to `.add(...)` it, or pass it to
+ * `configExtension`)? Import it from the `.` barrel instead — and accept
+ * that doing so pulls that extension's runtime into the bundle.
+ */
+export { type BuiltInExtensionName, builtInExtensions, } from './field/config/built-in-extension-names';
+export { type BylineToolbarConfig, BylineToolbarExtension, type BylineToolbarItem, type BylineToolbarPlacement, selectToolbarItems, } from './field/extensions/byline-toolbar';
+export { ToolbarActiveEditorProvider, useToolbarActiveEditor, } from './field/plugins/toolbar-plugin/toolbar-active-editor';
+export { lexicalEditor } from './lexical-editor';
+export type { ExtensionsList } from './field/config/extensions-list';
+export type { EditorConfig, EditorSettings, EditorSettingsOverride } from './field/config/types';
+export type { LexicalEditorConfigureInput } from './lexical-editor';

package/dist/config.js

@@ -0,0 +1,4 @@
+export { builtInExtensions } from "./field/config/built-in-extension-names.js";
+export { BylineToolbarExtension, selectToolbarItems } from "./field/extensions/byline-toolbar/index.js";
+export { ToolbarActiveEditorProvider, useToolbarActiveEditor } from "./field/plugins/toolbar-plugin/toolbar-active-editor.js";
+export { lexicalEditor } from "./lexical-editor.js";

package/dist/field/config/built-in-extension-names.d.ts

@@ -0,0 +1,51 @@
+/**
+ * This Source Code is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * Copyright (c) Infonomic Company Limited
+ */
+/**
+ * The `name` of every built-in extension, as a plain string map.
+ *
+ * This module is **React-free and runtime-free** — it carries only the
+ * identifying strings, never the extension classes (which statically
+ * import their React plugins / nodes). That lets config-only code paths
+ * (the `@byline/richtext-lexical/config` subpath) reference a built-in
+ * for `extensions.remove(...)` / `.has(...)` / `.replace(...)` without
+ * dragging the editor runtime into the importing bundle.
+ *
+ * ```ts
+ * import { builtInExtensions, lexicalEditor } from '@byline/richtext-lexical/config'
+ *
+ * lexicalEditor((c) => {
+ *   c.extensions.remove(builtInExtensions.FloatingTextFormat)
+ *   return c
+ * })
+ * ```
+ *
+ * Each value MUST stay in sync with the corresponding extension's
+ * `defineExtension({ name })` — they share the `@byline/richtext-lexical/*`
+ * convention (suffix === map key). `built-in-extension-names.test.node.ts`
+ * guards this module's own integrity (convention, uniqueness); the mirror
+ * against the live extension `name`s is exercised by the editor's
+ * jsdom/integration coverage.
+ */
+export declare const builtInExtensions: {
+    readonly Admonition: "@byline/richtext-lexical/Admonition";
+    readonly AutoEmbed: "@byline/richtext-lexical/AutoEmbed";
+    readonly AutoLink: "@byline/richtext-lexical/AutoLink";
+    readonly CodeHighlight: "@byline/richtext-lexical/CodeHighlight";
+    readonly FloatingTextFormat: "@byline/richtext-lexical/FloatingTextFormat";
+    readonly FloatingUI: "@byline/richtext-lexical/FloatingUI";
+    readonly HorizontalRule: "@byline/richtext-lexical/HorizontalRule";
+    readonly InlineImage: "@byline/richtext-lexical/InlineImage";
+    readonly Layout: "@byline/richtext-lexical/Layout";
+    readonly Link: "@byline/richtext-lexical/Link";
+    readonly Table: "@byline/richtext-lexical/Table";
+    readonly Toolbar: "@byline/richtext-lexical/Toolbar";
+    readonly Vimeo: "@byline/richtext-lexical/Vimeo";
+    readonly YouTube: "@byline/richtext-lexical/YouTube";
+};
+/** Union of the built-in extension `name` strings. */
+export type BuiltInExtensionName = (typeof builtInExtensions)[keyof typeof builtInExtensions];

package/dist/field/config/built-in-extension-names.js

@@ -0,0 +1,17 @@
+const builtInExtensions = {
+    Admonition: '@byline/richtext-lexical/Admonition',
+    AutoEmbed: '@byline/richtext-lexical/AutoEmbed',
+    AutoLink: '@byline/richtext-lexical/AutoLink',
+    CodeHighlight: '@byline/richtext-lexical/CodeHighlight',
+    FloatingTextFormat: '@byline/richtext-lexical/FloatingTextFormat',
+    FloatingUI: '@byline/richtext-lexical/FloatingUI',
+    HorizontalRule: '@byline/richtext-lexical/HorizontalRule',
+    InlineImage: '@byline/richtext-lexical/InlineImage',
+    Layout: '@byline/richtext-lexical/Layout',
+    Link: '@byline/richtext-lexical/Link',
+    Table: '@byline/richtext-lexical/Table',
+    Toolbar: '@byline/richtext-lexical/Toolbar',
+    Vimeo: '@byline/richtext-lexical/Vimeo',
+    YouTube: '@byline/richtext-lexical/YouTube'
+};
+export { builtInExtensions };

package/dist/field/config/extensions-list.d.ts

@@ -22,12 +22,19 @@ export declare class ExtensionsList {
     /** Append `extension` to the end of the list. */
     add(extension: AnyLexicalExtensionArgument): this;
     /**
-     * Remove every entry whose name matches `extension.name`. No-op when
-     * the extension isn't present.
+     * Remove every entry whose name matches the target. Accepts either an
+     * extension object (matched by `.name`) or the name string directly —
+     * the string form lets config-only code remove a built-in via
+     * `builtInExtensions.*` without importing the heavy extension class.
+     * No-op when the extension isn't present.
      */
-    remove(extension: AnyLexicalExtension): this;
-    /** Replace `oldExtension` with `newExtension`, preserving position. */
-    replace(oldExtension: AnyLexicalExtension, newExtension: AnyLexicalExtensionArgument): this;
+    remove(extension: AnyLexicalExtension | string): this;
+    /**
+     * Replace `oldExtension` with `newExtension`, preserving position.
+     * `oldExtension` may be an extension object or its name string; the
+     * replacement must be a real extension argument.
+     */
+    replace(oldExtension: AnyLexicalExtension | string, newExtension: AnyLexicalExtensionArgument): this;
     /**
      * Re-wrap an existing extension entry with a fresh `configExtension`
      * binding the supplied config. If the extension isn't present, it is
@@ -35,8 +42,11 @@ export declare class ExtensionsList {
      * is replaced rather than nested.
      */
     configure<Extension extends AnyLexicalExtension>(extension: Extension, config: Partial<LexicalExtensionConfig<Extension>>): this;
-    /** True when an entry with the same `name` is present. */
-    has(extension: AnyLexicalExtension): boolean;
+    /**
+     * True when an entry with the same `name` is present. Accepts an
+     * extension object or its name string.
+     */
+    has(extension: AnyLexicalExtension | string): boolean;
     /** Independent copy — safe to hand to a configure callback. */
     clone(): ExtensionsList;
     /** The list as a plain array, ready for `defineExtension({ dependencies })`. */

package/dist/field/config/extensions-list.js

@@ -5,12 +5,12 @@ class ExtensionsList {
         return this;
     }
     remove(extension) {
-        const targetName = extension.name;
+        const targetName = resolveTargetName(extension);
         this.items = this.items.filter((item)=>extensionName(item) !== targetName);
         return this;
     }
     replace(oldExtension, newExtension) {
-        const targetName = oldExtension.name;
+        const targetName = resolveTargetName(oldExtension);
         let replaced = false;
         this.items = this.items.map((item)=>{
             if (!replaced && extensionName(item) === targetName) {
@@ -27,7 +27,7 @@ class ExtensionsList {
         return this.replace(extension, wrapped);
     }
     has(extension) {
-        const targetName = extension.name;
+        const targetName = resolveTargetName(extension);
         return this.items.some((item)=>extensionName(item) === targetName);
     }
     clone() {
@@ -44,6 +44,9 @@ class ExtensionsList {
         ];
     }
 }
+function resolveTargetName(target) {
+    return 'string' == typeof target ? target : target.name;
+}
 function extensionName(item) {
     if (Array.isArray(item)) {
         const head = item[0];

package/dist/index.d.ts

@@ -1,4 +1,5 @@
 export type { SerializedEditor, SerializedEditorState, SerializedElementNode, SerializedLexicalNode, SerializedRootNode, SerializedTextNode, } from 'lexical';
+export { type BuiltInExtensionName, builtInExtensions, } from './field/config/built-in-extension-names';
 export { defaultEditorConfig } from './field/config/default';
 export { defaultClientEditorConfig, defaultExtensionsArray, defaultExtensionsList, } from './field/config/default-extensions';
 export { ExtensionsList } from './field/config/extensions-list';

package/dist/index.js

@@ -1,3 +1,4 @@
+export { builtInExtensions } from "./field/config/built-in-extension-names.js";
 export { defaultEditorConfig } from "./field/config/default.js";
 export { defaultClientEditorConfig, defaultExtensionsArray, defaultExtensionsList } from "./field/config/default-extensions.js";
 export { ExtensionsList } from "./field/config/extensions-list.js";

package/package.json

@@ -3,7 +3,7 @@
   "private": false,
   "type": "module",
   "license": "MPL-2.0",
-  "version": "3.0.2",
+  "version": "3.1.1",
   "engines": {
     "node": ">=20.9.0"
   },
@@ -42,6 +42,12 @@
       "main": "./dist/index.js",
       "default": "./dist/index.js"
     },
+    "./config": {
+      "types": "./dist/config.d.ts",
+      "import": "./dist/config.js",
+      "main": "./dist/config.js",
+      "default": "./dist/config.js"
+    },
     "./server": {
       "types": "./dist/server.d.ts",
       "import": "./dist/server.js",
@@ -72,10 +78,10 @@
     "npm-run-all": "^4.1.5",
     "prism-react-renderer": "^2.4.1",
     "react-error-boundary": "^6.1.1",
-    "@byline/admin": "3.0.2",
-    "@byline/client": "3.0.2",
-    "@byline/ui": "3.0.2",
-    "@byline/core": "3.0.2"
+    "@byline/client": "3.1.1",
+    "@byline/ui": "3.1.1",
+    "@byline/core": "3.1.1",
+    "@byline/admin": "3.1.1"
   },
   "peerDependencies": {
     "react": "^19.0.0",

package/src/config.ts

@@ -0,0 +1,65 @@
+/**
+ * This Source Code is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * Copyright (c) Infonomic Company Limited
+ */
+
+/**
+ * Config-only surface for `@byline/richtext-lexical`.
+ *
+ * This entry is intentionally **light**: it carries the `lexicalEditor`
+ * registration factory (which dynamic-imports the editor runtime on first
+ * mount), the config types, the built-in extension **names**, and the
+ * light toolbar-authoring primitives — but NOT `RichTextField` /
+ * `EditorField` / `Nodes` or the heavy *content* extension classes
+ * (Table, InlineImage, Admonition, …), all of which statically pull React
+ * plugins, nodes, and the Lexical core. Import from here at registration
+ * sites (e.g. an admin/client config that you want to evaluate eagerly)
+ * so referencing the editor doesn't drag the editor module graph into the
+ * importing bundle.
+ *
+ * To toggle a built-in extension without importing its heavy class, use
+ * the name-based form of `extensions.remove/has/replace` with
+ * `builtInExtensions.*`:
+ *
+ * ```ts
+ * import { builtInExtensions, lexicalEditor } from '@byline/richtext-lexical/config'
+ *
+ * lexicalEditor((c) => {
+ *   c.extensions.remove(builtInExtensions.FloatingTextFormat)
+ *   return c
+ * })
+ * ```
+ *
+ * Need an actual extension class (to `.add(...)` it, or pass it to
+ * `configExtension`)? Import it from the `.` barrel instead — and accept
+ * that doing so pulls that extension's runtime into the bundle.
+ */
+
+export {
+  type BuiltInExtensionName,
+  builtInExtensions,
+} from './field/config/built-in-extension-names'
+// Light extension-authoring primitives — the toolbar coordination
+// extension, its selectors/types, and the active-editor hook. These carry
+// no React plugin/node runtime (only `lexical` + a React context), so a
+// third-party extension (e.g. `@byline/ai`'s Lexical extension) can
+// declare a toolbar contribution and dispatch commands without pulling
+// the editor's content runtime into its bundle.
+export {
+  type BylineToolbarConfig,
+  BylineToolbarExtension,
+  type BylineToolbarItem,
+  type BylineToolbarPlacement,
+  selectToolbarItems,
+} from './field/extensions/byline-toolbar'
+export {
+  ToolbarActiveEditorProvider,
+  useToolbarActiveEditor,
+} from './field/plugins/toolbar-plugin/toolbar-active-editor'
+export { lexicalEditor } from './lexical-editor'
+export type { ExtensionsList } from './field/config/extensions-list'
+export type { EditorConfig, EditorSettings, EditorSettingsOverride } from './field/config/types'
+export type { LexicalEditorConfigureInput } from './lexical-editor'

package/src/field/config/built-in-extension-names.test.node.ts

@@ -0,0 +1,44 @@
+/**
+ * This Source Code is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * Copyright (c) Infonomic Company Limited
+ */
+
+import { describe, expect, it } from 'vitest'
+
+import { builtInExtensions } from './built-in-extension-names'
+
+/**
+ * Node-safe self-consistency checks for the `builtInExtensions` name map.
+ *
+ * The map deliberately carries strings only (no extension imports), so
+ * this test cannot diff against the live `defineExtension({ name })`
+ * values without dragging the React-heavy editor graph into a node test.
+ * Instead it guards the map's own integrity — the `@byline/richtext-lexical/*`
+ * convention, uniqueness, and that each key matches the suffix of its
+ * value. Each value must still mirror the corresponding extension's
+ * `name`; that mirror is asserted by the editor's jsdom/integration
+ * coverage, not here.
+ */
+describe('builtInExtensions name map', () => {
+  const entries = Object.entries(builtInExtensions)
+
+  it('namespaces every value under @byline/richtext-lexical/', () => {
+    for (const [, value] of entries) {
+      expect(value).toMatch(/^@byline\/richtext-lexical\/[A-Za-z]+$/)
+    }
+  })
+
+  it('uses each value exactly once', () => {
+    const values = entries.map(([, value]) => value)
+    expect(new Set(values).size).toBe(values.length)
+  })
+
+  it('names each key after the suffix of its value', () => {
+    for (const [key, value] of entries) {
+      expect(value).toBe(`@byline/richtext-lexical/${key}`)
+    }
+  })
+})

package/src/field/config/built-in-extension-names.ts

@@ -0,0 +1,53 @@
+/**
+ * This Source Code is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * Copyright (c) Infonomic Company Limited
+ */
+
+/**
+ * The `name` of every built-in extension, as a plain string map.
+ *
+ * This module is **React-free and runtime-free** — it carries only the
+ * identifying strings, never the extension classes (which statically
+ * import their React plugins / nodes). That lets config-only code paths
+ * (the `@byline/richtext-lexical/config` subpath) reference a built-in
+ * for `extensions.remove(...)` / `.has(...)` / `.replace(...)` without
+ * dragging the editor runtime into the importing bundle.
+ *
+ * ```ts
+ * import { builtInExtensions, lexicalEditor } from '@byline/richtext-lexical/config'
+ *
+ * lexicalEditor((c) => {
+ *   c.extensions.remove(builtInExtensions.FloatingTextFormat)
+ *   return c
+ * })
+ * ```
+ *
+ * Each value MUST stay in sync with the corresponding extension's
+ * `defineExtension({ name })` — they share the `@byline/richtext-lexical/*`
+ * convention (suffix === map key). `built-in-extension-names.test.node.ts`
+ * guards this module's own integrity (convention, uniqueness); the mirror
+ * against the live extension `name`s is exercised by the editor's
+ * jsdom/integration coverage.
+ */
+export const builtInExtensions = {
+  Admonition: '@byline/richtext-lexical/Admonition',
+  AutoEmbed: '@byline/richtext-lexical/AutoEmbed',
+  AutoLink: '@byline/richtext-lexical/AutoLink',
+  CodeHighlight: '@byline/richtext-lexical/CodeHighlight',
+  FloatingTextFormat: '@byline/richtext-lexical/FloatingTextFormat',
+  FloatingUI: '@byline/richtext-lexical/FloatingUI',
+  HorizontalRule: '@byline/richtext-lexical/HorizontalRule',
+  InlineImage: '@byline/richtext-lexical/InlineImage',
+  Layout: '@byline/richtext-lexical/Layout',
+  Link: '@byline/richtext-lexical/Link',
+  Table: '@byline/richtext-lexical/Table',
+  Toolbar: '@byline/richtext-lexical/Toolbar',
+  Vimeo: '@byline/richtext-lexical/Vimeo',
+  YouTube: '@byline/richtext-lexical/YouTube',
+} as const
+
+/** Union of the built-in extension `name` strings. */
+export type BuiltInExtensionName = (typeof builtInExtensions)[keyof typeof builtInExtensions]

package/src/field/config/extensions-list.ts

@@ -37,18 +37,28 @@ export class ExtensionsList {
   }
 
   /**
-   * Remove every entry whose name matches `extension.name`. No-op when
-   * the extension isn't present.
+   * Remove every entry whose name matches the target. Accepts either an
+   * extension object (matched by `.name`) or the name string directly —
+   * the string form lets config-only code remove a built-in via
+   * `builtInExtensions.*` without importing the heavy extension class.
+   * No-op when the extension isn't present.
    */
-  remove(extension: AnyLexicalExtension): this {
-    const targetName = extension.name
+  remove(extension: AnyLexicalExtension | string): this {
+    const targetName = resolveTargetName(extension)
     this.items = this.items.filter((item) => extensionName(item) !== targetName)
     return this
   }
 
-  /** Replace `oldExtension` with `newExtension`, preserving position. */
-  replace(oldExtension: AnyLexicalExtension, newExtension: AnyLexicalExtensionArgument): this {
-    const targetName = oldExtension.name
+  /**
+   * Replace `oldExtension` with `newExtension`, preserving position.
+   * `oldExtension` may be an extension object or its name string; the
+   * replacement must be a real extension argument.
+   */
+  replace(
+    oldExtension: AnyLexicalExtension | string,
+    newExtension: AnyLexicalExtensionArgument
+  ): this {
+    const targetName = resolveTargetName(oldExtension)
     let replaced = false
     this.items = this.items.map((item) => {
       if (!replaced && extensionName(item) === targetName) {
@@ -75,9 +85,12 @@ export class ExtensionsList {
     return this.replace(extension, wrapped)
   }
 
-  /** True when an entry with the same `name` is present. */
-  has(extension: AnyLexicalExtension): boolean {
-    const targetName = extension.name
+  /**
+   * True when an entry with the same `name` is present. Accepts an
+   * extension object or its name string.
+   */
+  has(extension: AnyLexicalExtension | string): boolean {
+    const targetName = resolveTargetName(extension)
     return this.items.some((item) => extensionName(item) === targetName)
   }
 
@@ -92,6 +105,11 @@ export class ExtensionsList {
   }
 }
 
+/** Resolve a remove/has/replace target to its comparison name. */
+function resolveTargetName(target: AnyLexicalExtension | string): string {
+  return typeof target === 'string' ? target : target.name
+}
+
 function extensionName(item: AnyLexicalExtensionArgument): string | undefined {
   if (Array.isArray(item)) {
     const head = item[0]

package/src/index.ts

@@ -10,6 +10,10 @@ export type {
   SerializedTextNode,
 } from 'lexical'
 
+export {
+  type BuiltInExtensionName,
+  builtInExtensions,
+} from './field/config/built-in-extension-names'
 export { defaultEditorConfig } from './field/config/default'
 export {
   defaultClientEditorConfig,