@payloadcms/richtext-lexical 3.59.0-internal.d8b427e → 3.59.0-internal.ee5f42c

package/dist/exports/client/chunk-K47TNP5J.js.map

@@ -1,7 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../../../src/features/blocks/client/componentInline/index.tsx", "../../../src/features/blocks/client/nodes/InlineBlocksNode.tsx", "../../../src/features/blocks/server/nodes/InlineBlocksNode.tsx"],
-  "sourcesContent": ["'use client'\n\nimport React, { createContext, useCallback, useEffect, useMemo, useRef } from 'react'\nconst baseClass = 'inline-block'\n\nimport type { BlocksFieldClient, ClientBlock, Data, FormState } from 'payload'\n\nimport { useLexicalComposerContext } from '@lexical/react/LexicalComposerContext'\nimport { getTranslation } from '@payloadcms/translations'\nimport {\n  Button,\n  Drawer,\n  EditDepthProvider,\n  Form,\n  formatDrawerSlug,\n  FormSubmit,\n  RenderFields,\n  ShimmerEffect,\n  useConfig,\n  useDocumentForm,\n  useDocumentInfo,\n  useEditDepth,\n  useServerFunctions,\n  useTranslation,\n} from '@payloadcms/ui'\nimport { abortAndIgnore } from '@payloadcms/ui/shared'\nimport { $getNodeByKey } from 'lexical'\n\nimport './index.scss'\n\nimport { deepCopyObjectSimpleWithoutReactComponents, reduceFieldsToValues } from 'payload/shared'\nimport { v4 as uuid } from 'uuid'\n\nimport type { InlineBlockFields } from '../../server/nodes/InlineBlocksNode.js'\n\nimport { useEditorConfigContext } from '../../../../lexical/config/client/EditorConfigProvider.js'\nimport { useLexicalDrawer } from '../../../../utilities/fieldsDrawer/useLexicalDrawer.js'\nimport { $isInlineBlockNode } from '../nodes/InlineBlocksNode.js'\n\ntype Props = {\n  /**\n   * Can be modified by the node in order to trigger the re-fetch of the initial state based on the\n   * formData. This is useful when node.setFields() is explicitly called from outside of the form - in\n   * this case, the new field state is likely not reflected in the form state, so we need to re-fetch\n   */\n  readonly cacheBuster: number\n  readonly formData: InlineBlockFields\n  readonly nodeKey: string\n}\n\ntype InlineBlockComponentContextType = {\n  EditButton?: React.FC\n  initialState: false | FormState | undefined\n  InlineBlockContainer?: React.FC<{ children: React.ReactNode }>\n  Label?: React.FC\n  nodeKey?: string\n  RemoveButton?: React.FC\n}\n\nconst InlineBlockComponentContext = createContext<InlineBlockComponentContextType>({\n  initialState: false,\n})\n\nexport const useInlineBlockComponentContext = () => React.use(InlineBlockComponentContext)\n\nexport const InlineBlockComponent: React.FC<Props> = (props) => {\n  const { cacheBuster, formData, nodeKey } = props\n\n  const [editor] = useLexicalComposerContext()\n  const { i18n, t } = useTranslation<object, string>()\n  const {\n    createdInlineBlock,\n    fieldProps: { featureClientSchemaMap, initialLexicalFormState, readOnly, schemaPath },\n    setCreatedInlineBlock,\n    uuid: uuidFromContext,\n  } = useEditorConfigContext()\n  const { fields: parentDocumentFields } = useDocumentForm()\n\n  const { getFormState } = useServerFunctions()\n  const editDepth = useEditDepth()\n  const firstTimeDrawer = useRef(false)\n\n  const [initialState, setInitialState] = React.useState<false | FormState | undefined>(\n    () => initialLexicalFormState?.[formData.id]?.formState,\n  )\n\n  const hasMounted = useRef(false)\n  const prevCacheBuster = useRef(cacheBuster)\n  useEffect(() => {\n    if (hasMounted.current) {\n      if (prevCacheBuster.current !== cacheBuster) {\n        setInitialState(false)\n      }\n      prevCacheBuster.current = cacheBuster\n    } else {\n      hasMounted.current = true\n    }\n  }, [cacheBuster])\n\n  const [CustomLabel, setCustomLabel] = React.useState<React.ReactNode | undefined>(\n    // @ts-expect-error - vestiges of when tsconfig was not strict. Feel free to improve\n    initialState?.['_components']?.customComponents?.BlockLabel,\n  )\n\n  const [CustomBlock, setCustomBlock] = React.useState<React.ReactNode | undefined>(\n    // @ts-expect-error - vestiges of when tsconfig was not strict. Feel free to improve\n    initialState?.['_components']?.customComponents?.Block,\n  )\n\n  const drawerSlug = formatDrawerSlug({\n    slug: `lexical-inlineBlocks-create-${uuidFromContext}-${formData.id}`,\n    depth: editDepth,\n  })\n  const { toggleDrawer } = useLexicalDrawer(drawerSlug, true)\n\n  const inlineBlockElemElemRef = useRef<HTMLDivElement | null>(null)\n  const { id, collectionSlug, getDocPreferences, globalSlug } = useDocumentInfo()\n  const { config } = useConfig()\n\n  const componentMapRenderedBlockPath = `${schemaPath}.lexical_internal_feature.blocks.lexical_inline_blocks.${formData.blockType}`\n\n  const clientSchemaMap = featureClientSchemaMap['blocks']\n\n  const blocksField: BlocksFieldClient = clientSchemaMap?.[\n    componentMapRenderedBlockPath\n  ]?.[0] as BlocksFieldClient\n\n  const clientBlock: ClientBlock | undefined = blocksField.blockReferences\n    ? typeof blocksField?.blockReferences?.[0] === 'string'\n      ? config.blocksMap[blocksField?.blockReferences?.[0]]\n      : blocksField?.blockReferences?.[0]\n    : blocksField?.blocks?.[0]\n\n  const clientBlockFields = clientBlock?.fields ?? []\n\n  // Open drawer on \"mount\"\n  useEffect(() => {\n    if (!firstTimeDrawer.current && createdInlineBlock?.getKey() === nodeKey) {\n      // > 2 because they always have \"id\" and \"blockName\" fields\n      if (clientBlockFields.length > 2) {\n        toggleDrawer()\n      }\n      setCreatedInlineBlock?.(undefined)\n      firstTimeDrawer.current = true\n    }\n  }, [clientBlockFields.length, createdInlineBlock, nodeKey, setCreatedInlineBlock, toggleDrawer])\n\n  const removeInlineBlock = useCallback(() => {\n    editor.update(() => {\n      $getNodeByKey(nodeKey)?.remove()\n    })\n  }, [editor, nodeKey])\n\n  const blockDisplayName = clientBlock?.labels?.singular\n    ? getTranslation(clientBlock?.labels.singular, i18n)\n    : clientBlock?.slug\n\n  const onChangeAbortControllerRef = useRef(new AbortController())\n  const schemaFieldsPath = `${schemaPath}.lexical_internal_feature.blocks.lexical_inline_blocks.${clientBlock?.slug}.fields`\n\n  // Initial state for newly created blocks\n  useEffect(() => {\n    const abortController = new AbortController()\n\n    const awaitInitialState = async () => {\n      /*\n       * This will only run if a new block is created. For all existing blocks that are loaded when the document is loaded, or when the form is saved,\n       * this is not run, as the lexical field RSC will fetch the state server-side and pass it to the client. That way, we avoid unnecessary client-side\n       * requests. Though for newly created blocks, we need to fetch the state client-side, as the server doesn't know about the block yet.\n       */\n      const { state } = await getFormState({\n        id,\n        collectionSlug,\n        data: formData,\n        docPermissions: { fields: true },\n        docPreferences: await getDocPreferences(),\n        documentFormState: deepCopyObjectSimpleWithoutReactComponents(parentDocumentFields),\n        globalSlug,\n        initialBlockData: formData,\n        initialBlockFormState: formData,\n        operation: 'update',\n        renderAllFields: true,\n        schemaPath: schemaFieldsPath,\n        signal: abortController.signal,\n      })\n\n      if (state) {\n        const newFormStateData: InlineBlockFields = reduceFieldsToValues(\n          deepCopyObjectSimpleWithoutReactComponents(state),\n          true,\n        ) as InlineBlockFields\n\n        // Things like default values may come back from the server => update the node with the new data\n        editor.update(() => {\n          const node = $getNodeByKey(nodeKey)\n          if (node && $isInlineBlockNode(node)) {\n            const newData = newFormStateData\n            newData.blockType = formData.blockType\n\n            node.setFields(newData, true)\n          }\n        })\n\n        setInitialState(state)\n        setCustomLabel(state['_components']?.customComponents?.BlockLabel)\n        setCustomBlock(state['_components']?.customComponents?.Block)\n      }\n    }\n\n    if (formData && !initialState) {\n      void awaitInitialState()\n    }\n\n    return () => {\n      abortAndIgnore(abortController)\n    }\n  }, [\n    getFormState,\n    editor,\n    nodeKey,\n    schemaFieldsPath,\n    id,\n    formData,\n    initialState,\n    collectionSlug,\n    globalSlug,\n    getDocPreferences,\n    parentDocumentFields,\n  ])\n\n  /**\n   * HANDLE ONCHANGE\n   */\n  const onChange = useCallback(\n    async ({ formState: prevFormState, submit }: { formState: FormState; submit?: boolean }) => {\n      abortAndIgnore(onChangeAbortControllerRef.current)\n\n      const controller = new AbortController()\n      onChangeAbortControllerRef.current = controller\n\n      const { state } = await getFormState({\n        id,\n        collectionSlug,\n        docPermissions: {\n          fields: true,\n        },\n        docPreferences: await getDocPreferences(),\n        documentFormState: deepCopyObjectSimpleWithoutReactComponents(parentDocumentFields),\n        formState: prevFormState,\n        globalSlug,\n        initialBlockFormState: prevFormState,\n        operation: 'update',\n        renderAllFields: submit ? true : false,\n        schemaPath: schemaFieldsPath,\n        signal: controller.signal,\n      })\n\n      if (!state) {\n        return prevFormState\n      }\n\n      if (submit) {\n        setCustomLabel(state['_components']?.customComponents?.BlockLabel)\n        setCustomBlock(state['_components']?.customComponents?.Block)\n      }\n\n      return state\n    },\n    [\n      getFormState,\n      id,\n      collectionSlug,\n      getDocPreferences,\n      parentDocumentFields,\n      globalSlug,\n      schemaFieldsPath,\n    ],\n  )\n  // cleanup effect\n  useEffect(() => {\n    const isStateOutOfSync = (formData: InlineBlockFields, initialState: FormState) => {\n      return Object.keys(initialState).some(\n        (key) => initialState[key] && formData[key] !== initialState[key].value,\n      )\n    }\n\n    return () => {\n      // If the component is unmounted (either via removeInlineBlock or via lexical itself) and the form state got changed before,\n      // we need to reset the initial state to force a re-fetch of the initial state when it gets mounted again (e.g. via lexical history undo).\n      // Otherwise it would use an outdated initial state.\n      if (initialState && isStateOutOfSync(formData, initialState)) {\n        setInitialState(false)\n      }\n      abortAndIgnore(onChangeAbortControllerRef.current)\n    }\n  }, [formData, initialState])\n\n  /**\n   * HANDLE FORM SUBMIT\n   */\n  const onFormSubmit = useCallback(\n    (formState: FormState, newData: Data) => {\n      newData.blockType = formData.blockType\n\n      editor.update(() => {\n        const node = $getNodeByKey(nodeKey)\n        if (node && $isInlineBlockNode(node)) {\n          node.setFields(newData as InlineBlockFields, true)\n        }\n      })\n    },\n    [editor, nodeKey, formData],\n  )\n\n  const RemoveButton = useMemo(\n    () => () => (\n      <Button\n        buttonStyle=\"icon-label\"\n        className={`${baseClass}__removeButton`}\n        disabled={readOnly}\n        icon=\"x\"\n        onClick={(e) => {\n          e.preventDefault()\n          removeInlineBlock()\n        }}\n        round\n        size=\"small\"\n        tooltip={t('lexical:blocks:inlineBlocks:remove', { label: blockDisplayName })}\n      />\n    ),\n    [blockDisplayName, readOnly, removeInlineBlock, t],\n  )\n\n  const EditButton = useMemo(\n    () => () => (\n      <Button\n        buttonStyle=\"icon-label\"\n        className={`${baseClass}__editButton`}\n        disabled={readOnly}\n        el=\"button\"\n        icon=\"edit\"\n        onClick={() => {\n          toggleDrawer()\n        }}\n        round\n        size=\"small\"\n        tooltip={t('lexical:blocks:inlineBlocks:edit', { label: blockDisplayName })}\n      />\n    ),\n    [blockDisplayName, readOnly, t, toggleDrawer],\n  )\n\n  const InlineBlockContainer = useMemo(\n    () =>\n      ({ children, className }: { children: React.ReactNode; className?: string }) => (\n        <div\n          className={[baseClass, baseClass + '-' + formData.blockType, className]\n            .filter(Boolean)\n            .join(' ')}\n          ref={inlineBlockElemElemRef}\n        >\n          {children}\n        </div>\n      ),\n    [formData.blockType],\n  )\n\n  const Label = useMemo(() => {\n    if (CustomLabel) {\n      return () => CustomLabel\n    } else {\n      return () => (\n        <div>{clientBlock?.labels ? getTranslation(clientBlock?.labels.singular, i18n) : ''}</div>\n      )\n    }\n  }, [CustomLabel, clientBlock?.labels, i18n])\n\n  if (!clientBlock) {\n    return (\n      <InlineBlockContainer className={`${baseClass}-not-found`}>\n        <span>Error: Block '{formData.blockType}' not found</span>\n        {editor.isEditable() ? (\n          <div className={`${baseClass}__actions`}>\n            <RemoveButton />\n          </div>\n        ) : null}\n      </InlineBlockContainer>\n    )\n  }\n\n  return (\n    <Form\n      beforeSubmit={[\n        async ({ formState }) => {\n          // This is only called when form is submitted from drawer\n          return await onChange({ formState, submit: true })\n        },\n      ]}\n      disableValidationOnSubmit\n      el=\"div\"\n      fields={clientBlock?.fields}\n      initialState={initialState || {}}\n      onChange={[onChange]}\n      onSubmit={(formState, data) => {\n        onFormSubmit(formState, data)\n        toggleDrawer()\n      }}\n      uuid={uuid()}\n    >\n      <EditDepthProvider>\n        <Drawer\n          className={''}\n          slug={drawerSlug}\n          title={t(`lexical:blocks:inlineBlocks:${formData?.id ? 'edit' : 'create'}`, {\n            label: blockDisplayName ?? t('lexical:blocks:inlineBlocks:label'),\n          })}\n        >\n          {initialState ? (\n            <>\n              <RenderFields\n                fields={clientBlock?.fields}\n                forceRender\n                parentIndexPath=\"\"\n                parentPath=\"\" // See Blocks feature path for details as for why this is empty\n                parentSchemaPath={schemaFieldsPath}\n                permissions={true}\n                readOnly={false}\n              />\n              <FormSubmit programmaticSubmit={true}>{t('fields:saveChanges')}</FormSubmit>\n            </>\n          ) : null}\n        </Drawer>\n      </EditDepthProvider>\n      {CustomBlock ? (\n        <InlineBlockComponentContext\n          value={{\n            EditButton,\n            initialState,\n            InlineBlockContainer,\n            Label,\n            nodeKey,\n            RemoveButton,\n          }}\n        >\n          {CustomBlock}\n        </InlineBlockComponentContext>\n      ) : (\n        <InlineBlockContainer>\n          {initialState ? <Label /> : <ShimmerEffect height=\"15px\" width=\"40px\" />}\n          {editor.isEditable() ? (\n            <div className={`${baseClass}__actions`}>\n              <EditButton />\n              <RemoveButton />\n            </div>\n          ) : null}\n        </InlineBlockContainer>\n      )}\n    </Form>\n  )\n}\n", "'use client'\nimport type { EditorConfig, LexicalEditor, LexicalNode } from 'lexical'\n\nimport ObjectID from 'bson-objectid'\nimport React, { type JSX } from 'react'\n\nimport type {\n  InlineBlockFields,\n  SerializedInlineBlockNode,\n} from '../../server/nodes/InlineBlocksNode.js'\n\nimport { ServerInlineBlockNode } from '../../server/nodes/InlineBlocksNode.js'\n\nconst InlineBlockComponent = React.lazy(() =>\n  import('../componentInline/index.js').then((module) => ({\n    default: module.InlineBlockComponent,\n  })),\n)\n\nexport class InlineBlockNode extends ServerInlineBlockNode {\n  static override clone(node: ServerInlineBlockNode): ServerInlineBlockNode {\n    return super.clone(node)\n  }\n\n  static override getType(): string {\n    return super.getType()\n  }\n\n  static override importJSON(serializedNode: SerializedInlineBlockNode): InlineBlockNode {\n    const node = $createInlineBlockNode(serializedNode.fields)\n    return node\n  }\n\n  override decorate(editor: LexicalEditor, config: EditorConfig): JSX.Element {\n    return (\n      <InlineBlockComponent\n        cacheBuster={this.getCacheBuster()}\n        formData={this.getFields()}\n        nodeKey={this.getKey()}\n      />\n    )\n  }\n\n  override exportJSON(): SerializedInlineBlockNode {\n    return super.exportJSON()\n  }\n}\n\nexport function $createInlineBlockNode(fields: Exclude<InlineBlockFields, 'id'>): InlineBlockNode {\n  return new InlineBlockNode({\n    fields: {\n      ...fields,\n      id: fields?.id || new ObjectID.default().toHexString(),\n    },\n  })\n}\n\nexport function $isInlineBlockNode(\n  node: InlineBlockNode | LexicalNode | null | undefined,\n): node is InlineBlockNode {\n  return node instanceof InlineBlockNode\n}\n", "import type {\n  DOMConversionMap,\n  DOMExportOutput,\n  EditorConfig,\n  LexicalEditor,\n  LexicalNode,\n  NodeKey,\n  SerializedLexicalNode,\n  Spread,\n} from 'lexical'\nimport type { JsonObject } from 'payload'\nimport type React from 'react'\nimport type { JSX } from 'react'\n\nimport ObjectID from 'bson-objectid'\nimport { DecoratorNode } from 'lexical'\n\nexport type InlineBlockFields<TInlineBlockFields extends JsonObject = JsonObject> = {\n  blockType: string\n  id: string\n} & TInlineBlockFields\n\nexport type SerializedInlineBlockNode<TBlockFields extends JsonObject = JsonObject> = Spread<\n  {\n    children?: never // required so that our typed editor state doesn't automatically add children\n    fields: InlineBlockFields<TBlockFields>\n    type: 'inlineBlock'\n  },\n  SerializedLexicalNode\n>\n\nexport class ServerInlineBlockNode extends DecoratorNode<null | React.ReactElement> {\n  __cacheBuster: number\n  __fields: InlineBlockFields\n\n  constructor({\n    cacheBuster,\n    fields,\n    key,\n  }: {\n    cacheBuster?: number\n    fields: InlineBlockFields\n    key?: NodeKey\n  }) {\n    super(key)\n    this.__fields = fields\n    this.__cacheBuster = cacheBuster || 0\n  }\n\n  static override clone(node: ServerInlineBlockNode): ServerInlineBlockNode {\n    return new this({\n      cacheBuster: node.__cacheBuster,\n      fields: node.__fields,\n      key: node.__key,\n    })\n  }\n\n  static override getType(): string {\n    return 'inlineBlock'\n  }\n\n  static override importDOM(): DOMConversionMap<HTMLDivElement> | null {\n    return {}\n  }\n\n  static override importJSON(serializedNode: SerializedInlineBlockNode): ServerInlineBlockNode {\n    const node = $createServerInlineBlockNode(serializedNode.fields)\n    return node\n  }\n\n  static isInline(): false {\n    return false\n  }\n\n  canIndent() {\n    return true\n  }\n  override createDOM() {\n    const element = document.createElement('span')\n    element.classList.add('inline-block-container')\n\n    return element\n  }\n\n  override decorate(editor: LexicalEditor, config: EditorConfig): JSX.Element | null {\n    return null\n  }\n\n  override exportDOM(): DOMExportOutput {\n    const element = document.createElement('span')\n    element.classList.add('inline-block-container')\n\n    const text = document.createTextNode(this.getTextContent())\n    element.append(text)\n    return { element }\n  }\n\n  override exportJSON(): SerializedInlineBlockNode {\n    return {\n      type: 'inlineBlock',\n      fields: this.getFields(),\n      version: 1,\n    }\n  }\n\n  getCacheBuster(): number {\n    return this.getLatest().__cacheBuster\n  }\n\n  getFields(): InlineBlockFields {\n    return this.getLatest().__fields\n  }\n\n  override getTextContent(): string {\n    return `Block Field`\n  }\n\n  override isInline() {\n    return true\n  }\n\n  setFields(fields: InlineBlockFields, preventFormStateUpdate?: boolean): void {\n    const writable = this.getWritable()\n    writable.__fields = fields\n    if (!preventFormStateUpdate) {\n      writable.__cacheBuster++\n    }\n  }\n\n  override updateDOM(): boolean {\n    return false\n  }\n}\n\nexport function $createServerInlineBlockNode(\n  fields: Exclude<InlineBlockFields, 'id'>,\n): ServerInlineBlockNode {\n  return new ServerInlineBlockNode({\n    fields: {\n      ...fields,\n      id: fields?.id || new ObjectID.default().toHexString(),\n    },\n  })\n}\n\nexport function $isServerInlineBlockNode(\n  node: LexicalNode | null | ServerInlineBlockNode | undefined,\n): node is ServerInlineBlockNode {\n  return node instanceof ServerInlineBlockNode\n}\n"],
-  "mappings": "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",
-  "names": ["React", "createContext", "useCallback", "useEffect", "useMemo", "useRef", "useLexicalComposerContext", "getTranslation", "Button", "Drawer", "EditDepthProvider", "Form", "formatDrawerSlug", "FormSubmit", "RenderFields", "ShimmerEffect", "useConfig", "useDocumentForm", "useDocumentInfo", "useEditDepth", "useServerFunctions", "useTranslation", "abortAndIgnore", "$getNodeByKey", "deepCopyObjectSimpleWithoutReactComponents", "reduceFieldsToValues", "v4", "uuid", "ObjectID", "React", "ObjectID", "DecoratorNode", "ServerInlineBlockNode", "__cacheBuster", "__fields", "constructor", "cacheBuster", "fields", "key", "clone", "node", "__key", "getType", "importDOM", "importJSON", "serializedNode", "$createServerInlineBlockNode", "isInline", "canIndent", "createDOM", "element", "document", "createElement", "classList", "add", "decorate", "editor", "config", "exportDOM", "text", "createTextNode", "getTextContent", "append", "exportJSON", "type", "getFields", "version", "getCacheBuster", "getLatest", "setFields", "preventFormStateUpdate", "writable", "getWritable", "updateDOM", "id", "default", "toHexString", "InlineBlockComponent", "React", "lazy", "then", "module", "default", "InlineBlockNode", "ServerInlineBlockNode", "clone", "node", "getType", "importJSON", "serializedNode", "$createInlineBlockNode", "fields", "decorate", "editor", "config", "_jsx", "cacheBuster", "getCacheBuster", "formData", "getFields", "nodeKey", "getKey", "exportJSON", "id", "ObjectID", "toHexString", "$isInlineBlockNode", "baseClass", "InlineBlockComponentContext", "createContext", "initialState", "useInlineBlockComponentContext", "React", "use", "InlineBlockComponent", "props", "cacheBuster", "formData", "nodeKey", "editor", "useLexicalComposerContext", "i18n", "t", "useTranslation", "createdInlineBlock", "fieldProps", "featureClientSchemaMap", "initialLexicalFormState", "readOnly", "schemaPath", "setCreatedInlineBlock", "uuid", "uuidFromContext", "useEditorConfigContext", "fields", "parentDocumentFields", "useDocumentForm", "getFormState", "useServerFunctions", "editDepth", "useEditDepth", "firstTimeDrawer", "useRef", "setInitialState", "useState", "id", "formState", "hasMounted", "prevCacheBuster", "useEffect", "current", "CustomLabel", "setCustomLabel", "customComponents", "BlockLabel", "CustomBlock", "setCustomBlock", "Block", "drawerSlug", "formatDrawerSlug", "slug", "depth", "toggleDrawer", "useLexicalDrawer", "inlineBlockElemElemRef", "collectionSlug", "getDocPreferences", "globalSlug", "useDocumentInfo", "config", "useConfig", "componentMapRenderedBlockPath", "blockType", "blocksField", "clientBlock", "blockReferences", "blocksMap", "blocks", "clientBlockFields", "getKey", "length", "undefined", "removeInlineBlock", "useCallback", "update", "$getNodeByKey", "remove", "blockDisplayName", "labels", "singular", "getTranslation", "onChangeAbortControllerRef", "AbortController", "schemaFieldsPath", "abortController", "state", "data", "docPermissions", "docPreferences", "documentFormState", "deepCopyObjectSimpleWithoutReactComponents", "initialBlockData", "initialBlockFormState", "operation", "renderAllFields", "signal", "newFormStateData", "reduceFieldsToValues", "node", "$isInlineBlockNode", "newData", "setFields", "abortAndIgnore", "onChange", "prevFormState", "submit", "controller", "isStateOutOfSync", "Object", "keys", "some", "key", "value", "onFormSubmit", "RemoveButton", "useMemo", "_jsx", "Button", "buttonStyle", "className", "disabled", "icon", "onClick", "e", "preventDefault", "round", "size", "tooltip", "label", "EditButton", "el", "InlineBlockContainer", "children", "filter", "Boolean", "join", "ref", "Label", "_jsxs", "Form", "beforeSubmit", "disableValidationOnSubmit", "onSubmit", "EditDepthProvider", "Drawer", "title", "_Fragment", "RenderFields", "forceRender", "parentIndexPath", "parentPath", "parentSchemaPath", "permissions", "FormSubmit", "programmaticSubmit", "ShimmerEffect", "height", "width", "isEditable"]
-}

