@payloadcms/richtext-lexical 4.0.0-internal.a0ef1b8 → 4.0.0-internal.a7ca468

package/dist/features/experimental_table/client/plugins/TablePlugin/index.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.js","names":["useLexicalComposerContext","TablePlugin","LexicalReactTablePlugin","INSERT_TABLE_COMMAND","TableCellNode","TableNode","TableRowNode","mergeRegister","$getSelection","$isRangeSelection","$setSelection","COMMAND_PRIORITY_EDITOR","createCommand","createContext","use","useCallback","useEffect","useMemo","useRef","useState","React","TableGridPopup","OPEN_TABLE_DRAWER_COMMAND","CellContext","cellEditorConfig","cellEditorPlugins","set","TableContext","children","contextValue","setContextValue","_jsx","value","editor","cellContext","isPopupOpen","setIsPopupOpen","popupPosition","setPopupPosition","selectionRef","anchorElem","setAnchorElem","rootElement","getRootElement","editorWrapper","closest","parentElement","hasNodes","Error","registerCommand","anchor","anchorRect","getBoundingClientRect","pos","getEditorState","read","selection","current","clone","anchorNode","getNode","domElem","getElementByKey","getKey","elemRect","height","left","top","bottom","nativeSelection","window","getSelection","rangeCount","range","getRangeAt","rangeRect","handleClose","handleInsert","cols","rows","focus","update","discrete","skipTransforms","setTimeout","dispatchCommand","columns","String","_jsxs","Fragment","isOpen","onClose","onInsert","position","hasCellBackgroundColor","hasCellMerge","hasHorizontalScroll"],"sources":["../../../../../../src/features/experimental_table/client/plugins/TablePlugin/index.tsx"],"sourcesContent":["'use client'\n\nimport type {\n  BaseSelection,\n  EditorThemeClasses,\n  Klass,\n  LexicalCommand,\n  LexicalEditor,\n  LexicalNode,\n} from 'lexical'\nimport type { JSX } from 'react'\n\nimport { useLexicalComposerContext } from '@lexical/react/LexicalComposerContext'\nimport { TablePlugin as LexicalReactTablePlugin } from '@lexical/react/LexicalTablePlugin'\nimport { INSERT_TABLE_COMMAND, TableCellNode, TableNode, TableRowNode } from '@lexical/table'\nimport { mergeRegister } from '@lexical/utils'\nimport {\n  $getSelection,\n  $isRangeSelection,\n  $setSelection,\n  COMMAND_PRIORITY_EDITOR,\n  createCommand,\n} from 'lexical'\nimport { createContext, use, useCallback, useEffect, useMemo, useRef, useState } from 'react'\nimport * as React from 'react'\n\nimport type { PluginComponent } from '../../../../typesClient.js'\n\nimport { TableGridPopup } from './TableGridPopup/index.js'\nimport './index.css'\n\nexport type CellContextShape = {\n  cellEditorConfig: CellEditorConfig | null\n  cellEditorPlugins: Array<JSX.Element> | JSX.Element | null\n  set: (\n    cellEditorConfig: CellEditorConfig | null,\n    cellEditorPlugins: Array<JSX.Element> | JSX.Element | null,\n  ) => void\n}\n\nexport type CellEditorConfig = Readonly<{\n  namespace: string\n  nodes?: ReadonlyArray<Klass<LexicalNode>>\n  onError: (error: Error, editor: LexicalEditor) => void\n  readOnly?: boolean\n  theme?: EditorThemeClasses\n}>\n\nexport const OPEN_TABLE_DRAWER_COMMAND: LexicalCommand<{}> = createCommand(\n  'OPEN_EMBED_DRAWER_COMMAND',\n)\n\nexport const CellContext = createContext<CellContextShape>({\n  cellEditorConfig: null,\n  cellEditorPlugins: null,\n  set: () => {\n    // Empty\n  },\n})\n\nexport function TableContext({ children }: { children: JSX.Element }) {\n  const [contextValue, setContextValue] = useState<{\n    cellEditorConfig: CellEditorConfig | null\n    cellEditorPlugins: Array<JSX.Element> | JSX.Element | null\n  }>({\n    cellEditorConfig: null,\n    cellEditorPlugins: null,\n  })\n  return (\n    <CellContext\n      value={useMemo(\n        () => ({\n          cellEditorConfig: contextValue.cellEditorConfig,\n          cellEditorPlugins: contextValue.cellEditorPlugins,\n          set: (cellEditorConfig, cellEditorPlugins) => {\n            setContextValue({ cellEditorConfig, cellEditorPlugins })\n          },\n        }),\n        [contextValue.cellEditorConfig, contextValue.cellEditorPlugins],\n      )}\n    >\n      {children}\n    </CellContext>\n  )\n}\n\nexport const TablePlugin: PluginComponent = () => {\n  const [editor] = useLexicalComposerContext()\n  const cellContext = use(CellContext)\n  const [isPopupOpen, setIsPopupOpen] = useState(false)\n  const [popupPosition, setPopupPosition] = useState<{ left: number; top: number } | null>(null)\n  const selectionRef = useRef<BaseSelection | null>(null)\n  const [anchorElem, setAnchorElem] = useState<HTMLElement | null>(null)\n\n  useEffect(() => {\n    const rootElement = editor.getRootElement()\n    if (rootElement) {\n      const editorWrapper: HTMLElement | null =\n        (rootElement.closest('.editor') as HTMLElement) ?? null\n      setAnchorElem(editorWrapper ?? rootElement.parentElement)\n    }\n  }, [editor])\n\n  useEffect(() => {\n    if (!editor.hasNodes([TableNode, TableRowNode, TableCellNode])) {\n      throw new Error(\n        'TablePlugin: TableNode, TableRowNode, or TableCellNode is not registered on editor',\n      )\n    }\n\n    return mergeRegister(\n      editor.registerCommand(\n        OPEN_TABLE_DRAWER_COMMAND,\n        () => {\n          const anchor = anchorElem\n          if (!anchor) {\n            return true\n          }\n\n          const anchorRect = anchor.getBoundingClientRect()\n          let pos: { left: number; top: number } | null = null\n\n          editor.getEditorState().read(() => {\n            const selection = $getSelection()\n            if ($isRangeSelection(selection)) {\n              selectionRef.current = selection.clone()\n\n              const anchorNode = selection.anchor.getNode()\n              const domElem = editor.getElementByKey(anchorNode.getKey())\n              if (domElem) {\n                const elemRect = domElem.getBoundingClientRect()\n                if (elemRect.height > 0) {\n                  pos = {\n                    left: elemRect.left - anchorRect.left,\n                    top: elemRect.bottom - anchorRect.top + 8,\n                  }\n                }\n              }\n            }\n          })\n\n          const nativeSelection = window.getSelection()\n          if (nativeSelection && nativeSelection.rangeCount > 0) {\n            const range = nativeSelection.getRangeAt(0)\n            const rangeRect = range.getBoundingClientRect()\n            if (rangeRect.height > 0) {\n              pos = {\n                left: rangeRect.left - anchorRect.left,\n                top: rangeRect.bottom - anchorRect.top + 8,\n              }\n            }\n          }\n\n          // Fallback: position at start of editor\n          if (!pos) {\n            pos = { left: 0, top: 40 }\n          }\n\n          setPopupPosition(pos)\n          setIsPopupOpen(true)\n          return true\n        },\n        COMMAND_PRIORITY_EDITOR,\n      ),\n    )\n  }, [cellContext, editor, anchorElem])\n\n  const handleClose = useCallback(() => {\n    setIsPopupOpen(false)\n  }, [])\n\n  const handleInsert = useCallback(\n    (cols: number, rows: number) => {\n      setIsPopupOpen(false)\n      editor.focus()\n      editor.update(\n        () => {\n          if (selectionRef.current) {\n            $setSelection(selectionRef.current.clone())\n          }\n        },\n        { discrete: true, skipTransforms: true },\n      )\n      setTimeout(() => {\n        editor.dispatchCommand(INSERT_TABLE_COMMAND, {\n          columns: String(cols),\n          rows: String(rows),\n        })\n      }, 1)\n    },\n    [editor],\n  )\n\n  return (\n    <React.Fragment>\n      <TableGridPopup\n        anchorElem={anchorElem}\n        editor={editor}\n        isOpen={isPopupOpen}\n        onClose={handleClose}\n        onInsert={handleInsert}\n        position={popupPosition}\n      />\n      <LexicalReactTablePlugin\n        hasCellBackgroundColor={false}\n        hasCellMerge\n        hasHorizontalScroll={true}\n      />\n    </React.Fragment>\n  )\n}\n"],"mappings":"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","ignoreList":[]}

package/dist/features/experimental_table/client/utils/debounce.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"debounce.d.ts","sourceRoot":"","sources":["../../../../../src/features/experimental_table/client/utils/debounce.ts"],"names":[],"mappings":"AA+DA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqDG;AACH,iBAAS,QAAQ,CAAC,IAAI,KAAA,EAAE,IAAI,KAAA,EAAE,OAAO,KAAA;;;;EA+HpC;AAGD,eAAe,QAAQ,CAAA"}

package/dist/features/experimental_table/client/utils/debounce.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"debounce.js","names":["FUNC_ERROR_TEXT","nativeMax","Math","max","nativeMin","min","debounce","func","wait","options","lastArgs","lastCallTime","lastInvokeTime","lastThis","leading","maxing","maxWait","result","timerID","trailing","TypeError","invokeFunc","time","args","thisArg","undefined","apply","leadingEdge","setTimeout","timerExpired","remainingWait","timeSinceLastCall","timeSinceLastInvoke","timeWaiting","shouldInvoke","Date","now","trailingEdge","cancel","clearTimeout","flush","debounced","isInvoking","arguments"],"sources":["../../../../../src/features/experimental_table/client/utils/debounce.ts"],"sourcesContent":["// eslint-disable-next-line @typescript-eslint/ban-ts-comment\n// @ts-nocheck - not worth it migrate jsdoc to tsdoc\n'use client'\n// Copied & modified from https://github.com/lodash/lodash/blob/main/src/debounce.ts\n/*\nThe MIT License\n\nCopyright JS Foundation and other contributors <https://js.foundation/>\n\nBased on Underscore.js, copyright Jeremy Ashkenas,\nDocumentCloud and Investigative Reporters & Editors <http://underscorejs.org/>\n\nThis software consists of voluntary contributions made by many\nindividuals. For exact contribution history, see the revision history\navailable at https://github.com/lodash/lodash\n\nThe following license applies to all parts of this software except as\ndocumented below:\n\n====\n\nPermission is hereby granted, free of charge, to any person obtaining\na copy of this software and associated documentation files (the\n\"Software\"), to deal in the Software without restriction, including\nwithout limitation the rights to use, copy, modify, merge, publish,\ndistribute, sublicense, and/or sell copies of the Software, and to\npermit persons to whom the Software is furnished to do so, subject to\nthe following conditions:\n\nThe above copyright notice and this permission notice shall be\nincluded in all copies or substantial portions of the Software.\n\nTHE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND,\nEXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\nMERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND\nNONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE\nLIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION\nOF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION\nWITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.\n\n====\n\nCopyright and related rights for sample code are waived via CC0. Sample\ncode is defined as all source code displayed within the prose of the\ndocumentation.\n\nCC0: http://creativecommons.org/publicdomain/zero/1.0/\n\n====\n\nFiles located in the node_modules and vendor directories are externally\nmaintained libraries used by this software which have their own\nlicenses; we recommend you read them, as their terms may differ from the\nterms above.\n */\n\n/** Error message constants. */\nconst FUNC_ERROR_TEXT = 'Expected a function'\n\n/* Built-in method references for those with the same name as other `lodash` methods. */\nconst nativeMax = Math.max,\n  nativeMin = Math.min\n\n/**\n * Creates a debounced function that delays invoking `func` until after `wait`\n * milliseconds have elapsed since the last time the debounced function was\n * invoked. The debounced function comes with a `cancel` method to cancel\n * delayed `func` invocations and a `flush` method to immediately invoke them.\n * Provide `options` to indicate whether `func` should be invoked on the\n * leading and/or trailing edge of the `wait` timeout. The `func` is invoked\n * with the last arguments provided to the debounced function. Subsequent\n * calls to the debounced function return the result of the last `func`\n * invocation.\n *\n * **Note:** If `leading` and `trailing` options are `true`, `func` is\n * invoked on the trailing edge of the timeout only if the debounced function\n * is invoked more than once during the `wait` timeout.\n *\n * If `wait` is `0` and `leading` is `false`, `func` invocation is deferred\n * until to the next tick, similar to `setTimeout` with a timeout of `0`.\n *\n * See [David Corbacho's article](https://css-tricks.com/debouncing-throttling-explained-examples/)\n * for details over the differences between `_.debounce` and `_.throttle`.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Function\n * @param {Function} func The function to debounce.\n * @param {number} [wait=0] The number of milliseconds to delay.\n * @param {Object} [sortOnOptions={}] The options object.\n * @param {boolean} [sortOnOptions.leading=false]\n *  Specify invoking on the leading edge of the timeout.\n * @param {number} [sortOnOptions.maxWait]\n *  The maximum time `func` is allowed to be delayed before it's invoked.\n * @param {boolean} [sortOnOptions.trailing=true]\n *  Specify invoking on the trailing edge of the timeout.\n * @returns {Function} Returns the new debounced function.\n * @example\n *\n * // Avoid costly calculations while the window size is in flux.\n * jQuery(window).on('resize', _.debounce(calculateLayout, 150));\n *\n * // Invoke `sendMail` when clicked, debouncing subsequent calls.\n * jQuery(element).on('click', _.debounce(sendMail, 300, {\n *   'leading': true,\n *   'trailing': false\n * }));\n *\n * // Ensure `batchLog` is invoked once after 1 second of debounced calls.\n * var debounced = _.debounce(batchLog, 250, { 'maxWait': 1000 });\n * var source = new EventSource('/stream');\n * jQuery(source).on('message', debounced);\n *\n * // Cancel the trailing debounced invocation.\n * jQuery(window).on('popstate', debounced.cancel);\n */\nfunction debounce(func, wait, options) {\n  let lastArgs,\n    lastCallTime,\n    lastInvokeTime = 0,\n    lastThis,\n    leading = false,\n    maxing = false,\n    maxWait,\n    result,\n    timerID,\n    trailing = true\n\n  if (typeof func != 'function') {\n    throw new TypeError(FUNC_ERROR_TEXT)\n  }\n  wait = wait || 0\n  if (typeof options === 'object') {\n    leading = !!options.leading\n    maxing = 'maxWait' in options\n    maxWait = maxing ? nativeMax(options.maxWait || 0, wait) : maxWait\n    trailing = 'trailing' in options ? !!options.trailing : trailing\n  }\n\n  function invokeFunc(time) {\n    const args = lastArgs,\n      thisArg = lastThis\n\n    lastArgs = lastThis = undefined\n    lastInvokeTime = time\n    result = func.apply(thisArg, args)\n    return result\n  }\n\n  function leadingEdge(time) {\n    // Reset any `maxWait` timer.\n    lastInvokeTime = time\n    // Start the timer for the trailing edge.\n    timerID = setTimeout(timerExpired, wait)\n    // Invoke the leading edge.\n    return leading ? invokeFunc(time) : result\n  }\n\n  function remainingWait(time) {\n    const timeSinceLastCall = time - lastCallTime,\n      timeSinceLastInvoke = time - lastInvokeTime,\n      timeWaiting = wait - timeSinceLastCall\n\n    return maxing ? nativeMin(timeWaiting, maxWait - timeSinceLastInvoke) : timeWaiting\n  }\n\n  function shouldInvoke(time) {\n    const timeSinceLastCall = time - lastCallTime,\n      timeSinceLastInvoke = time - lastInvokeTime\n\n    // Either this is the first call, activity has stopped and we're at the\n    // trailing edge, the system time has gone backwards and we're treating\n    // it as the trailing edge, or we've hit the `maxWait` limit.\n    return (\n      lastCallTime === undefined ||\n      timeSinceLastCall >= wait ||\n      timeSinceLastCall < 0 ||\n      (maxing && timeSinceLastInvoke >= maxWait)\n    )\n  }\n\n  function timerExpired() {\n    const time = Date.now()\n    if (shouldInvoke(time)) {\n      return trailingEdge(time)\n    }\n    // Restart the timer.\n    timerID = setTimeout(timerExpired, remainingWait(time))\n  }\n\n  function trailingEdge(time) {\n    timerID = undefined\n\n    // Only invoke if we have `lastArgs` which means `func` has been\n    // debounced at least once.\n    if (trailing && lastArgs) {\n      return invokeFunc(time)\n    }\n    lastArgs = lastThis = undefined\n    return result\n  }\n\n  function cancel() {\n    if (timerID !== undefined) {\n      clearTimeout(timerID)\n    }\n    lastInvokeTime = 0\n    lastArgs = lastCallTime = lastThis = timerID = undefined\n  }\n\n  function flush() {\n    return timerID === undefined ? result : trailingEdge(Date.now())\n  }\n\n  function debounced() {\n    const time = Date.now(),\n      isInvoking = shouldInvoke(time)\n\n    // eslint-disable-next-line prefer-rest-params\n    lastArgs = arguments\n    // eslint-disable-next-line @typescript-eslint/no-this-alias\n    lastThis = this\n    lastCallTime = time\n\n    if (isInvoking) {\n      if (timerID === undefined) {\n        return leadingEdge(lastCallTime)\n      }\n      if (maxing) {\n        // Handle invocations in a tight loop.\n        clearTimeout(timerID)\n        timerID = setTimeout(timerExpired, wait)\n        return invokeFunc(lastCallTime)\n      }\n    }\n    if (timerID === undefined) {\n      timerID = setTimeout(timerExpired, wait)\n    }\n    return result\n  }\n  debounced.cancel = cancel\n  debounced.flush = flush\n  return debounced\n}\n\n// eslint-disable-next-line no-restricted-exports\nexport default debounce\n"],"mappings":"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","ignoreList":[]}

package/dist/features/experimental_table/client/utils/useDebounce.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"useDebounce.d.ts","sourceRoot":"","sources":["../../../../../src/features/experimental_table/client/utils/useDebounce.ts"],"names":[],"mappings":"AAWA,wBAAgB,WAAW,CAAC,CAAC,SAAS,CAAC,GAAG,IAAI,EAAE,KAAK,EAAE,KAAK,IAAI,EAC9D,EAAE,EAAE,CAAC,EACL,EAAE,EAAE,MAAM,EACV,OAAO,CAAC,EAAE,MAAM,aAauB,UAAU,CAAC,CAAC,CAAC,UAOrD"}

