@ruya.sa/richtext-lexical 3.71.7

package/dist/utilities/fieldsDrawer/useLexicalListDrawer.js

@@ -0,0 +1,154 @@
+'use client';
+
+import { c as _c } from "react/compiler-runtime";
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useLexicalComposerContext } from '@lexical/react/LexicalComposerContext';
+import { useListDrawer, useModal } from '@ruya.sa/ui';
+import { $getNodeByKey, $getPreviousSelection, $getRoot, $getSelection, $isRangeSelection, $setSelection } from 'lexical';
+import { useCallback, useEffect, useState } from 'react';
+/**
+ *
+ * Wrapper around useListDrawer that restores and saves selection state (cursor position) when opening and closing the drawer.
+ * By default, the lexical cursor position may be lost when opening a drawer and clicking somewhere on that drawer.
+ */
+export const useLexicalListDrawer = args => {
+  const $ = _c(23);
+  const [editor] = useLexicalComposerContext();
+  const [selectionState, setSelectionState] = useState(null);
+  const [wasOpen, setWasOpen] = useState(false);
+  const [BaseListDrawer, BaseListDrawerToggler, t0] = useListDrawer(args);
+  const {
+    closeDrawer: baseCloseDrawer,
+    drawerSlug: listDrawerSlug,
+    isDrawerOpen,
+    openDrawer: baseOpenDrawer
+  } = t0;
+  const {
+    modalState
+  } = useModal();
+  let t1;
+  if ($[0] === Symbol.for("react.memo_cache_sentinel")) {
+    t1 = () => {
+      const selection = $getSelection() ?? $getPreviousSelection();
+      setSelectionState(selection);
+    };
+    $[0] = t1;
+  } else {
+    t1 = $[0];
+  }
+  const $storeSelection = t1;
+  let t2;
+  if ($[1] !== editor || $[2] !== selectionState) {
+    t2 = () => {
+      if (selectionState) {
+        editor.update(() => {
+          if ($isRangeSelection(selectionState)) {
+            const {
+              anchor,
+              focus
+            } = selectionState;
+            if ($getNodeByKey(anchor.key) && $getNodeByKey(focus.key)) {
+              $setSelection(selectionState.clone());
+            }
+          } else {
+            $getRoot().selectEnd();
+          }
+        }, {
+          discrete: true,
+          skipTransforms: true
+        });
+      }
+    };
+    $[1] = editor;
+    $[2] = selectionState;
+    $[3] = t2;
+  } else {
+    t2 = $[3];
+  }
+  const restoreSelection = t2;
+  let t3;
+  if ($[4] !== baseCloseDrawer) {
+    t3 = () => {
+      baseCloseDrawer();
+    };
+    $[4] = baseCloseDrawer;
+    $[5] = t3;
+  } else {
+    t3 = $[5];
+  }
+  const closeListDrawer = t3;
+  let t4;
+  let t5;
+  if ($[6] !== listDrawerSlug || $[7] !== modalState || $[8] !== restoreSelection || $[9] !== wasOpen) {
+    t4 = () => {
+      if (!wasOpen) {
+        return;
+      }
+      const thisModalState = modalState[listDrawerSlug];
+      if (thisModalState && !thisModalState?.isOpen) {
+        setWasOpen(false);
+        setTimeout(() => {
+          restoreSelection();
+        }, 1);
+      }
+    };
+    t5 = [modalState, listDrawerSlug, restoreSelection, wasOpen];
+    $[6] = listDrawerSlug;
+    $[7] = modalState;
+    $[8] = restoreSelection;
+    $[9] = wasOpen;
+    $[10] = t4;
+    $[11] = t5;
+  } else {
+    t4 = $[10];
+    t5 = $[11];
+  }
+  useEffect(t4, t5);
+  let t6;
+  if ($[12] !== BaseListDrawerToggler) {
+    t6 = props => _jsx(BaseListDrawerToggler, {
+      ...props,
+      onClick: () => {
+        $storeSelection();
+      }
+    });
+    $[12] = BaseListDrawerToggler;
+    $[13] = t6;
+  } else {
+    t6 = $[13];
+  }
+  let t7;
+  if ($[14] !== baseOpenDrawer) {
+    t7 = () => {
+      $storeSelection();
+      baseOpenDrawer();
+      setWasOpen(true);
+    };
+    $[14] = baseOpenDrawer;
+    $[15] = t7;
+  } else {
+    t7 = $[15];
+  }
+  let t8;
+  if ($[16] !== BaseListDrawer || $[17] !== closeListDrawer || $[18] !== isDrawerOpen || $[19] !== listDrawerSlug || $[20] !== t6 || $[21] !== t7) {
+    t8 = {
+      closeListDrawer,
+      isListDrawerOpen: isDrawerOpen,
+      ListDrawer: BaseListDrawer,
+      listDrawerSlug,
+      ListDrawerToggler: t6,
+      openListDrawer: t7
+    };
+    $[16] = BaseListDrawer;
+    $[17] = closeListDrawer;
+    $[18] = isDrawerOpen;
+    $[19] = listDrawerSlug;
+    $[20] = t6;
+    $[21] = t7;
+    $[22] = t8;
+  } else {
+    t8 = $[22];
+  }
+  return t8;
+};
+//# sourceMappingURL=useLexicalListDrawer.js.map