package/dist/exports/client/componentInline-AGFSKAY4.js

@@ -1,2 +0,0 @@
-"use client";import{a,b}from"./chunk-K47TNP5J.js";import"./chunk-INBEEENE.js";import"./chunk-BZZVLW4U.js";export{b as InlineBlockComponent,a as useInlineBlockComponentContext};
-//# sourceMappingURL=componentInline-AGFSKAY4.js.map

package/dist/features/blocks/client/markdown/getLexicalToMarkdown.d.ts

@@ -1,6 +0,0 @@
-import type { Klass, LexicalNode, LexicalNodeReplacement } from 'lexical';
-import { type Transformer } from '../../../../packages/@lexical/markdown/index.js';
-export declare function getLexicalToMarkdown(allNodes: Array<Klass<LexicalNode> | LexicalNodeReplacement>, allTransformers: Transformer[]): (args: {
-    editorState: Record<string, any>;
-}) => string;
-//# sourceMappingURL=getLexicalToMarkdown.d.ts.map

package/dist/features/blocks/client/markdown/getLexicalToMarkdown.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"getLexicalToMarkdown.d.ts","sourceRoot":"","sources":["../../../../../src/features/blocks/client/markdown/getLexicalToMarkdown.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,WAAW,EAAE,sBAAsB,EAAE,MAAM,SAAS,CAAA;AAIzE,OAAO,EAEL,KAAK,WAAW,EACjB,MAAM,iDAAiD,CAAA;AAExD,wBAAgB,oBAAoB,CAClC,QAAQ,EAAE,KAAK,CAAC,KAAK,CAAC,WAAW,CAAC,GAAG,sBAAsB,CAAC,EAC5D,eAAe,EAAE,WAAW,EAAE,GAC7B,CAAC,IAAI,EAAE;IAAE,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAA;CAAE,KAAK,MAAM,CAoBxD"}

