@payloadcms/richtext-lexical 3.0.0-canary.fb81f02 → 3.0.0

package/dist/utilities/fieldsDrawer/useLexicalListDrawer.js

@@ -0,0 +1,144 @@
+'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 '@payloadcms/ui';
+import { $getPreviousSelection, $getSelection, $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] !== selectionState || $[2] !== editor) {
+    t2 = () => {
+      if (selectionState) {
+        editor.update(() => {
+          $setSelection(selectionState.clone());
+        }, {
+          discrete: true,
+          skipTransforms: true
+        });
+      }
+    };
+    $[1] = selectionState;
+    $[2] = editor;
+    $[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] !== wasOpen || $[7] !== modalState || $[8] !== listDrawerSlug || $[9] !== restoreSelection) {
+    t4 = () => {
+      if (!wasOpen) {
+        return;
+      }
+      const thisModalState = modalState[listDrawerSlug];
+      if (thisModalState && !thisModalState?.isOpen) {
+        setWasOpen(false);
+        setTimeout(() => {
+          restoreSelection();
+        }, 1);
+      }
+    };
+    t5 = [modalState, listDrawerSlug, restoreSelection, wasOpen];
+    $[6] = wasOpen;
+    $[7] = modalState;
+    $[8] = listDrawerSlug;
+    $[9] = restoreSelection;
+    $[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] !== closeListDrawer || $[17] !== isDrawerOpen || $[18] !== BaseListDrawer || $[19] !== listDrawerSlug || $[20] !== t6 || $[21] !== t7) {
+    t8 = {
+      closeListDrawer,
+      isListDrawerOpen: isDrawerOpen,
+      ListDrawer: BaseListDrawer,
+      listDrawerSlug,
+      ListDrawerToggler: t6,
+      openListDrawer: t7
+    };
+    $[16] = closeListDrawer;
+    $[17] = isDrawerOpen;
+    $[18] = BaseListDrawer;
+    $[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","$getPreviousSelection","$getSelection","$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","clone","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 '@payloadcms/ui'\nimport type { BaseSelection } from 'lexical'\n\nimport { useLexicalComposerContext } from '@lexical/react/LexicalComposerContext'\nimport { useListDrawer, useModal } from '@payloadcms/ui'\nimport { $getPreviousSelection, $getSelection, $setSelection } 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          $setSelection(selectionState.clone())\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.js

@@ -1,24 +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 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
-            });
-        }
+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

