@ruya.sa/richtext-lexical 3.71.7

package/dist/features/toolbars/shared/ToolbarDropdown/index.js

@@ -0,0 +1,196 @@
+'use client';
+
+import { c as _c } from "react/compiler-runtime";
+import { jsx as _jsx } from "react/jsx-runtime";
+import React, { useCallback, useDeferredValue, useEffect, useMemo } from 'react';
+const baseClass = 'toolbar-popup__dropdown';
+import { mergeRegister } from '@lexical/utils';
+import { useTranslation } from '@ruya.sa/ui';
+import { $getSelection } from 'lexical';
+import { useEditorConfigContext } from '../../../../lexical/config/client/EditorConfigProvider.js';
+import { useRunDeprioritized } from '../../../../utilities/useRunDeprioritized.js';
+import { DropDown, DropDownItem } from './DropDown.js';
+const ToolbarItem = t0 => {
+  const $ = _c(14);
+  const {
+    active,
+    anchorElem,
+    editor,
+    enabled,
+    item
+  } = t0;
+  const {
+    i18n
+  } = useTranslation();
+  const {
+    fieldProps: t1
+  } = useEditorConfigContext();
+  const {
+    featureClientSchemaMap,
+    schemaPath
+  } = t1;
+  if (item.Component) {
+    let t2;
+    if ($[0] !== active || $[1] !== anchorElem || $[2] !== editor || $[3] !== enabled || $[4] !== item) {
+      t2 = item?.Component && _jsx(item.Component, {
+        active,
+        anchorElem,
+        editor,
+        enabled,
+        item
+      }, item.key);
+      $[0] = active;
+      $[1] = anchorElem;
+      $[2] = editor;
+      $[3] = enabled;
+      $[4] = item;
+      $[5] = t2;
+    } else {
+      t2 = $[5];
+    }
+    return t2;
+  }
+  let t2;
+  if ($[6] !== active || $[7] !== editor || $[8] !== enabled || $[9] !== featureClientSchemaMap || $[10] !== i18n || $[11] !== item || $[12] !== schemaPath) {
+    let title = item.key;
+    let croppedTitle;
+    if (item.label) {
+      title = typeof item.label === "function" ? item.label({
+        featureClientSchemaMap,
+        i18n,
+        schemaPath
+      }) : item.label;
+    }
+    if (title.length > 25) {
+      croppedTitle = title.substring(0, 25) + "...";
+    } else {
+      croppedTitle = title;
+    }
+    t2 = _jsx(DropDownItem, {
+      active,
+      editor,
+      enabled,
+      Icon: item?.ChildComponent ? _jsx(item.ChildComponent, {}) : undefined,
+      item,
+      itemKey: item.key,
+      tooltip: title,
+      children: _jsx("span", {
+        className: "text",
+        children: croppedTitle
+      })
+    }, item.key);
+    $[6] = active;
+    $[7] = editor;
+    $[8] = enabled;
+    $[9] = featureClientSchemaMap;
+    $[10] = i18n;
+    $[11] = item;
+    $[12] = schemaPath;
+    $[13] = t2;
+  } else {
+    t2 = $[13];
+  }
+  return t2;
+};
+const MemoToolbarItem = /*#__PURE__*/React.memo(ToolbarItem);
+export const ToolbarDropdown = ({
+  anchorElem,
+  classNames,
+  editor,
+  group,
+  Icon,
+  itemsContainerClassNames,
+  label,
+  maxActiveItems,
+  onActiveChange
+}) => {
+  const [toolbarState, setToolbarState] = React.useState({
+    activeItemKeys: [],
+    enabledGroup: true,
+    enabledItemKeys: []
+  });
+  const deferredToolbarState = useDeferredValue(toolbarState);
+  const editorConfigContext = useEditorConfigContext();
+  const {
+    items,
+    key: groupKey
+  } = group;
+  const runDeprioritized = useRunDeprioritized();
+  const updateStates = useCallback(() => {
+    editor.getEditorState().read(() => {
+      const selection = $getSelection();
+      if (!selection) {
+        return;
+      }
+      const _activeItemKeys = [];
+      const _activeItems = [];
+      const _enabledItemKeys = [];
+      for (const item of items) {
+        if (item.isActive && (!maxActiveItems || _activeItemKeys.length < maxActiveItems)) {
+          const isActive = item.isActive({
+            editor,
+            editorConfigContext,
+            selection
+          });
+          if (isActive) {
+            _activeItemKeys.push(item.key);
+            _activeItems.push(item);
+          }
+        }
+        if (item.isEnabled) {
+          const isEnabled = item.isEnabled({
+            editor,
+            editorConfigContext,
+            selection
+          });
+          if (isEnabled) {
+            _enabledItemKeys.push(item.key);
+          }
+        } else {
+          _enabledItemKeys.push(item.key);
+        }
+      }
+      setToolbarState({
+        activeItemKeys: _activeItemKeys,
+        enabledGroup: group.isEnabled ? group.isEnabled({
+          editor,
+          editorConfigContext,
+          selection
+        }) : true,
+        enabledItemKeys: _enabledItemKeys
+      });
+      if (onActiveChange) {
+        onActiveChange({
+          activeItems: _activeItems
+        });
+      }
+    });
+  }, [editor, editorConfigContext, group, items, maxActiveItems, onActiveChange]);
+  useEffect(() => {
+    // Run on mount in order to update states when dropdown is opened
+    void runDeprioritized(updateStates);
+    return mergeRegister(editor.registerUpdateListener(async () => {
+      await runDeprioritized(updateStates);
+    }));
+  }, [editor, runDeprioritized, updateStates]);
+  const renderedItems = useMemo(() => {
+    return items?.length ? items.map(item_0 => /*#__PURE__*/_jsx(MemoToolbarItem, {
+      active: deferredToolbarState.activeItemKeys.includes(item_0.key),
+      anchorElem: anchorElem,
+      editor: editor,
+      enabled: deferredToolbarState.enabledItemKeys.includes(item_0.key),
+      item: item_0
+    }, item_0.key)) : null;
+  }, [items, deferredToolbarState, anchorElem, editor]);
+  return /*#__PURE__*/_jsx(DropDown, {
+    buttonAriaLabel: `${groupKey} dropdown`,
+    buttonClassName: [baseClass, `${baseClass}-${groupKey}`, ...(classNames || [])].filter(Boolean).join(' '),
+    disabled: !deferredToolbarState.enabledGroup,
+    dropdownKey: groupKey,
+    Icon: Icon,
+    itemsContainerClassNames: [`${baseClass}-items`, ...(itemsContainerClassNames || [])],
+    label: label,
+    children: renderedItems
+  }, groupKey);
+};
+//# sourceMappingURL=index.js.map