package/dist/utilities/fieldsDrawer/useLexicalListDrawer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useLexicalListDrawer.js","names":["c","_c","useLexicalComposerContext","useListDrawer","useModal","$getNodeByKey","$getPreviousSelection","$getRoot","$getSelection","$isRangeSelection","$setSelection","useCallback","useEffect","useState","useLexicalListDrawer","args","$","editor","selectionState","setSelectionState","wasOpen","setWasOpen","BaseListDrawer","BaseListDrawerToggler","t0","closeDrawer","baseCloseDrawer","drawerSlug","listDrawerSlug","isDrawerOpen","openDrawer","baseOpenDrawer","modalState","t1","Symbol","for","selection","$storeSelection","t2","update","anchor","focus","key","clone","selectEnd","discrete","skipTransforms","restoreSelection","t3","closeListDrawer","t4","t5","thisModalState","isOpen","setTimeout","t6","props","_jsx","onClick","t7","t8","isListDrawerOpen","ListDrawer","ListDrawerToggler"],"sources":["../../../src/utilities/fieldsDrawer/useLexicalListDrawer.tsx"],"sourcesContent":["'use client'\nimport type { UseListDrawer } from '@ruya.sa/ui'\nimport type { BaseSelection } from 'lexical'\n\nimport { useLexicalComposerContext } from '@lexical/react/LexicalComposerContext'\nimport { useListDrawer, useModal } from '@ruya.sa/ui'\nimport {\n  $getNodeByKey,\n  $getPreviousSelection,\n  $getRoot,\n  $getSelection,\n  $isRangeSelection,\n  $setSelection,\n} from 'lexical'\nimport { useCallback, useEffect, useState } from 'react'\n\n/**\n *\n * Wrapper around useListDrawer that restores and saves selection state (cursor position) when opening and closing the drawer.\n * By default, the lexical cursor position may be lost when opening a drawer and clicking somewhere on that drawer.\n */\nexport const useLexicalListDrawer = (\n  args: Parameters<UseListDrawer>[0],\n): {\n  closeListDrawer: () => void\n  isListDrawerOpen: boolean\n  ListDrawer: ReturnType<UseListDrawer>[0]\n  listDrawerSlug: string\n  ListDrawerToggler: ReturnType<UseListDrawer>[1]\n  openListDrawer: (selection?: BaseSelection) => void\n} => {\n  const [editor] = useLexicalComposerContext()\n  const [selectionState, setSelectionState] = useState<BaseSelection | null>(null)\n  const [wasOpen, setWasOpen] = useState<boolean>(false)\n\n  const [\n    BaseListDrawer,\n    BaseListDrawerToggler,\n    {\n      closeDrawer: baseCloseDrawer,\n      drawerSlug: listDrawerSlug,\n      isDrawerOpen,\n      openDrawer: baseOpenDrawer,\n    },\n  ] = useListDrawer(args)\n  const { modalState } = useModal()\n\n  const $storeSelection = useCallback(() => {\n    // editor.read() causes an error here when creating a new upload node from the slash menu. It seems like we can omit it here though, as all\n    // invocations of that functions are wrapped in editor.read() or editor.update() somewhere in the call stack.\n    const selection = $getSelection() ?? $getPreviousSelection()\n    setSelectionState(selection)\n  }, [])\n\n  const restoreSelection = useCallback(() => {\n    if (selectionState) {\n      editor.update(\n        () => {\n          if ($isRangeSelection(selectionState)) {\n            const { anchor, focus } = selectionState\n            if ($getNodeByKey(anchor.key) && $getNodeByKey(focus.key)) {\n              $setSelection(selectionState.clone())\n            }\n          } else {\n            // not ideal, but better than losing the selection. Try to set the selection\n            // in a valid place if you remove selected nodes!\n            $getRoot().selectEnd()\n          }\n        },\n        { discrete: true, skipTransforms: true },\n      )\n    }\n  }, [editor, selectionState])\n\n  const closeListDrawer = () => {\n    //restoreSelection() // Should already be stored by the useEffect below\n    baseCloseDrawer()\n  }\n\n  // We need to handle drawer closing via a useEffect, as toggleDrawer / closeDrawer will not be triggered if the drawer\n  // is closed by clicking outside of the drawer. This useEffect will handle everything.\n  useEffect(() => {\n    if (!wasOpen) {\n      return\n    }\n\n    const thisModalState = modalState[listDrawerSlug]\n    // Exists in modalState (thus has opened at least once before) and is closed\n    if (thisModalState && !thisModalState?.isOpen) {\n      setWasOpen(false)\n      setTimeout(() => {\n        restoreSelection()\n      }, 1)\n    }\n  }, [modalState, listDrawerSlug, restoreSelection, wasOpen])\n\n  return {\n    closeListDrawer,\n    isListDrawerOpen: isDrawerOpen,\n    ListDrawer: BaseListDrawer,\n    listDrawerSlug,\n    ListDrawerToggler: (props) => (\n      <BaseListDrawerToggler\n        {...props}\n        onClick={() => {\n          $storeSelection()\n        }}\n      />\n    ),\n    openListDrawer: () => {\n      $storeSelection()\n      baseOpenDrawer()\n      setWasOpen(true)\n    },\n  }\n}\n"],"mappings":"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","ignoreList":[]}

package/dist/utilities/forEachNodeRecursively.d.ts

@@ -0,0 +1,10 @@
+import type { SerializedLexicalNode } from 'lexical';
+export declare function recurseNodes({ callback, nodes, }: {
+    callback: (node: SerializedLexicalNode) => void;
+    nodes: SerializedLexicalNode[];
+}): void;
+export declare function recurseNodesAsync({ callback, nodes, }: {
+    callback: (node: SerializedLexicalNode) => Promise<void>;
+    nodes: SerializedLexicalNode[];
+}): Promise<void>;
+//# sourceMappingURL=forEachNodeRecursively.d.ts.map

package/dist/utilities/forEachNodeRecursively.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"forEachNodeRecursively.d.ts","sourceRoot":"","sources":["../../src/utilities/forEachNodeRecursively.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,SAAS,CAAA;AAEpD,wBAAgB,YAAY,CAAC,EAC3B,QAAQ,EACR,KAAK,GACN,EAAE;IACD,QAAQ,EAAE,CAAC,IAAI,EAAE,qBAAqB,KAAK,IAAI,CAAA;IAC/C,KAAK,EAAE,qBAAqB,EAAE,CAAA;CAC/B,QAQA;AAED,wBAAsB,iBAAiB,CAAC,EACtC,QAAQ,EACR,KAAK,GACN,EAAE;IACD,QAAQ,EAAE,CAAC,IAAI,EAAE,qBAAqB,KAAK,OAAO,CAAC,IAAI,CAAC,CAAA;IACxD,KAAK,EAAE,qBAAqB,EAAE,CAAA;CAC/B,iBAQA"}

package/dist/utilities/forEachNodeRecursively.js

@@ -0,0 +1,29 @@
+export function recurseNodes({
+  callback,
+  nodes
+}) {
+  for (const node of nodes) {
+    callback(node);
+    if ('children' in node && Array.isArray(node?.children) && node?.children?.length) {
+      recurseNodes({
+        callback,
+        nodes: node.children
+      });
+    }
+  }
+}
+export async function recurseNodesAsync({
+  callback,
+  nodes
+}) {
+  for (const node of nodes) {
+    await callback(node);
+    if ('children' in node && Array.isArray(node?.children) && node?.children?.length) {
+      await recurseNodesAsync({
+        callback,
+        nodes: node.children
+      });
+    }
+  }
+}
+//# sourceMappingURL=forEachNodeRecursively.js.map

package/dist/utilities/forEachNodeRecursively.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"forEachNodeRecursively.js","names":["recurseNodes","callback","nodes","node","Array","isArray","children","length","recurseNodesAsync"],"sources":["../../src/utilities/forEachNodeRecursively.ts"],"sourcesContent":["import type { SerializedLexicalNode } from 'lexical'\n\nexport function recurseNodes({\n  callback,\n  nodes,\n}: {\n  callback: (node: SerializedLexicalNode) => void\n  nodes: SerializedLexicalNode[]\n}) {\n  for (const node of nodes) {\n    callback(node)\n\n    if ('children' in node && Array.isArray(node?.children) && node?.children?.length) {\n      recurseNodes({ callback, nodes: node.children as SerializedLexicalNode[] })\n    }\n  }\n}\n\nexport async function recurseNodesAsync({\n  callback,\n  nodes,\n}: {\n  callback: (node: SerializedLexicalNode) => Promise<void>\n  nodes: SerializedLexicalNode[]\n}) {\n  for (const node of nodes) {\n    await callback(node)\n\n    if ('children' in node && Array.isArray(node?.children) && node?.children?.length) {\n      await recurseNodesAsync({ callback, nodes: node.children as SerializedLexicalNode[] })\n    }\n  }\n}\n"],"mappings":"AAEA,OAAO,SAASA,aAAa;EAC3BC,QAAQ;EACRC;AAAK,CAIN;EACC,KAAK,MAAMC,IAAA,IAAQD,KAAA,EAAO;IACxBD,QAAA,CAASE,IAAA;IAET,IAAI,cAAcA,IAAA,IAAQC,KAAA,CAAMC,OAAO,CAACF,IAAA,EAAMG,QAAA,KAAaH,IAAA,EAAMG,QAAA,EAAUC,MAAA,EAAQ;MACjFP,YAAA,CAAa;QAAEC,QAAA;QAAUC,KAAA,EAAOC,IAAA,CAAKG;MAAoC;IAC3E;EACF;AACF;AAEA,OAAO,eAAeE,kBAAkB;EACtCP,QAAQ;EACRC;AAAK,CAIN;EACC,KAAK,MAAMC,IAAA,IAAQD,KAAA,EAAO;IACxB,MAAMD,QAAA,CAASE,IAAA;IAEf,IAAI,cAAcA,IAAA,IAAQC,KAAA,CAAMC,OAAO,CAACF,IAAA,EAAMG,QAAA,KAAaH,IAAA,EAAMG,QAAA,EAAUC,MAAA,EAAQ;MACjF,MAAMC,iBAAA,CAAkB;QAAEP,QAAA;QAAUC,KAAA,EAAOC,IAAA,CAAKG;MAAoC;IACtF;EACF;AACF","ignoreList":[]}

package/dist/utilities/generateImportMap.d.ts

@@ -0,0 +1,8 @@
+import type { RichTextAdapter } from '@ruya.sa/payload';
+import type { ResolvedServerFeatureMap } from '../features/typesServer.js';
+import type { LexicalEditorProps } from '../types.js';
+export declare const getGenerateImportMap: (args: {
+    lexicalEditorArgs?: LexicalEditorProps;
+    resolvedFeatureMap: ResolvedServerFeatureMap;
+}) => RichTextAdapter["generateImportMap"];
+//# sourceMappingURL=generateImportMap.d.ts.map

package/dist/utilities/generateImportMap.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"generateImportMap.d.ts","sourceRoot":"","sources":["../../src/utilities/generateImportMap.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAA;AAIvD,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,4BAA4B,CAAA;AAC1E,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,aAAa,CAAA;AAErD,eAAO,MAAM,oBAAoB,SACxB;IACL,iBAAiB,CAAC,EAAE,kBAAkB,CAAA;IACtC,kBAAkB,EAAE,wBAAwB,CAAA;CAC7C,KAAG,eAAe,CAAC,mBAAmB,CA+CtC,CAAA"}

package/dist/utilities/generateImportMap.js

@@ -0,0 +1,52 @@
+import { genImportMapIterateFields } from '@ruya.sa/payload';
+export const getGenerateImportMap = args => ({
+  addToImportMap,
+  baseDir,
+  config,
+  importMap,
+  imports
+}) => {
+  addToImportMap('@ruya.sa/richtext-lexical/rsc#RscEntryLexicalCell');
+  addToImportMap('@ruya.sa/richtext-lexical/rsc#RscEntryLexicalField');
+  addToImportMap('@ruya.sa/richtext-lexical/rsc#LexicalDiffComponent');
+  for (const resolvedFeature of args.resolvedFeatureMap.values()) {
+    if ('componentImports' in resolvedFeature) {
+      if (typeof resolvedFeature.componentImports === 'function') {
+        resolvedFeature.componentImports({
+          addToImportMap,
+          baseDir,
+          config,
+          importMap,
+          imports
+        });
+      } else if (Array.isArray(resolvedFeature.componentImports)) {
+        addToImportMap(resolvedFeature.componentImports);
+      } else if (typeof resolvedFeature.componentImports === 'object') {
+        addToImportMap(Object.values(resolvedFeature.componentImports));
+      }
+    }
+    addToImportMap(resolvedFeature.ClientFeature);
+    /*
+    * Now run for all possible sub-fields
+    */
+    if (resolvedFeature.nodes?.length) {
+      for (const node of resolvedFeature.nodes) {
+        if (typeof node?.getSubFields !== 'function') {
+          continue;
+        }
+        const subFields = node.getSubFields({});
+        if (subFields?.length) {
+          genImportMapIterateFields({
+            addToImportMap,
+            baseDir,
+            config,
+            fields: subFields,
+            importMap,
+            imports
+          });
+        }
+      }
+    }
+  }
+};
+//# sourceMappingURL=generateImportMap.js.map

package/dist/utilities/generateImportMap.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"generateImportMap.js","names":["genImportMapIterateFields","getGenerateImportMap","args","addToImportMap","baseDir","config","importMap","imports","resolvedFeature","resolvedFeatureMap","values","componentImports","Array","isArray","Object","ClientFeature","nodes","length","node","getSubFields","subFields","fields"],"sources":["../../src/utilities/generateImportMap.tsx"],"sourcesContent":["import type { RichTextAdapter } from '@ruya.sa/payload'\n\nimport { genImportMapIterateFields } from '@ruya.sa/payload'\n\nimport type { ResolvedServerFeatureMap } from '../features/typesServer.js'\nimport type { LexicalEditorProps } from '../types.js'\n\nexport const getGenerateImportMap =\n  (args: {\n    lexicalEditorArgs?: LexicalEditorProps\n    resolvedFeatureMap: ResolvedServerFeatureMap\n  }): RichTextAdapter['generateImportMap'] =>\n  ({ addToImportMap, baseDir, config, importMap, imports }) => {\n    addToImportMap('@ruya.sa/richtext-lexical/rsc#RscEntryLexicalCell')\n    addToImportMap('@ruya.sa/richtext-lexical/rsc#RscEntryLexicalField')\n    addToImportMap('@ruya.sa/richtext-lexical/rsc#LexicalDiffComponent')\n\n    for (const resolvedFeature of args.resolvedFeatureMap.values()) {\n      if ('componentImports' in resolvedFeature) {\n        if (typeof resolvedFeature.componentImports === 'function') {\n          resolvedFeature.componentImports({\n            addToImportMap,\n            baseDir,\n            config,\n            importMap,\n            imports,\n          })\n        } else if (Array.isArray(resolvedFeature.componentImports)) {\n          addToImportMap(resolvedFeature.componentImports)\n        } else if (typeof resolvedFeature.componentImports === 'object') {\n          addToImportMap(Object.values(resolvedFeature.componentImports))\n        }\n      }\n\n      addToImportMap(resolvedFeature.ClientFeature)\n\n      /*\n       * Now run for all possible sub-fields\n       */\n      if (resolvedFeature.nodes?.length) {\n        for (const node of resolvedFeature.nodes) {\n          if (typeof node?.getSubFields !== 'function') {\n            continue\n          }\n          const subFields = node.getSubFields({})\n          if (subFields?.length) {\n            genImportMapIterateFields({\n              addToImportMap,\n              baseDir,\n              config,\n              fields: subFields,\n              importMap,\n              imports,\n            })\n          }\n        }\n      }\n    }\n  }\n"],"mappings":"AAEA,SAASA,yBAAyB,QAAQ;AAK1C,OAAO,MAAMC,oBAAA,GACVC,IAAA,IAID,CAAC;EAAEC,cAAc;EAAEC,OAAO;EAAEC,MAAM;EAAEC,SAAS;EAAEC;AAAO,CAAE;EACtDJ,cAAA,CAAe;EACfA,cAAA,CAAe;EACfA,cAAA,CAAe;EAEf,KAAK,MAAMK,eAAA,IAAmBN,IAAA,CAAKO,kBAAkB,CAACC,MAAM,IAAI;IAC9D,IAAI,sBAAsBF,eAAA,EAAiB;MACzC,IAAI,OAAOA,eAAA,CAAgBG,gBAAgB,KAAK,YAAY;QAC1DH,eAAA,CAAgBG,gBAAgB,CAAC;UAC/BR,cAAA;UACAC,OAAA;UACAC,MAAA;UACAC,SAAA;UACAC;QACF;MACF,OAAO,IAAIK,KAAA,CAAMC,OAAO,CAACL,eAAA,CAAgBG,gBAAgB,GAAG;QAC1DR,cAAA,CAAeK,eAAA,CAAgBG,gBAAgB;MACjD,OAAO,IAAI,OAAOH,eAAA,CAAgBG,gBAAgB,KAAK,UAAU;QAC/DR,cAAA,CAAeW,MAAA,CAAOJ,MAAM,CAACF,eAAA,CAAgBG,gBAAgB;MAC/D;IACF;IAEAR,cAAA,CAAeK,eAAA,CAAgBO,aAAa;IAE5C;;;IAGA,IAAIP,eAAA,CAAgBQ,KAAK,EAAEC,MAAA,EAAQ;MACjC,KAAK,MAAMC,IAAA,IAAQV,eAAA,CAAgBQ,KAAK,EAAE;QACxC,IAAI,OAAOE,IAAA,EAAMC,YAAA,KAAiB,YAAY;UAC5C;QACF;QACA,MAAMC,SAAA,GAAYF,IAAA,CAAKC,YAAY,CAAC,CAAC;QACrC,IAAIC,SAAA,EAAWH,MAAA,EAAQ;UACrBjB,yBAAA,CAA0B;YACxBG,cAAA;YACAC,OAAA;YACAC,MAAA;YACAgB,MAAA,EAAQD,SAAA;YACRd,SAAA;YACAC;UACF;QACF;MACF;IACF;EACF;AACF","ignoreList":[]}

package/dist/utilities/generateSchemaMap.d.ts

@@ -0,0 +1,6 @@
+import type { RichTextAdapter } from '@ruya.sa/payload';
+import type { ResolvedServerFeatureMap } from '../features/typesServer.js';
+export declare const getGenerateSchemaMap: (args: {
+    resolvedFeatureMap: ResolvedServerFeatureMap;
+}) => RichTextAdapter["generateSchemaMap"];
+//# sourceMappingURL=generateSchemaMap.d.ts.map

package/dist/utilities/generateSchemaMap.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"generateSchemaMap.d.ts","sourceRoot":"","sources":["../../src/utilities/generateSchemaMap.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAA;AAIvD,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,4BAA4B,CAAA;AAE1E,eAAO,MAAM,oBAAoB,SACxB;IAAE,kBAAkB,EAAE,wBAAwB,CAAA;CAAE,KAAG,eAAe,CAAC,mBAAmB,CAsC5F,CAAA"}

package/dist/utilities/generateSchemaMap.js

@@ -0,0 +1,40 @@
+import { traverseFields } from '@ruya.sa/ui/utilities/buildFieldSchemaMap/traverseFields';
+export const getGenerateSchemaMap = args => ({
+  config,
+  field,
+  i18n,
+  schemaMap,
+  schemaPath
+}) => {
+  for (const [featureKey, resolvedFeature] of args.resolvedFeatureMap.entries()) {
+    if (!('generateSchemaMap' in resolvedFeature) || typeof resolvedFeature.generateSchemaMap !== 'function') {
+      continue;
+    }
+    const schemas = resolvedFeature.generateSchemaMap({
+      config,
+      field,
+      i18n,
+      props: resolvedFeature.sanitizedServerFeatureProps,
+      schemaMap,
+      schemaPath
+    });
+    if (schemas) {
+      for (const [schemaKey, field] of schemas.entries()) {
+        if ('fields' in field) {
+          // generate schema map entries for sub-fields using traverseFields
+          traverseFields({
+            config,
+            fields: field.fields,
+            i18n,
+            parentIndexPath: '',
+            parentSchemaPath: `${schemaPath}.lexical_internal_feature.${featureKey}.${schemaKey}`,
+            schemaMap
+          });
+        }
+        schemaMap.set(`${schemaPath}.lexical_internal_feature.${featureKey}.${schemaKey}`, field);
+      }
+    }
+  }
+  return schemaMap;
+};
+//# sourceMappingURL=generateSchemaMap.js.map

package/dist/utilities/generateSchemaMap.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"generateSchemaMap.js","names":["traverseFields","getGenerateSchemaMap","args","config","field","i18n","schemaMap","schemaPath","featureKey","resolvedFeature","resolvedFeatureMap","entries","generateSchemaMap","schemas","props","sanitizedServerFeatureProps","schemaKey","fields","parentIndexPath","parentSchemaPath","set"],"sources":["../../src/utilities/generateSchemaMap.ts"],"sourcesContent":["import type { RichTextAdapter } from '@ruya.sa/payload'\n\nimport { traverseFields } from '@ruya.sa/ui/utilities/buildFieldSchemaMap/traverseFields'\n\nimport type { ResolvedServerFeatureMap } from '../features/typesServer.js'\n\nexport const getGenerateSchemaMap =\n  (args: { resolvedFeatureMap: ResolvedServerFeatureMap }): RichTextAdapter['generateSchemaMap'] =>\n  ({ config, field, i18n, schemaMap, schemaPath }) => {\n    for (const [featureKey, resolvedFeature] of args.resolvedFeatureMap.entries()) {\n      if (\n        !('generateSchemaMap' in resolvedFeature) ||\n        typeof resolvedFeature.generateSchemaMap !== 'function'\n      ) {\n        continue\n      }\n      const schemas = resolvedFeature.generateSchemaMap({\n        config,\n        field,\n        i18n,\n        props: resolvedFeature.sanitizedServerFeatureProps,\n        schemaMap,\n        schemaPath,\n      })\n\n      if (schemas) {\n        for (const [schemaKey, field] of schemas.entries()) {\n          if ('fields' in field) {\n            // generate schema map entries for sub-fields using traverseFields\n            traverseFields({\n              config,\n              fields: field.fields,\n              i18n,\n              parentIndexPath: '',\n              parentSchemaPath: `${schemaPath}.lexical_internal_feature.${featureKey}.${schemaKey}`,\n              schemaMap,\n            })\n          }\n\n          schemaMap.set(`${schemaPath}.lexical_internal_feature.${featureKey}.${schemaKey}`, field)\n        }\n      }\n    }\n\n    return schemaMap\n  }\n"],"mappings":"AAEA,SAASA,cAAc,QAAQ;AAI/B,OAAO,MAAMC,oBAAA,GACVC,IAAA,IACD,CAAC;EAAEC,MAAM;EAAEC,KAAK;EAAEC,IAAI;EAAEC,SAAS;EAAEC;AAAU,CAAE;EAC7C,KAAK,MAAM,CAACC,UAAA,EAAYC,eAAA,CAAgB,IAAIP,IAAA,CAAKQ,kBAAkB,CAACC,OAAO,IAAI;IAC7E,IACE,EAAE,uBAAuBF,eAAc,KACvC,OAAOA,eAAA,CAAgBG,iBAAiB,KAAK,YAC7C;MACA;IACF;IACA,MAAMC,OAAA,GAAUJ,eAAA,CAAgBG,iBAAiB,CAAC;MAChDT,MAAA;MACAC,KAAA;MACAC,IAAA;MACAS,KAAA,EAAOL,eAAA,CAAgBM,2BAA2B;MAClDT,SAAA;MACAC;IACF;IAEA,IAAIM,OAAA,EAAS;MACX,KAAK,MAAM,CAACG,SAAA,EAAWZ,KAAA,CAAM,IAAIS,OAAA,CAAQF,OAAO,IAAI;QAClD,IAAI,YAAYP,KAAA,EAAO;UACrB;UACAJ,cAAA,CAAe;YACbG,MAAA;YACAc,MAAA,EAAQb,KAAA,CAAMa,MAAM;YACpBZ,IAAA;YACAa,eAAA,EAAiB;YACjBC,gBAAA,EAAkB,GAAGZ,UAAA,6BAAuCC,UAAA,IAAcQ,SAAA,EAAW;YACrFV;UACF;QACF;QAEAA,SAAA,CAAUc,GAAG,CAAC,GAAGb,UAAA,6BAAuCC,UAAA,IAAcQ,SAAA,EAAW,EAAEZ,KAAA;MACrF;IACF;EACF;EAEA,OAAOE,SAAA;AACT","ignoreList":[]}