package/dist/features/blocks/client/markdown/getLexicalToMarkdown.js

@@ -1,24 +0,0 @@
-import { createHeadlessEditor } from '@lexical/headless';
-import { $convertToMarkdownString } from '../../../../packages/@lexical/markdown/index.js';
-export function getLexicalToMarkdown(allNodes, allTransformers) {
-  const lexicalToMarkdown = ({
-    editorState
-  }) => {
-    const headlessEditor = createHeadlessEditor({
-      nodes: allNodes
-    });
-    try {
-      headlessEditor.setEditorState(headlessEditor.parseEditorState(editorState)) // This should commit the editor state immediately
-      ;
-    } catch (e) {
-      console.error('getLexicalToMarkdown: ERROR parsing editor state', e);
-    }
-    let markdown = '';
-    headlessEditor.getEditorState().read(() => {
-      markdown = $convertToMarkdownString(allTransformers);
-    });
-    return markdown;
-  };
-  return lexicalToMarkdown;
-}
-//# sourceMappingURL=getLexicalToMarkdown.js.map

package/dist/features/blocks/client/markdown/getLexicalToMarkdown.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"getLexicalToMarkdown.js","names":["createHeadlessEditor","$convertToMarkdownString","getLexicalToMarkdown","allNodes","allTransformers","lexicalToMarkdown","editorState","headlessEditor","nodes","setEditorState","parseEditorState","e","console","error","markdown","getEditorState","read"],"sources":["../../../../../src/features/blocks/client/markdown/getLexicalToMarkdown.ts"],"sourcesContent":["import type { Klass, LexicalNode, LexicalNodeReplacement } from 'lexical'\n\nimport { createHeadlessEditor } from '@lexical/headless'\n\nimport {\n  $convertToMarkdownString,\n  type Transformer,\n} from '../../../../packages/@lexical/markdown/index.js'\n\nexport function getLexicalToMarkdown(\n  allNodes: Array<Klass<LexicalNode> | LexicalNodeReplacement>,\n  allTransformers: Transformer[],\n): (args: { editorState: Record<string, any> }) => string {\n  const lexicalToMarkdown = ({ editorState }: { editorState: Record<string, any> }): string => {\n    const headlessEditor = createHeadlessEditor({\n      nodes: allNodes,\n    })\n\n    try {\n      headlessEditor.setEditorState(headlessEditor.parseEditorState(editorState as any)) // This should commit the editor state immediately\n    } catch (e) {\n      console.error('getLexicalToMarkdown: ERROR parsing editor state', e)\n    }\n\n    let markdown: string = ''\n    headlessEditor.getEditorState().read(() => {\n      markdown = $convertToMarkdownString(allTransformers)\n    })\n\n    return markdown\n  }\n  return lexicalToMarkdown\n}\n"],"mappings":"AAEA,SAASA,oBAAoB,QAAQ;AAErC,SACEC,wBAAwB,QAEnB;AAEP,OAAO,SAASC,qBACdC,QAA4D,EAC5DC,eAA8B;EAE9B,MAAMC,iBAAA,GAAoBA,CAAC;IAAEC;EAAW,CAAwC;IAC9E,MAAMC,cAAA,GAAiBP,oBAAA,CAAqB;MAC1CQ,KAAA,EAAOL;IACT;IAEA,IAAI;MACFI,cAAA,CAAeE,cAAc,CAACF,cAAA,CAAeG,gBAAgB,CAACJ,WAAA,GAAqB;MAAA;IACrF,EAAE,OAAOK,CAAA,EAAG;MACVC,OAAA,CAAQC,KAAK,CAAC,oDAAoDF,CAAA;IACpE;IAEA,IAAIG,QAAA,GAAmB;IACvBP,cAAA,CAAeQ,cAAc,GAAGC,IAAI,CAAC;MACnCF,QAAA,GAAWb,wBAAA,CAAyBG,eAAA;IACtC;IAEA,OAAOU,QAAA;EACT;EACA,OAAOT,iBAAA;AACT","ignoreList":[]}