package/dist/features/toolbars/shared/ToolbarDropdown/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":["c","_c","React","useCallback","useDeferredValue","useEffect","useMemo","baseClass","mergeRegister","useTranslation","$getSelection","useEditorConfigContext","useRunDeprioritized","DropDown","DropDownItem","ToolbarItem","t0","$","active","anchorElem","editor","enabled","item","i18n","fieldProps","t1","featureClientSchemaMap","schemaPath","Component","t2","_jsx","key","title","croppedTitle","label","length","substring","Icon","ChildComponent","undefined","itemKey","tooltip","children","className","MemoToolbarItem","memo","ToolbarDropdown","classNames","group","itemsContainerClassNames","maxActiveItems","onActiveChange","toolbarState","setToolbarState","useState","activeItemKeys","enabledGroup","enabledItemKeys","deferredToolbarState","editorConfigContext","items","groupKey","runDeprioritized","updateStates","getEditorState","read","selection","_activeItemKeys","_activeItems","_enabledItemKeys","isActive","push","isEnabled","activeItems","registerUpdateListener","renderedItems","map","includes","buttonAriaLabel","buttonClassName","filter","Boolean","join","disabled","dropdownKey"],"sources":["../../../../../src/features/toolbars/shared/ToolbarDropdown/index.tsx"],"sourcesContent":["'use client'\nimport React, { useCallback, useDeferredValue, useEffect, useMemo } from 'react'\n\nconst baseClass = 'toolbar-popup__dropdown'\n\nimport type { LexicalEditor } from 'lexical'\n\nimport { mergeRegister } from '@lexical/utils'\nimport { useTranslation } from '@ruya.sa/ui'\nimport { $getSelection } from 'lexical'\n\nimport type { ToolbarDropdownGroup, ToolbarGroupItem } from '../../types.js'\n\nimport { useEditorConfigContext } from '../../../../lexical/config/client/EditorConfigProvider.js'\nimport { useRunDeprioritized } from '../../../../utilities/useRunDeprioritized.js'\nimport './index.scss'\nimport { DropDown, DropDownItem } from './DropDown.js'\n\nconst ToolbarItem = ({\n  active,\n  anchorElem,\n  editor,\n  enabled,\n  item,\n}: {\n  active?: boolean\n  anchorElem: HTMLElement\n  editor: LexicalEditor\n  enabled?: boolean\n  item: ToolbarGroupItem\n}) => {\n  const { i18n } = useTranslation<{}, string>()\n  const {\n    fieldProps: { featureClientSchemaMap, schemaPath },\n  } = useEditorConfigContext()\n\n  if (item.Component) {\n    return (\n      item?.Component && (\n        <item.Component\n          active={active}\n          anchorElem={anchorElem}\n          editor={editor}\n          enabled={enabled}\n          item={item}\n          key={item.key}\n        />\n      )\n    )\n  }\n\n  let title = item.key\n  let croppedTitle = item.key\n  if (item.label) {\n    title =\n      typeof item.label === 'function'\n        ? item.label({ featureClientSchemaMap, i18n, schemaPath })\n        : item.label\n  }\n  // Crop title to max. 25 characters\n  if (title.length > 25) {\n    croppedTitle = title.substring(0, 25) + '...'\n  } else {\n    croppedTitle = title\n  }\n\n  return (\n    <DropDownItem\n      active={active}\n      editor={editor}\n      enabled={enabled}\n      Icon={item?.ChildComponent ? <item.ChildComponent /> : undefined}\n      item={item}\n      itemKey={item.key}\n      key={item.key}\n      tooltip={title}\n    >\n      <span className=\"text\">{croppedTitle}</span>\n    </DropDownItem>\n  )\n}\n\nconst MemoToolbarItem = React.memo(ToolbarItem)\n\nexport const ToolbarDropdown = ({\n  anchorElem,\n  classNames,\n  editor,\n  group,\n  Icon,\n  itemsContainerClassNames,\n  label,\n  maxActiveItems,\n  onActiveChange,\n}: {\n  anchorElem: HTMLElement\n  classNames?: string[]\n  editor: LexicalEditor\n  group: ToolbarDropdownGroup\n  Icon?: React.FC\n  itemsContainerClassNames?: string[]\n  label?: string\n  /**\n   * Maximum number of active items allowed. This is a performance optimization to prevent\n   * unnecessary item active checks when the maximum number of active items is reached.\n   */\n  maxActiveItems?: number\n  onActiveChange?: ({ activeItems }: { activeItems: ToolbarGroupItem[] }) => void\n}) => {\n  const [toolbarState, setToolbarState] = React.useState<{\n    activeItemKeys: string[]\n    enabledGroup: boolean\n    enabledItemKeys: string[]\n  }>({\n    activeItemKeys: [],\n    enabledGroup: true,\n    enabledItemKeys: [],\n  })\n  const deferredToolbarState = useDeferredValue(toolbarState)\n\n  const editorConfigContext = useEditorConfigContext()\n  const { items, key: groupKey } = group\n\n  const runDeprioritized = useRunDeprioritized()\n\n  const updateStates = useCallback(() => {\n    editor.getEditorState().read(() => {\n      const selection = $getSelection()\n      if (!selection) {\n        return\n      }\n\n      const _activeItemKeys: string[] = []\n      const _activeItems: ToolbarGroupItem[] = []\n      const _enabledItemKeys: string[] = []\n\n      for (const item of items) {\n        if (item.isActive && (!maxActiveItems || _activeItemKeys.length < maxActiveItems)) {\n          const isActive = item.isActive({ editor, editorConfigContext, selection })\n          if (isActive) {\n            _activeItemKeys.push(item.key)\n            _activeItems.push(item)\n          }\n        }\n        if (item.isEnabled) {\n          const isEnabled = item.isEnabled({ editor, editorConfigContext, selection })\n          if (isEnabled) {\n            _enabledItemKeys.push(item.key)\n          }\n        } else {\n          _enabledItemKeys.push(item.key)\n        }\n      }\n\n      setToolbarState({\n        activeItemKeys: _activeItemKeys,\n        enabledGroup: group.isEnabled\n          ? group.isEnabled({ editor, editorConfigContext, selection })\n          : true,\n        enabledItemKeys: _enabledItemKeys,\n      })\n\n      if (onActiveChange) {\n        onActiveChange({ activeItems: _activeItems })\n      }\n    })\n  }, [editor, editorConfigContext, group, items, maxActiveItems, onActiveChange])\n\n  useEffect(() => {\n    // Run on mount in order to update states when dropdown is opened\n    void runDeprioritized(updateStates)\n\n    return mergeRegister(\n      editor.registerUpdateListener(async () => {\n        await runDeprioritized(updateStates)\n      }),\n    )\n  }, [editor, runDeprioritized, updateStates])\n\n  const renderedItems = useMemo(() => {\n    return items?.length\n      ? items.map((item) => (\n          <MemoToolbarItem\n            active={deferredToolbarState.activeItemKeys.includes(item.key)}\n            anchorElem={anchorElem}\n            editor={editor}\n            enabled={deferredToolbarState.enabledItemKeys.includes(item.key)}\n            item={item}\n            key={item.key}\n          />\n        ))\n      : null\n  }, [items, deferredToolbarState, anchorElem, editor])\n\n  return (\n    <DropDown\n      buttonAriaLabel={`${groupKey} dropdown`}\n      buttonClassName={[baseClass, `${baseClass}-${groupKey}`, ...(classNames || [])]\n        .filter(Boolean)\n        .join(' ')}\n      disabled={!deferredToolbarState.enabledGroup}\n      dropdownKey={groupKey}\n      Icon={Icon}\n      itemsContainerClassNames={[`${baseClass}-items`, ...(itemsContainerClassNames || [])]}\n      key={groupKey}\n      label={label}\n    >\n      {renderedItems}\n    </DropDown>\n  )\n}\n"],"mappings":"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","ignoreList":[]}

package/dist/features/toolbars/types.d.ts

@@ -0,0 +1,103 @@
+import type { I18nClient } from '@ruya.sa/translations';
+import type { BaseSelection, LexicalEditor } from 'lexical';
+import type React from 'react';
+import type { EditorConfigContextType } from '../../lexical/config/client/EditorConfigProvider.js';
+import type { FeatureClientSchemaMap } from '../../types.js';
+export type ToolbarGroup = ToolbarButtonsGroup | ToolbarDropdownGroup;
+export type ToolbarDropdownGroup = {
+    /**
+     * The dropdown toolbar ChildComponent allows you to pass in a React Component which will be displayed within the dropdown button.
+     */
+    ChildComponent?: React.FC;
+    /**
+     * This is optional and controls if the toolbar group is highlighted or not.
+     */
+    isEnabled?: ({ editor, editorConfigContext, selection, }: {
+        editor: LexicalEditor;
+        editorConfigContext: EditorConfigContextType;
+        selection: BaseSelection;
+    }) => boolean;
+    /**
+     * All toolbar items part of this toolbar group need to be added here.
+     */
+    items: Array<ToolbarGroupItem>;
+    /**
+     * Each toolbar group needs to have a unique key. Groups with the same keys will have their items merged together.
+     */
+    key: string;
+    /**
+     * The maximum number of active items that can be selected at once.
+     * Increasing this will hurt performance, as more nodes need to be checked for their active state.
+     *
+     * E.g. if this is 1, we can stop checking nodes once we find an active node.
+     *
+     * @default 1
+     */
+    maxActiveItems?: number;
+    /**
+     * Determines where the toolbar group will be.
+     */
+    order?: number;
+    /**
+     * Controls the toolbar group type. Set to `dropdown` to create a buttons toolbar group, which displays toolbar items vertically using their icons and labels, if the dropdown is open.
+     */
+    type: 'dropdown';
+};
+export type ToolbarButtonsGroup = {
+    /**
+     * All toolbar items part of this toolbar group need to be added here.
+     */
+    items: Array<ToolbarGroupItem>;
+    /**
+     * Each toolbar group needs to have a unique key. Groups with the same keys will have their items merged together.
+     */
+    key: string;
+    /**
+     * Determines where the toolbar group will be.
+     */
+    order?: number;
+    /**
+     * Controls the toolbar group type. Set to `buttons` to create a buttons toolbar group, which displays toolbar items horizontally using only their icons.
+     */
+    type: 'buttons';
+};
+export type ToolbarGroupItem = {
+    /** A React component which is rendered within your toolbar item's default button component. Usually, you want this to be an icon. */
+    ChildComponent?: React.FC;
+    /** A React component which is rendered in place of the toolbar item's default button component, thus completely replacing it. The `ChildComponent` and `onSelect` properties will be ignored. */
+    Component?: React.FC<{
+        active?: boolean;
+        anchorElem: HTMLElement;
+        editor: LexicalEditor;
+        enabled?: boolean;
+        item: ToolbarGroupItem;
+    }>;
+    /** This is optional and controls if the toolbar item is highlighted or not. */
+    isActive?: ({ editor, editorConfigContext, selection, }: {
+        editor: LexicalEditor;
+        editorConfigContext: EditorConfigContextType;
+        selection: BaseSelection;
+    }) => boolean;
+    /** This is optional and controls if the toolbar item is clickable or not. If `false` is returned here, it will be grayed out and unclickable. */
+    isEnabled?: ({ editor, editorConfigContext, selection, }: {
+        editor: LexicalEditor;
+        editorConfigContext: EditorConfigContextType;
+        selection: BaseSelection;
+    }) => boolean;
+    /** Each toolbar item needs to have a unique key. */
+    key: string;
+    /** The label will be displayed in your toolbar item, if it's within a dropdown group. In order to make use of i18n, this can be a function. */
+    label?: ((args: {
+        featureClientSchemaMap: FeatureClientSchemaMap;
+        i18n: I18nClient<{}, string>;
+        schemaPath: string;
+    }) => string) | string;
+    /** Each toolbar item needs to have a unique key. */
+    onSelect?: ({ editor, isActive }: {
+        editor: LexicalEditor;
+        isActive: boolean;
+    }) => void;
+    order?: number;
+};
+export type CustomGroups = Record<string, Partial<Omit<ToolbarButtonsGroup, 'items' | 'key'>> | Partial<Omit<ToolbarDropdownGroup, 'isEnabled' | 'items' | 'key'>>>;
+//# sourceMappingURL=types.d.ts.map

package/dist/features/toolbars/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/features/toolbars/types.ts"],"names":[],"mappings":"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"}

package/dist/features/toolbars/types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=types.js.map

package/dist/features/toolbars/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","names":[],"sources":["../../../src/features/toolbars/types.ts"],"sourcesContent":["import type { I18nClient } from '@ruya.sa/translations'\nimport type { BaseSelection, LexicalEditor } from 'lexical'\nimport type React from 'react'\n\nimport type { EditorConfigContextType } from '../../lexical/config/client/EditorConfigProvider.js'\nimport type { FeatureClientSchemaMap } from '../../types.js'\n\nexport type ToolbarGroup = ToolbarButtonsGroup | ToolbarDropdownGroup\n\nexport type ToolbarDropdownGroup = {\n  /**\n   * The dropdown toolbar ChildComponent allows you to pass in a React Component which will be displayed within the dropdown button.\n   */\n  ChildComponent?: React.FC\n  /**\n   * This is optional and controls if the toolbar group is highlighted or not.\n   */\n  isEnabled?: ({\n    editor,\n    editorConfigContext,\n    selection,\n  }: {\n    editor: LexicalEditor\n    editorConfigContext: EditorConfigContextType\n    selection: BaseSelection\n  }) => boolean\n  /**\n   * All toolbar items part of this toolbar group need to be added here.\n   */\n  items: Array<ToolbarGroupItem>\n  /**\n   * Each toolbar group needs to have a unique key. Groups with the same keys will have their items merged together.\n   */\n  key: string\n  /**\n   * The maximum number of active items that can be selected at once.\n   * Increasing this will hurt performance, as more nodes need to be checked for their active state.\n   *\n   * E.g. if this is 1, we can stop checking nodes once we find an active node.\n   *\n   * @default 1\n   */\n  maxActiveItems?: number\n  /**\n   * Determines where the toolbar group will be.\n   */\n  order?: number\n  /**\n   * Controls the toolbar group type. Set to `dropdown` to create a buttons toolbar group, which displays toolbar items vertically using their icons and labels, if the dropdown is open.\n   */\n  type: 'dropdown'\n}\n\nexport type ToolbarButtonsGroup = {\n  /**\n   * All toolbar items part of this toolbar group need to be added here.\n   */\n  items: Array<ToolbarGroupItem>\n  /**\n   * Each toolbar group needs to have a unique key. Groups with the same keys will have their items merged together.\n   */\n  key: string\n  /**\n   * Determines where the toolbar group will be.\n   */\n  order?: number\n  /**\n   * Controls the toolbar group type. Set to `buttons` to create a buttons toolbar group, which displays toolbar items horizontally using only their icons.\n   */\n  type: 'buttons'\n}\n\nexport type ToolbarGroupItem = {\n  /** A React component which is rendered within your toolbar item's default button component. Usually, you want this to be an icon. */\n  ChildComponent?: React.FC\n  /** A React component which is rendered in place of the toolbar item's default button component, thus completely replacing it. The `ChildComponent` and `onSelect` properties will be ignored. */\n  Component?: React.FC<{\n    active?: boolean\n    anchorElem: HTMLElement\n    editor: LexicalEditor\n    enabled?: boolean\n    item: ToolbarGroupItem\n  }>\n  /** This is optional and controls if the toolbar item is highlighted or not. */\n  isActive?: ({\n    editor,\n    editorConfigContext,\n    selection,\n  }: {\n    editor: LexicalEditor\n    editorConfigContext: EditorConfigContextType\n    selection: BaseSelection\n  }) => boolean\n  /** This is optional and controls if the toolbar item is clickable or not. If `false` is returned here, it will be grayed out and unclickable. */\n  isEnabled?: ({\n    editor,\n    editorConfigContext,\n    selection,\n  }: {\n    editor: LexicalEditor\n    editorConfigContext: EditorConfigContextType\n    selection: BaseSelection\n  }) => boolean\n  /** Each toolbar item needs to have a unique key. */\n  key: string\n  /** The label will be displayed in your toolbar item, if it's within a dropdown group. In order to make use of i18n, this can be a function. */\n  label?:\n    | ((args: {\n        featureClientSchemaMap: FeatureClientSchemaMap\n        i18n: I18nClient<{}, string>\n        schemaPath: string\n      }) => string)\n    | string\n  /** Each toolbar item needs to have a unique key. */\n  onSelect?: ({ editor, isActive }: { editor: LexicalEditor; isActive: boolean }) => void\n  order?: number\n}\n\nexport type CustomGroups = Record<\n  string,\n  | Partial<Omit<ToolbarButtonsGroup, 'items' | 'key'>>\n  | Partial<Omit<ToolbarDropdownGroup, 'isEnabled' | 'items' | 'key'>>\n>\n"],"mappings":"AAsHA","ignoreList":[]}

package/dist/features/typeUtilities.d.ts

@@ -0,0 +1,8 @@
+import type { LexicalNode } from 'lexical';
+import type { NodeWithHooks } from './typesServer.js';
+/**
+ * Utility function to create a node with hooks. You don't have to use this utility, but it improves type inference
+ * @param node the node
+ */
+export declare function createNode<Node extends LexicalNode>(node: NodeWithHooks<Node>): NodeWithHooks<Node>;
+//# sourceMappingURL=typeUtilities.d.ts.map

package/dist/features/typeUtilities.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"typeUtilities.d.ts","sourceRoot":"","sources":["../../src/features/typeUtilities.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,SAAS,CAAA;AAE1C,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAA;AAErD;;;GAGG;AACH,wBAAgB,UAAU,CAAC,IAAI,SAAS,WAAW,EACjD,IAAI,EAAE,aAAa,CAAC,IAAI,CAAC,GACxB,aAAa,CAAC,IAAI,CAAC,CAErB"}

package/dist/features/typeUtilities.js

@@ -0,0 +1,7 @@
+/**
+ * Utility function to create a node with hooks. You don't have to use this utility, but it improves type inference
+ * @param node the node
+ */export function createNode(node) {
+  return node;
+}
+//# sourceMappingURL=typeUtilities.js.map

package/dist/features/typeUtilities.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"typeUtilities.js","names":["createNode","node"],"sources":["../../src/features/typeUtilities.ts"],"sourcesContent":["import type { LexicalNode } from 'lexical'\n\nimport type { NodeWithHooks } from './typesServer.js'\n\n/**\n * Utility function to create a node with hooks. You don't have to use this utility, but it improves type inference\n * @param node the node\n */\nexport function createNode<Node extends LexicalNode>(\n  node: NodeWithHooks<Node>,\n): NodeWithHooks<Node> {\n  return node\n}\n"],"mappings":"AAIA;;;GAIA,OAAO,SAASA,WACdC,IAAyB;EAEzB,OAAOA,IAAA;AACT","ignoreList":[]}