package/dist/features/experimental_table/client/utils/useDebounce.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"useDebounce.js","names":["c","_c","useCallback","useEffect","useRef","debounce","useDebounce","fn","ms","maxWait","$","debouncedRef","t0","t1","current","cancel","t2","Symbol","for","t3","args","callback"],"sources":["../../../../../src/features/experimental_table/client/utils/useDebounce.ts"],"sourcesContent":["'use client'\nimport { useCallback, useEffect, useRef } from 'react'\n\nimport debounce from './debounce.js'\n\n// Define the type for debounced function that includes cancel method\ninterface DebouncedFunction<T extends (...args: any[]) => any> {\n  (...args: Parameters<T>): ReturnType<T>\n  cancel: () => void\n}\n\nexport function useDebounce<T extends (...args: never[]) => void>(\n  fn: T,\n  ms: number,\n  maxWait?: number,\n) {\n  // Update the ref type to include cancel method\n  const debouncedRef = useRef<DebouncedFunction<T> | null>(null)\n\n  useEffect(() => {\n    debouncedRef.current = debounce(fn, ms, { maxWait }) as DebouncedFunction<T>\n\n    return () => {\n      debouncedRef.current?.cancel()\n    }\n  }, [fn, ms, maxWait])\n\n  const callback = useCallback((...args: Parameters<T>) => {\n    if (debouncedRef.current) {\n      debouncedRef.current(...args)\n    }\n  }, [])\n\n  return callback\n}\n"],"mappings":"AAAA;;AAAA,SAAAA,CAAA,IAAAC,EAAA;AACA,SAASC,WAAW,EAAEC,SAAS,EAAEC,MAAM,QAAQ;AAE/C,OAAOC,QAAA,MAAc;AAQrB,OAAO,SAAAC,YAAAC,EAAA,EAAAC,EAAA,EAAAC,OAAA;EAAA,MAAAC,CAAA,GAAAT,EAAA;EAML,MAAAU,YAAA,GAAqBP,MAAA,KAAoC;EAAA,IAAAQ,EAAA;EAAA,IAAAC,EAAA;EAAA,IAAAH,CAAA,QAAAH,EAAA,IAAAG,CAAA,QAAAD,OAAA,IAAAC,CAAA,QAAAF,EAAA;IAE/CI,EAAA,GAAAA,CAAA;MACRD,YAAA,CAAAG,OAAA,GAAuBT,QAAA,CAASE,EAAA,EAAIC,EAAA;QAAAC;MAAA,CAAc;MAAA;QAGhDE,YAAA,CAAAG,OAAA,EAAAC,MAAA;MAAA;IAAA;IAEDF,EAAA,IAACN,EAAA,EAAIC,EAAA,EAAIC,OAAA;IAAQC,CAAA,MAAAH,EAAA;IAAAG,CAAA,MAAAD,OAAA;IAAAC,CAAA,MAAAF,EAAA;IAAAE,CAAA,MAAAE,EAAA;IAAAF,CAAA,MAAAG,EAAA;EAAA;IAAAD,EAAA,GAAAF,CAAA;IAAAG,EAAA,GAAAH,CAAA;EAAA;EANpBP,SAAA,CAAUS,EAMV,EAAGC,EAAiB;EAAA,IAAAG,EAAA;EAAA,IAAAN,CAAA,QAAAO,MAAA,CAAAC,GAAA;IAESF,EAAA,GAAAA,CAAA,GAAAG,EAAA;MAAC,MAAAC,IAAA,GAAAD,EAAG;MAAA,IAC3BR,YAAA,CAAAG,OAAA;QACFH,YAAA,CAAAG,OAAA,IAAwBM,IAAA;MAAA;IAAA;IAE5BV,CAAA,MAAAM,EAAA;EAAA;IAAAA,EAAA,GAAAN,CAAA;EAAA;EAJA,MAAAW,QAAA,GAAiBL,EAIZ;EAAA,OAEEK,QAAA;AAAA","ignoreList":[]}

package/dist/features/experimental_table/markdownTransformer.d.ts

@@ -1,5 +0,0 @@
-import { type ElementTransformer, type Transformer } from '../../packages/@lexical/markdown/index.js';
-export declare const TableMarkdownTransformer: (props: {
-    allTransformers: Transformer[];
-}) => ElementTransformer;
-//# sourceMappingURL=markdownTransformer.d.ts.map

package/dist/features/experimental_table/markdownTransformer.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"markdownTransformer.d.ts","sourceRoot":"","sources":["../../../src/features/experimental_table/markdownTransformer.ts"],"names":[],"mappings":"AAgBA,OAAO,EAGL,KAAK,kBAAkB,EACvB,KAAK,WAAW,EACjB,MAAM,2CAA2C,CAAA;AAOlD,eAAO,MAAM,wBAAwB,EAAE,CAAC,KAAK,EAAE;IAC7C,eAAe,EAAE,WAAW,EAAE,CAAA;CAC/B,KAAK,kBAiIJ,CAAA"}