package/dist/features/blocks/client/markdown/getMarkdownToLexical.d.ts

@@ -1,6 +0,0 @@
-import type { Klass, LexicalNode, LexicalNodeReplacement, SerializedEditorState } from 'lexical';
-import { type Transformer } from '../../../../packages/@lexical/markdown/index.js';
-export declare function getMarkdownToLexical(allNodes: Array<Klass<LexicalNode> | LexicalNodeReplacement>, allTransformers: Transformer[]): (args: {
-    markdown: string;
-}) => SerializedEditorState;
-//# sourceMappingURL=getMarkdownToLexical.d.ts.map

package/dist/features/blocks/client/markdown/getMarkdownToLexical.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"getMarkdownToLexical.d.ts","sourceRoot":"","sources":["../../../../../src/features/blocks/client/markdown/getMarkdownToLexical.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,WAAW,EAAE,sBAAsB,EAAE,qBAAqB,EAAE,MAAM,SAAS,CAAA;AAIhG,OAAO,EAEL,KAAK,WAAW,EACjB,MAAM,iDAAiD,CAAA;AAExD,wBAAgB,oBAAoB,CAClC,QAAQ,EAAE,KAAK,CAAC,KAAK,CAAC,WAAW,CAAC,GAAG,sBAAsB,CAAC,EAC5D,eAAe,EAAE,WAAW,EAAE,GAC7B,CAAC,IAAI,EAAE;IAAE,QAAQ,EAAE,MAAM,CAAA;CAAE,KAAK,qBAAqB,CAkBvD"}

package/dist/features/blocks/client/markdown/getMarkdownToLexical.js

@@ -1,20 +0,0 @@
-import { createHeadlessEditor } from '@lexical/headless';
-import { $convertFromMarkdownString } from '../../../../packages/@lexical/markdown/index.js';
-export function getMarkdownToLexical(allNodes, allTransformers) {
-  const markdownToLexical = ({
-    markdown
-  }) => {
-    const headlessEditor = createHeadlessEditor({
-      nodes: allNodes
-    });
-    headlessEditor.update(() => {
-      $convertFromMarkdownString(markdown, allTransformers);
-    }, {
-      discrete: true
-    });
-    const editorJSON = headlessEditor.getEditorState().toJSON();
-    return editorJSON;
-  };
-  return markdownToLexical;
-}
-//# sourceMappingURL=getMarkdownToLexical.js.map