@@ -1 +1 @@
-{"version":3,"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"],"names":["recurseNodes","callback","nodes","node","Array","isArray","children","length","recurseNodesAsync"],"mappings":"AAEA,OAAO,SAASA,aAAa,EAC3BC,QAAQ,EACRC,KAAK,EAIN;IACC,KAAK,MAAMC,QAAQD,MAAO;QACxBD,SAASE;QAET,IAAI,cAAcA,QAAQC,MAAMC,OAAO,CAACF,MAAMG,aAAaH,MAAMG,UAAUC,QAAQ;YACjFP,aAAa;gBAAEC;gBAAUC,OAAOC,KAAKG,QAAQ;YAA4B;QAC3E;IACF;AACF;AAEA,OAAO,eAAeE,kBAAkB,EACtCP,QAAQ,EACRC,KAAK,EAIN;IACC,KAAK,MAAMC,QAAQD,MAAO;QACxB,MAAMD,SAASE;QAEf,IAAI,cAAcA,QAAQC,MAAMC,OAAO,CAACF,MAAMG,aAAaH,MAAMG,UAAUC,QAAQ;YACjF,MAAMC,kBAAkB;gBAAEP;gBAAUC,OAAOC,KAAKG,QAAQ;YAA4B;QACtF;IACF;AACF"}
+{"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,6 @@
+import type { RichTextAdapter } from 'payload';
+import type { ResolvedServerFeatureMap } from '../features/typesServer.js';
+export declare const getGenerateImportMap: (args: {
+    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,SAAS,CAAA;AAI9C,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,4BAA4B,CAAA;AAE1E,eAAO,MAAM,oBAAoB,SACxB;IAAE,kBAAkB,EAAE,wBAAwB,CAAA;CAAE,KAAG,eAAe,CAAC,mBAAmB,CAkD5F,CAAA"}

package/dist/utilities/generateImportMap.js

@@ -0,0 +1,55 @@
+import { genImportMapIterateFields } from 'payload';
+export const getGenerateImportMap = args => ({
+  addToImportMap,
+  baseDir,
+  config,
+  importMap,
+  imports
+}) => {
+  addToImportMap('@payloadcms/richtext-lexical/rsc#RscEntryLexicalCell');
+  addToImportMap('@payloadcms/richtext-lexical/rsc#RscEntryLexicalField');
+  // iterate just through args.resolvedFeatureMap.values()
+  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 (resolvedFeature.componentImports?.length) {
+        resolvedFeature.componentImports.forEach(component => {
+          addToImportMap(component);
+        });
+      }
+    }
+    const ClientComponent = resolvedFeature.ClientFeature;
+    if (ClientComponent) {
+      addToImportMap(ClientComponent);
+    }
+    /*
+    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","length","forEach","component","ClientComponent","ClientFeature","nodes","node","getSubFields","subFields","fields"],"sources":["../../src/utilities/generateImportMap.tsx"],"sourcesContent":["import type { RichTextAdapter } from 'payload'\n\nimport { genImportMapIterateFields } from 'payload'\n\nimport type { ResolvedServerFeatureMap } from '../features/typesServer.js'\n\nexport const getGenerateImportMap =\n  (args: { resolvedFeatureMap: ResolvedServerFeatureMap }): RichTextAdapter['generateImportMap'] =>\n  ({ addToImportMap, baseDir, config, importMap, imports }) => {\n    addToImportMap('@payloadcms/richtext-lexical/rsc#RscEntryLexicalCell')\n    addToImportMap('@payloadcms/richtext-lexical/rsc#RscEntryLexicalField')\n\n    // iterate just through args.resolvedFeatureMap.values()\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 (resolvedFeature.componentImports?.length) {\n          resolvedFeature.componentImports.forEach((component) => {\n            addToImportMap(component)\n          })\n        }\n      }\n\n      const ClientComponent = resolvedFeature.ClientFeature\n      if (ClientComponent) {\n        addToImportMap(ClientComponent)\n      }\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;AAI1C,OAAO,MAAMC,oBAAA,GACVC,IAAA,IACD,CAAC;EAAEC,cAAc;EAAEC,OAAO;EAAEC,MAAM;EAAEC,SAAS;EAAEC;AAAO,CAAE;EACtDJ,cAAA,CAAe;EACfA,cAAA,CAAe;EAEf;EACA,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,IAAIC,eAAA,CAAgBG,gBAAgB,EAAEC,MAAA,EAAQ;QACnDJ,eAAA,CAAgBG,gBAAgB,CAACE,OAAO,CAAEC,SAAA;UACxCX,cAAA,CAAeW,SAAA;QACjB;MACF;IACF;IAEA,MAAMC,eAAA,GAAkBP,eAAA,CAAgBQ,aAAa;IACrD,IAAID,eAAA,EAAiB;MACnBZ,cAAA,CAAeY,eAAA;IACjB;IAEA;;;IAGA,IAAIP,eAAA,CAAgBS,KAAK,EAAEL,MAAA,EAAQ;MACjC,KAAK,MAAMM,IAAA,IAAQV,eAAA,CAAgBS,KAAK,EAAE;QACxC,IAAI,OAAOC,IAAA,EAAMC,YAAA,KAAiB,YAAY;UAC5C;QACF;QACA,MAAMC,SAAA,GAAYF,IAAA,CAAKC,YAAY,CAAC,CAAC;QACrC,IAAIC,SAAA,EAAWR,MAAA,EAAQ;UACrBZ,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.map

@@ -1 +1 @@
-{"version":3,"file":"generateSchemaMap.d.ts","sourceRoot":"","sources":["../../src/utilities/generateSchemaMap.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,SAAS,CAAA;AAI9C,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,4BAA4B,CAAA;AAE1E,eAAO,MAAM,oBAAoB,SACxB;IAAE,kBAAkB,EAAE,wBAAwB,CAAA;CAAE,KAAG,eAAe,CAAC,mBAAmB,CAkC5F,CAAA"}
+{"version":3,"file":"generateSchemaMap.d.ts","sourceRoot":"","sources":["../../src/utilities/generateSchemaMap.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,SAAS,CAAA;AAI9C,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

@@ -1,31 +1,40 @@
 import { traverseFields } from '@payloadcms/ui/utilities/buildFieldSchemaMap/traverseFields';
-export const getGenerateSchemaMap = (args)=>({ config, 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,
-                i18n,
-                props: resolvedFeature.sanitizedServerFeatureProps,
-                schemaMap,
-                schemaPath
-            });
-            if (schemas) {
-                for (const [schemaKey, fields] of schemas.entries()){
-                    // generate schema map entries for sub-fields using traverseFields
-                    traverseFields({
-                        config,
-                        fields,
-                        i18n,
-                        schemaMap: schemas,
-                        schemaPath: schemaKey
-                    });
-                    schemaMap.set(`${schemaPath}.lexical_internal_feature.${featureKey}.${schemaKey}`, fields);
-                }
-            }
+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
+          });
         }
-        return schemaMap;
-    };
-
+        schemaMap.set(`${schemaPath}.lexical_internal_feature.${featureKey}.${schemaKey}`, field);
+      }
+    }
+  }
+  return schemaMap;
+};
 //# sourceMappingURL=generateSchemaMap.js.map

package/dist/utilities/generateSchemaMap.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/utilities/generateSchemaMap.ts"],"sourcesContent":["import type { RichTextAdapter } from 'payload'\n\nimport { traverseFields } from '@payloadcms/ui/utilities/buildFieldSchemaMap/traverseFields'\n\nimport type { ResolvedServerFeatureMap } from '../features/typesServer.js'\n\nexport const getGenerateSchemaMap =\n  (args: { resolvedFeatureMap: ResolvedServerFeatureMap }): RichTextAdapter['generateSchemaMap'] =>\n  ({ config, 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        i18n,\n        props: resolvedFeature.sanitizedServerFeatureProps,\n        schemaMap,\n        schemaPath,\n      })\n\n      if (schemas) {\n        for (const [schemaKey, fields] of schemas.entries()) {\n          // generate schema map entries for sub-fields using traverseFields\n          traverseFields({\n            config,\n            fields,\n            i18n,\n            schemaMap: schemas,\n            schemaPath: schemaKey,\n          })\n\n          schemaMap.set(`${schemaPath}.lexical_internal_feature.${featureKey}.${schemaKey}`, fields)\n        }\n      }\n    }\n\n    return schemaMap\n  }\n"],"names":["traverseFields","getGenerateSchemaMap","args","config","i18n","schemaMap","schemaPath","featureKey","resolvedFeature","resolvedFeatureMap","entries","generateSchemaMap","schemas","props","sanitizedServerFeatureProps","schemaKey","fields","set"],"mappings":"AAEA,SAASA,cAAc,QAAQ,8DAA6D;AAI5F,OAAO,MAAMC,uBACX,CAACC,OACD,CAAC,EAAEC,MAAM,EAAEC,IAAI,EAAEC,SAAS,EAAEC,UAAU,EAAE;QACtC,KAAK,MAAM,CAACC,YAAYC,gBAAgB,IAAIN,KAAKO,kBAAkB,CAACC,OAAO,GAAI;YAC7E,IACE,CAAE,CAAA,uBAAuBF,eAAc,KACvC,OAAOA,gBAAgBG,iBAAiB,KAAK,YAC7C;gBACA;YACF;YACA,MAAMC,UAAUJ,gBAAgBG,iBAAiB,CAAC;gBAChDR;gBACAC;gBACAS,OAAOL,gBAAgBM,2BAA2B;gBAClDT;gBACAC;YACF;YAEA,IAAIM,SAAS;gBACX,KAAK,MAAM,CAACG,WAAWC,OAAO,IAAIJ,QAAQF,OAAO,GAAI;oBACnD,kEAAkE;oBAClEV,eAAe;wBACbG;wBACAa;wBACAZ;wBACAC,WAAWO;wBACXN,YAAYS;oBACd;oBAEAV,UAAUY,GAAG,CAAC,CAAC,EAAEX,WAAW,0BAA0B,EAAEC,WAAW,CAAC,EAAEQ,UAAU,CAAC,EAAEC;gBACrF;YACF;QACF;QAEA,OAAOX;IACT,EAAC"}
+{"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 'payload'\n\nimport { traverseFields } from '@payloadcms/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/initLexicalFeatures.d.ts

@@ -0,0 +1,18 @@
+import type { I18nClient } from '@payloadcms/translations';
+import { type FieldSchemaMap, type Payload } from 'payload';
+import type { SanitizedServerEditorConfig } from '../lexical/config/types.js';
+import type { FeatureClientSchemaMap, LexicalRichTextFieldProps } from '../types.js';
+type Args = {
+    fieldSchemaMap: FieldSchemaMap;
+    i18n: I18nClient;
+    path: string;
+    payload: Payload;
+    sanitizedEditorConfig: SanitizedServerEditorConfig;
+    schemaPath: string;
+};
+export declare function initLexicalFeatures(args: Args): {
+    clientFeatures: LexicalRichTextFieldProps['clientFeatures'];
+    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,0BAA0B,CAAA;AAE1D,OAAO,EAIL,KAAK,cAAc,EACnB,KAAK,OAAO,EACb,MAAM,SAAS,CAAA;AAIhB,OAAO,KAAK,EAAE,2BAA2B,EAAE,MAAM,4BAA4B,CAAA;AAC7E,OAAO,KAAK,EAAE,sBAAsB,EAAE,yBAAyB,EAAE,MAAM,aAAa,CAAA;AACpF,KAAK,IAAI,GAAG;IACV,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,sBAAsB,CAAA;CAC/C,CA4HA"}

package/dist/utilities/initLexicalFeatures.js

@@ -0,0 +1,96 @@
+import { createClientFields, deepCopyObjectSimple } from 'payload';
+import { getFromImportMap } from 'payload/shared';
+export function initLexicalFeatures(args) {
+  const clientFeatures = {};
+  const fieldSchemaMap = Object.fromEntries(new Map(args.fieldSchemaMap));
+  //&const value = deepCopyObjectSimple(args.fieldState.value)
+  // turn args.resolvedFeatureMap into an array of [key, value] pairs, ordered by value.order, lowest order first:
+  const resolvedFeatureMapArray = Array.from(args.sanitizedEditorConfig.resolvedFeatureMap.entries()).sort((a, b) => a[1].order - b[1].order);
+  const featureClientSchemaMap = {};
+  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)ttt
+    */ // 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.split('.'), 'lexical_internal_feature', featureKey].join('.');
+      const featurePath = [...args.path.split('.'), 'lexical_internal_feature', featureKey].join('.');
+      // Like args.fieldSchemaMap, we only want to include the sub-fields of the current feature
+      const featureSchemaMap = {};
+      for (const key in fieldSchemaMap) {
+        const state = fieldSchemaMap[key];
+        if (key.startsWith(featureSchemaPath)) {
+          featureSchemaMap[key] = state;
+        }
+      }
+      featureClientSchemaMap[featureKey] = {};
+      for (const key in featureSchemaMap) {
+        const state = featureSchemaMap[key];
+        const clientFields = createClientFields({
+          clientFields: 'fields' in state ? deepCopyObjectSimple(state.fields) : [deepCopyObjectSimple(state)],
+          defaultIDType: args.payload.config.db.defaultIDType,
+          disableAddingID: true,
+          fields: 'fields' in state ? state.fields : [state],
+          i18n: args.i18n,
+          importMap: args.payload.importMap
+        });
+        featureClientSchemaMap[featureKey][key] = clientFields;
+      }
+      /*
+      This is for providing an initial form state. Right now we only want to provide the clientfields though
+      const schemaMap: {
+      [key: string]: FieldState
+      } = {}
+      const lexicalDeepIterate = (editorState) => {
+      console.log('STATE', editorState)
+       if (
+        editorState &&
+        typeof editorState === 'object' &&
+        'children' in editorState &&
+        Array.isArray(editorState.children)
+      ) {
+        for (const childKey in editorState.children) {
+          const childState = editorState.children[childKey]
+           if (childState && typeof childState === 'object') {
+            lexicalDeepIterate(childState)
+          }
+        }
+      }
+      }
+      lexicalDeepIterate(value.root)*/
+    }
+  }
+  return {
+    clientFeatures,
+    featureClientSchemaMap
+  };
+}
+//# sourceMappingURL=initLexicalFeatures.js.map