package/dist/utilities/getDefaultSanitizedEditorConfig.d.ts

@@ -0,0 +1,7 @@
+import type { SanitizedConfig } from '@ruya.sa/payload';
+import { type SanitizedServerEditorConfig } from '../index.js';
+export declare const getDefaultSanitizedEditorConfig: (args: {
+    config: SanitizedConfig;
+    parentIsLocalized: boolean;
+}) => Promise<SanitizedServerEditorConfig>;
+//# sourceMappingURL=getDefaultSanitizedEditorConfig.d.ts.map

package/dist/utilities/getDefaultSanitizedEditorConfig.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"getDefaultSanitizedEditorConfig.d.ts","sourceRoot":"","sources":["../../src/utilities/getDefaultSanitizedEditorConfig.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAA;AAEvD,OAAO,EAAE,KAAK,2BAA2B,EAAE,MAAM,aAAa,CAAA;AAgB9D,eAAO,MAAM,+BAA+B,SAAgB;IAC1D,MAAM,EAAE,eAAe,CAAA;IACvB,iBAAiB,EAAE,OAAO,CAAA;CAC3B,KAAG,OAAO,CAAC,2BAA2B,CAoBtC,CAAA"}

package/dist/utilities/getDefaultSanitizedEditorConfig.js

@@ -0,0 +1,21 @@
+import { defaultEditorConfig } from '../lexical/config/server/default.js';
+import { sanitizeServerEditorConfig } from '../lexical/config/server/sanitize.js';
+let cachedDefaultSanitizedServerEditorConfig = global._payload_lexical_defaultSanitizedServerEditorConfig;
+if (!cachedDefaultSanitizedServerEditorConfig) {
+  cachedDefaultSanitizedServerEditorConfig = global._payload_lexical_defaultSanitizedServerEditorConfig = null;
+}
+export const getDefaultSanitizedEditorConfig = async args => {
+  const {
+    config,
+    parentIsLocalized
+  } = args;
+  if (cachedDefaultSanitizedServerEditorConfig) {
+    return await cachedDefaultSanitizedServerEditorConfig;
+  }
+  cachedDefaultSanitizedServerEditorConfig = sanitizeServerEditorConfig(defaultEditorConfig, config, parentIsLocalized);
+  global.payload_lexical_defaultSanitizedServerEditorConfig = cachedDefaultSanitizedServerEditorConfig;
+  cachedDefaultSanitizedServerEditorConfig = await cachedDefaultSanitizedServerEditorConfig;
+  global.payload_lexical_defaultSanitizedServerEditorConfig = cachedDefaultSanitizedServerEditorConfig;
+  return cachedDefaultSanitizedServerEditorConfig;
+};
+//# sourceMappingURL=getDefaultSanitizedEditorConfig.js.map