package/dist/features/typesClient.d.ts

@@ -0,0 +1,188 @@
+import type { Klass, LexicalEditor, LexicalNode, LexicalNodeReplacement, TextFormatType } from 'lexical';
+import type { ClientConfig, RichTextFieldClient } from '@ruya.sa/payload';
+import type React from 'react';
+import type { JSX } from 'react';
+import type { ClientEditorConfig } from '../lexical/config/types.js';
+import type { SlashMenuGroup } from '../lexical/plugins/SlashMenu/LexicalTypeaheadMenuPlugin/types.js';
+import type { Transformer } from '../packages/@lexical/markdown/index.js';
+import type { FeatureClientSchemaMap } from '../types.js';
+import type { ToolbarGroup } from './toolbars/types.js';
+export type FeatureProviderProviderClient<UnSanitizedClientFeatureProps = undefined, ClientFeatureProps = UnSanitizedClientFeatureProps> = (props: BaseClientFeatureProps<ClientFeatureProps>) => FeatureProviderClient<ClientFeatureProps>;
+/**
+ * No dependencies => Features need to be sorted on the server first, then sent to client in right order
+ */
+export type FeatureProviderClient<UnSanitizedClientFeatureProps = undefined, ClientFeatureProps = UnSanitizedClientFeatureProps> = {
+    /**
+     * Return props, to make it easy to retrieve passed in props to this Feature for the client if anyone wants to
+     */
+    clientFeatureProps: BaseClientFeatureProps<UnSanitizedClientFeatureProps>;
+    feature: ((props: {
+        config: ClientConfig;
+        featureClientImportMap: Record<string, any>;
+        featureClientSchemaMap: FeatureClientSchemaMap;
+        /** unSanitizedEditorConfig.features, but mapped */
+        featureProviderMap: ClientFeatureProviderMap;
+        field?: RichTextFieldClient;
+        resolvedFeatures: ResolvedClientFeatureMap;
+        schemaPath: string;
+        unSanitizedEditorConfig: ClientEditorConfig;
+    }) => ClientFeature<ClientFeatureProps>) | ClientFeature<ClientFeatureProps>;
+};
+export type PluginComponent<ClientFeatureProps = any> = React.FC<{
+    clientProps: ClientFeatureProps;
+}>;
+export type PluginComponentWithAnchor<ClientFeatureProps = any> = React.FC<{
+    anchorElem: HTMLElement;
+    clientProps: ClientFeatureProps;
+}>;
+/**
+ * Plugins are react components which get added to the editor. You can use them to interact with lexical, e.g. to create a command which creates a node, or opens a modal, or some other more "outside" functionality
+ */
+export type SanitizedPlugin = {
+    clientProps: any;
+    Component: PluginComponent;
+    key: string;
+    position: 'bottom';
+} | {
+    clientProps: any;
+    Component: PluginComponent;
+    key: string;
+    position: 'normal';
+} | {
+    clientProps: any;
+    Component: PluginComponent;
+    key: string;
+    position: 'top';
+} | {
+    clientProps: any;
+    Component: PluginComponentWithAnchor;
+    desktopOnly?: boolean;
+    key: string;
+    position: 'floatingAnchorElem';
+} | {
+    clientProps: any;
+    Component: PluginComponent;
+    key: string;
+    position: 'aboveContainer';
+} | {
+    clientProps: any;
+    Component: PluginComponent;
+    key: string;
+    position: 'belowContainer';
+};
+export type ClientFeature<ClientFeatureProps> = {
+    /**
+     * The text formats which are enabled by this feature.
+     */
+    enableFormats?: TextFormatType[];
+    markdownTransformers?: (((props: {
+        allNodes: Array<Klass<LexicalNode> | LexicalNodeReplacement>;
+        allTransformers: Transformer[];
+    }) => Transformer) | Transformer)[];
+    nodes?: Array<Klass<LexicalNode> | LexicalNodeReplacement>;
+    /**
+     * Plugins are react components which get added to the editor. You can use them to interact with lexical, e.g. to create a command which creates a node, or opens a modal, or some other more "outside" functionality
+     */
+    plugins?: Array<{
+        Component: PluginComponent<ClientFeatureProps>;
+        position: 'aboveContainer';
+    } | {
+        Component: PluginComponent<ClientFeatureProps>;
+        position: 'bottom';
+    } | {
+        Component: PluginComponent<ClientFeatureProps>;
+        position: 'normal';
+    } | {
+        Component: PluginComponent<ClientFeatureProps>;
+        position: 'top';
+    } | {
+        Component: PluginComponentWithAnchor<ClientFeatureProps>;
+        position: 'floatingAnchorElem';
+    } | {
+        Component: PluginComponent<ClientFeatureProps>;
+        position: 'belowContainer';
+    }>;
+    /**
+     * Client Features can register their own providers, which will be nested below the EditorConfigProvider
+     */
+    providers?: Array<React.FC<{
+        children: JSX.Element;
+    }>>;
+    /**
+     * Return props, to make it easy to retrieve passed in props to this Feature for the client if anyone wants to
+     */
+    sanitizedClientFeatureProps?: BaseClientFeatureProps<ClientFeatureProps>;
+    slashMenu?: {
+        /**
+         * Dynamic groups allow you to add different groups depending on the query string (so, the text after the slash).
+         * Thus, to re-calculate the available groups, this function will be called every time you type after the /.
+         *
+         * The groups provided by dynamicGroups will be merged with the static groups provided by the groups property.
+         */
+        dynamicGroups?: ({ editor, queryString, }: {
+            editor: LexicalEditor;
+            queryString: string;
+        }) => SlashMenuGroup[];
+        /**
+         * Static array of groups together with the items in them. These will always be present.
+         * While typing after the /, they will be filtered by the query string and the keywords, key and display name of the items.
+         */
+        groups?: SlashMenuGroup[];
+    };
+    /**
+     * An opt-in, classic fixed toolbar which stays at the top of the editor
+     */
+    toolbarFixed?: {
+        groups: ToolbarGroup[];
+    };
+    /**
+     * The default, floating toolbar which appears when you select text.
+     */
+    toolbarInline?: {
+        /**
+         * Array of toolbar groups / sections. Each section can contain multiple toolbar items.
+         */
+        groups: ToolbarGroup[];
+    };
+};
+export type BaseClientFeatureProps<ClientFeatureProps> = ClientFeatureProps extends undefined ? {
+    featureKey: string;
+    order: number;
+} : {
+    featureKey: string;
+    order: number;
+} & ClientFeatureProps;
+export type ResolvedClientFeature<ClientFeatureProps> = {
+    key: string;
+    order: number;
+} & ClientFeature<ClientFeatureProps>;
+export type ResolvedClientFeatureMap = Map<string, ResolvedClientFeature<any>>;
+export type ClientFeatureProviderMap = Map<string, FeatureProviderClient<any, any>>;
+export type SanitizedClientFeatures = {
+    /** The keys of all enabled features */
+    enabledFeatures: string[];
+    enabledFormats: TextFormatType[];
+    markdownTransformers: Transformer[];
+    /**
+     * Plugins are react components which get added to the editor. You can use them to interact with lexical, e.g. to create a command which creates a node, or opens a modal, or some other more "outside" functionality
+     */
+    plugins?: Array<SanitizedPlugin>;
+    slashMenu: {
+        /**
+         * Dynamic groups allow you to add different groups depending on the query string (so, the text after the slash).
+         * Thus, to re-calculate the available groups, this function will be called every time you type after the /.
+         *
+         * The groups provided by dynamicGroups will be merged with the static groups provided by the groups property.
+         */
+        dynamicGroups: Array<({ editor, queryString }: {
+            editor: LexicalEditor;
+            queryString: string;
+        }) => SlashMenuGroup[]>;
+        /**
+         * Static array of groups together with the items in them. These will always be present.
+         * While typing after the /, they will be filtered by the query string and the keywords, key and display name of the items.
+         */
+        groups: SlashMenuGroup[];
+    };
+} & Required<Pick<ResolvedClientFeature<unknown>, 'nodes' | 'providers' | 'toolbarFixed' | 'toolbarInline'>>;
+//# sourceMappingURL=typesClient.d.ts.map