package/dist/features/experimental_table/markdownTransformer.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"markdownTransformer.js","names":["$createTableCellNode","$createTableNode","$createTableRowNode","$isTableCellNode","$isTableNode","$isTableRowNode","TableCellHeaderStates","TableCellNode","TableNode","TableRowNode","$isParagraphNode","$isTextNode","$convertFromMarkdownString","$convertToMarkdownString","TABLE_ROW_REG_EXP","TABLE_ROW_DIVIDER_REG_EXP","TableMarkdownTransformer","allTransformers","type","dependencies","export","node","output","row","getChildren","rowOutput","isHeaderRow","cell","push","replace","trim","__headerState","ROW","join","map","_","regExp","parentNode","_1","match","match0","test","table","getPreviousSibling","rows","lastRow","length","forEach","setHeaderStyles","remove","matchCells","mapToTableCells","sibling","maxCells","getChildrenSize","firstChild","getFirstChild","cells","getTextContent","Math","max","unshift","previousSibling","tableRow","append","i","$createTableCell","getTableColumnsSize","selectEnd","textContent","NO_STATUS","split","text"],"sources":["../../../src/features/experimental_table/markdownTransformer.ts"],"sourcesContent":["import type { LexicalNode } from 'lexical'\n\nimport {\n  $createTableCellNode,\n  $createTableNode,\n  $createTableRowNode,\n  $isTableCellNode,\n  $isTableNode,\n  $isTableRowNode,\n  TableCellHeaderStates,\n  TableCellNode,\n  TableNode,\n  TableRowNode,\n} from '@lexical/table'\nimport { $isParagraphNode, $isTextNode } from 'lexical'\n\nimport {\n  $convertFromMarkdownString,\n  $convertToMarkdownString,\n  type ElementTransformer,\n  type Transformer,\n} from '../../packages/@lexical/markdown/index.js'\n\n// Very primitive table setup\nconst TABLE_ROW_REG_EXP = /^\\|(.+)\\|\\s?$/\n// eslint-disable-next-line regexp/no-unused-capturing-group\nconst TABLE_ROW_DIVIDER_REG_EXP = /^(\\| ?:?-*:? ?)+\\|\\s?$/\n\nexport const TableMarkdownTransformer: (props: {\n  allTransformers: Transformer[]\n}) => ElementTransformer = ({ allTransformers }) => ({\n  type: 'element',\n  dependencies: [TableNode, TableRowNode, TableCellNode],\n  export: (node: LexicalNode) => {\n    if (!$isTableNode(node)) {\n      return null\n    }\n\n    const output: string[] = []\n\n    for (const row of node.getChildren()) {\n      const rowOutput: string[] = []\n      if (!$isTableRowNode(row)) {\n        continue\n      }\n\n      let isHeaderRow = false\n      for (const cell of row.getChildren()) {\n        // It's TableCellNode, so it's just to make flow happy\n        if ($isTableCellNode(cell)) {\n          rowOutput.push(\n            $convertToMarkdownString(allTransformers, cell).replace(/\\n/g, '\\\\n').trim(),\n          )\n\n          if (cell.__headerState === TableCellHeaderStates.ROW) {\n            isHeaderRow = true\n          }\n        }\n      }\n\n      output.push(`| ${rowOutput.join(' | ')} |`)\n      if (isHeaderRow) {\n        output.push(`| ${rowOutput.map((_) => '---').join(' | ')} |`)\n      }\n    }\n\n    return output.join('\\n')\n  },\n  regExp: TABLE_ROW_REG_EXP,\n  replace: (parentNode, _1, match) => {\n    const match0 = match[0]\n    if (!match0) {\n      return\n    }\n    // Header row\n    if (TABLE_ROW_DIVIDER_REG_EXP.test(match0)) {\n      const table = parentNode.getPreviousSibling()\n      if (!table || !$isTableNode(table)) {\n        return\n      }\n\n      const rows = table.getChildren()\n      const lastRow = rows[rows.length - 1]\n      if (!lastRow || !$isTableRowNode(lastRow)) {\n        return\n      }\n\n      // Add header state to row cells\n      lastRow.getChildren().forEach((cell) => {\n        if (!$isTableCellNode(cell)) {\n          return\n        }\n        cell.setHeaderStyles(TableCellHeaderStates.ROW, TableCellHeaderStates.ROW)\n      })\n\n      // Remove line\n      parentNode.remove()\n      return\n    }\n\n    const matchCells = mapToTableCells(match0, allTransformers)\n\n    if (matchCells == null) {\n      return\n    }\n\n    const rows = [matchCells]\n    let sibling = parentNode.getPreviousSibling()\n    let maxCells = matchCells.length\n\n    while (sibling) {\n      if (!$isParagraphNode(sibling)) {\n        break\n      }\n\n      if (sibling.getChildrenSize() !== 1) {\n        break\n      }\n\n      const firstChild = sibling.getFirstChild()\n\n      if (!$isTextNode(firstChild)) {\n        break\n      }\n\n      const cells = mapToTableCells(firstChild.getTextContent(), allTransformers)\n\n      if (cells == null) {\n        break\n      }\n\n      maxCells = Math.max(maxCells, cells.length)\n      rows.unshift(cells)\n      const previousSibling = sibling.getPreviousSibling()\n      sibling.remove()\n      sibling = previousSibling\n    }\n\n    const table = $createTableNode()\n\n    for (const cells of rows) {\n      const tableRow = $createTableRowNode()\n      table.append(tableRow)\n\n      for (let i = 0; i < maxCells; i++) {\n        tableRow.append(i < cells.length ? cells[i]! : $createTableCell('', allTransformers))\n      }\n    }\n\n    const previousSibling = parentNode.getPreviousSibling()\n    if ($isTableNode(previousSibling) && getTableColumnsSize(previousSibling) === maxCells) {\n      previousSibling.append(...table.getChildren())\n      parentNode.remove()\n    } else {\n      parentNode.replace(table)\n    }\n\n    table.selectEnd()\n  },\n})\n\nfunction getTableColumnsSize(table: TableNode) {\n  const row = table.getFirstChild()\n  return $isTableRowNode(row) ? row.getChildrenSize() : 0\n}\n\nconst $createTableCell = (textContent: string, allTransformers: Transformer[]): TableCellNode => {\n  textContent = textContent.replace(/\\\\n/g, '\\n')\n  const cell = $createTableCellNode(TableCellHeaderStates.NO_STATUS)\n  $convertFromMarkdownString(textContent, allTransformers, cell)\n  return cell\n}\n\nconst mapToTableCells = (\n  textContent: string,\n  allTransformers: Transformer[],\n): Array<TableCellNode> | null => {\n  const match = textContent.match(TABLE_ROW_REG_EXP)\n  if (!match || !match[1]) {\n    return null\n  }\n  return match[1].split('|').map((text) => $createTableCell(text, allTransformers))\n}\n"],"mappings":"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","ignoreList":[]}

package/dist/features/experimental_table/server/index.d.ts

@@ -1,3 +0,0 @@
-export type { SerializedTableCellNode, SerializedTableNode, SerializedTableRowNode, } from './schema.js';
-export declare const EXPERIMENTAL_TableFeature: import("../../typesServer.js").FeatureProviderProviderServer<undefined, undefined, undefined>;
-//# sourceMappingURL=index.d.ts.map

package/dist/features/experimental_table/server/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/features/experimental_table/server/index.ts"],"names":[],"mappings":"AAUA,YAAY,EACV,uBAAuB,EACvB,mBAAmB,EACnB,sBAAsB,GACvB,MAAM,aAAa,CAAA;AAiBpB,eAAO,MAAM,yBAAyB,+FAwCpC,CAAA"}

package/dist/features/experimental_table/server/index.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.js","names":["TableCellNode","TableNode","TableRowNode","sanitizeFields","createServerFeature","createNode","TableMarkdownTransformer","tableCellNodeJSONSchema","tableNodeJSONSchema","tableRowNodeJSONSchema","fields","name","type","defaultValue","required","EXPERIMENTAL_TableFeature","feature","config","isRoot","parentIsLocalized","validRelationships","collections","map","c","slug","sanitizedFields","requireFieldLevelRichTextEditor","ClientFeature","generateSchemaMap","schemaMap","Map","set","markdownTransformers","nodes","jsonSchema","node","key"],"sources":["../../../../src/features/experimental_table/server/index.ts"],"sourcesContent":["import type { Config, Field, FieldSchemaMap } from 'payload'\n\nimport { TableCellNode, TableNode, TableRowNode } from '@lexical/table'\nimport { sanitizeFields } from 'payload'\n\nimport { createServerFeature } from '../../../utilities/createServerFeature.js'\nimport { createNode } from '../../typeUtilities.js'\nimport { TableMarkdownTransformer } from '../markdownTransformer.js'\nimport { tableCellNodeJSONSchema, tableNodeJSONSchema, tableRowNodeJSONSchema } from './schema.js'\n\nexport type {\n  SerializedTableCellNode,\n  SerializedTableNode,\n  SerializedTableRowNode,\n} from './schema.js'\n\nconst fields: Field[] = [\n  {\n    name: 'rows',\n    type: 'number',\n    defaultValue: 5,\n    required: true,\n  },\n  {\n    name: 'columns',\n    type: 'number',\n    defaultValue: 5,\n    required: true,\n  },\n]\n\nexport const EXPERIMENTAL_TableFeature = createServerFeature({\n  feature: async ({ config, isRoot, parentIsLocalized }) => {\n    const validRelationships = config.collections.map((c) => c.slug) || []\n\n    const sanitizedFields = await sanitizeFields({\n      config: config as unknown as Config,\n      fields,\n      parentIsLocalized,\n      requireFieldLevelRichTextEditor: isRoot,\n      validRelationships,\n    })\n    return {\n      ClientFeature: '@payloadcms/richtext-lexical/client#TableFeatureClient',\n      generateSchemaMap: () => {\n        const schemaMap: FieldSchemaMap = new Map()\n\n        schemaMap.set('fields', {\n          fields: sanitizedFields,\n        })\n\n        return schemaMap\n      },\n      markdownTransformers: [TableMarkdownTransformer],\n      nodes: [\n        createNode({\n          jsonSchema: tableNodeJSONSchema,\n          node: TableNode,\n        }),\n        createNode({\n          jsonSchema: tableCellNodeJSONSchema,\n          node: TableCellNode,\n        }),\n        createNode({\n          jsonSchema: tableRowNodeJSONSchema,\n          node: TableRowNode,\n        }),\n      ],\n    }\n  },\n  key: 'experimental_table',\n})\n"],"mappings":"AAEA,SAASA,aAAa,EAAEC,SAAS,EAAEC,YAAY,QAAQ;AACvD,SAASC,cAAc,QAAQ;AAE/B,SAASC,mBAAmB,QAAQ;AACpC,SAASC,UAAU,QAAQ;AAC3B,SAASC,wBAAwB,QAAQ;AACzC,SAASC,uBAAuB,EAAEC,mBAAmB,EAAEC,sBAAsB,QAAQ;AAQrF,MAAMC,MAAA,GAAkB,CACtB;EACEC,IAAA,EAAM;EACNC,IAAA,EAAM;EACNC,YAAA,EAAc;EACdC,QAAA,EAAU;AACZ,GACA;EACEH,IAAA,EAAM;EACNC,IAAA,EAAM;EACNC,YAAA,EAAc;EACdC,QAAA,EAAU;AACZ,EACD;AAED,OAAO,MAAMC,yBAAA,GAA4BX,mBAAA,CAAoB;EAC3DY,OAAA,EAAS,MAAAA,CAAO;IAAEC,MAAM;IAAEC,MAAM;IAAEC;EAAiB,CAAE;IACnD,MAAMC,kBAAA,GAAqBH,MAAA,CAAOI,WAAW,CAACC,GAAG,CAAEC,CAAA,IAAMA,CAAA,CAAEC,IAAI,KAAK,EAAE;IAEtE,MAAMC,eAAA,GAAkB,MAAMtB,cAAA,CAAe;MAC3Cc,MAAA,EAAQA,MAAA;MACRP,MAAA;MACAS,iBAAA;MACAO,+BAAA,EAAiCR,MAAA;MACjCE;IACF;IACA,OAAO;MACLO,aAAA,EAAe;MACfC,iBAAA,EAAmBA,CAAA;QACjB,MAAMC,SAAA,GAA4B,IAAIC,GAAA;QAEtCD,SAAA,CAAUE,GAAG,CAAC,UAAU;UACtBrB,MAAA,EAAQe;QACV;QAEA,OAAOI,SAAA;MACT;MACAG,oBAAA,EAAsB,CAAC1B,wBAAA,CAAyB;MAChD2B,KAAA,EAAO,CACL5B,UAAA,CAAW;QACT6B,UAAA,EAAY1B,mBAAA;QACZ2B,IAAA,EAAMlC;MACR,IACAI,UAAA,CAAW;QACT6B,UAAA,EAAY3B,uBAAA;QACZ4B,IAAA,EAAMnC;MACR,IACAK,UAAA,CAAW;QACT6B,UAAA,EAAYzB,sBAAA;QACZ0B,IAAA,EAAMjC;MACR;IAEJ;EACF;EACAkC,GAAA,EAAK;AACP","ignoreList":[]}