package/dist/utilities/getDefaultSanitizedEditorConfig.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"getDefaultSanitizedEditorConfig.js","names":["defaultEditorConfig","sanitizeServerEditorConfig","cachedDefaultSanitizedServerEditorConfig","global","_payload_lexical_defaultSanitizedServerEditorConfig","getDefaultSanitizedEditorConfig","args","config","parentIsLocalized","payload_lexical_defaultSanitizedServerEditorConfig"],"sources":["../../src/utilities/getDefaultSanitizedEditorConfig.ts"],"sourcesContent":["import type { SanitizedConfig } from '@ruya.sa/payload'\n\nimport { type SanitizedServerEditorConfig } from '../index.js'\nimport { defaultEditorConfig } from '../lexical/config/server/default.js'\nimport { sanitizeServerEditorConfig } from '../lexical/config/server/sanitize.js'\n\nlet cachedDefaultSanitizedServerEditorConfig:\n  | null\n  | Promise<SanitizedServerEditorConfig>\n  | SanitizedServerEditorConfig = (global as any)\n  ._payload_lexical_defaultSanitizedServerEditorConfig\n\nif (!cachedDefaultSanitizedServerEditorConfig) {\n  cachedDefaultSanitizedServerEditorConfig = (\n    global as any\n  )._payload_lexical_defaultSanitizedServerEditorConfig = null\n}\n\nexport const getDefaultSanitizedEditorConfig = async (args: {\n  config: SanitizedConfig\n  parentIsLocalized: boolean\n}): Promise<SanitizedServerEditorConfig> => {\n  const { config, parentIsLocalized } = args\n\n  if (cachedDefaultSanitizedServerEditorConfig) {\n    return await cachedDefaultSanitizedServerEditorConfig\n  }\n\n  cachedDefaultSanitizedServerEditorConfig = sanitizeServerEditorConfig(\n    defaultEditorConfig,\n    config,\n    parentIsLocalized,\n  )\n  ;(global as any).payload_lexical_defaultSanitizedServerEditorConfig =\n    cachedDefaultSanitizedServerEditorConfig\n\n  cachedDefaultSanitizedServerEditorConfig = await cachedDefaultSanitizedServerEditorConfig\n  ;(global as any).payload_lexical_defaultSanitizedServerEditorConfig =\n    cachedDefaultSanitizedServerEditorConfig\n\n  return cachedDefaultSanitizedServerEditorConfig\n}\n"],"mappings":"AAGA,SAASA,mBAAmB,QAAQ;AACpC,SAASC,0BAA0B,QAAQ;AAE3C,IAAIC,wCAAA,GAG8BC,MAAC,CAChCC,mDAAmD;AAEtD,IAAI,CAACF,wCAAA,EAA0C;EAC7CA,wCAAA,GAA2CC,MACzC,CACAC,mDAAmD,GAAG;AAC1D;AAEA,OAAO,MAAMC,+BAAA,GAAkC,MAAOC,IAAA;EAIpD,MAAM;IAAEC,MAAM;IAAEC;EAAiB,CAAE,GAAGF,IAAA;EAEtC,IAAIJ,wCAAA,EAA0C;IAC5C,OAAO,MAAMA,wCAAA;EACf;EAEAA,wCAAA,GAA2CD,0BAAA,CACzCD,mBAAA,EACAO,MAAA,EACAC,iBAAA;EAEAL,MAAA,CAAeM,kDAAkD,GACjEP,wCAAA;EAEFA,wCAAA,GAA2C,MAAMA,wCAAA;EAC/CC,MAAA,CAAeM,kDAAkD,GACjEP,wCAAA;EAEF,OAAOA,wCAAA;AACT","ignoreList":[]}