package/dist/features/blocks/client/markdown/getMarkdownToLexical.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"getMarkdownToLexical.js","names":["createHeadlessEditor","$convertFromMarkdownString","getMarkdownToLexical","allNodes","allTransformers","markdownToLexical","markdown","headlessEditor","nodes","update","discrete","editorJSON","getEditorState","toJSON"],"sources":["../../../../../src/features/blocks/client/markdown/getMarkdownToLexical.ts"],"sourcesContent":["import type { Klass, LexicalNode, LexicalNodeReplacement, SerializedEditorState } from 'lexical'\n\nimport { createHeadlessEditor } from '@lexical/headless'\n\nimport {\n  $convertFromMarkdownString,\n  type Transformer,\n} from '../../../../packages/@lexical/markdown/index.js'\n\nexport function getMarkdownToLexical(\n  allNodes: Array<Klass<LexicalNode> | LexicalNodeReplacement>,\n  allTransformers: Transformer[],\n): (args: { markdown: string }) => SerializedEditorState {\n  const markdownToLexical = ({ markdown }: { markdown: string }): SerializedEditorState => {\n    const headlessEditor = createHeadlessEditor({\n      nodes: allNodes,\n    })\n\n    headlessEditor.update(\n      () => {\n        $convertFromMarkdownString(markdown, allTransformers)\n      },\n      { discrete: true },\n    )\n\n    const editorJSON = headlessEditor.getEditorState().toJSON()\n\n    return editorJSON\n  }\n  return markdownToLexical\n}\n"],"mappings":"AAEA,SAASA,oBAAoB,QAAQ;AAErC,SACEC,0BAA0B,QAErB;AAEP,OAAO,SAASC,qBACdC,QAA4D,EAC5DC,eAA8B;EAE9B,MAAMC,iBAAA,GAAoBA,CAAC;IAAEC;EAAQ,CAAwB;IAC3D,MAAMC,cAAA,GAAiBP,oBAAA,CAAqB;MAC1CQ,KAAA,EAAOL;IACT;IAEAI,cAAA,CAAeE,MAAM,CACnB;MACER,0BAAA,CAA2BK,QAAA,EAAUF,eAAA;IACvC,GACA;MAAEM,QAAA,EAAU;IAAK;IAGnB,MAAMC,UAAA,GAAaJ,cAAA,CAAeK,cAAc,GAAGC,MAAM;IAEzD,OAAOF,UAAA;EACT;EACA,OAAON,iBAAA;AACT","ignoreList":[]}

package/dist/features/blocks/client/markdown/markdownTransformer.d.ts

@@ -1,12 +0,0 @@
-import type { ClientBlock } from 'payload';
-import { type Klass, type LexicalNode, type LexicalNodeReplacement } from 'lexical';
-import type { Transformer } from '../../../../packages/@lexical/markdown/index.js';
-import type { MultilineElementTransformer, TextMatchTransformer } from '../../../../packages/@lexical/markdown/MarkdownTransformers.js';
-export declare const getBlockMarkdownTransformers: ({ blocks, inlineBlocks, }: {
-    blocks: ClientBlock[];
-    inlineBlocks: ClientBlock[];
-}) => ((props: {
-    allNodes: Array<Klass<LexicalNode> | LexicalNodeReplacement>;
-    allTransformers: Transformer[];
-}) => MultilineElementTransformer | TextMatchTransformer)[];
-//# sourceMappingURL=markdownTransformer.d.ts.map

package/dist/features/blocks/client/markdown/markdownTransformer.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"markdownTransformer.d.ts","sourceRoot":"","sources":["../../../../../src/features/blocks/client/markdown/markdownTransformer.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,SAAS,CAAA;AAE1C,OAAO,EAGL,KAAK,KAAK,EACV,KAAK,WAAW,EAChB,KAAK,sBAAsB,EAE5B,MAAM,SAAS,CAAA;AAEhB,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,iDAAiD,CAAA;AAClF,OAAO,KAAK,EACV,2BAA2B,EAC3B,oBAAoB,EACrB,MAAM,gEAAgE,CAAA;AAqBvE,eAAO,MAAM,4BAA4B,8BAGtC;IACD,MAAM,EAAE,WAAW,EAAE,CAAA;IACrB,YAAY,EAAE,WAAW,EAAE,CAAA;CAC5B,KAAG,CAAC,CAAC,KAAK,EAAE;IACX,QAAQ,EAAE,KAAK,CAAC,KAAK,CAAC,WAAW,CAAC,GAAG,sBAAsB,CAAC,CAAA;IAC5D,eAAe,EAAE,WAAW,EAAE,CAAA;CAC/B,KAAK,2BAA2B,GAAG,oBAAoB,CAAC,EA8BxD,CAAA"}

package/dist/features/blocks/client/markdown/markdownTransformer.js