package/dist/features/experimental_table/server/schema.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../../../src/features/experimental_table/server/schema.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,SAAS,CAAA;AAEpD,OAAO,KAAK,EAAE,4BAA4B,EAAE,MAAM,6BAA6B,CAAA;AAC/E,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAA;AAExD,MAAM,WAAW,uBAAuB,CACtC,SAAS,SAAS,qBAAqB,GAAG,qBAAqB,CAC/D,SAAQ,4BAA4B,CAAC,SAAS,CAAC;IAC/C,eAAe,CAAC,EAAE,IAAI,GAAG,MAAM,CAAA;IAC/B,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,WAAW,EAAE,MAAM,CAAA;IACnB,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,IAAI,EAAE,WAAW,CAAA;IACjB,aAAa,CAAC,EAAE,MAAM,CAAA;IACtB,KAAK,CAAC,EAAE,MAAM,CAAA;CACf;AAED,MAAM,WAAW,mBAAmB,CAClC,SAAS,SAAS,qBAAqB,GAAG,qBAAqB,CAC/D,SAAQ,4BAA4B,CAAC,SAAS,CAAC;IAC/C,SAAS,CAAC,EAAE,MAAM,EAAE,CAAA;IACpB,iBAAiB,CAAC,EAAE,MAAM,CAAA;IAC1B,cAAc,CAAC,EAAE,MAAM,CAAA;IACvB,WAAW,CAAC,EAAE,OAAO,CAAA;IACrB,IAAI,EAAE,OAAO,CAAA;CACd;AAED,MAAM,WAAW,sBAAsB,CACrC,SAAS,SAAS,qBAAqB,GAAG,qBAAqB,CAC/D,SAAQ,4BAA4B,CAAC,SAAS,CAAC;IAC/C,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,IAAI,EAAE,UAAU,CAAA;CACjB;AA2BD,eAAO,MAAM,mBAAmB,EAAE,YAgBjC,CAAA;AAED,eAAO,MAAM,uBAAuB,EAAE,YAuBrC,CAAA;AAED,eAAO,MAAM,sBAAsB,EAAE,YAWpC,CAAA"}

package/dist/features/experimental_table/server/schema.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"schema.js","names":["TABLE_NODES_TS","tableNodeJSONSchema","elementNodeSchema","nodeUnionName","typeStringDefinitions","add","nodeType","properties","colWidths","type","items","frozenColumnCount","frozenRowCount","rowStriping","tsType","tableCellNodeJSONSchema","backgroundColor","oneOf","colSpan","description","headerState","rowSpan","verticalAlign","width","required","tableRowNodeJSONSchema","height"],"sources":["../../../../src/features/experimental_table/server/schema.ts"],"sourcesContent":["import type { SerializedLexicalNode } from 'lexical'\n\nimport type { SerializedLexicalElementBase } from '../../../types/nodeTypes.js'\nimport type { JSONSchemaFn } from '../../typesServer.js'\n\nexport interface SerializedTableCellNode<\n  TChildren extends SerializedLexicalNode = SerializedLexicalNode,\n> extends SerializedLexicalElementBase<TChildren> {\n  backgroundColor?: null | string\n  colSpan?: number\n  headerState: number\n  rowSpan?: number\n  type: 'tablecell'\n  verticalAlign?: string\n  width?: number\n}\n\nexport interface SerializedTableNode<\n  TChildren extends SerializedLexicalNode = SerializedLexicalNode,\n> extends SerializedLexicalElementBase<TChildren> {\n  colWidths?: number[]\n  frozenColumnCount?: number\n  frozenRowCount?: number\n  rowStriping?: boolean\n  type: 'table'\n}\n\nexport interface SerializedTableRowNode<\n  TChildren extends SerializedLexicalNode = SerializedLexicalNode,\n> extends SerializedLexicalElementBase<TChildren> {\n  height?: number\n  type: 'tablerow'\n}\n\n/**\n * MUST stay byte-for-byte in sync with the runtime `SerializedTableNode`,\n * `SerializedTableRowNode`, and `SerializedTableCellNode` declared above.\n */\nconst TABLE_NODES_TS = `export interface SerializedTableNode<TChildren> extends SerializedLexicalElementBase<TChildren> {\n  type: 'table';\n  colWidths?: number[];\n  frozenColumnCount?: number;\n  frozenRowCount?: number;\n  rowStriping?: boolean;\n}\nexport interface SerializedTableRowNode<TChildren> extends SerializedLexicalElementBase<TChildren> {\n  type: 'tablerow';\n  height?: number;\n}\nexport interface SerializedTableCellNode<TChildren> extends SerializedLexicalElementBase<TChildren> {\n  type: 'tablecell';\n  backgroundColor?: string | null;\n  colSpan?: number;\n  headerState: number;\n  rowSpan?: number;\n  verticalAlign?: string;\n  width?: number;\n}`\n\nexport const tableNodeJSONSchema: JSONSchemaFn = ({\n  elementNodeSchema,\n  nodeUnionName,\n  typeStringDefinitions,\n}) => {\n  typeStringDefinitions.add(TABLE_NODES_TS)\n  return elementNodeSchema({\n    nodeType: 'table',\n    properties: {\n      colWidths: { type: 'array', items: { type: 'number' } },\n      frozenColumnCount: { type: 'integer' },\n      frozenRowCount: { type: 'integer' },\n      rowStriping: { type: 'boolean' },\n    },\n    tsType: `SerializedTableNode<${nodeUnionName}>`,\n  })\n}\n\nexport const tableCellNodeJSONSchema: JSONSchemaFn = ({\n  elementNodeSchema,\n  nodeUnionName,\n  typeStringDefinitions,\n}) => {\n  typeStringDefinitions.add(TABLE_NODES_TS)\n  return elementNodeSchema({\n    nodeType: 'tablecell',\n    properties: {\n      backgroundColor: { oneOf: [{ type: 'string' }, { type: 'null' }] },\n      colSpan: { type: 'integer', description: 'How many columns this cell spans (default 1).' },\n      headerState: {\n        type: 'integer',\n        description:\n          'Header bitmask: 0 = normal cell, 1 = row header, 2 = column header, 3 = both.',\n      },\n      rowSpan: { type: 'integer', description: 'How many rows this cell spans (default 1).' },\n      verticalAlign: { type: 'string' },\n      width: { type: 'integer' },\n    },\n    required: ['headerState'],\n    tsType: `SerializedTableCellNode<${nodeUnionName}>`,\n  })\n}\n\nexport const tableRowNodeJSONSchema: JSONSchemaFn = ({\n  elementNodeSchema,\n  nodeUnionName,\n  typeStringDefinitions,\n}) => {\n  typeStringDefinitions.add(TABLE_NODES_TS)\n  return elementNodeSchema({\n    nodeType: 'tablerow',\n    properties: { height: { type: 'integer' } },\n    tsType: `SerializedTableRowNode<${nodeUnionName}>`,\n  })\n}\n"],"mappings":"AAkCA;;;GAIA,MAAMA,cAAA,GAAiB;;;;;;;;;;;;;;;;;;;EAmBrB;AAEF,OAAO,MAAMC,mBAAA,GAAoCA,CAAC;EAChDC,iBAAiB;EACjBC,aAAa;EACbC;AAAqB,CACtB;EACCA,qBAAA,CAAsBC,GAAG,CAACL,cAAA;EAC1B,OAAOE,iBAAA,CAAkB;IACvBI,QAAA,EAAU;IACVC,UAAA,EAAY;MACVC,SAAA,EAAW;QAAEC,IAAA,EAAM;QAASC,KAAA,EAAO;UAAED,IAAA,EAAM;QAAS;MAAE;MACtDE,iBAAA,EAAmB;QAAEF,IAAA,EAAM;MAAU;MACrCG,cAAA,EAAgB;QAAEH,IAAA,EAAM;MAAU;MAClCI,WAAA,EAAa;QAAEJ,IAAA,EAAM;MAAU;IACjC;IACAK,MAAA,EAAQ,uBAAuBX,aAAA;EACjC;AACF;AAEA,OAAO,MAAMY,uBAAA,GAAwCA,CAAC;EACpDb,iBAAiB;EACjBC,aAAa;EACbC;AAAqB,CACtB;EACCA,qBAAA,CAAsBC,GAAG,CAACL,cAAA;EAC1B,OAAOE,iBAAA,CAAkB;IACvBI,QAAA,EAAU;IACVC,UAAA,EAAY;MACVS,eAAA,EAAiB;QAAEC,KAAA,EAAO,CAAC;UAAER,IAAA,EAAM;QAAS,GAAG;UAAEA,IAAA,EAAM;QAAO;MAAG;MACjES,OAAA,EAAS;QAAET,IAAA,EAAM;QAAWU,WAAA,EAAa;MAAgD;MACzFC,WAAA,EAAa;QACXX,IAAA,EAAM;QACNU,WAAA,EACE;MACJ;MACAE,OAAA,EAAS;QAAEZ,IAAA,EAAM;QAAWU,WAAA,EAAa;MAA6C;MACtFG,aAAA,EAAe;QAAEb,IAAA,EAAM;MAAS;MAChCc,KAAA,EAAO;QAAEd,IAAA,EAAM;MAAU;IAC3B;IACAe,QAAA,EAAU,CAAC,cAAc;IACzBV,MAAA,EAAQ,2BAA2BX,aAAA;EACrC;AACF;AAEA,OAAO,MAAMsB,sBAAA,GAAuCA,CAAC;EACnDvB,iBAAiB;EACjBC,aAAa;EACbC;AAAqB,CACtB;EACCA,qBAAA,CAAsBC,GAAG,CAACL,cAAA;EAC1B,OAAOE,iBAAA,CAAkB;IACvBI,QAAA,EAAU;IACVC,UAAA,EAAY;MAAEmB,MAAA,EAAQ;QAAEjB,IAAA,EAAM;MAAU;IAAE;IAC1CK,MAAA,EAAQ,0BAA0BX,aAAA;EACpC;AACF","ignoreList":[]}

package/dist/features/format/bold/markdownTransformers.d.ts