package/dist/utilities/initLexicalFeatures.d.ts

@@ -0,0 +1,20 @@
+import type { I18nClient } from '@ruya.sa/translations';
+import { type ClientFieldSchemaMap, type FieldSchemaMap, type Payload } from '@ruya.sa/payload';
+import type { SanitizedServerEditorConfig } from '../lexical/config/types.js';
+import type { FeatureClientSchemaMap, LexicalRichTextFieldProps } from '../types.js';
+type Args = {
+    clientFieldSchemaMap: ClientFieldSchemaMap;
+    fieldSchemaMap: FieldSchemaMap;
+    i18n: I18nClient;
+    path: string;
+    payload: Payload;
+    sanitizedEditorConfig: SanitizedServerEditorConfig;
+    schemaPath: string;
+};
+export declare function initLexicalFeatures(args: Args): {
+    clientFeatures: LexicalRichTextFieldProps['clientFeatures'];
+    featureClientImportMap: Record<string, any>;
+    featureClientSchemaMap: FeatureClientSchemaMap;
+};
+export {};
+//# sourceMappingURL=initLexicalFeatures.d.ts.map

package/dist/utilities/initLexicalFeatures.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"initLexicalFeatures.d.ts","sourceRoot":"","sources":["../../src/utilities/initLexicalFeatures.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,uBAAuB,CAAA;AAEvD,OAAO,EAAE,KAAK,oBAAoB,EAAE,KAAK,cAAc,EAAE,KAAK,OAAO,EAAE,MAAM,kBAAkB,CAAA;AAO/F,OAAO,KAAK,EAAE,2BAA2B,EAAE,MAAM,4BAA4B,CAAA;AAC7E,OAAO,KAAK,EAAE,sBAAsB,EAAE,yBAAyB,EAAE,MAAM,aAAa,CAAA;AACpF,KAAK,IAAI,GAAG;IACV,oBAAoB,EAAE,oBAAoB,CAAA;IAC1C,cAAc,EAAE,cAAc,CAAA;IAC9B,IAAI,EAAE,UAAU,CAAA;IAChB,IAAI,EAAE,MAAM,CAAA;IACZ,OAAO,EAAE,OAAO,CAAA;IAChB,qBAAqB,EAAE,2BAA2B,CAAA;IAClD,UAAU,EAAE,MAAM,CAAA;CACnB,CAAA;AAED,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,IAAI,GAAG;IAC/C,cAAc,EAAE,yBAAyB,CAAC,gBAAgB,CAAC,CAAA;IAC3D,sBAAsB,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAA;IAC3C,sBAAsB,EAAE,sBAAsB,CAAA;CAC/C,CA0FA"}