package/dist/features/typesClient.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"typesClient.d.ts","sourceRoot":"","sources":["../../src/features/typesClient.ts"],"names":[],"mappings":"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"}

package/dist/features/typesClient.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=typesClient.js.map

package/dist/features/typesClient.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"typesClient.js","names":[],"sources":["../../src/features/typesClient.ts"],"sourcesContent":["import type {\n  Klass,\n  LexicalEditor,\n  LexicalNode,\n  LexicalNodeReplacement,\n  TextFormatType,\n} from 'lexical'\nimport type { ClientConfig, RichTextFieldClient } from '@ruya.sa/payload'\nimport type React from 'react'\nimport type { JSX } from 'react'\n\nimport type { ClientEditorConfig } from '../lexical/config/types.js'\nimport type { SlashMenuGroup } from '../lexical/plugins/SlashMenu/LexicalTypeaheadMenuPlugin/types.js'\nimport type { Transformer } from '../packages/@lexical/markdown/index.js'\nimport type { FeatureClientSchemaMap } from '../types.js'\nimport type { ToolbarGroup } from './toolbars/types.js'\n\nexport type FeatureProviderProviderClient<\n  UnSanitizedClientFeatureProps = undefined,\n  ClientFeatureProps = UnSanitizedClientFeatureProps,\n> = (props: BaseClientFeatureProps<ClientFeatureProps>) => FeatureProviderClient<ClientFeatureProps>\n\n/**\n * No dependencies => Features need to be sorted on the server first, then sent to client in right order\n */\nexport type FeatureProviderClient<\n  UnSanitizedClientFeatureProps = undefined,\n  ClientFeatureProps = UnSanitizedClientFeatureProps,\n> = {\n  /**\n   * Return props, to make it easy to retrieve passed in props to this Feature for the client if anyone wants to\n   */\n  clientFeatureProps: BaseClientFeatureProps<UnSanitizedClientFeatureProps>\n  feature:\n    | ((props: {\n        config: ClientConfig\n        featureClientImportMap: Record<string, any>\n        featureClientSchemaMap: FeatureClientSchemaMap\n        /** unSanitizedEditorConfig.features, but mapped */\n        featureProviderMap: ClientFeatureProviderMap\n        field?: RichTextFieldClient\n        // other resolved features, which have been loaded before this one. All features declared in 'dependencies' should be available here\n        resolvedFeatures: ResolvedClientFeatureMap\n        schemaPath: string\n        // unSanitized EditorConfig,\n        unSanitizedEditorConfig: ClientEditorConfig\n      }) => ClientFeature<ClientFeatureProps>)\n    | ClientFeature<ClientFeatureProps>\n}\n\nexport type PluginComponent<ClientFeatureProps = any> = React.FC<{\n  clientProps: ClientFeatureProps\n}>\nexport type PluginComponentWithAnchor<ClientFeatureProps = any> = React.FC<{\n  anchorElem: HTMLElement\n  clientProps: ClientFeatureProps\n}>\n\n/**\n * Plugins are react components which get added to the editor. You can use them to interact with lexical, e.g. to create a command which creates a node, or opens a modal, or some other more \"outside\" functionality\n */\nexport type SanitizedPlugin =\n  | {\n      clientProps: any\n      // plugins are anything which is not directly part of the editor. Like, creating a command which creates a node, or opens a modal, or some other more \"outside\" functionality\n      Component: PluginComponent\n      key: string\n      position: 'bottom' // Determines at which position the Component will be added.\n    }\n  | {\n      clientProps: any\n      // plugins are anything which is not directly part of the editor. Like, creating a command which creates a node, or opens a modal, or some other more \"outside\" functionality\n      Component: PluginComponent\n      key: string\n      position: 'normal' // Determines at which position the Component will be added.\n    }\n  | {\n      clientProps: any\n      // plugins are anything which is not directly part of the editor. Like, creating a command which creates a node, or opens a modal, or some other more \"outside\" functionality\n      Component: PluginComponent\n      key: string\n      position: 'top' // Determines at which position the Component will be added.\n    }\n  | {\n      clientProps: any\n      // plugins are anything which is not directly part of the editor. Like, creating a command which creates a node, or opens a modal, or some other more \"outside\" functionality\n      Component: PluginComponentWithAnchor\n      desktopOnly?: boolean\n      key: string\n      position: 'floatingAnchorElem' // Determines at which position the Component will be added.\n    }\n  | {\n      clientProps: any\n      Component: PluginComponent\n      key: string\n      position: 'aboveContainer'\n    }\n  | {\n      clientProps: any\n      Component: PluginComponent\n      key: string\n      position: 'belowContainer'\n    }\n\nexport type ClientFeature<ClientFeatureProps> = {\n  /**\n   * The text formats which are enabled by this feature.\n   */\n  enableFormats?: TextFormatType[]\n  markdownTransformers?: (\n    | ((props: {\n        allNodes: Array<Klass<LexicalNode> | LexicalNodeReplacement>\n        allTransformers: Transformer[]\n      }) => Transformer)\n    | Transformer\n  )[]\n  nodes?: Array<Klass<LexicalNode> | LexicalNodeReplacement>\n  /**\n   * Plugins are react components which get added to the editor. You can use them to interact with lexical, e.g. to create a command which creates a node, or opens a modal, or some other more \"outside\" functionality\n   */\n  plugins?: Array<\n    | {\n        // plugins are anything which is not directly part of the editor. Like, creating a command which creates a node, or opens a modal, or some other more \"outside\" functionality\n        Component: PluginComponent<ClientFeatureProps>\n        position: 'aboveContainer' // Determines at which position the Component will be added.\n      }\n    | {\n        // plugins are anything which is not directly part of the editor. Like, creating a command which creates a node, or opens a modal, or some other more \"outside\" functionality\n        Component: PluginComponent<ClientFeatureProps>\n        position: 'bottom' // Determines at which position the Component will be added.\n      }\n    | {\n        // plugins are anything which is not directly part of the editor. Like, creating a command which creates a node, or opens a modal, or some other more \"outside\" functionality\n        Component: PluginComponent<ClientFeatureProps>\n        position: 'normal' // Determines at which position the Component will be added.\n      }\n    | {\n        // plugins are anything which is not directly part of the editor. Like, creating a command which creates a node, or opens a modal, or some other more \"outside\" functionality\n        Component: PluginComponent<ClientFeatureProps>\n        position: 'top' // Determines at which position the Component will be added.\n      }\n    | {\n        // plugins are anything which is not directly part of the editor. Like, creating a command which creates a node, or opens a modal, or some other more \"outside\" functionality\n        Component: PluginComponentWithAnchor<ClientFeatureProps>\n        position: 'floatingAnchorElem' // Determines at which position the Component will be added.\n      }\n    | {\n        Component: PluginComponent<ClientFeatureProps>\n        position: 'belowContainer' // Determines at which position the Component will be added.\n      }\n  >\n  /**\n   * Client Features can register their own providers, which will be nested below the EditorConfigProvider\n   */\n  providers?: Array<React.FC<{ children: JSX.Element }>>\n  /**\n   * Return props, to make it easy to retrieve passed in props to this Feature for the client if anyone wants to\n   */\n  sanitizedClientFeatureProps?: BaseClientFeatureProps<ClientFeatureProps>\n  slashMenu?: {\n    /**\n     * Dynamic groups allow you to add different groups depending on the query string (so, the text after the slash).\n     * Thus, to re-calculate the available groups, this function will be called every time you type after the /.\n     *\n     * The groups provided by dynamicGroups will be merged with the static groups provided by the groups property.\n     */\n    dynamicGroups?: ({\n      editor,\n      queryString,\n    }: {\n      editor: LexicalEditor\n      queryString: string\n    }) => SlashMenuGroup[]\n    /**\n     * Static array of groups together with the items in them. These will always be present.\n     * While typing after the /, they will be filtered by the query string and the keywords, key and display name of the items.\n     */\n    groups?: SlashMenuGroup[]\n  }\n  /**\n   * An opt-in, classic fixed toolbar which stays at the top of the editor\n   */\n  toolbarFixed?: {\n    groups: ToolbarGroup[]\n  }\n  /**\n   * The default, floating toolbar which appears when you select text.\n   */\n  toolbarInline?: {\n    /**\n     * Array of toolbar groups / sections. Each section can contain multiple toolbar items.\n     */\n    groups: ToolbarGroup[]\n  }\n}\n\nexport type BaseClientFeatureProps<ClientFeatureProps> = ClientFeatureProps extends undefined\n  ? {\n      featureKey: string\n      order: number\n    }\n  : {\n      featureKey: string\n      order: number\n    } & ClientFeatureProps\n\nexport type ResolvedClientFeature<ClientFeatureProps> = {\n  key: string\n  order: number\n} & ClientFeature<ClientFeatureProps>\n\nexport type ResolvedClientFeatureMap = Map<string, ResolvedClientFeature<any>>\n\nexport type ClientFeatureProviderMap = Map<string, FeatureProviderClient<any, any>>\n\nexport type SanitizedClientFeatures = {\n  /** The keys of all enabled features */\n  enabledFeatures: string[]\n  enabledFormats: TextFormatType[]\n  markdownTransformers: Transformer[]\n\n  /**\n   * Plugins are react components which get added to the editor. You can use them to interact with lexical, e.g. to create a command which creates a node, or opens a modal, or some other more \"outside\" functionality\n   */\n  plugins?: Array<SanitizedPlugin>\n  slashMenu: {\n    /**\n     * Dynamic groups allow you to add different groups depending on the query string (so, the text after the slash).\n     * Thus, to re-calculate the available groups, this function will be called every time you type after the /.\n     *\n     * The groups provided by dynamicGroups will be merged with the static groups provided by the groups property.\n     */\n    dynamicGroups: Array<\n      ({ editor, queryString }: { editor: LexicalEditor; queryString: string }) => SlashMenuGroup[]\n    >\n    /**\n     * Static array of groups together with the items in them. These will always be present.\n     * While typing after the /, they will be filtered by the query string and the keywords, key and display name of the items.\n     */\n    groups: SlashMenuGroup[]\n  }\n} & Required<\n  Pick<ResolvedClientFeature<unknown>, 'nodes' | 'providers' | 'toolbarFixed' | 'toolbarInline'>\n>\n"],"mappings":"AAuNA","ignoreList":[]}