@@ -1,6 +0,0 @@
-import type { TextFormatTransformer } from '../../../packages/@lexical/markdown/MarkdownTransformers.js';
-export declare const BOLD_ITALIC_STAR: TextFormatTransformer;
-export declare const BOLD_ITALIC_UNDERSCORE: TextFormatTransformer;
-export declare const BOLD_STAR: TextFormatTransformer;
-export declare const BOLD_UNDERSCORE: TextFormatTransformer;
-//# sourceMappingURL=markdownTransformers.d.ts.map

package/dist/features/format/bold/markdownTransformers.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"markdownTransformers.d.ts","sourceRoot":"","sources":["../../../../src/features/format/bold/markdownTransformers.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,6DAA6D,CAAA;AAExG,eAAO,MAAM,gBAAgB,EAAE,qBAI9B,CAAA;AAED,eAAO,MAAM,sBAAsB,EAAE,qBAKpC,CAAA;AAED,eAAO,MAAM,SAAS,EAAE,qBAIvB,CAAA;AAED,eAAO,MAAM,eAAe,EAAE,qBAK7B,CAAA"}

package/dist/features/format/bold/markdownTransformers.js

@@ -1,23 +0,0 @@
-export const BOLD_ITALIC_STAR = {
-  type: 'text-format',
-  format: ['bold', 'italic'],
-  tag: '***'
-};
-export const BOLD_ITALIC_UNDERSCORE = {
-  type: 'text-format',
-  format: ['bold', 'italic'],
-  intraword: false,
-  tag: '___'
-};
-export const BOLD_STAR = {
-  type: 'text-format',
-  format: ['bold'],
-  tag: '**'
-};
-export const BOLD_UNDERSCORE = {
-  type: 'text-format',
-  format: ['bold'],
-  intraword: false,
-  tag: '__'
-};
-//# sourceMappingURL=markdownTransformers.js.map

package/dist/features/format/bold/markdownTransformers.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"markdownTransformers.js","names":["BOLD_ITALIC_STAR","type","format","tag","BOLD_ITALIC_UNDERSCORE","intraword","BOLD_STAR","BOLD_UNDERSCORE"],"sources":["../../../../src/features/format/bold/markdownTransformers.ts"],"sourcesContent":["import type { TextFormatTransformer } from '../../../packages/@lexical/markdown/MarkdownTransformers.js'\n\nexport const BOLD_ITALIC_STAR: TextFormatTransformer = {\n  type: 'text-format',\n  format: ['bold', 'italic'],\n  tag: '***',\n}\n\nexport const BOLD_ITALIC_UNDERSCORE: TextFormatTransformer = {\n  type: 'text-format',\n  format: ['bold', 'italic'],\n  intraword: false,\n  tag: '___',\n}\n\nexport const BOLD_STAR: TextFormatTransformer = {\n  type: 'text-format',\n  format: ['bold'],\n  tag: '**',\n}\n\nexport const BOLD_UNDERSCORE: TextFormatTransformer = {\n  type: 'text-format',\n  format: ['bold'],\n  intraword: false,\n  tag: '__',\n}\n"],"mappings":"AAEA,OAAO,MAAMA,gBAAA,GAA0C;EACrDC,IAAA,EAAM;EACNC,MAAA,EAAQ,CAAC,QAAQ,SAAS;EAC1BC,GAAA,EAAK;AACP;AAEA,OAAO,MAAMC,sBAAA,GAAgD;EAC3DH,IAAA,EAAM;EACNC,MAAA,EAAQ,CAAC,QAAQ,SAAS;EAC1BG,SAAA,EAAW;EACXF,GAAA,EAAK;AACP;AAEA,OAAO,MAAMG,SAAA,GAAmC;EAC9CL,IAAA,EAAM;EACNC,MAAA,EAAQ,CAAC,OAAO;EAChBC,GAAA,EAAK;AACP;AAEA,OAAO,MAAMI,eAAA,GAAyC;EACpDN,IAAA,EAAM;EACNC,MAAA,EAAQ,CAAC,OAAO;EAChBG,SAAA,EAAW;EACXF,GAAA,EAAK;AACP","ignoreList":[]}

package/dist/features/format/inlineCode/markdownTransformers.d.ts

@@ -1,3 +0,0 @@
-import type { TextFormatTransformer } from '../../../packages/@lexical/markdown/MarkdownTransformers.js';
-export declare const INLINE_CODE: TextFormatTransformer;
-//# sourceMappingURL=markdownTransformers.d.ts.map

package/dist/features/format/inlineCode/markdownTransformers.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"markdownTransformers.d.ts","sourceRoot":"","sources":["../../../../src/features/format/inlineCode/markdownTransformers.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,6DAA6D,CAAA;AAExG,eAAO,MAAM,WAAW,EAAE,qBAIzB,CAAA"}

package/dist/features/format/inlineCode/markdownTransformers.js

@@ -1,6 +0,0 @@
-export const INLINE_CODE = {
-  type: 'text-format',
-  format: ['code'],
-  tag: '`'
-};
-//# sourceMappingURL=markdownTransformers.js.map

package/dist/features/format/inlineCode/markdownTransformers.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"markdownTransformers.js","names":["INLINE_CODE","type","format","tag"],"sources":["../../../../src/features/format/inlineCode/markdownTransformers.ts"],"sourcesContent":["import type { TextFormatTransformer } from '../../../packages/@lexical/markdown/MarkdownTransformers.js'\n\nexport const INLINE_CODE: TextFormatTransformer = {\n  type: 'text-format',\n  format: ['code'],\n  tag: '`',\n}\n"],"mappings":"AAEA,OAAO,MAAMA,WAAA,GAAqC;EAChDC,IAAA,EAAM;EACNC,MAAA,EAAQ,CAAC,OAAO;EAChBC,GAAA,EAAK;AACP","ignoreList":[]}

package/dist/features/format/italic/markdownTransformers.d.ts

@@ -1,4 +0,0 @@
-import type { TextFormatTransformer } from '../../../packages/@lexical/markdown/MarkdownTransformers.js';
-export declare const ITALIC_STAR: TextFormatTransformer;
-export declare const ITALIC_UNDERSCORE: TextFormatTransformer;
-//# sourceMappingURL=markdownTransformers.d.ts.map

package/dist/features/format/italic/markdownTransformers.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"markdownTransformers.d.ts","sourceRoot":"","sources":["../../../../src/features/format/italic/markdownTransformers.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,6DAA6D,CAAA;AAExG,eAAO,MAAM,WAAW,EAAE,qBAIzB,CAAA;AAED,eAAO,MAAM,iBAAiB,EAAE,qBAK/B,CAAA"}

package/dist/features/format/italic/markdownTransformers.js

@@ -1,12 +0,0 @@
-export const ITALIC_STAR = {
-  type: 'text-format',
-  format: ['italic'],
-  tag: '*'
-};
-export const ITALIC_UNDERSCORE = {
-  type: 'text-format',
-  format: ['italic'],
-  intraword: false,
-  tag: '_'
-};
-//# sourceMappingURL=markdownTransformers.js.map

package/dist/features/format/italic/markdownTransformers.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"markdownTransformers.js","names":["ITALIC_STAR","type","format","tag","ITALIC_UNDERSCORE","intraword"],"sources":["../../../../src/features/format/italic/markdownTransformers.ts"],"sourcesContent":["import type { TextFormatTransformer } from '../../../packages/@lexical/markdown/MarkdownTransformers.js'\n\nexport const ITALIC_STAR: TextFormatTransformer = {\n  type: 'text-format',\n  format: ['italic'],\n  tag: '*',\n}\n\nexport const ITALIC_UNDERSCORE: TextFormatTransformer = {\n  type: 'text-format',\n  format: ['italic'],\n  intraword: false,\n  tag: '_',\n}\n"],"mappings":"AAEA,OAAO,MAAMA,WAAA,GAAqC;EAChDC,IAAA,EAAM;EACNC,MAAA,EAAQ,CAAC,SAAS;EAClBC,GAAA,EAAK;AACP;AAEA,OAAO,MAAMC,iBAAA,GAA2C;EACtDH,IAAA,EAAM;EACNC,MAAA,EAAQ,CAAC,SAAS;EAClBG,SAAA,EAAW;EACXF,GAAA,EAAK;AACP","ignoreList":[]}

package/dist/features/format/strikethrough/markdownTransformers.d.ts

@@ -1,3 +0,0 @@
-import type { TextFormatTransformer } from '../../../packages/@lexical/markdown/MarkdownTransformers.js';
-export declare const STRIKETHROUGH: TextFormatTransformer;
-//# sourceMappingURL=markdownTransformers.d.ts.map

package/dist/features/format/strikethrough/markdownTransformers.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"markdownTransformers.d.ts","sourceRoot":"","sources":["../../../../src/features/format/strikethrough/markdownTransformers.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,6DAA6D,CAAA;AAExG,eAAO,MAAM,aAAa,EAAE,qBAI3B,CAAA"}

package/dist/features/format/strikethrough/markdownTransformers.js

@@ -1,6 +0,0 @@
-export const STRIKETHROUGH = {
-  type: 'text-format',
-  format: ['strikethrough'],
-  tag: '~~'
-};
-//# sourceMappingURL=markdownTransformers.js.map

package/dist/features/format/strikethrough/markdownTransformers.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"markdownTransformers.js","names":["STRIKETHROUGH","type","format","tag"],"sources":["../../../../src/features/format/strikethrough/markdownTransformers.ts"],"sourcesContent":["import type { TextFormatTransformer } from '../../../packages/@lexical/markdown/MarkdownTransformers.js'\n\nexport const STRIKETHROUGH: TextFormatTransformer = {\n  type: 'text-format',\n  format: ['strikethrough'],\n  tag: '~~',\n}\n"],"mappings":"AAEA,OAAO,MAAMA,aAAA,GAAuC;EAClDC,IAAA,EAAM;EACNC,MAAA,EAAQ,CAAC,gBAAgB;EACzBC,GAAA,EAAK;AACP","ignoreList":[]}

package/dist/features/lists/checklist/markdownTransformers.d.ts

@@ -1,3 +0,0 @@
-import type { ElementTransformer } from '../../../packages/@lexical/markdown/MarkdownTransformers.js';
-export declare const CHECK_LIST: ElementTransformer;
-//# sourceMappingURL=markdownTransformers.d.ts.map

package/dist/features/lists/checklist/markdownTransformers.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"markdownTransformers.d.ts","sourceRoot":"","sources":["../../../../src/features/lists/checklist/markdownTransformers.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,6DAA6D,CAAA;AAIrG,eAAO,MAAM,UAAU,EAAE,kBAQxB,CAAA"}

package/dist/features/lists/checklist/markdownTransformers.js

@@ -1,12 +0,0 @@
-import { $isListNode, ListItemNode, ListNode } from '@lexical/list';
-import { listExport, listReplace } from '../shared/markdown.js';
-export const CHECK_LIST = {
-  type: 'element',
-  dependencies: [ListNode, ListItemNode],
-  export: (node, exportChildren) => {
-    return $isListNode(node) ? listExport(node, exportChildren, 0) : null;
-  },
-  regExp: /^(\s*)(?:-\s)?\s?(\[(\s|x)?\])\s/i,
-  replace: listReplace('check')
-};
-//# sourceMappingURL=markdownTransformers.js.map