package/dist/utilities/initLexicalFeatures.js

@@ -0,0 +1,72 @@
+import { getFromImportMap } from '@ruya.sa/payload/shared';
+export function initLexicalFeatures(args) {
+  const clientFeatures = {};
+  // turn args.resolvedFeatureMap into an array of [key, value] pairs, ordered by value.order, lowest order first:
+  const resolvedFeatureMapArray = [...args.sanitizedEditorConfig.resolvedFeatureMap].sort((a, b) => a[1].order - b[1].order);
+  const featureClientSchemaMap = {};
+  /**
+  * All modules added to the import map, keyed by the provided key, if feature.componentImports with type object is used
+  */
+  const featureClientImportMap = {};
+  for (const [featureKey, resolvedFeature] of resolvedFeatureMapArray) {
+    clientFeatures[featureKey] = {};
+    /**
+    * Handle client features
+    */
+    const ClientFeaturePayloadComponent = resolvedFeature.ClientFeature;
+    if (ClientFeaturePayloadComponent) {
+      const clientFeatureProvider = getFromImportMap({
+        importMap: args.payload.importMap,
+        PayloadComponent: ClientFeaturePayloadComponent,
+        schemaPath: 'lexical-clientComponent',
+        silent: true
+      });
+      if (!clientFeatureProvider) {
+        continue;
+      }
+      const clientFeatureProps = resolvedFeature.clientFeatureProps ?? {};
+      clientFeatureProps.featureKey = resolvedFeature.key;
+      clientFeatureProps.order = resolvedFeature.order;
+      if (typeof ClientFeaturePayloadComponent === 'object' && ClientFeaturePayloadComponent.clientProps) {
+        clientFeatureProps.clientProps = ClientFeaturePayloadComponent.clientProps;
+      }
+      // As clientFeatureProvider is a client function, we cannot execute it on the server here. Thus, the client will have to execute clientFeatureProvider with its props
+      clientFeatures[featureKey] = {
+        clientFeatureProps,
+        clientFeatureProvider
+      };
+    }
+    /**
+    * Handle sub-fields (formstate of those)
+    */ // The args.fieldSchemaMap generated before in buildFormState should contain all of lexical features' sub-field schemas
+    // as well, as it already called feature.generateSchemaMap for each feature.
+    // We will check for the existance resolvedFeature.generateSchemaMap to skip unnecessary loops for constructing featureSchemaMap, but we don't run it here
+    if (resolvedFeature.generateSchemaMap) {
+      const featureSchemaPath = `${args.schemaPath}.lexical_internal_feature.${featureKey}`;
+      featureClientSchemaMap[featureKey] = {};
+      // Like args.fieldSchemaMap, we only want to include the sub-fields of the current feature
+      for (const [key, entry] of args.clientFieldSchemaMap.entries()) {
+        if (key.startsWith(featureSchemaPath)) {
+          featureClientSchemaMap[featureKey][key] = 'fields' in entry ? entry.fields : [entry];
+        }
+      }
+    }
+    if (resolvedFeature.componentImports && typeof resolvedFeature.componentImports === 'object' && !Array.isArray(resolvedFeature.componentImports)) {
+      for (const [key, payloadComponent] of Object.entries(resolvedFeature.componentImports)) {
+        const resolvedComponent = getFromImportMap({
+          importMap: args.payload.importMap,
+          PayloadComponent: payloadComponent,
+          schemaPath: 'lexical-clientComponent',
+          silent: true
+        });
+        featureClientImportMap[`${resolvedFeature.key}.${key}`] = resolvedComponent;
+      }
+    }
+  }
+  return {
+    clientFeatures,
+    featureClientImportMap,
+    featureClientSchemaMap
+  };
+}
+//# sourceMappingURL=initLexicalFeatures.js.map