@@ -1,348 +0,0 @@
-import { $parseSerializedNode } from 'lexical';
-import { extractPropsFromJSXPropsString } from '../../../../utilities/jsx/extractPropsFromJSXPropsString.js';
-import { propsToJSXString } from '../../../../utilities/jsx/jsx.js';
-import { linesFromStartToContentAndPropsString } from '../../server/markdown/linesFromMatchToContentAndPropsString.js';
-import { $createBlockNode, $isBlockNode, BlockNode } from '../nodes/BlocksNode.js';
-import { $createInlineBlockNode, $isInlineBlockNode, InlineBlockNode } from '../nodes/InlineBlocksNode.js';
-import { getLexicalToMarkdown } from './getLexicalToMarkdown.js';
-import { getMarkdownToLexical } from './getMarkdownToLexical.js';
-function createTagRegexes(tagName) {
-  const escapedTagName = tagName.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-  return {
-    regExpEnd: new RegExp(`</(${escapedTagName})\\s*>|<${escapedTagName}[^>]*?/>`, 'i'),
-    regExpStart: new RegExp(`<(${escapedTagName})([^>]*?)\\s*(/?)>`, 'i')
-  };
-}
-export const getBlockMarkdownTransformers = ({
-  blocks,
-  inlineBlocks
-}) => {
-  if (!blocks?.length && !inlineBlocks?.length) {
-    return [];
-  }
-  let transformers = [];
-  if (blocks?.length) {
-    for (const block of blocks) {
-      const transformer = getMarkdownTransformerForBlock(block, false);
-      if (transformer) {
-        transformers = transformers.concat(transformer);
-      }
-    }
-  }
-  if (inlineBlocks?.length) {
-    for (const block of inlineBlocks) {
-      const transformer = getMarkdownTransformerForBlock(block, true);
-      if (transformer) {
-        transformers = transformers.concat(transformer);
-      }
-    }
-  }
-  return transformers;
-};
-function getMarkdownTransformerForBlock(block, isInlineBlock) {
-  if (!block.jsx) {
-    return null;
-  }
-  const regex = createTagRegexes(block.slug);
-  const toReturn = [];
-  if (isInlineBlock) {
-    toReturn.push(({
-      allNodes,
-      allTransformers
-    }) => ({
-      type: 'text-match',
-      dependencies: [InlineBlockNode],
-      export: node => {
-        if (!$isInlineBlockNode(node)) {
-          return null;
-        }
-        if (node.getFields()?.blockType?.toLowerCase() !== block.slug.toLowerCase()) {
-          return null;
-        }
-        const nodeFields = node.getFields();
-        const lexicalToMarkdown = getLexicalToMarkdown(allNodes, allTransformers);
-        const exportResult = block.jsx.export({
-          fields: nodeFields,
-          lexicalToMarkdown
-        });
-        if (exportResult === false) {
-          return null;
-        }
-        if (typeof exportResult === 'string') {
-          return exportResult;
-        }
-        const hasProps = exportResult.props && Object.keys(exportResult.props)?.length > 0;
-        const props = exportResult.props ?? {};
-        if (exportResult?.children?.length) {
-          return `<${nodeFields.blockType}${hasProps ? ' ' + propsToJSXString({
-            props
-          }) : ''}>${exportResult.children}</${nodeFields.blockType}>`;
-        }
-        return `<${nodeFields.blockType}${hasProps ? ' ' + propsToJSXString({
-          props
-        }) : ''}/>`;
-      },
-      getEndIndex: (node, match) => {
-        const {
-          endlineLastCharIndex
-        } = linesFromStartToContentAndPropsString({
-          isEndOptional: false,
-          lines: [node.getTextContent()],
-          regexpEndRegex: regex.regExpEnd,
-          startLineIndex: 0,
-          startMatch: match,
-          trimChildren: false
-        });
-        return endlineLastCharIndex;
-      },
-      importRegExp: block.jsx?.customStartRegex ?? regex.regExpStart,
-      regExp: /___ignoreignoreignore___/g,
-      replace(node, match) {
-        const {
-          content,
-          propsString
-        } = linesFromStartToContentAndPropsString({
-          isEndOptional: false,
-          lines: [node.getTextContent()],
-          regexpEndRegex: regex.regExpEnd,
-          startLineIndex: 0,
-          startMatch: {
-            ...match,
-            index: 0
-          },
-          trimChildren: false
-        });
-        if (!block?.jsx?.import) {
-          // No multiline transformer handled this line successfully
-          return;
-        }
-        const markdownToLexical = getMarkdownToLexical(allNodes, allTransformers);
-        const blockFields = block.jsx.import({
-          children: content,
-          closeMatch: null,
-          htmlToLexical: null,
-          markdownToLexical,
-          openMatch: match,
-          props: propsString ? extractPropsFromJSXPropsString({
-            propsString
-          }) : {}
-        });
-        if (blockFields === false) {
-          return;
-        }
-        const inlineBlockNode = $createInlineBlockNode({
-          blockType: block.slug,
-          ...blockFields
-        });
-        node.replace(inlineBlockNode);
-      }
-    }));
-    return toReturn;
-  }
-  toReturn.push(({
-    allNodes,
-    allTransformers
-  }) => ({
-    dependencies: [BlockNode],
-    export: node => {
-      if (!$isBlockNode(node)) {
-        return null;
-      }
-      if (node.getFields()?.blockType?.toLowerCase() !== block.slug.toLowerCase()) {
-        return null;
-      }
-      const nodeFields = node.getFields();
-      const lexicalToMarkdown = getLexicalToMarkdown(allNodes, allTransformers);
-      const exportResult = block.jsx.export({
-        fields: nodeFields,
-        lexicalToMarkdown
-      });
-      if (exportResult === false) {
-        return null;
-      }
-      if (typeof exportResult === 'string') {
-        return exportResult;
-      }
-      const hasProps = exportResult.props && Object.keys(exportResult.props)?.length > 0;
-      const props = exportResult.props ?? {};
-      if (exportResult?.children?.length) {
-        const children = exportResult.children;
-        let sanitizedChildren = '';
-        // Ensure it has a leftpad of at least 2 spaces. The data is saved without those spaces, so we can just blindly add it to every child
-        if (children.includes('\n')) {
-          for (const child of children.split('\n')) {
-            let sanitizedChild = '';
-            if (!block?.jsx?.doNotTrimChildren && child !== '') {
-              sanitizedChild = '  ';
-            }
-            sanitizedChild += child + '\n';
-            sanitizedChildren += sanitizedChild;
-          }
-        } else {
-          sanitizedChildren = (block?.jsx?.doNotTrimChildren ? '' : '  ') + children + '\n';
-        }
-        return `<${nodeFields.blockType}${hasProps ? ' ' + propsToJSXString({
-          props
-        }) : ''}>\n${sanitizedChildren}</${nodeFields.blockType}>`;
-      }
-      return `<${nodeFields.blockType}${hasProps ? ' ' + propsToJSXString({
-        props
-      }) : ''}/>`;
-    },
-    handleImportAfterStartMatch: block.jsx?.customEndRegex ? undefined : ({
-      lines,
-      rootNode,
-      startLineIndex,
-      startMatch,
-      transformer
-    }) => {
-      const regexpEndRegex = typeof transformer.regExpEnd === 'object' && 'regExp' in transformer.regExpEnd ? transformer.regExpEnd.regExp : transformer.regExpEnd;
-      const isEndOptional = transformer.regExpEnd && typeof transformer.regExpEnd === 'object' && 'optional' in transformer.regExpEnd ? transformer.regExpEnd.optional : !transformer.regExpEnd;
-      const {
-        afterEndLine,
-        beforeStartLine,
-        content: unsanitizedContent,
-        endLineIndex,
-        propsString
-      } = linesFromStartToContentAndPropsString({
-        isEndOptional,
-        lines,
-        regexpEndRegex,
-        startLineIndex,
-        startMatch,
-        trimChildren: false
-      });
-      let content = '';
-      if (block?.jsx?.doNotTrimChildren) {
-        content = unsanitizedContent.endsWith('\n') ? unsanitizedContent.slice(0, -1) : unsanitizedContent;
-      } else {
-        // Ensure it has a leftpad of at least 2 spaces. The data is saved without those spaces, so we can just blindly add it to every child
-        if (unsanitizedContent.includes('\n')) {
-          const split = unsanitizedContent.split('\n');
-          let index = 0;
-          for (const child of split) {
-            index++;
-            if (child.startsWith('  ')) {
-              content += child.slice(2);
-            } else {
-              // If one child is misaligned, skip aligning completely, unless it's just empty
-              if (child === '') {
-                content += child;
-              } else {
-                content = unsanitizedContent.endsWith('\n') ? unsanitizedContent.slice(0, -1) : unsanitizedContent;
-                break;
-              }
-            }
-            content += index === split.length ? '' : '\n';
-          }
-        } else {
-          content = (!unsanitizedContent.startsWith('  ') ? unsanitizedContent : unsanitizedContent.slice(2)) + '\n';
-        }
-      }
-      if (!block?.jsx?.import) {
-        // No multiline transformer handled this line successfully
-        return [false, startLineIndex];
-      }
-      const markdownToLexical = getMarkdownToLexical(allNodes, allTransformers);
-      const blockFields = block.jsx.import({
-        children: content,
-        closeMatch: null,
-        htmlToLexical: null,
-        markdownToLexical,
-        openMatch: startMatch,
-        props: propsString ? extractPropsFromJSXPropsString({
-          propsString
-        }) : {}
-      });
-      if (blockFields === false) {
-        return [false, startLineIndex];
-      }
-      const node = $createBlockNode({
-        blockType: block.slug,
-        ...blockFields
-      });
-      if (node) {
-        // Now handle beforeStartLine and afterEndLine. If those are not empty, we need to add them as text nodes before and after the block node.
-        // However, those themselves can contain other markdown matches, so we need to parse them as well.
-        // Example where this is needed: "Hello <InlineCode>inline code</InlineCode> test."
-        let prevNodes = null;
-        let nextNodes = null;
-        // TODO: Might not need this prevNodes and nextNodes handling if inline nodes are handled by textmatch transformers
-        if (beforeStartLine?.length) {
-          prevNodes = markdownToLexical({
-            markdown: beforeStartLine
-          })?.root?.children ?? [];
-          const firstPrevNode = prevNodes?.[0];
-          if (firstPrevNode) {
-            rootNode.append($parseSerializedNode(firstPrevNode));
-          }
-        }
-        rootNode.append(node);
-        if (afterEndLine?.length) {
-          nextNodes = markdownToLexical({
-            markdown: afterEndLine
-          })?.root?.children;
-          const lastChild = rootNode.getChildren()[rootNode.getChildren().length - 1];
-          const children = $parseSerializedNode(nextNodes[0])?.getChildren();
-          if (children?.length) {
-            for (const child of children) {
-              lastChild.append(child);
-            }
-          }
-        }
-      }
-      return [true, endLineIndex];
-    },
-    regExpEnd: block.jsx?.customEndRegex ?? regex.regExpEnd,
-    regExpStart: block.jsx?.customStartRegex ?? regex.regExpStart,
-    // This replace is ONLY run for ``` code blocks (so any blocks with custom start and end regexes). For others, we use the special JSX handling above:
-    type: 'multiline-element',
-    replace: (rootNode, children, openMatch, closeMatch, linesInBetween) => {
-      if (block?.jsx?.import) {
-        if (!linesInBetween) {
-          // convert children to linesInBetween
-          let line = '';
-          if (children) {
-            for (const child of children) {
-              line += child.getTextContent();
-            }
-          }
-          linesInBetween = [line];
-        }
-        let childrenString = '';
-        if (block?.jsx?.doNotTrimChildren) {
-          childrenString = linesInBetween.join('\n');
-        } else {
-          childrenString = linesInBetween.join('\n').trim();
-        }
-        const propsString = openMatch[1]?.trim();
-        const markdownToLexical = getMarkdownToLexical(allNodes, allTransformers);
-        const blockFields = block.jsx.import({
-          children: childrenString,
-          closeMatch: closeMatch,
-          htmlToLexical: null,
-          markdownToLexical,
-          openMatch: openMatch,
-          props: propsString ? extractPropsFromJSXPropsString({
-            propsString
-          }) : {}
-        });
-        if (blockFields === false) {
-          return false;
-        }
-        const node = $createBlockNode({
-          blockType: block.slug,
-          ...blockFields
-        });
-        if (node) {
-          rootNode.append(node);
-        }
-        return;
-      }
-      return false // Run next transformer
-      ;
-    }
-  }));
-  return toReturn;
-}
-//# sourceMappingURL=markdownTransformer.js.map