package/dist/features/lists/checklist/markdownTransformers.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"markdownTransformers.js","names":["$isListNode","ListItemNode","ListNode","listExport","listReplace","CHECK_LIST","type","dependencies","export","node","exportChildren","regExp","replace"],"sources":["../../../../src/features/lists/checklist/markdownTransformers.ts"],"sourcesContent":["import { $isListNode, ListItemNode, ListNode } from '@lexical/list'\n\nimport type { ElementTransformer } from '../../../packages/@lexical/markdown/MarkdownTransformers.js'\n\nimport { listExport, listReplace } from '../shared/markdown.js'\n\nexport const CHECK_LIST: ElementTransformer = {\n  type: 'element',\n  dependencies: [ListNode, ListItemNode],\n  export: (node, exportChildren) => {\n    return $isListNode(node) ? listExport(node, exportChildren, 0) : null\n  },\n  regExp: /^(\\s*)(?:-\\s)?\\s?(\\[(\\s|x)?\\])\\s/i,\n  replace: listReplace('check'),\n}\n"],"mappings":"AAAA,SAASA,WAAW,EAAEC,YAAY,EAAEC,QAAQ,QAAQ;AAIpD,SAASC,UAAU,EAAEC,WAAW,QAAQ;AAExC,OAAO,MAAMC,UAAA,GAAiC;EAC5CC,IAAA,EAAM;EACNC,YAAA,EAAc,CAACL,QAAA,EAAUD,YAAA,CAAa;EACtCO,MAAA,EAAQA,CAACC,IAAA,EAAMC,cAAA;IACb,OAAOV,WAAA,CAAYS,IAAA,IAAQN,UAAA,CAAWM,IAAA,EAAMC,cAAA,EAAgB,KAAK;EACnE;EACAC,MAAA,EAAQ;EACRC,OAAA,EAASR,WAAA,CAAY;AACvB","ignoreList":[]}

package/dist/features/lists/orderedList/markdownTransformer.d.ts

@@ -1,3 +0,0 @@
-import type { ElementTransformer } from '../../../packages/@lexical/markdown/MarkdownTransformers.js';
-export declare const ORDERED_LIST: ElementTransformer;
-//# sourceMappingURL=markdownTransformer.d.ts.map

package/dist/features/lists/orderedList/markdownTransformer.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"markdownTransformer.d.ts","sourceRoot":"","sources":["../../../../src/features/lists/orderedList/markdownTransformer.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,6DAA6D,CAAA;AAIrG,eAAO,MAAM,YAAY,EAAE,kBAQ1B,CAAA"}

package/dist/features/lists/orderedList/markdownTransformer.js

@@ -1,12 +0,0 @@
-import { $isListNode, ListItemNode, ListNode } from '@lexical/list';
-import { listExport, listReplace } from '../shared/markdown.js';
-export const ORDERED_LIST = {
-  type: 'element',
-  dependencies: [ListNode, ListItemNode],
-  export: (node, exportChildren) => {
-    return $isListNode(node) ? listExport(node, exportChildren, 0) : null;
-  },
-  regExp: /^(\s*)(\d+)\.\s/,
-  replace: listReplace('number')
-};
-//# sourceMappingURL=markdownTransformer.js.map

package/dist/features/lists/orderedList/markdownTransformer.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"markdownTransformer.js","names":["$isListNode","ListItemNode","ListNode","listExport","listReplace","ORDERED_LIST","type","dependencies","export","node","exportChildren","regExp","replace"],"sources":["../../../../src/features/lists/orderedList/markdownTransformer.ts"],"sourcesContent":["import { $isListNode, ListItemNode, ListNode } from '@lexical/list'\n\nimport type { ElementTransformer } from '../../../packages/@lexical/markdown/MarkdownTransformers.js'\n\nimport { listExport, listReplace } from '../shared/markdown.js'\n\nexport const ORDERED_LIST: ElementTransformer = {\n  type: 'element',\n  dependencies: [ListNode, ListItemNode],\n  export: (node, exportChildren) => {\n    return $isListNode(node) ? listExport(node, exportChildren, 0) : null\n  },\n  regExp: /^(\\s*)(\\d+)\\.\\s/,\n  replace: listReplace('number'),\n}\n"],"mappings":"AAAA,SAASA,WAAW,EAAEC,YAAY,EAAEC,QAAQ,QAAQ;AAIpD,SAASC,UAAU,EAAEC,WAAW,QAAQ;AAExC,OAAO,MAAMC,YAAA,GAAmC;EAC9CC,IAAA,EAAM;EACNC,YAAA,EAAc,CAACL,QAAA,EAAUD,YAAA,CAAa;EACtCO,MAAA,EAAQA,CAACC,IAAA,EAAMC,cAAA;IACb,OAAOV,WAAA,CAAYS,IAAA,IAAQN,UAAA,CAAWM,IAAA,EAAMC,cAAA,EAAgB,KAAK;EACnE;EACAC,MAAA,EAAQ;EACRC,OAAA,EAASR,WAAA,CAAY;AACvB","ignoreList":[]}

package/dist/features/lists/shared/markdown.d.ts

@@ -1,6 +0,0 @@
-import type { ListNode, ListType } from '@lexical/list';
-import type { ElementNode } from 'lexical';
-import type { ElementTransformer } from '../../../packages/@lexical/markdown/MarkdownTransformers.js';
-export declare const listReplace: (listType: ListType) => ElementTransformer["replace"];
-export declare const listExport: (listNode: ListNode, exportChildren: (node: ElementNode) => string, depth: number) => string;
-//# sourceMappingURL=markdown.d.ts.map

package/dist/features/lists/shared/markdown.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"markdown.d.ts","sourceRoot":"","sources":["../../../../src/features/lists/shared/markdown.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAA;AACvD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,SAAS,CAAA;AAI1C,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,6DAA6D,CAAA;AAKrG,eAAO,MAAM,WAAW,GAAI,UAAU,QAAQ,KAAG,kBAAkB,CAAC,SAAS,CA6B5E,CAAA;AAED,eAAO,MAAM,UAAU,GACrB,UAAU,QAAQ,EAClB,gBAAgB,CAAC,IAAI,EAAE,WAAW,KAAK,MAAM,EAC7C,OAAO,MAAM,KACZ,MA2BF,CAAA"}

package/dist/features/lists/shared/markdown.js

@@ -1,57 +0,0 @@
-// Copied from https://github.com/facebook/lexical/blob/176b8cf16ecb332ee5efe2c75219e223b7b019f2/packages/lexical-markdown/src/MarkdownTransformers.ts#L97C1-L172C1
-import { $createListItemNode, $createListNode, $isListItemNode, $isListNode } from '@lexical/list';
-// Amount of spaces that define indentation level
-const LIST_INDENT_SIZE = 4;
-export const listReplace = listType => {
-  return (parentNode, children, match) => {
-    const previousNode = parentNode.getPreviousSibling();
-    const nextNode = parentNode.getNextSibling();
-    const listItem = $createListItemNode(listType === 'check' ? match[3] === 'x' : undefined);
-    if ($isListNode(nextNode) && nextNode.getListType() === listType) {
-      const firstChild = nextNode.getFirstChild();
-      if (firstChild !== null) {
-        firstChild.insertBefore(listItem);
-      } else {
-        // should never happen, but let's handle gracefully, just in case.
-        nextNode.append(listItem);
-      }
-      parentNode.remove();
-    } else if ($isListNode(previousNode) && previousNode.getListType() === listType) {
-      previousNode.append(listItem);
-      parentNode.remove();
-    } else {
-      const list = $createListNode(listType, listType === 'number' ? Number(match[2]) : undefined);
-      list.append(listItem);
-      parentNode.replace(list);
-    }
-    listItem.append(...children);
-    listItem.select(0, 0);
-    const indent = Math.floor(match[1].length / LIST_INDENT_SIZE);
-    if (indent) {
-      listItem.setIndent(indent);
-    }
-  };
-};
-export const listExport = (listNode, exportChildren, depth) => {
-  const output = [];
-  const children = listNode.getChildren();
-  let index = 0;
-  for (const listItemNode of children) {
-    if ($isListItemNode(listItemNode)) {
-      if (listItemNode.getChildrenSize() === 1) {
-        const firstChild = listItemNode.getFirstChild();
-        if ($isListNode(firstChild)) {
-          output.push(listExport(firstChild, exportChildren, depth + 1));
-          continue;
-        }
-      }
-      const indent = ' '.repeat(depth * LIST_INDENT_SIZE);
-      const listType = listNode.getListType();
-      const prefix = listType === 'number' ? `${listNode.getStart() + index}. ` : listType === 'check' ? `- [${listItemNode.getChecked() ? 'x' : ' '}] ` : '- ';
-      output.push(indent + prefix + exportChildren(listItemNode));
-      index++;
-    }
-  }
-  return output.join('\n');
-};
-//# sourceMappingURL=markdown.js.map