package/dist/utilities/initLexicalFeatures.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"initLexicalFeatures.js","names":["getFromImportMap","initLexicalFeatures","args","clientFeatures","resolvedFeatureMapArray","sanitizedEditorConfig","resolvedFeatureMap","sort","a","b","order","featureClientSchemaMap","featureClientImportMap","featureKey","resolvedFeature","ClientFeaturePayloadComponent","ClientFeature","clientFeatureProvider","importMap","payload","PayloadComponent","schemaPath","silent","clientFeatureProps","key","clientProps","generateSchemaMap","featureSchemaPath","entry","clientFieldSchemaMap","entries","startsWith","fields","componentImports","Array","isArray","payloadComponent","Object","resolvedComponent"],"sources":["../../src/utilities/initLexicalFeatures.ts"],"sourcesContent":["import type { I18nClient } from '@ruya.sa/translations'\n\nimport { type ClientFieldSchemaMap, type FieldSchemaMap, type Payload } from '@ruya.sa/payload'\nimport { getFromImportMap } from '@ruya.sa/payload/shared'\n\nimport type {\n  BaseClientFeatureProps,\n  FeatureProviderProviderClient,\n} from '../features/typesClient.js'\nimport type { SanitizedServerEditorConfig } from '../lexical/config/types.js'\nimport type { FeatureClientSchemaMap, LexicalRichTextFieldProps } from '../types.js'\ntype Args = {\n  clientFieldSchemaMap: ClientFieldSchemaMap\n  fieldSchemaMap: FieldSchemaMap\n  i18n: I18nClient\n  path: string\n  payload: Payload\n  sanitizedEditorConfig: SanitizedServerEditorConfig\n  schemaPath: string\n}\n\nexport function initLexicalFeatures(args: Args): {\n  clientFeatures: LexicalRichTextFieldProps['clientFeatures']\n  featureClientImportMap: Record<string, any>\n  featureClientSchemaMap: FeatureClientSchemaMap\n} {\n  const clientFeatures: LexicalRichTextFieldProps['clientFeatures'] = {}\n\n  // turn args.resolvedFeatureMap into an array of [key, value] pairs, ordered by value.order, lowest order first:\n  const resolvedFeatureMapArray = [...args.sanitizedEditorConfig.resolvedFeatureMap].sort(\n    (a, b) => a[1].order - b[1].order,\n  )\n\n  const featureClientSchemaMap: FeatureClientSchemaMap = {}\n\n  /**\n   * All modules added to the import map, keyed by the provided key, if feature.componentImports with type object is used\n   */\n  const featureClientImportMap: Record<string, any> | undefined = {}\n\n  for (const [featureKey, resolvedFeature] of resolvedFeatureMapArray) {\n    clientFeatures[featureKey] = {}\n\n    /**\n     * Handle client features\n     */\n    const ClientFeaturePayloadComponent = resolvedFeature.ClientFeature\n\n    if (ClientFeaturePayloadComponent) {\n      const clientFeatureProvider = getFromImportMap<FeatureProviderProviderClient>({\n        importMap: args.payload.importMap,\n        PayloadComponent: ClientFeaturePayloadComponent,\n        schemaPath: 'lexical-clientComponent',\n        silent: true,\n      })\n\n      if (!clientFeatureProvider) {\n        continue\n      }\n\n      const clientFeatureProps: BaseClientFeatureProps<Record<string, any>> =\n        resolvedFeature.clientFeatureProps ?? {}\n      clientFeatureProps.featureKey = resolvedFeature.key\n      clientFeatureProps.order = resolvedFeature.order\n      if (\n        typeof ClientFeaturePayloadComponent === 'object' &&\n        ClientFeaturePayloadComponent.clientProps\n      ) {\n        clientFeatureProps.clientProps = ClientFeaturePayloadComponent.clientProps\n      }\n      // As clientFeatureProvider is a client function, we cannot execute it on the server here. Thus, the client will have to execute clientFeatureProvider with its props\n      clientFeatures[featureKey] = { clientFeatureProps, clientFeatureProvider }\n    }\n\n    /**\n     * Handle sub-fields (formstate of those)\n     */\n    // The args.fieldSchemaMap generated before in buildFormState should contain all of lexical features' sub-field schemas\n    // as well, as it already called feature.generateSchemaMap for each feature.\n    // We will check for the existance resolvedFeature.generateSchemaMap to skip unnecessary loops for constructing featureSchemaMap, but we don't run it here\n    if (resolvedFeature.generateSchemaMap) {\n      const featureSchemaPath = `${args.schemaPath}.lexical_internal_feature.${featureKey}`\n\n      featureClientSchemaMap[featureKey] = {}\n\n      // Like args.fieldSchemaMap, we only want to include the sub-fields of the current feature\n      for (const [key, entry] of args.clientFieldSchemaMap.entries()) {\n        if (key.startsWith(featureSchemaPath)) {\n          featureClientSchemaMap[featureKey][key] = 'fields' in entry ? entry.fields : [entry]\n        }\n      }\n    }\n\n    if (\n      resolvedFeature.componentImports &&\n      typeof resolvedFeature.componentImports === 'object' &&\n      !Array.isArray(resolvedFeature.componentImports)\n    ) {\n      for (const [key, payloadComponent] of Object.entries(resolvedFeature.componentImports)) {\n        const resolvedComponent = getFromImportMap({\n          importMap: args.payload.importMap,\n          PayloadComponent: payloadComponent,\n          schemaPath: 'lexical-clientComponent',\n          silent: true,\n        })\n\n        featureClientImportMap[`${resolvedFeature.key}.${key}`] = resolvedComponent\n      }\n    }\n  }\n  return {\n    clientFeatures,\n    featureClientImportMap,\n    featureClientSchemaMap,\n  }\n}\n"],"mappings":"AAGA,SAASA,gBAAgB,QAAQ;AAkBjC,OAAO,SAASC,oBAAoBC,IAAU;EAK5C,MAAMC,cAAA,GAA8D,CAAC;EAErE;EACA,MAAMC,uBAAA,GAA0B,C,GAAIF,IAAA,CAAKG,qBAAqB,CAACC,kBAAkB,CAAC,CAACC,IAAI,CACrF,CAACC,CAAA,EAAGC,CAAA,KAAMD,CAAC,CAAC,EAAE,CAACE,KAAK,GAAGD,CAAC,CAAC,EAAE,CAACC,KAAK;EAGnC,MAAMC,sBAAA,GAAiD,CAAC;EAExD;;;EAGA,MAAMC,sBAAA,GAA0D,CAAC;EAEjE,KAAK,MAAM,CAACC,UAAA,EAAYC,eAAA,CAAgB,IAAIV,uBAAA,EAAyB;IACnED,cAAc,CAACU,UAAA,CAAW,GAAG,CAAC;IAE9B;;;IAGA,MAAME,6BAAA,GAAgCD,eAAA,CAAgBE,aAAa;IAEnE,IAAID,6BAAA,EAA+B;MACjC,MAAME,qBAAA,GAAwBjB,gBAAA,CAAgD;QAC5EkB,SAAA,EAAWhB,IAAA,CAAKiB,OAAO,CAACD,SAAS;QACjCE,gBAAA,EAAkBL,6BAAA;QAClBM,UAAA,EAAY;QACZC,MAAA,EAAQ;MACV;MAEA,IAAI,CAACL,qBAAA,EAAuB;QAC1B;MACF;MAEA,MAAMM,kBAAA,GACJT,eAAA,CAAgBS,kBAAkB,IAAI,CAAC;MACzCA,kBAAA,CAAmBV,UAAU,GAAGC,eAAA,CAAgBU,GAAG;MACnDD,kBAAA,CAAmBb,KAAK,GAAGI,eAAA,CAAgBJ,KAAK;MAChD,IACE,OAAOK,6BAAA,KAAkC,YACzCA,6BAAA,CAA8BU,WAAW,EACzC;QACAF,kBAAA,CAAmBE,WAAW,GAAGV,6BAAA,CAA8BU,WAAW;MAC5E;MACA;MACAtB,cAAc,CAACU,UAAA,CAAW,GAAG;QAAEU,kBAAA;QAAoBN;MAAsB;IAC3E;IAEA;;MAAA,CAGA;IACA;IACA;IACA,IAAIH,eAAA,CAAgBY,iBAAiB,EAAE;MACrC,MAAMC,iBAAA,GAAoB,GAAGzB,IAAA,CAAKmB,UAAU,6BAA6BR,UAAA,EAAY;MAErFF,sBAAsB,CAACE,UAAA,CAAW,GAAG,CAAC;MAEtC;MACA,KAAK,MAAM,CAACW,GAAA,EAAKI,KAAA,CAAM,IAAI1B,IAAA,CAAK2B,oBAAoB,CAACC,OAAO,IAAI;QAC9D,IAAIN,GAAA,CAAIO,UAAU,CAACJ,iBAAA,GAAoB;UACrChB,sBAAsB,CAACE,UAAA,CAAW,CAACW,GAAA,CAAI,GAAG,YAAYI,KAAA,GAAQA,KAAA,CAAMI,MAAM,GAAG,CAACJ,KAAA,CAAM;QACtF;MACF;IACF;IAEA,IACEd,eAAA,CAAgBmB,gBAAgB,IAChC,OAAOnB,eAAA,CAAgBmB,gBAAgB,KAAK,YAC5C,CAACC,KAAA,CAAMC,OAAO,CAACrB,eAAA,CAAgBmB,gBAAgB,GAC/C;MACA,KAAK,MAAM,CAACT,GAAA,EAAKY,gBAAA,CAAiB,IAAIC,MAAA,CAAOP,OAAO,CAAChB,eAAA,CAAgBmB,gBAAgB,GAAG;QACtF,MAAMK,iBAAA,GAAoBtC,gBAAA,CAAiB;UACzCkB,SAAA,EAAWhB,IAAA,CAAKiB,OAAO,CAACD,SAAS;UACjCE,gBAAA,EAAkBgB,gBAAA;UAClBf,UAAA,EAAY;UACZC,MAAA,EAAQ;QACV;QAEAV,sBAAsB,CAAC,GAAGE,eAAA,CAAgBU,GAAG,IAAIA,GAAA,EAAK,CAAC,GAAGc,iBAAA;MAC5D;IACF;EACF;EACA,OAAO;IACLnC,cAAA;IACAS,sBAAA;IACAD;EACF;AACF","ignoreList":[]}