package/dist/utilities/initLexicalFeatures.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"initLexicalFeatures.js","names":["createClientFields","deepCopyObjectSimple","getFromImportMap","initLexicalFeatures","args","clientFeatures","fieldSchemaMap","Object","fromEntries","Map","resolvedFeatureMapArray","Array","from","sanitizedEditorConfig","resolvedFeatureMap","entries","sort","a","b","order","featureClientSchemaMap","featureKey","resolvedFeature","ClientFeaturePayloadComponent","ClientFeature","clientFeatureProvider","importMap","payload","PayloadComponent","schemaPath","silent","clientFeatureProps","key","clientProps","generateSchemaMap","featureSchemaPath","split","join","featurePath","path","featureSchemaMap","state","startsWith","clientFields","fields","defaultIDType","config","db","disableAddingID","i18n"],"sources":["../../src/utilities/initLexicalFeatures.ts"],"sourcesContent":["import type { I18nClient } from '@payloadcms/translations'\n\nimport {\n  type ClientField,\n  createClientFields,\n  deepCopyObjectSimple,\n  type FieldSchemaMap,\n  type Payload,\n} from 'payload'\nimport { getFromImportMap } from 'payload/shared'\n\nimport type { FeatureProviderProviderClient } from '../features/typesClient.js'\nimport type { SanitizedServerEditorConfig } from '../lexical/config/types.js'\nimport type { FeatureClientSchemaMap, LexicalRichTextFieldProps } from '../types.js'\ntype Args = {\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  featureClientSchemaMap: FeatureClientSchemaMap\n} {\n  const clientFeatures: LexicalRichTextFieldProps['clientFeatures'] = {}\n\n  const fieldSchemaMap = Object.fromEntries(new Map(args.fieldSchemaMap))\n  //&const value = deepCopyObjectSimple(args.fieldState.value)\n\n  // turn args.resolvedFeatureMap into an array of [key, value] pairs, ordered by value.order, lowest order first:\n  const resolvedFeatureMapArray = Array.from(\n    args.sanitizedEditorConfig.resolvedFeatureMap.entries(),\n  ).sort((a, b) => a[1].order - b[1].order)\n\n  const featureClientSchemaMap: FeatureClientSchemaMap = {}\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 = 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\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)ttt\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 = [\n        ...args.schemaPath.split('.'),\n        'lexical_internal_feature',\n        featureKey,\n      ].join('.')\n\n      const featurePath = [...args.path.split('.'), 'lexical_internal_feature', featureKey].join(\n        '.',\n      )\n\n      // Like args.fieldSchemaMap, we only want to include the sub-fields of the current feature\n      const featureSchemaMap: typeof fieldSchemaMap = {}\n      for (const key in fieldSchemaMap) {\n        const state = fieldSchemaMap[key]\n\n        if (key.startsWith(featureSchemaPath)) {\n          featureSchemaMap[key] = state\n        }\n      }\n\n      featureClientSchemaMap[featureKey] = {}\n\n      for (const key in featureSchemaMap) {\n        const state = featureSchemaMap[key]\n\n        const clientFields = createClientFields({\n          clientFields: ('fields' in state\n            ? deepCopyObjectSimple(state.fields)\n            : [deepCopyObjectSimple(state)]) as ClientField[],\n          defaultIDType: args.payload.config.db.defaultIDType,\n          disableAddingID: true,\n          fields: 'fields' in state ? state.fields : [state],\n          i18n: args.i18n,\n          importMap: args.payload.importMap,\n        })\n        featureClientSchemaMap[featureKey][key] = clientFields\n      }\n\n      /*\n      This is for providing an initial form state. Right now we only want to provide the clientfields though\n      const schemaMap: {\n        [key: string]: FieldState\n      } = {}\n\n      const lexicalDeepIterate = (editorState) => {\n        console.log('STATE', editorState)\n\n        if (\n          editorState &&\n          typeof editorState === 'object' &&\n          'children' in editorState &&\n          Array.isArray(editorState.children)\n        ) {\n          for (const childKey in editorState.children) {\n            const childState = editorState.children[childKey]\n\n            if (childState && typeof childState === 'object') {\n              lexicalDeepIterate(childState)\n            }\n          }\n        }\n      }\n\n      lexicalDeepIterate(value.root)*/\n    }\n  }\n  return {\n    clientFeatures,\n    featureClientSchemaMap,\n  }\n}\n"],"mappings":"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","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,CAiCF"}