package/dist/features/lists/shared/markdown.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"markdown.js","names":["$createListItemNode","$createListNode","$isListItemNode","$isListNode","LIST_INDENT_SIZE","listReplace","listType","parentNode","children","match","previousNode","getPreviousSibling","nextNode","getNextSibling","listItem","undefined","getListType","firstChild","getFirstChild","insertBefore","append","remove","list","Number","replace","select","indent","Math","floor","length","setIndent","listExport","listNode","exportChildren","depth","output","getChildren","index","listItemNode","getChildrenSize","push","repeat","prefix","getStart","getChecked","join"],"sources":["../../../../src/features/lists/shared/markdown.ts"],"sourcesContent":["// Copied from https://github.com/facebook/lexical/blob/176b8cf16ecb332ee5efe2c75219e223b7b019f2/packages/lexical-markdown/src/MarkdownTransformers.ts#L97C1-L172C1\n\nimport type { ListNode, ListType } from '@lexical/list'\nimport type { ElementNode } from 'lexical'\n\nimport { $createListItemNode, $createListNode, $isListItemNode, $isListNode } from '@lexical/list'\n\nimport type { ElementTransformer } from '../../../packages/@lexical/markdown/MarkdownTransformers.js'\n\n// Amount of spaces that define indentation level\nconst LIST_INDENT_SIZE = 4\n\nexport const listReplace = (listType: ListType): ElementTransformer['replace'] => {\n  return (parentNode, children, match) => {\n    const previousNode = parentNode.getPreviousSibling()\n    const nextNode = parentNode.getNextSibling()\n    const listItem = $createListItemNode(listType === 'check' ? match[3] === 'x' : undefined)\n    if ($isListNode(nextNode) && nextNode.getListType() === listType) {\n      const firstChild = nextNode.getFirstChild()\n      if (firstChild !== null) {\n        firstChild.insertBefore(listItem)\n      } else {\n        // should never happen, but let's handle gracefully, just in case.\n        nextNode.append(listItem)\n      }\n      parentNode.remove()\n    } else if ($isListNode(previousNode) && previousNode.getListType() === listType) {\n      previousNode.append(listItem)\n      parentNode.remove()\n    } else {\n      const list = $createListNode(listType, listType === 'number' ? Number(match[2]) : undefined)\n      list.append(listItem)\n      parentNode.replace(list)\n    }\n    listItem.append(...children)\n    listItem.select(0, 0)\n    const indent = Math.floor(match[1]!.length / LIST_INDENT_SIZE)\n    if (indent) {\n      listItem.setIndent(indent)\n    }\n  }\n}\n\nexport const listExport = (\n  listNode: ListNode,\n  exportChildren: (node: ElementNode) => string,\n  depth: number,\n): string => {\n  const output: string[] = []\n  const children = listNode.getChildren()\n  let index = 0\n  for (const listItemNode of children) {\n    if ($isListItemNode(listItemNode)) {\n      if (listItemNode.getChildrenSize() === 1) {\n        const firstChild = listItemNode.getFirstChild()\n        if ($isListNode(firstChild)) {\n          output.push(listExport(firstChild, exportChildren, depth + 1))\n          continue\n        }\n      }\n      const indent = ' '.repeat(depth * LIST_INDENT_SIZE)\n      const listType = listNode.getListType()\n      const prefix =\n        listType === 'number'\n          ? `${listNode.getStart() + index}. `\n          : listType === 'check'\n            ? `- [${listItemNode.getChecked() ? 'x' : ' '}] `\n            : '- '\n      output.push(indent + prefix + exportChildren(listItemNode))\n      index++\n    }\n  }\n\n  return output.join('\\n')\n}\n"],"mappings":"AAAA;AAKA,SAASA,mBAAmB,EAAEC,eAAe,EAAEC,eAAe,EAAEC,WAAW,QAAQ;AAInF;AACA,MAAMC,gBAAA,GAAmB;AAEzB,OAAO,MAAMC,WAAA,GAAeC,QAAA;EAC1B,OAAO,CAACC,UAAA,EAAYC,QAAA,EAAUC,KAAA;IAC5B,MAAMC,YAAA,GAAeH,UAAA,CAAWI,kBAAkB;IAClD,MAAMC,QAAA,GAAWL,UAAA,CAAWM,cAAc;IAC1C,MAAMC,QAAA,GAAWd,mBAAA,CAAoBM,QAAA,KAAa,UAAUG,KAAK,CAAC,EAAE,KAAK,MAAMM,SAAA;IAC/E,IAAIZ,WAAA,CAAYS,QAAA,KAAaA,QAAA,CAASI,WAAW,OAAOV,QAAA,EAAU;MAChE,MAAMW,UAAA,GAAaL,QAAA,CAASM,aAAa;MACzC,IAAID,UAAA,KAAe,MAAM;QACvBA,UAAA,CAAWE,YAAY,CAACL,QAAA;MAC1B,OAAO;QACL;QACAF,QAAA,CAASQ,MAAM,CAACN,QAAA;MAClB;MACAP,UAAA,CAAWc,MAAM;IACnB,OAAO,IAAIlB,WAAA,CAAYO,YAAA,KAAiBA,YAAA,CAAaM,WAAW,OAAOV,QAAA,EAAU;MAC/EI,YAAA,CAAaU,MAAM,CAACN,QAAA;MACpBP,UAAA,CAAWc,MAAM;IACnB,OAAO;MACL,MAAMC,IAAA,GAAOrB,eAAA,CAAgBK,QAAA,EAAUA,QAAA,KAAa,WAAWiB,MAAA,CAAOd,KAAK,CAAC,EAAE,IAAIM,SAAA;MAClFO,IAAA,CAAKF,MAAM,CAACN,QAAA;MACZP,UAAA,CAAWiB,OAAO,CAACF,IAAA;IACrB;IACAR,QAAA,CAASM,MAAM,IAAIZ,QAAA;IACnBM,QAAA,CAASW,MAAM,CAAC,GAAG;IACnB,MAAMC,MAAA,GAASC,IAAA,CAAKC,KAAK,CAACnB,KAAK,CAAC,EAAE,CAAEoB,MAAM,GAAGzB,gBAAA;IAC7C,IAAIsB,MAAA,EAAQ;MACVZ,QAAA,CAASgB,SAAS,CAACJ,MAAA;IACrB;EACF;AACF;AAEA,OAAO,MAAMK,UAAA,GAAaA,CACxBC,QAAA,EACAC,cAAA,EACAC,KAAA;EAEA,MAAMC,MAAA,GAAmB,EAAE;EAC3B,MAAM3B,QAAA,GAAWwB,QAAA,CAASI,WAAW;EACrC,IAAIC,KAAA,GAAQ;EACZ,KAAK,MAAMC,YAAA,IAAgB9B,QAAA,EAAU;IACnC,IAAIN,eAAA,CAAgBoC,YAAA,GAAe;MACjC,IAAIA,YAAA,CAAaC,eAAe,OAAO,GAAG;QACxC,MAAMtB,UAAA,GAAaqB,YAAA,CAAapB,aAAa;QAC7C,IAAIf,WAAA,CAAYc,UAAA,GAAa;UAC3BkB,MAAA,CAAOK,IAAI,CAACT,UAAA,CAAWd,UAAA,EAAYgB,cAAA,EAAgBC,KAAA,GAAQ;UAC3D;QACF;MACF;MACA,MAAMR,MAAA,GAAS,IAAIe,MAAM,CAACP,KAAA,GAAQ9B,gBAAA;MAClC,MAAME,QAAA,GAAW0B,QAAA,CAAShB,WAAW;MACrC,MAAM0B,MAAA,GACJpC,QAAA,KAAa,WACT,GAAG0B,QAAA,CAASW,QAAQ,KAAKN,KAAA,IAAS,GAClC/B,QAAA,KAAa,UACX,MAAMgC,YAAA,CAAaM,UAAU,KAAK,MAAM,OAAO,GAC/C;MACRT,MAAA,CAAOK,IAAI,CAACd,MAAA,GAASgB,MAAA,GAAST,cAAA,CAAeK,YAAA;MAC7CD,KAAA;IACF;EACF;EAEA,OAAOF,MAAA,CAAOU,IAAI,CAAC;AACrB","ignoreList":[]}

package/dist/features/lists/unorderedList/markdownTransformer.d.ts

@@ -1,3 +0,0 @@
-import type { ElementTransformer } from '../../../packages/@lexical/markdown/MarkdownTransformers.js';
-export declare const UNORDERED_LIST: ElementTransformer;
-//# sourceMappingURL=markdownTransformer.d.ts.map

package/dist/features/lists/unorderedList/markdownTransformer.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"markdownTransformer.d.ts","sourceRoot":"","sources":["../../../../src/features/lists/unorderedList/markdownTransformer.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,6DAA6D,CAAA;AAIrG,eAAO,MAAM,cAAc,EAAE,kBAQ5B,CAAA"}

package/dist/features/lists/unorderedList/markdownTransformer.js

@@ -1,12 +0,0 @@
-import { $isListNode, ListItemNode, ListNode } from '@lexical/list';
-import { listExport, listReplace } from '../shared/markdown.js';
-export const UNORDERED_LIST = {
-  type: 'element',
-  dependencies: [ListNode, ListItemNode],
-  export: (node, exportChildren) => {
-    return $isListNode(node) ? listExport(node, exportChildren, 0) : null;
-  },
-  regExp: /^(\s*)[-*+]\s/,
-  replace: listReplace('bullet')
-};
-//# sourceMappingURL=markdownTransformer.js.map

package/dist/features/lists/unorderedList/markdownTransformer.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"markdownTransformer.js","names":["$isListNode","ListItemNode","ListNode","listExport","listReplace","UNORDERED_LIST","type","dependencies","export","node","exportChildren","regExp","replace"],"sources":["../../../../src/features/lists/unorderedList/markdownTransformer.ts"],"sourcesContent":["import { $isListNode, ListItemNode, ListNode } from '@lexical/list'\n\nimport type { ElementTransformer } from '../../../packages/@lexical/markdown/MarkdownTransformers.js'\n\nimport { listExport, listReplace } from '../shared/markdown.js'\n\nexport const UNORDERED_LIST: ElementTransformer = {\n  type: 'element',\n  dependencies: [ListNode, ListItemNode],\n  export: (node, exportChildren) => {\n    return $isListNode(node) ? listExport(node, exportChildren, 0) : null\n  },\n  regExp: /^(\\s*)[-*+]\\s/,\n  replace: listReplace('bullet'),\n}\n"],"mappings":"AAAA,SAASA,WAAW,EAAEC,YAAY,EAAEC,QAAQ,QAAQ;AAIpD,SAASC,UAAU,EAAEC,WAAW,QAAQ;AAExC,OAAO,MAAMC,cAAA,GAAqC;EAChDC,IAAA,EAAM;EACNC,YAAA,EAAc,CAACL,QAAA,EAAUD,YAAA,CAAa;EACtCO,MAAA,EAAQA,CAACC,IAAA,EAAMC,cAAA;IACb,OAAOV,WAAA,CAAYS,IAAA,IAAQN,UAAA,CAAWM,IAAA,EAAMC,cAAA,EAAgB,KAAK;EACnE;EACAC,MAAA,EAAQ;EACRC,OAAA,EAASR,WAAA,CAAY;AACvB","ignoreList":[]}

package/dist/field/clientEntry.d.ts

@@ -1,29 +0,0 @@
-import type { ImportMap, RichTextFieldClientProps } from 'payload';
-import React from 'react';
-import type { FeatureClientSchemaMap } from '../types/index.js';
-type SerializedFeatureMetadata = {
-    ClientFeature?: {
-        clientProps?: Record<string, any>;
-        path: string;
-    } | string;
-    clientFeatureProps?: Record<string, any>;
-    componentImports?: Record<string, {
-        clientProps?: Record<string, any>;
-        path: string;
-    } | string>;
-    key: string;
-    order: number;
-};
-export type ClientEntryLexicalFieldProps = {
-    featureClientSchemaMap?: FeatureClientSchemaMap;
-    features?: Record<string, SerializedFeatureMetadata>;
-    importMap: ImportMap;
-} & RichTextFieldClientProps;
-/**
- * Client-only entry point for the Lexical rich text field.
- * Resolves feature providers and component imports from the import map on the client,
- * bypassing the RSC entry point that requires server-only data.
- */
-export declare const ClientEntryLexicalField: React.FC<ClientEntryLexicalFieldProps>;
-export {};
-//# sourceMappingURL=clientEntry.d.ts.map