package/dist/utilities/jsx/collectTopLevelJSXInLines.d.ts

@@ -0,0 +1,52 @@
+/**
+ * Helpful utility for parsing out all matching top-level JSX tags in a given string.
+ * This will collect them in a list, that contains the content of the JSX tag and the props string.
+ *
+ * While this is not used within payload, this can be used for certain payload blocks that need to
+ * be serializable and deserializable to and from JSX.
+ *
+ * @example:
+ *
+ * Say you have Steps block that contains a steps array. Its JSX representation may look like this:
+ *
+ * <Steps>
+ *   <Step title="Step1">
+ *     <h1>Step 1</h1>
+ *   </Step>
+ *   <Step title="Step2">
+ *     <h1>Step 2</h1>
+ *   </Step>
+ * </Steps>
+ *
+ * In this case, the Steps block would have the following content as its children string:
+ * <Step title="Step1">
+ *   <h1>Step 1</h1>
+ * </Step>
+ * <Step title="Step2">
+ *   <h1>Step 2</h1>
+ * </Step>
+ *
+ * It could then use this function to collect all the top-level JSX tags (= the steps):
+ *
+ * collectTopLevelJSXInLines(children.split('\n'), 'Step')
+ *
+ * This will return:
+ *
+ * [
+ *   {
+ *     content: '<h1>Step 1</h1>',
+ *     propsString: 'title="Step1"',
+ *   },
+ *   {
+ *     content: '<h1>Step 2</h1>',
+ *     propsString: 'title="Step2"',
+ *   },
+ * ]
+ *
+ * You can then map this data to construct the data for this blocks array field.
+ */
+export declare function collectTopLevelJSXInLines(lines: Array<string>, jsxToMatch: string): {
+    content: string;
+    propsString: string;
+}[];
+//# sourceMappingURL=collectTopLevelJSXInLines.d.ts.map

package/dist/utilities/jsx/collectTopLevelJSXInLines.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"collectTopLevelJSXInLines.d.ts","sourceRoot":"","sources":["../../../src/utilities/jsx/collectTopLevelJSXInLines.ts"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8CG;AACH,wBAAgB,yBAAyB,CACvC,KAAK,EAAE,KAAK,CAAC,MAAM,CAAC,EACpB,UAAU,EAAE,MAAM,GACjB;IACD,OAAO,EAAE,MAAM,CAAA;IACf,WAAW,EAAE,MAAM,CAAA;CACpB,EAAE,CAkCF"}