package/dist/features/blocks/client/markdown/markdownTransformer.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"markdownTransformer.js","names":["$parseSerializedNode","extractPropsFromJSXPropsString","propsToJSXString","linesFromStartToContentAndPropsString","$createBlockNode","$isBlockNode","BlockNode","$createInlineBlockNode","$isInlineBlockNode","InlineBlockNode","getLexicalToMarkdown","getMarkdownToLexical","createTagRegexes","tagName","escapedTagName","replace","regExpEnd","RegExp","regExpStart","getBlockMarkdownTransformers","blocks","inlineBlocks","length","transformers","block","transformer","getMarkdownTransformerForBlock","concat","isInlineBlock","jsx","regex","slug","toReturn","push","allNodes","allTransformers","type","dependencies","export","node","getFields","blockType","toLowerCase","nodeFields","lexicalToMarkdown","exportResult","fields","hasProps","props","Object","keys","children","getEndIndex","match","endlineLastCharIndex","isEndOptional","lines","getTextContent","regexpEndRegex","startLineIndex","startMatch","trimChildren","importRegExp","customStartRegex","regExp","content","propsString","index","import","markdownToLexical","blockFields","closeMatch","htmlToLexical","openMatch","inlineBlockNode","sanitizedChildren","includes","child","split","sanitizedChild","doNotTrimChildren","handleImportAfterStartMatch","customEndRegex","undefined","rootNode","optional","afterEndLine","beforeStartLine","unsanitizedContent","endLineIndex","endsWith","slice","startsWith","prevNodes","nextNodes","markdown","root","firstPrevNode","append","lastChild","getChildren","linesInBetween","line","childrenString","join","trim"],"sources":["../../../../../src/features/blocks/client/markdown/markdownTransformer.ts"],"sourcesContent":["import type { ClientBlock } from 'payload'\n\nimport {\n  $parseSerializedNode,\n  type ElementNode,\n  type Klass,\n  type LexicalNode,\n  type LexicalNodeReplacement,\n  type SerializedLexicalNode,\n} from 'lexical'\n\nimport type { Transformer } from '../../../../packages/@lexical/markdown/index.js'\nimport type {\n  MultilineElementTransformer,\n  TextMatchTransformer,\n} from '../../../../packages/@lexical/markdown/MarkdownTransformers.js'\n\nimport { extractPropsFromJSXPropsString } from '../../../../utilities/jsx/extractPropsFromJSXPropsString.js'\nimport { propsToJSXString } from '../../../../utilities/jsx/jsx.js'\nimport { linesFromStartToContentAndPropsString } from '../../server/markdown/linesFromMatchToContentAndPropsString.js'\nimport { $createBlockNode, $isBlockNode, BlockNode } from '../nodes/BlocksNode.js'\nimport {\n  $createInlineBlockNode,\n  $isInlineBlockNode,\n  InlineBlockNode,\n} from '../nodes/InlineBlocksNode.js'\nimport { getLexicalToMarkdown } from './getLexicalToMarkdown.js'\nimport { getMarkdownToLexical } from './getMarkdownToLexical.js'\n\nfunction createTagRegexes(tagName: string) {\n  const escapedTagName = tagName.replace(/[.*+?^${}()|[\\]\\\\]/g, '\\\\$&')\n  return {\n    regExpEnd: new RegExp(`</(${escapedTagName})\\\\s*>|<${escapedTagName}[^>]*?/>`, 'i'),\n    regExpStart: new RegExp(`<(${escapedTagName})([^>]*?)\\\\s*(/?)>`, 'i'),\n  }\n}\nexport const getBlockMarkdownTransformers = ({\n  blocks,\n  inlineBlocks,\n}: {\n  blocks: ClientBlock[]\n  inlineBlocks: ClientBlock[]\n}): ((props: {\n  allNodes: Array<Klass<LexicalNode> | LexicalNodeReplacement>\n  allTransformers: Transformer[]\n}) => MultilineElementTransformer | TextMatchTransformer)[] => {\n  if (!blocks?.length && !inlineBlocks?.length) {\n    return []\n  }\n  let transformers: ((props: {\n    allNodes: Array<Klass<LexicalNode> | LexicalNodeReplacement>\n    allTransformers: Transformer[]\n  }) => MultilineElementTransformer | TextMatchTransformer)[] = []\n\n  if (blocks?.length) {\n    for (const block of blocks) {\n      const transformer = getMarkdownTransformerForBlock(block, false)\n\n      if (transformer) {\n        transformers = transformers.concat(transformer)\n      }\n    }\n  }\n\n  if (inlineBlocks?.length) {\n    for (const block of inlineBlocks) {\n      const transformer = getMarkdownTransformerForBlock(block, true)\n\n      if (transformer) {\n        transformers = transformers.concat(transformer)\n      }\n    }\n  }\n\n  return transformers\n}\n\nfunction getMarkdownTransformerForBlock(\n  block: ClientBlock,\n  isInlineBlock: boolean,\n): Array<\n  (props: {\n    allNodes: Array<Klass<LexicalNode> | LexicalNodeReplacement>\n    allTransformers: Transformer[]\n  }) => MultilineElementTransformer | TextMatchTransformer\n> | null {\n  if (!block.jsx) {\n    return null\n  }\n  const regex = createTagRegexes(block.slug)\n  const toReturn: Array<\n    (props: {\n      allNodes: Array<Klass<LexicalNode> | LexicalNodeReplacement>\n      allTransformers: Transformer[]\n    }) => MultilineElementTransformer | TextMatchTransformer\n  > = []\n\n  if (isInlineBlock) {\n    toReturn.push(({ allNodes, allTransformers }) => ({\n      type: 'text-match',\n      dependencies: [InlineBlockNode],\n      export: (node) => {\n        if (!$isInlineBlockNode(node)) {\n          return null\n        }\n\n        if (node.getFields()?.blockType?.toLowerCase() !== block.slug.toLowerCase()) {\n          return null\n        }\n\n        const nodeFields = node.getFields()\n        const lexicalToMarkdown = getLexicalToMarkdown(allNodes, allTransformers)\n\n        const exportResult = block.jsx!.export({\n          fields: nodeFields,\n          lexicalToMarkdown,\n        })\n        if (exportResult === false) {\n          return null\n        }\n        if (typeof exportResult === 'string') {\n          return exportResult\n        }\n\n        const hasProps = exportResult.props && Object.keys(exportResult.props)?.length > 0\n        const props = exportResult.props ?? {}\n\n        if (exportResult?.children?.length) {\n          return `<${nodeFields.blockType}${hasProps ? ' ' + propsToJSXString({ props }) : ''}>${exportResult.children}</${nodeFields.blockType}>`\n        }\n\n        return `<${nodeFields.blockType}${hasProps ? ' ' + propsToJSXString({ props }) : ''}/>`\n      },\n      getEndIndex: (node, match) => {\n        const { endlineLastCharIndex } = linesFromStartToContentAndPropsString({\n          isEndOptional: false,\n          lines: [node.getTextContent()],\n          regexpEndRegex: regex.regExpEnd,\n          startLineIndex: 0,\n          startMatch: match,\n          trimChildren: false,\n        })\n\n        return endlineLastCharIndex\n      },\n      importRegExp: block.jsx?.customStartRegex ?? regex.regExpStart,\n      regExp: /___ignoreignoreignore___/g,\n      replace(node, match) {\n        const { content, propsString } = linesFromStartToContentAndPropsString({\n          isEndOptional: false,\n          lines: [node.getTextContent()],\n          regexpEndRegex: regex.regExpEnd,\n          startLineIndex: 0,\n          startMatch: {\n            ...match,\n            index: 0,\n          },\n          trimChildren: false,\n        })\n\n        if (!block?.jsx?.import) {\n          // No multiline transformer handled this line successfully\n          return\n        }\n\n        const markdownToLexical = getMarkdownToLexical(allNodes, allTransformers)\n\n        const blockFields = block.jsx.import({\n          children: content,\n          closeMatch: null,\n          htmlToLexical: null, // TODO\n          markdownToLexical,\n          openMatch: match,\n          props: propsString\n            ? extractPropsFromJSXPropsString({\n                propsString,\n              })\n            : {},\n        })\n        if (blockFields === false) {\n          return\n        }\n\n        const inlineBlockNode = $createInlineBlockNode({\n          blockType: block.slug,\n          ...(blockFields as any),\n        })\n\n        node.replace(inlineBlockNode)\n      },\n    }))\n\n    return toReturn\n  }\n\n  toReturn.push(({ allNodes, allTransformers }) => ({\n    dependencies: [BlockNode],\n    export: (node) => {\n      if (!$isBlockNode(node)) {\n        return null\n      }\n\n      if (node.getFields()?.blockType?.toLowerCase() !== block.slug.toLowerCase()) {\n        return null\n      }\n\n      const nodeFields = node.getFields()\n      const lexicalToMarkdown = getLexicalToMarkdown(allNodes, allTransformers)\n\n      const exportResult = block.jsx!.export({\n        fields: nodeFields,\n        lexicalToMarkdown,\n      })\n      if (exportResult === false) {\n        return null\n      }\n      if (typeof exportResult === 'string') {\n        return exportResult\n      }\n\n      const hasProps = exportResult.props && Object.keys(exportResult.props)?.length > 0\n      const props = exportResult.props ?? {}\n\n      if (exportResult?.children?.length) {\n        const children = exportResult.children\n        let sanitizedChildren = ''\n\n        // Ensure it has a leftpad of at least 2 spaces. The data is saved without those spaces, so we can just blindly add it to every child\n        if (children.includes('\\n')) {\n          for (const child of children.split('\\n')) {\n            let sanitizedChild = ''\n            if (!block?.jsx?.doNotTrimChildren && child !== '') {\n              sanitizedChild = '  '\n            }\n            sanitizedChild += child + '\\n'\n\n            sanitizedChildren += sanitizedChild\n          }\n        } else {\n          sanitizedChildren = (block?.jsx?.doNotTrimChildren ? '' : '  ') + children + '\\n'\n        }\n\n        return `<${nodeFields.blockType}${hasProps ? ' ' + propsToJSXString({ props }) : ''}>\\n${sanitizedChildren}</${nodeFields.blockType}>`\n      }\n\n      return `<${nodeFields.blockType}${hasProps ? ' ' + propsToJSXString({ props }) : ''}/>`\n    },\n    handleImportAfterStartMatch: block.jsx?.customEndRegex\n      ? undefined\n      : ({ lines, rootNode, startLineIndex, startMatch, transformer }) => {\n          const regexpEndRegex: RegExp | undefined =\n            typeof transformer.regExpEnd === 'object' && 'regExp' in transformer.regExpEnd\n              ? transformer.regExpEnd.regExp\n              : transformer.regExpEnd\n\n          const isEndOptional =\n            transformer.regExpEnd &&\n            typeof transformer.regExpEnd === 'object' &&\n            'optional' in transformer.regExpEnd\n              ? transformer.regExpEnd.optional\n              : !transformer.regExpEnd\n\n          const {\n            afterEndLine,\n            beforeStartLine,\n            content: unsanitizedContent,\n            endLineIndex,\n            propsString,\n          } = linesFromStartToContentAndPropsString({\n            isEndOptional,\n            lines,\n            regexpEndRegex,\n            startLineIndex,\n            startMatch,\n            trimChildren: false,\n          })\n\n          let content = ''\n\n          if (block?.jsx?.doNotTrimChildren) {\n            content = unsanitizedContent.endsWith('\\n')\n              ? unsanitizedContent.slice(0, -1)\n              : unsanitizedContent\n          } else {\n            // Ensure it has a leftpad of at least 2 spaces. The data is saved without those spaces, so we can just blindly add it to every child\n            if (unsanitizedContent.includes('\\n')) {\n              const split = unsanitizedContent.split('\\n')\n              let index = 0\n              for (const child of split) {\n                index++\n\n                if (child.startsWith('  ')) {\n                  content += child.slice(2)\n                } else {\n                  // If one child is misaligned, skip aligning completely, unless it's just empty\n                  if (child === '') {\n                    content += child\n                  } else {\n                    content = unsanitizedContent.endsWith('\\n')\n                      ? unsanitizedContent.slice(0, -1)\n                      : unsanitizedContent\n                    break\n                  }\n                }\n\n                content += index === split.length ? '' : '\\n'\n              }\n            } else {\n              content =\n                (!unsanitizedContent.startsWith('  ')\n                  ? unsanitizedContent\n                  : unsanitizedContent.slice(2)) + '\\n'\n            }\n          }\n\n          if (!block?.jsx?.import) {\n            // No multiline transformer handled this line successfully\n            return [false, startLineIndex]\n          }\n\n          const markdownToLexical = getMarkdownToLexical(allNodes, allTransformers)\n\n          const blockFields = block.jsx.import({\n            children: content,\n            closeMatch: null,\n            htmlToLexical: null, // TODO\n            markdownToLexical,\n            openMatch: startMatch,\n            props: propsString\n              ? extractPropsFromJSXPropsString({\n                  propsString,\n                })\n              : {},\n          })\n          if (blockFields === false) {\n            return [false, startLineIndex]\n          }\n\n          const node = $createBlockNode({\n            blockType: block.slug,\n            ...blockFields,\n          } as any)\n\n          if (node) {\n            // Now handle beforeStartLine and afterEndLine. If those are not empty, we need to add them as text nodes before and after the block node.\n            // However, those themselves can contain other markdown matches, so we need to parse them as well.\n            // Example where this is needed: \"Hello <InlineCode>inline code</InlineCode> test.\"\n            let prevNodes: null | SerializedLexicalNode[] = null\n            let nextNodes: null | SerializedLexicalNode[] = null\n            // TODO: Might not need this prevNodes and nextNodes handling if inline nodes are handled by textmatch transformers\n\n            if (beforeStartLine?.length) {\n              prevNodes = markdownToLexical({ markdown: beforeStartLine })?.root?.children ?? []\n\n              const firstPrevNode = prevNodes?.[0]\n              if (firstPrevNode) {\n                rootNode.append($parseSerializedNode(firstPrevNode))\n              }\n            }\n\n            rootNode.append(node)\n\n            if (afterEndLine?.length) {\n              nextNodes = markdownToLexical({ markdown: afterEndLine })?.root?.children\n              const lastChild = rootNode.getChildren()[rootNode.getChildren().length - 1]\n\n              const children = ($parseSerializedNode(nextNodes[0]!) as ElementNode)?.getChildren()\n              if (children?.length) {\n                for (const child of children) {\n                  ;(lastChild as ElementNode).append(child)\n                }\n              }\n            }\n          }\n\n          return [true, endLineIndex]\n        },\n    regExpEnd: block.jsx?.customEndRegex ?? regex.regExpEnd,\n    regExpStart: block.jsx?.customStartRegex ?? regex.regExpStart,\n    // This replace is ONLY run for ``` code blocks (so any blocks with custom start and end regexes). For others, we use the special JSX handling above:\n    type: 'multiline-element',\n    replace: (rootNode, children, openMatch, closeMatch, linesInBetween) => {\n      if (block?.jsx?.import) {\n        if (!linesInBetween) {\n          // convert children to linesInBetween\n          let line = ''\n          if (children) {\n            for (const child of children) {\n              line += child.getTextContent()\n            }\n          }\n\n          linesInBetween = [line]\n        }\n\n        let childrenString = ''\n        if (block?.jsx?.doNotTrimChildren) {\n          childrenString = linesInBetween.join('\\n')\n        } else {\n          childrenString = linesInBetween.join('\\n').trim()\n        }\n\n        const propsString = openMatch[1]?.trim()\n\n        const markdownToLexical = getMarkdownToLexical(allNodes, allTransformers)\n\n        const blockFields = block.jsx.import({\n          children: childrenString,\n          closeMatch: closeMatch as RegExpMatchArray,\n          htmlToLexical: null, // TODO\n          markdownToLexical,\n          openMatch: openMatch as RegExpMatchArray,\n          props: propsString\n            ? extractPropsFromJSXPropsString({\n                propsString,\n              })\n            : {},\n        })\n        if (blockFields === false) {\n          return false\n        }\n\n        const node = $createBlockNode({\n          blockType: block.slug,\n          ...blockFields,\n        } as any)\n\n        if (node) {\n          rootNode.append(node)\n        }\n\n        return\n      }\n      return false // Run next transformer\n    },\n  }))\n\n  return toReturn\n}\n"],"mappings":"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","ignoreList":[]}

package/dist/features/blocks/premade/CodeBlock/Component/Block.d.ts

@@ -1,5 +0,0 @@
-import React from 'react';
-import './index.scss';
-import type { AdditionalCodeComponentProps } from './Code.js';
-export declare const CodeBlockBlockComponent: React.FC<Required<Pick<AdditionalCodeComponentProps, 'languages'>>>;
-//# sourceMappingURL=Block.d.ts.map

package/dist/features/blocks/premade/CodeBlock/Component/Block.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"Block.d.ts","sourceRoot":"","sources":["../../../../../../src/features/blocks/premade/CodeBlock/Component/Block.tsx"],"names":[],"mappings":"AAYA,OAAO,KAAK,MAAM,OAAO,CAAA;AAEzB,OAAO,cAAc,CAAA;AAErB,OAAO,KAAK,EAAE,4BAA4B,EAAE,MAAM,WAAW,CAAA;AAQ7D,eAAO,MAAM,uBAAuB,EAAE,KAAK,CAAC,EAAE,CAC5C,QAAQ,CAAC,IAAI,CAAC,4BAA4B,EAAE,WAAW,CAAC,CAAC,CA+F1D,CAAA"}