package/dist/field/clientEntry.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"clientEntry.d.ts","sourceRoot":"","sources":["../../src/field/clientEntry.tsx"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,SAAS,EAAuB,wBAAwB,EAAE,MAAM,SAAS,CAAA;AAGvF,OAAO,KAAkB,MAAM,OAAO,CAAA;AAMtC,OAAO,KAAK,EAAE,sBAAsB,EAA6B,MAAM,mBAAmB,CAAA;AAI1F,KAAK,yBAAyB,GAAG;IAC/B,aAAa,CAAC,EAAE;QAAE,WAAW,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE,GAAG,MAAM,CAAA;IAC5E,kBAAkB,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAA;IACxC,gBAAgB,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE;QAAE,WAAW,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE,GAAG,MAAM,CAAC,CAAA;IAC/F,GAAG,EAAE,MAAM,CAAA;IACX,KAAK,EAAE,MAAM,CAAA;CACd,CAAA;AAED,MAAM,MAAM,4BAA4B,GAAG;IACzC,sBAAsB,CAAC,EAAE,sBAAsB,CAAA;IAC/C,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,yBAAyB,CAAC,CAAA;IACpD,SAAS,EAAE,SAAS,CAAA;CACrB,GAAG,wBAAwB,CAAA;AAE5B;;;;GAIG;AACH,eAAO,MAAM,uBAAuB,EAAE,KAAK,CAAC,EAAE,CAAC,4BAA4B,CAqF1E,CAAA"}

package/dist/field/clientEntry.js

@@ -1,86 +0,0 @@
-'use client';
-
-import { jsx as _jsx } from "react/jsx-runtime";
-import { getFromImportMap } from 'payload/shared';
-import React, { useMemo } from 'react';
-import { RichTextField } from './index.js';
-/**
- * Client-only entry point for the Lexical rich text field.
- * Resolves feature providers and component imports from the import map on the client,
- * bypassing the RSC entry point that requires server-only data.
- */
-export const ClientEntryLexicalField = props => {
-  const {
-    featureClientSchemaMap = {},
-    features = {},
-    field,
-    forceRender,
-    importMap,
-    path,
-    permissions,
-    readOnly,
-    schemaPath
-  } = props;
-  const {
-    clientFeatures,
-    featureClientImportMap
-  } = useMemo(() => {
-    const resolvedClientFeatures = {};
-    const resolvedFeatureImportMap = {};
-    const sortedFeatures = Object.entries(features).sort(([, a], [, b]) => a.order - b.order);
-    for (const [featureKey, featureMeta] of sortedFeatures) {
-      resolvedClientFeatures[featureKey] = {};
-      if (featureMeta.ClientFeature) {
-        const clientFeatureProvider = getFromImportMap({
-          importMap,
-          PayloadComponent: featureMeta.ClientFeature,
-          schemaPath: 'lexical-clientComponent',
-          silent: true
-        });
-        if (clientFeatureProvider) {
-          const clientFeatureProps = {
-            ...(featureMeta.clientFeatureProps ?? {}),
-            featureKey: featureMeta.key,
-            order: featureMeta.order
-          };
-          if (typeof featureMeta.ClientFeature === 'object' && featureMeta.ClientFeature.clientProps) {
-            clientFeatureProps.clientProps = featureMeta.ClientFeature.clientProps;
-          }
-          resolvedClientFeatures[featureKey] = {
-            clientFeatureProps,
-            clientFeatureProvider
-          };
-        }
-      }
-      if (featureMeta.componentImports && typeof featureMeta.componentImports === 'object') {
-        for (const [importKey, payloadComponent] of Object.entries(featureMeta.componentImports)) {
-          const resolvedComponent = getFromImportMap({
-            importMap,
-            PayloadComponent: payloadComponent,
-            schemaPath: 'lexical-clientComponent',
-            silent: true
-          });
-          if (resolvedComponent) {
-            resolvedFeatureImportMap[`${featureKey}.${importKey}`] = resolvedComponent;
-          }
-        }
-      }
-    }
-    return {
-      clientFeatures: resolvedClientFeatures,
-      featureClientImportMap: resolvedFeatureImportMap
-    };
-  }, [features, importMap]);
-  return /*#__PURE__*/_jsx(RichTextField, {
-    clientFeatures: clientFeatures,
-    featureClientImportMap: featureClientImportMap,
-    featureClientSchemaMap: featureClientSchemaMap,
-    field: field,
-    forceRender: forceRender,
-    path: path,
-    permissions: permissions,
-    readOnly: readOnly,
-    schemaPath: schemaPath
-  });
-};
-//# sourceMappingURL=clientEntry.js.map

package/dist/field/clientEntry.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"clientEntry.js","names":["getFromImportMap","React","useMemo","RichTextField","ClientEntryLexicalField","props","featureClientSchemaMap","features","field","forceRender","importMap","path","permissions","readOnly","schemaPath","clientFeatures","featureClientImportMap","resolvedClientFeatures","resolvedFeatureImportMap","sortedFeatures","Object","entries","sort","a","b","order","featureKey","featureMeta","ClientFeature","clientFeatureProvider","PayloadComponent","silent","clientFeatureProps","key","clientProps","componentImports","importKey","payloadComponent","resolvedComponent","_jsx"],"sources":["../../src/field/clientEntry.tsx"],"sourcesContent":["'use client'\n\nimport type { ImportMap, RichTextFieldClient, RichTextFieldClientProps } from 'payload'\n\nimport { getFromImportMap } from 'payload/shared'\nimport React, { useMemo } from 'react'\n\nimport type {\n  BaseClientFeatureProps,\n  FeatureProviderProviderClient,\n} from '../features/typesClient.js'\nimport type { FeatureClientSchemaMap, LexicalRichTextFieldProps } from '../types/index.js'\n\nimport { RichTextField } from './index.js'\n\ntype SerializedFeatureMetadata = {\n  ClientFeature?: { clientProps?: Record<string, any>; path: string } | string\n  clientFeatureProps?: Record<string, any>\n  componentImports?: Record<string, { clientProps?: Record<string, any>; path: string } | string>\n  key: string\n  order: number\n}\n\nexport type ClientEntryLexicalFieldProps = {\n  featureClientSchemaMap?: FeatureClientSchemaMap\n  features?: Record<string, SerializedFeatureMetadata>\n  importMap: ImportMap\n} & RichTextFieldClientProps\n\n/**\n * Client-only entry point for the Lexical rich text field.\n * Resolves feature providers and component imports from the import map on the client,\n * bypassing the RSC entry point that requires server-only data.\n */\nexport const ClientEntryLexicalField: React.FC<ClientEntryLexicalFieldProps> = (props) => {\n  const {\n    featureClientSchemaMap = {},\n    features = {},\n    field,\n    forceRender,\n    importMap,\n    path,\n    permissions,\n    readOnly,\n    schemaPath,\n  } = props\n\n  const { clientFeatures, featureClientImportMap } = useMemo(() => {\n    const resolvedClientFeatures: LexicalRichTextFieldProps['clientFeatures'] = {}\n    const resolvedFeatureImportMap: Record<string, any> = {}\n\n    const sortedFeatures = Object.entries(features).sort(([, a], [, b]) => a.order - b.order)\n\n    for (const [featureKey, featureMeta] of sortedFeatures) {\n      resolvedClientFeatures[featureKey] = {}\n\n      if (featureMeta.ClientFeature) {\n        const clientFeatureProvider = getFromImportMap<FeatureProviderProviderClient | undefined>({\n          importMap,\n          PayloadComponent: featureMeta.ClientFeature,\n          schemaPath: 'lexical-clientComponent',\n          silent: true,\n        })\n\n        if (clientFeatureProvider) {\n          const clientFeatureProps: BaseClientFeatureProps<Record<string, any>> = {\n            ...(featureMeta.clientFeatureProps ?? {}),\n            featureKey: featureMeta.key,\n            order: featureMeta.order,\n          }\n\n          if (\n            typeof featureMeta.ClientFeature === 'object' &&\n            featureMeta.ClientFeature.clientProps\n          ) {\n            clientFeatureProps.clientProps = (featureMeta.ClientFeature as any).clientProps\n          }\n\n          resolvedClientFeatures[featureKey] = {\n            clientFeatureProps,\n            clientFeatureProvider,\n          }\n        }\n      }\n\n      if (featureMeta.componentImports && typeof featureMeta.componentImports === 'object') {\n        for (const [importKey, payloadComponent] of Object.entries(featureMeta.componentImports)) {\n          const resolvedComponent = getFromImportMap({\n            importMap,\n            PayloadComponent: payloadComponent,\n            schemaPath: 'lexical-clientComponent',\n            silent: true,\n          })\n          if (resolvedComponent) {\n            resolvedFeatureImportMap[`${featureKey}.${importKey}`] = resolvedComponent\n          }\n        }\n      }\n    }\n\n    return {\n      clientFeatures: resolvedClientFeatures,\n      featureClientImportMap: resolvedFeatureImportMap,\n    }\n  }, [features, importMap])\n\n  return (\n    <RichTextField\n      clientFeatures={clientFeatures}\n      featureClientImportMap={featureClientImportMap}\n      featureClientSchemaMap={featureClientSchemaMap}\n      field={field as RichTextFieldClient}\n      forceRender={forceRender}\n      path={path}\n      permissions={permissions as LexicalRichTextFieldProps['permissions']}\n      readOnly={readOnly}\n      schemaPath={schemaPath}\n    />\n  )\n}\n"],"mappings":"AAAA;;;AAIA,SAASA,gBAAgB,QAAQ;AACjC,OAAOC,KAAA,IAASC,OAAO,QAAQ;AAQ/B,SAASC,aAAa,QAAQ;AAgB9B;;;;;AAKA,OAAO,MAAMC,uBAAA,GAAmEC,KAAA;EAC9E,MAAM;IACJC,sBAAA,GAAyB,CAAC,CAAC;IAC3BC,QAAA,GAAW,CAAC,CAAC;IACbC,KAAK;IACLC,WAAW;IACXC,SAAS;IACTC,IAAI;IACJC,WAAW;IACXC,QAAQ;IACRC;EAAU,CACX,GAAGT,KAAA;EAEJ,MAAM;IAAEU,cAAc;IAAEC;EAAsB,CAAE,GAAGd,OAAA,CAAQ;IACzD,MAAMe,sBAAA,GAAsE,CAAC;IAC7E,MAAMC,wBAAA,GAAgD,CAAC;IAEvD,MAAMC,cAAA,GAAiBC,MAAA,CAAOC,OAAO,CAACd,QAAA,EAAUe,IAAI,CAAC,CAAC,GAAGC,CAAA,CAAE,EAAE,GAAGC,CAAA,CAAE,KAAKD,CAAA,CAAEE,KAAK,GAAGD,CAAA,CAAEC,KAAK;IAExF,KAAK,MAAM,CAACC,UAAA,EAAYC,WAAA,CAAY,IAAIR,cAAA,EAAgB;MACtDF,sBAAsB,CAACS,UAAA,CAAW,GAAG,CAAC;MAEtC,IAAIC,WAAA,CAAYC,aAAa,EAAE;QAC7B,MAAMC,qBAAA,GAAwB7B,gBAAA,CAA4D;UACxFU,SAAA;UACAoB,gBAAA,EAAkBH,WAAA,CAAYC,aAAa;UAC3Cd,UAAA,EAAY;UACZiB,MAAA,EAAQ;QACV;QAEA,IAAIF,qBAAA,EAAuB;UACzB,MAAMG,kBAAA,GAAkE;YACtE,IAAIL,WAAA,CAAYK,kBAAkB,IAAI,CAAC,CAAC;YACxCN,UAAA,EAAYC,WAAA,CAAYM,GAAG;YAC3BR,KAAA,EAAOE,WAAA,CAAYF;UACrB;UAEA,IACE,OAAOE,WAAA,CAAYC,aAAa,KAAK,YACrCD,WAAA,CAAYC,aAAa,CAACM,WAAW,EACrC;YACAF,kBAAA,CAAmBE,WAAW,GAAGP,WAAC,CAAYC,aAAa,CAASM,WAAW;UACjF;UAEAjB,sBAAsB,CAACS,UAAA,CAAW,GAAG;YACnCM,kBAAA;YACAH;UACF;QACF;MACF;MAEA,IAAIF,WAAA,CAAYQ,gBAAgB,IAAI,OAAOR,WAAA,CAAYQ,gBAAgB,KAAK,UAAU;QACpF,KAAK,MAAM,CAACC,SAAA,EAAWC,gBAAA,CAAiB,IAAIjB,MAAA,CAAOC,OAAO,CAACM,WAAA,CAAYQ,gBAAgB,GAAG;UACxF,MAAMG,iBAAA,GAAoBtC,gBAAA,CAAiB;YACzCU,SAAA;YACAoB,gBAAA,EAAkBO,gBAAA;YAClBvB,UAAA,EAAY;YACZiB,MAAA,EAAQ;UACV;UACA,IAAIO,iBAAA,EAAmB;YACrBpB,wBAAwB,CAAC,GAAGQ,UAAA,IAAcU,SAAA,EAAW,CAAC,GAAGE,iBAAA;UAC3D;QACF;MACF;IACF;IAEA,OAAO;MACLvB,cAAA,EAAgBE,sBAAA;MAChBD,sBAAA,EAAwBE;IAC1B;EACF,GAAG,CAACX,QAAA,EAAUG,SAAA,CAAU;EAExB,oBACE6B,IAAA,CAACpC,aAAA;IACCY,cAAA,EAAgBA,cAAA;IAChBC,sBAAA,EAAwBA,sBAAA;IACxBV,sBAAA,EAAwBA,sBAAA;IACxBE,KAAA,EAAOA,KAAA;IACPC,WAAA,EAAaA,WAAA;IACbE,IAAA,EAAMA,IAAA;IACNC,WAAA,EAAaA,WAAA;IACbC,QAAA,EAAUA,QAAA;IACVC,UAAA,EAAYA;;AAGlB","ignoreList":[]}

package/dist/lexical/utils/guard.d.ts

@@ -1,5 +0,0 @@
-/**
- * @deprecated - remove in 4.0. lexical already exports an isHTMLElement utility
- */
-export declare function isHTMLElement(x: unknown): x is HTMLElement;
-//# sourceMappingURL=guard.d.ts.map