@payloadcms/richtext-lexical 3.91.0-internal.c1569dc → 4.0.0-beta.1

package/dist/features/migrations/slateToLexical/converter/converters/indent/converter.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"converter.js","names":["convertSlateNodesToLexical","SlateIndentConverter","converter","converters","slateNode","convertChildren","node","indentLevel","type","children","text","canContainParagraphs","parentNodeType","slateNodes","indent","map","child","direction","format","version","nodeTypes"],"sources":["../../../../../../../src/features/migrations/slateToLexical/converter/converters/indent/converter.ts"],"sourcesContent":["import type { SerializedLexicalNode, SerializedParagraphNode } from 'lexical'\n\nimport type { SlateNodeConverter } from '../../types.js'\n\nimport { convertSlateNodesToLexical } from '../../index.js'\n\nexport const SlateIndentConverter: SlateNodeConverter = {\n  converter({ converters, slateNode }) {\n    const convertChildren = (node: any, indentLevel: number = 0): SerializedLexicalNode => {\n      if (\n        (node?.type && (!node.children || node.type !== 'indent')) ||\n        (!node?.type && node?.text)\n      ) {\n        return {\n          ...convertSlateNodesToLexical({\n            canContainParagraphs: false,\n            converters,\n            parentNodeType: 'indent',\n            slateNodes: [node],\n          })[0],\n          indent: indentLevel,\n        } as const as SerializedLexicalNode\n      }\n\n      const children = node.children.map((child: any) => convertChildren(child, indentLevel + 1))\n      return {\n        type: 'paragraph',\n        children,\n        direction: 'ltr',\n        format: '',\n        indent: indentLevel,\n        version: 1,\n      } as const as SerializedParagraphNode\n    }\n\n    return convertChildren(slateNode)\n  },\n  nodeTypes: ['indent'],\n}\n"],"mappings":"AAIA,SAASA,0BAA0B,QAAQ;AAE3C,OAAO,MAAMC,oBAAA,GAA2C;EACtDC,UAAU;IAAEC,UAAU;IAAEC;EAAS,CAAE;IACjC,MAAMC,eAAA,GAAkBA,CAACC,IAAA,EAAWC,WAAA,GAAsB,CAAC;MACzD,IACED,IAAC,EAAME,IAAA,KAAS,CAACF,IAAA,CAAKG,QAAQ,IAAIH,IAAA,CAAKE,IAAI,KAAK,QAAO,KACtD,CAACF,IAAA,EAAME,IAAA,IAAQF,IAAA,EAAMI,IAAA,EACtB;QACA,OAAO;UACL,GAAGV,0BAAA,CAA2B;YAC5BW,oBAAA,EAAsB;YACtBR,UAAA;YACAS,cAAA,EAAgB;YAChBC,UAAA,EAAY,CAACP,IAAA;UACf,EAAE,CAAC,EAAE;UACLQ,MAAA,EAAQP;QACV;MACF;MAEA,MAAME,QAAA,GAAWH,IAAA,CAAKG,QAAQ,CAACM,GAAG,CAAEC,KAAA,IAAeX,eAAA,CAAgBW,KAAA,EAAOT,WAAA,GAAc;MACxF,OAAO;QACLC,IAAA,EAAM;QACNC,QAAA;QACAQ,SAAA,EAAW;QACXC,MAAA,EAAQ;QACRJ,MAAA,EAAQP,WAAA;QACRY,OAAA,EAAS;MACX;IACF;IAEA,OAAOd,eAAA,CAAgBD,SAAA;EACzB;EACAgB,SAAA,EAAW,CAAC;AACd","ignoreList":[]}

package/dist/features/migrations/slateToLexical/converter/converters/link/converter.d.ts

@@ -1,3 +0,0 @@
-import type { SlateNodeConverter } from '../../types.js';
-export declare const SlateLinkConverter: SlateNodeConverter;
-//# sourceMappingURL=converter.d.ts.map

package/dist/features/migrations/slateToLexical/converter/converters/link/converter.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"converter.d.ts","sourceRoot":"","sources":["../../../../../../../src/features/migrations/slateToLexical/converter/converters/link/converter.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,gBAAgB,CAAA;AAIxD,eAAO,MAAM,kBAAkB,EAAE,kBAwBhC,CAAA"}

package/dist/features/migrations/slateToLexical/converter/converters/link/converter.js

@@ -1,30 +0,0 @@
-import { convertSlateNodesToLexical } from '../../index.js';
-export const SlateLinkConverter = {
-  converter({
-    converters,
-    slateNode
-  }) {
-    return {
-      type: 'link',
-      children: convertSlateNodesToLexical({
-        canContainParagraphs: false,
-        converters,
-        parentNodeType: 'link',
-        slateNodes: slateNode.children
-      }),
-      direction: 'ltr',
-      fields: {
-        ...(slateNode.fields || {}),
-        doc: slateNode.doc || null,
-        linkType: slateNode.linkType || 'custom',
-        newTab: slateNode.newTab || false,
-        url: (slateNode.linkType || 'custom') === 'custom' ? slateNode.url || 'https' : undefined
-      },
-      format: '',
-      indent: 0,
-      version: 2
-    };
-  },
-  nodeTypes: ['link']
-};
-//# sourceMappingURL=converter.js.map

package/dist/features/migrations/slateToLexical/converter/converters/link/converter.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"converter.js","names":["convertSlateNodesToLexical","SlateLinkConverter","converter","converters","slateNode","type","children","canContainParagraphs","parentNodeType","slateNodes","direction","fields","doc","linkType","newTab","url","undefined","format","indent","version","nodeTypes"],"sources":["../../../../../../../src/features/migrations/slateToLexical/converter/converters/link/converter.ts"],"sourcesContent":["import type { SerializedLinkNode } from '../../../../../link/nodes/types.js'\nimport type { SlateNodeConverter } from '../../types.js'\n\nimport { convertSlateNodesToLexical } from '../../index.js'\n\nexport const SlateLinkConverter: SlateNodeConverter = {\n  converter({ converters, slateNode }) {\n    return {\n      type: 'link',\n      children: convertSlateNodesToLexical({\n        canContainParagraphs: false,\n        converters,\n        parentNodeType: 'link',\n        slateNodes: slateNode.children!,\n      }),\n      direction: 'ltr',\n      fields: {\n        ...(slateNode.fields || {}),\n        doc: slateNode.doc || null,\n        linkType: slateNode.linkType || 'custom',\n        newTab: slateNode.newTab || false,\n        url: (slateNode.linkType || 'custom') === 'custom' ? slateNode.url || 'https' : undefined, // can be undefined only if linkType is not custom, otherwise: validation error\n      },\n      format: '',\n      indent: 0,\n      version: 2,\n    } as const as SerializedLinkNode\n  },\n  nodeTypes: ['link'],\n}\n"],"mappings":"AAGA,SAASA,0BAA0B,QAAQ;AAE3C,OAAO,MAAMC,kBAAA,GAAyC;EACpDC,UAAU;IAAEC,UAAU;IAAEC;EAAS,CAAE;IACjC,OAAO;MACLC,IAAA,EAAM;MACNC,QAAA,EAAUN,0BAAA,CAA2B;QACnCO,oBAAA,EAAsB;QACtBJ,UAAA;QACAK,cAAA,EAAgB;QAChBC,UAAA,EAAYL,SAAA,CAAUE;MACxB;MACAI,SAAA,EAAW;MACXC,MAAA,EAAQ;QACN,IAAIP,SAAA,CAAUO,MAAM,IAAI,CAAC,CAAC;QAC1BC,GAAA,EAAKR,SAAA,CAAUQ,GAAG,IAAI;QACtBC,QAAA,EAAUT,SAAA,CAAUS,QAAQ,IAAI;QAChCC,MAAA,EAAQV,SAAA,CAAUU,MAAM,IAAI;QAC5BC,GAAA,EAAK,CAACX,SAAA,CAAUS,QAAQ,IAAI,QAAO,MAAO,WAAWT,SAAA,CAAUW,GAAG,IAAI,UAAUC;MAClF;MACAC,MAAA,EAAQ;MACRC,MAAA,EAAQ;MACRC,OAAA,EAAS;IACX;EACF;EACAC,SAAA,EAAW,CAAC;AACd","ignoreList":[]}

package/dist/features/migrations/slateToLexical/converter/converters/listItem/converter.d.ts

@@ -1,3 +0,0 @@
-import type { SlateNodeConverter } from '../../types.js';
-export declare const SlateListItemConverter: SlateNodeConverter;
-//# sourceMappingURL=converter.d.ts.map

package/dist/features/migrations/slateToLexical/converter/converters/listItem/converter.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"converter.d.ts","sourceRoot":"","sources":["../../../../../../../src/features/migrations/slateToLexical/converter/converters/listItem/converter.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,gBAAgB,CAAA;AAIxD,eAAO,MAAM,sBAAsB,EAAE,kBAmBpC,CAAA"}

package/dist/features/migrations/slateToLexical/converter/converters/listItem/converter.js

@@ -1,26 +0,0 @@
-import { convertSlateNodesToLexical } from '../../index.js';
-export const SlateListItemConverter = {
-  converter({
-    childIndex,
-    converters,
-    slateNode
-  }) {
-    return {
-      type: 'listitem',
-      checked: undefined,
-      children: convertSlateNodesToLexical({
-        canContainParagraphs: false,
-        converters,
-        parentNodeType: 'listitem',
-        slateNodes: slateNode.children
-      }),
-      direction: 'ltr',
-      format: '',
-      indent: 0,
-      value: childIndex + 1,
-      version: 1
-    };
-  },
-  nodeTypes: ['li']
-};
-//# sourceMappingURL=converter.js.map

package/dist/features/migrations/slateToLexical/converter/converters/listItem/converter.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"converter.js","names":["convertSlateNodesToLexical","SlateListItemConverter","converter","childIndex","converters","slateNode","type","checked","undefined","children","canContainParagraphs","parentNodeType","slateNodes","direction","format","indent","value","version","nodeTypes"],"sources":["../../../../../../../src/features/migrations/slateToLexical/converter/converters/listItem/converter.ts"],"sourcesContent":["import type { SerializedListItemNode } from '../../../../../lists/plugin/index.js'\nimport type { SlateNodeConverter } from '../../types.js'\n\nimport { convertSlateNodesToLexical } from '../../index.js'\n\nexport const SlateListItemConverter: SlateNodeConverter = {\n  converter({ childIndex, converters, slateNode }) {\n    return {\n      type: 'listitem',\n      checked: undefined,\n      children: convertSlateNodesToLexical({\n        canContainParagraphs: false,\n        converters,\n        parentNodeType: 'listitem',\n        slateNodes: slateNode.children!,\n      }),\n      direction: 'ltr',\n      format: '',\n      indent: 0,\n      value: childIndex + 1,\n      version: 1,\n    } as const as SerializedListItemNode\n  },\n  nodeTypes: ['li'],\n}\n"],"mappings":"AAGA,SAASA,0BAA0B,QAAQ;AAE3C,OAAO,MAAMC,sBAAA,GAA6C;EACxDC,UAAU;IAAEC,UAAU;IAAEC,UAAU;IAAEC;EAAS,CAAE;IAC7C,OAAO;MACLC,IAAA,EAAM;MACNC,OAAA,EAASC,SAAA;MACTC,QAAA,EAAUT,0BAAA,CAA2B;QACnCU,oBAAA,EAAsB;QACtBN,UAAA;QACAO,cAAA,EAAgB;QAChBC,UAAA,EAAYP,SAAA,CAAUI;MACxB;MACAI,SAAA,EAAW;MACXC,MAAA,EAAQ;MACRC,MAAA,EAAQ;MACRC,KAAA,EAAOb,UAAA,GAAa;MACpBc,OAAA,EAAS;IACX;EACF;EACAC,SAAA,EAAW,CAAC;AACd","ignoreList":[]}

package/dist/features/migrations/slateToLexical/converter/converters/orderedList/converter.d.ts

@@ -1,3 +0,0 @@
-import type { SlateNodeConverter } from '../../types.js';
-export declare const SlateOrderedListConverter: SlateNodeConverter;
-//# sourceMappingURL=converter.d.ts.map

package/dist/features/migrations/slateToLexical/converter/converters/orderedList/converter.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"converter.d.ts","sourceRoot":"","sources":["../../../../../../../src/features/migrations/slateToLexical/converter/converters/orderedList/converter.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,gBAAgB,CAAA;AAIxD,eAAO,MAAM,yBAAyB,EAAE,kBAoBvC,CAAA"}

package/dist/features/migrations/slateToLexical/converter/converters/orderedList/converter.js

@@ -1,26 +0,0 @@
-import { convertSlateNodesToLexical } from '../../index.js';
-export const SlateOrderedListConverter = {
-  converter({
-    converters,
-    slateNode
-  }) {
-    return {
-      type: 'list',
-      children: convertSlateNodesToLexical({
-        canContainParagraphs: false,
-        converters,
-        parentNodeType: 'list',
-        slateNodes: slateNode.children
-      }),
-      direction: 'ltr',
-      format: '',
-      indent: 0,
-      listType: 'number',
-      start: 1,
-      tag: 'ol',
-      version: 1
-    };
-  },
-  nodeTypes: ['ol']
-};
-//# sourceMappingURL=converter.js.map

package/dist/features/migrations/slateToLexical/converter/converters/orderedList/converter.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"converter.js","names":["convertSlateNodesToLexical","SlateOrderedListConverter","converter","converters","slateNode","type","children","canContainParagraphs","parentNodeType","slateNodes","direction","format","indent","listType","start","tag","version","nodeTypes"],"sources":["../../../../../../../src/features/migrations/slateToLexical/converter/converters/orderedList/converter.ts"],"sourcesContent":["import type { SerializedListNode } from '../../../../../lists/plugin/index.js'\nimport type { SlateNodeConverter } from '../../types.js'\n\nimport { convertSlateNodesToLexical } from '../../index.js'\n\nexport const SlateOrderedListConverter: SlateNodeConverter = {\n  converter({ converters, slateNode }) {\n    return {\n      type: 'list',\n      children: convertSlateNodesToLexical({\n        canContainParagraphs: false,\n        converters,\n        parentNodeType: 'list',\n        slateNodes: slateNode.children!,\n      }),\n      direction: 'ltr',\n      format: '',\n      indent: 0,\n      listType: 'number',\n      start: 1,\n      tag: 'ol',\n      version: 1,\n    } as const as SerializedListNode\n  },\n  nodeTypes: ['ol'],\n}\n"],"mappings":"AAGA,SAASA,0BAA0B,QAAQ;AAE3C,OAAO,MAAMC,yBAAA,GAAgD;EAC3DC,UAAU;IAAEC,UAAU;IAAEC;EAAS,CAAE;IACjC,OAAO;MACLC,IAAA,EAAM;MACNC,QAAA,EAAUN,0BAAA,CAA2B;QACnCO,oBAAA,EAAsB;QACtBJ,UAAA;QACAK,cAAA,EAAgB;QAChBC,UAAA,EAAYL,SAAA,CAAUE;MACxB;MACAI,SAAA,EAAW;MACXC,MAAA,EAAQ;MACRC,MAAA,EAAQ;MACRC,QAAA,EAAU;MACVC,KAAA,EAAO;MACPC,GAAA,EAAK;MACLC,OAAA,EAAS;IACX;EACF;EACAC,SAAA,EAAW,CAAC;AACd","ignoreList":[]}

package/dist/features/migrations/slateToLexical/converter/converters/relationship/converter.d.ts

@@ -1,3 +0,0 @@
-import type { SlateNodeConverter } from '../../types.js';
-export declare const SlateRelationshipConverter: SlateNodeConverter;
-//# sourceMappingURL=converter.d.ts.map

package/dist/features/migrations/slateToLexical/converter/converters/relationship/converter.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"converter.d.ts","sourceRoot":"","sources":["../../../../../../../src/features/migrations/slateToLexical/converter/converters/relationship/converter.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,gBAAgB,CAAA;AAExD,eAAO,MAAM,0BAA0B,EAAE,kBAWxC,CAAA"}

package/dist/features/migrations/slateToLexical/converter/converters/relationship/converter.js

@@ -1,15 +0,0 @@
-export const SlateRelationshipConverter = {
-  converter({
-    slateNode
-  }) {
-    return {
-      type: 'relationship',
-      format: '',
-      relationTo: slateNode.relationTo,
-      value: slateNode?.value?.id || '',
-      version: 2
-    };
-  },
-  nodeTypes: ['relationship']
-};
-//# sourceMappingURL=converter.js.map

package/dist/features/migrations/slateToLexical/converter/converters/relationship/converter.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"converter.js","names":["SlateRelationshipConverter","converter","slateNode","type","format","relationTo","value","id","version","nodeTypes"],"sources":["../../../../../../../src/features/migrations/slateToLexical/converter/converters/relationship/converter.ts"],"sourcesContent":["import type { SerializedRelationshipNode } from '../../../../../relationship/server/nodes/RelationshipNode.js'\nimport type { SlateNodeConverter } from '../../types.js'\n\nexport const SlateRelationshipConverter: SlateNodeConverter = {\n  converter({ slateNode }) {\n    return {\n      type: 'relationship',\n      format: '',\n      relationTo: slateNode.relationTo,\n      value: slateNode?.value?.id || '',\n      version: 2,\n    } as const as SerializedRelationshipNode\n  },\n  nodeTypes: ['relationship'],\n}\n"],"mappings":"AAGA,OAAO,MAAMA,0BAAA,GAAiD;EAC5DC,UAAU;IAAEC;EAAS,CAAE;IACrB,OAAO;MACLC,IAAA,EAAM;MACNC,MAAA,EAAQ;MACRC,UAAA,EAAYH,SAAA,CAAUG,UAAU;MAChCC,KAAA,EAAOJ,SAAA,EAAWI,KAAA,EAAOC,EAAA,IAAM;MAC/BC,OAAA,EAAS;IACX;EACF;EACAC,SAAA,EAAW,CAAC;AACd","ignoreList":[]}

package/dist/features/migrations/slateToLexical/converter/converters/unknown/converter.d.ts

@@ -1,3 +0,0 @@
-import type { SlateNodeConverter } from '../../types.js';
-export declare const SlateUnknownConverter: SlateNodeConverter;
-//# sourceMappingURL=converter.d.ts.map

package/dist/features/migrations/slateToLexical/converter/converters/unknown/converter.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"converter.d.ts","sourceRoot":"","sources":["../../../../../../../src/features/migrations/slateToLexical/converter/converters/unknown/converter.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,gBAAgB,CAAA;AAIxD,eAAO,MAAM,qBAAqB,EAAE,kBAqBnC,CAAA"}

package/dist/features/migrations/slateToLexical/converter/converters/unknown/converter.js

@@ -1,27 +0,0 @@
-import { convertSlateNodesToLexical } from '../../index.js';
-export const SlateUnknownConverter = {
-  converter({
-    converters,
-    slateNode
-  }) {
-    return {
-      type: 'unknownConverted',
-      children: convertSlateNodesToLexical({
-        canContainParagraphs: false,
-        converters,
-        parentNodeType: 'unknownConverted',
-        slateNodes: slateNode.children
-      }),
-      data: {
-        nodeData: slateNode,
-        nodeType: slateNode.type
-      },
-      direction: 'ltr',
-      format: '',
-      indent: 0,
-      version: 1
-    };
-  },
-  nodeTypes: ['unknown']
-};
-//# sourceMappingURL=converter.js.map

package/dist/features/migrations/slateToLexical/converter/converters/unknown/converter.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"converter.js","names":["convertSlateNodesToLexical","SlateUnknownConverter","converter","converters","slateNode","type","children","canContainParagraphs","parentNodeType","slateNodes","data","nodeData","nodeType","direction","format","indent","version","nodeTypes"],"sources":["../../../../../../../src/features/migrations/slateToLexical/converter/converters/unknown/converter.ts"],"sourcesContent":["import type { SerializedUnknownConvertedNode } from '../../../nodes/unknownConvertedNode/index.js'\nimport type { SlateNodeConverter } from '../../types.js'\n\nimport { convertSlateNodesToLexical } from '../../index.js'\n\nexport const SlateUnknownConverter: SlateNodeConverter = {\n  converter({ converters, slateNode }) {\n    return {\n      type: 'unknownConverted',\n      children: convertSlateNodesToLexical({\n        canContainParagraphs: false,\n        converters,\n        parentNodeType: 'unknownConverted',\n        slateNodes: slateNode.children!,\n      }),\n      data: {\n        nodeData: slateNode,\n        nodeType: slateNode.type,\n      },\n      direction: 'ltr',\n      format: '',\n      indent: 0,\n      version: 1,\n    } as const as SerializedUnknownConvertedNode\n  },\n  nodeTypes: ['unknown'],\n}\n"],"mappings":"AAGA,SAASA,0BAA0B,QAAQ;AAE3C,OAAO,MAAMC,qBAAA,GAA4C;EACvDC,UAAU;IAAEC,UAAU;IAAEC;EAAS,CAAE;IACjC,OAAO;MACLC,IAAA,EAAM;MACNC,QAAA,EAAUN,0BAAA,CAA2B;QACnCO,oBAAA,EAAsB;QACtBJ,UAAA;QACAK,cAAA,EAAgB;QAChBC,UAAA,EAAYL,SAAA,CAAUE;MACxB;MACAI,IAAA,EAAM;QACJC,QAAA,EAAUP,SAAA;QACVQ,QAAA,EAAUR,SAAA,CAAUC;MACtB;MACAQ,SAAA,EAAW;MACXC,MAAA,EAAQ;MACRC,MAAA,EAAQ;MACRC,OAAA,EAAS;IACX;EACF;EACAC,SAAA,EAAW,CAAC;AACd","ignoreList":[]}

package/dist/features/migrations/slateToLexical/converter/converters/unorderedList/converter.d.ts

@@ -1,3 +0,0 @@
-import type { SlateNodeConverter } from '../../types.js';
-export declare const SlateUnorderedListConverter: SlateNodeConverter;
-//# sourceMappingURL=converter.d.ts.map

package/dist/features/migrations/slateToLexical/converter/converters/unorderedList/converter.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"converter.d.ts","sourceRoot":"","sources":["../../../../../../../src/features/migrations/slateToLexical/converter/converters/unorderedList/converter.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,gBAAgB,CAAA;AAIxD,eAAO,MAAM,2BAA2B,EAAE,kBAoBzC,CAAA"}

package/dist/features/migrations/slateToLexical/converter/converters/unorderedList/converter.js

@@ -1,26 +0,0 @@
-import { convertSlateNodesToLexical } from '../../index.js';
-export const SlateUnorderedListConverter = {
-  converter({
-    converters,
-    slateNode
-  }) {
-    return {
-      type: 'list',
-      children: convertSlateNodesToLexical({
-        canContainParagraphs: false,
-        converters,
-        parentNodeType: 'list',
-        slateNodes: slateNode.children
-      }),
-      direction: 'ltr',
-      format: '',
-      indent: 0,
-      listType: 'bullet',
-      start: 1,
-      tag: 'ul',
-      version: 1
-    };
-  },
-  nodeTypes: ['ul']
-};
-//# sourceMappingURL=converter.js.map

package/dist/features/migrations/slateToLexical/converter/converters/unorderedList/converter.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"converter.js","names":["convertSlateNodesToLexical","SlateUnorderedListConverter","converter","converters","slateNode","type","children","canContainParagraphs","parentNodeType","slateNodes","direction","format","indent","listType","start","tag","version","nodeTypes"],"sources":["../../../../../../../src/features/migrations/slateToLexical/converter/converters/unorderedList/converter.ts"],"sourcesContent":["import type { SerializedListNode } from '../../../../../lists/plugin/index.js'\nimport type { SlateNodeConverter } from '../../types.js'\n\nimport { convertSlateNodesToLexical } from '../../index.js'\n\nexport const SlateUnorderedListConverter: SlateNodeConverter = {\n  converter({ converters, slateNode }) {\n    return {\n      type: 'list',\n      children: convertSlateNodesToLexical({\n        canContainParagraphs: false,\n        converters,\n        parentNodeType: 'list',\n        slateNodes: slateNode.children!,\n      }),\n      direction: 'ltr',\n      format: '',\n      indent: 0,\n      listType: 'bullet',\n      start: 1,\n      tag: 'ul',\n      version: 1,\n    } as const as SerializedListNode\n  },\n  nodeTypes: ['ul'],\n}\n"],"mappings":"AAGA,SAASA,0BAA0B,QAAQ;AAE3C,OAAO,MAAMC,2BAAA,GAAkD;EAC7DC,UAAU;IAAEC,UAAU;IAAEC;EAAS,CAAE;IACjC,OAAO;MACLC,IAAA,EAAM;MACNC,QAAA,EAAUN,0BAAA,CAA2B;QACnCO,oBAAA,EAAsB;QACtBJ,UAAA;QACAK,cAAA,EAAgB;QAChBC,UAAA,EAAYL,SAAA,CAAUE;MACxB;MACAI,SAAA,EAAW;MACXC,MAAA,EAAQ;MACRC,MAAA,EAAQ;MACRC,QAAA,EAAU;MACVC,KAAA,EAAO;MACPC,GAAA,EAAK;MACLC,OAAA,EAAS;IACX;EACF;EACAC,SAAA,EAAW,CAAC;AACd","ignoreList":[]}

package/dist/features/migrations/slateToLexical/converter/converters/upload/converter.d.ts

@@ -1,3 +0,0 @@
-import type { SlateNodeConverter } from '../../types.js';
-export declare const SlateUploadConverter: SlateNodeConverter;
-//# sourceMappingURL=converter.d.ts.map

package/dist/features/migrations/slateToLexical/converter/converters/upload/converter.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"converter.d.ts","sourceRoot":"","sources":["../../../../../../../src/features/migrations/slateToLexical/converter/converters/upload/converter.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,gBAAgB,CAAA;AAExD,eAAO,MAAM,oBAAoB,EAAE,kBAclC,CAAA"}

package/dist/features/migrations/slateToLexical/converter/converters/upload/converter.js

@@ -1,18 +0,0 @@
-export const SlateUploadConverter = {
-  converter({
-    slateNode
-  }) {
-    return {
-      type: 'upload',
-      fields: {
-        ...slateNode.fields
-      },
-      format: '',
-      relationTo: slateNode.relationTo,
-      value: slateNode.value?.id || '',
-      version: 2
-    };
-  },
-  nodeTypes: ['upload']
-};
-//# sourceMappingURL=converter.js.map

package/dist/features/migrations/slateToLexical/converter/converters/upload/converter.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"converter.js","names":["SlateUploadConverter","converter","slateNode","type","fields","format","relationTo","value","id","version","nodeTypes"],"sources":["../../../../../../../src/features/migrations/slateToLexical/converter/converters/upload/converter.ts"],"sourcesContent":["import type { SerializedUploadNode } from '../../../../../upload/server/nodes/UploadNode.js'\nimport type { SlateNodeConverter } from '../../types.js'\n\nexport const SlateUploadConverter: SlateNodeConverter = {\n  converter({ slateNode }) {\n    return {\n      type: 'upload',\n      fields: {\n        ...slateNode.fields,\n      },\n      format: '',\n      relationTo: slateNode.relationTo,\n      value: slateNode.value?.id || '',\n      version: 2,\n    } as const as SerializedUploadNode\n  },\n  nodeTypes: ['upload'],\n}\n"],"mappings":"AAGA,OAAO,MAAMA,oBAAA,GAA2C;EACtDC,UAAU;IAAEC;EAAS,CAAE;IACrB,OAAO;MACLC,IAAA,EAAM;MACNC,MAAA,EAAQ;QACN,GAAGF,SAAA,CAAUE;MACf;MACAC,MAAA,EAAQ;MACRC,UAAA,EAAYJ,SAAA,CAAUI,UAAU;MAChCC,KAAA,EAAOL,SAAA,CAAUK,KAAK,EAAEC,EAAA,IAAM;MAC9BC,OAAA,EAAS;IACX;EACF;EACAC,SAAA,EAAW,CAAC;AACd","ignoreList":[]}

package/dist/features/migrations/slateToLexical/converter/defaultConverters.d.ts

@@ -1,3 +0,0 @@
-import type { SlateNodeConverter } from './types.js';
-export declare const defaultSlateConverters: SlateNodeConverter[];
-//# sourceMappingURL=defaultConverters.d.ts.map

package/dist/features/migrations/slateToLexical/converter/defaultConverters.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"defaultConverters.d.ts","sourceRoot":"","sources":["../../../../../src/features/migrations/slateToLexical/converter/defaultConverters.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,YAAY,CAAA;AAapD,eAAO,MAAM,sBAAsB,EAAE,kBAAkB,EAWtD,CAAA"}

package/dist/features/migrations/slateToLexical/converter/defaultConverters.js

@@ -1,12 +0,0 @@
-import { SlateBlockquoteConverter } from './converters/blockquote/converter.js';
-import { SlateHeadingConverter } from './converters/heading/converter.js';
-import { SlateIndentConverter } from './converters/indent/converter.js';
-import { SlateLinkConverter } from './converters/link/converter.js';
-import { SlateListItemConverter } from './converters/listItem/converter.js';
-import { SlateOrderedListConverter } from './converters/orderedList/converter.js';
-import { SlateRelationshipConverter } from './converters/relationship/converter.js';
-import { SlateUnknownConverter } from './converters/unknown/converter.js';
-import { SlateUnorderedListConverter } from './converters/unorderedList/converter.js';
-import { SlateUploadConverter } from './converters/upload/converter.js';
-export const defaultSlateConverters = [SlateBlockquoteConverter, SlateHeadingConverter, SlateIndentConverter, SlateLinkConverter, SlateListItemConverter, SlateOrderedListConverter, SlateRelationshipConverter, SlateUnorderedListConverter, SlateUploadConverter, SlateUnknownConverter];
-//# sourceMappingURL=defaultConverters.js.map

package/dist/features/migrations/slateToLexical/converter/defaultConverters.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"defaultConverters.js","names":["SlateBlockquoteConverter","SlateHeadingConverter","SlateIndentConverter","SlateLinkConverter","SlateListItemConverter","SlateOrderedListConverter","SlateRelationshipConverter","SlateUnknownConverter","SlateUnorderedListConverter","SlateUploadConverter","defaultSlateConverters"],"sources":["../../../../../src/features/migrations/slateToLexical/converter/defaultConverters.ts"],"sourcesContent":["import type { SlateNodeConverter } from './types.js'\n\nimport { SlateBlockquoteConverter } from './converters/blockquote/converter.js'\nimport { SlateHeadingConverter } from './converters/heading/converter.js'\nimport { SlateIndentConverter } from './converters/indent/converter.js'\nimport { SlateLinkConverter } from './converters/link/converter.js'\nimport { SlateListItemConverter } from './converters/listItem/converter.js'\nimport { SlateOrderedListConverter } from './converters/orderedList/converter.js'\nimport { SlateRelationshipConverter } from './converters/relationship/converter.js'\nimport { SlateUnknownConverter } from './converters/unknown/converter.js'\nimport { SlateUnorderedListConverter } from './converters/unorderedList/converter.js'\nimport { SlateUploadConverter } from './converters/upload/converter.js'\n\nexport const defaultSlateConverters: SlateNodeConverter[] = [\n  SlateBlockquoteConverter,\n  SlateHeadingConverter,\n  SlateIndentConverter,\n  SlateLinkConverter,\n  SlateListItemConverter,\n  SlateOrderedListConverter,\n  SlateRelationshipConverter,\n  SlateUnorderedListConverter,\n  SlateUploadConverter,\n  SlateUnknownConverter,\n]\n"],"mappings":"AAEA,SAASA,wBAAwB,QAAQ;AACzC,SAASC,qBAAqB,QAAQ;AACtC,SAASC,oBAAoB,QAAQ;AACrC,SAASC,kBAAkB,QAAQ;AACnC,SAASC,sBAAsB,QAAQ;AACvC,SAASC,yBAAyB,QAAQ;AAC1C,SAASC,0BAA0B,QAAQ;AAC3C,SAASC,qBAAqB,QAAQ;AACtC,SAASC,2BAA2B,QAAQ;AAC5C,SAASC,oBAAoB,QAAQ;AAErC,OAAO,MAAMC,sBAAA,GAA+C,CAC1DV,wBAAA,EACAC,qBAAA,EACAC,oBAAA,EACAC,kBAAA,EACAC,sBAAA,EACAC,yBAAA,EACAC,0BAAA,EACAE,2BAAA,EACAC,oBAAA,EACAF,qBAAA,CACD","ignoreList":[]}

package/dist/features/migrations/slateToLexical/converter/index.d.ts

@@ -1,19 +0,0 @@
-import type { SerializedEditorState, SerializedLexicalNode, SerializedParagraphNode, SerializedTextNode } from 'lexical';
-import type { SlateNode, SlateNodeConverter } from './types.js';
-export declare function convertSlateToLexical({ converters, slateData, }: {
-    converters: SlateNodeConverter[];
-    slateData: SlateNode[];
-}): SerializedEditorState;
-export declare function convertSlateNodesToLexical({ canContainParagraphs, converters, parentNodeType, slateNodes, }: {
-    canContainParagraphs: boolean;
-    converters: SlateNodeConverter[] | undefined;
-    /**
-     * Type of the parent lexical node (not the type of the original, parent slate type)
-     */
-    parentNodeType: string;
-    slateNodes: SlateNode[];
-}): SerializedLexicalNode[];
-export declare function convertParagraphNode(converters: SlateNodeConverter[], node: SlateNode): SerializedParagraphNode;
-export declare function convertTextNode(node: SlateNode): SerializedTextNode;
-export declare function convertNodeToFormat(node: SlateNode): number;
-//# sourceMappingURL=index.d.ts.map

package/dist/features/migrations/slateToLexical/converter/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/features/migrations/slateToLexical/converter/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,qBAAqB,EACrB,qBAAqB,EACrB,uBAAuB,EACvB,kBAAkB,EACnB,MAAM,SAAS,CAAA;AAEhB,OAAO,KAAK,EAAE,SAAS,EAAE,kBAAkB,EAAE,MAAM,YAAY,CAAA;AAI/D,wBAAgB,qBAAqB,CAAC,EACpC,UAAU,EACV,SAAS,GACV,EAAE;IACD,UAAU,EAAE,kBAAkB,EAAE,CAAA;IAChC,SAAS,EAAE,SAAS,EAAE,CAAA;CACvB,GAAG,qBAAqB,CAgBxB;AAED,wBAAgB,0BAA0B,CAAC,EACzC,oBAAoB,EACpB,UAAU,EACV,cAAc,EACd,UAAU,GACX,EAAE;IACD,oBAAoB,EAAE,OAAO,CAAA;IAC7B,UAAU,EAAE,kBAAkB,EAAE,GAAG,SAAS,CAAA;IAC5C;;OAEG;IACH,cAAc,EAAE,MAAM,CAAA;IACtB,UAAU,EAAE,SAAS,EAAE,CAAA;CACxB,GAAG,qBAAqB,EAAE,CAiD1B;AAED,wBAAgB,oBAAoB,CAClC,UAAU,EAAE,kBAAkB,EAAE,EAChC,IAAI,EAAE,SAAS,GACd,uBAAuB,CAgBzB;AACD,wBAAgB,eAAe,CAAC,IAAI,EAAE,SAAS,GAAG,kBAAkB,CAUnE;AAED,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,SAAS,GAAG,MAAM,CAwB3D"}

package/dist/features/migrations/slateToLexical/converter/index.js

@@ -1,130 +0,0 @@
-import { NodeFormat } from '../../../../lexical/utils/nodeFormat.js';
-export function convertSlateToLexical({
-  converters,
-  slateData
-}) {
-  return {
-    root: {
-      type: 'root',
-      children: convertSlateNodesToLexical({
-        canContainParagraphs: true,
-        converters,
-        parentNodeType: 'root',
-        slateNodes: slateData
-      }),
-      direction: 'ltr',
-      format: '',
-      indent: 0,
-      version: 1
-    }
-  };
-}
-export function convertSlateNodesToLexical({
-  canContainParagraphs,
-  converters,
-  parentNodeType,
-  slateNodes
-}) {
-  if (!converters?.length || !slateNodes?.length) {
-    return [];
-  }
-  const unknownConverter = converters.find(converter => converter.nodeTypes.includes('unknown'));
-  // @ts-expect-error - vestiges of the migration to strict mode. Probably not important enough in this file to fix
-  return (
-    // Flatten in case we unwrap an array of child nodes
-    slateNodes.flatMap((slateNode, i) => {
-      if (!('type' in slateNode)) {
-        if (canContainParagraphs) {
-          // This is a paragraph node. They do not have a type property in Slate
-          return convertParagraphNode(converters, slateNode);
-        } else {
-          // Unwrap generic Slate nodes recursively since depth wasn't guaranteed by Slate, especially when copy + pasting rich text
-          // - If there are children and it can't be a paragraph in Lexical, assume that the generic node should be unwrapped until the text nodes, and only assume that its a text node when there are no more children
-          if (slateNode.children) {
-            return convertSlateNodesToLexical({
-              canContainParagraphs,
-              converters,
-              parentNodeType,
-              slateNodes: slateNode.children || []
-            });
-          }
-          // This is a simple text node. canContainParagraphs may be false if this is nested inside a paragraph already, since paragraphs cannot contain paragraphs
-          return convertTextNode(slateNode);
-        }
-      }
-      if (slateNode.type === 'p') {
-        return convertParagraphNode(converters, slateNode);
-      }
-      const converter = converters.find(converter => converter.nodeTypes.includes(slateNode.type));
-      if (converter) {
-        return converter.converter({
-          childIndex: i,
-          converters,
-          parentNodeType,
-          slateNode
-        });
-      }
-      console.warn('slateToLexical > No converter found for node type: ' + slateNode.type);
-      return unknownConverter?.converter({
-        childIndex: i,
-        converters,
-        parentNodeType,
-        slateNode
-      });
-    }) || []
-  );
-}
-export function convertParagraphNode(converters, node) {
-  return {
-    type: 'paragraph',
-    children: convertSlateNodesToLexical({
-      canContainParagraphs: false,
-      converters,
-      parentNodeType: 'paragraph',
-      slateNodes: node.children || []
-    }),
-    direction: 'ltr',
-    format: '',
-    indent: 0,
-    textFormat: 0,
-    textStyle: '',
-    version: 1
-  };
-}
-export function convertTextNode(node) {
-  return {
-    type: 'text',
-    detail: 0,
-    format: convertNodeToFormat(node),
-    mode: 'normal',
-    style: '',
-    text: node.text ?? '',
-    version: 1
-  };
-}
-export function convertNodeToFormat(node) {
-  let format = 0;
-  if (node.bold) {
-    format = format | NodeFormat.IS_BOLD;
-  }
-  if (node.italic) {
-    format = format | NodeFormat.IS_ITALIC;
-  }
-  if (node.strikethrough) {
-    format = format | NodeFormat.IS_STRIKETHROUGH;
-  }
-  if (node.underline) {
-    format = format | NodeFormat.IS_UNDERLINE;
-  }
-  if (node.subscript) {
-    format = format | NodeFormat.IS_SUBSCRIPT;
-  }
-  if (node.superscript) {
-    format = format | NodeFormat.IS_SUPERSCRIPT;
-  }
-  if (node.code) {
-    format = format | NodeFormat.IS_CODE;
-  }
-  return format;
-}
-//# sourceMappingURL=index.js.map

package/dist/features/migrations/slateToLexical/converter/index.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.js","names":["NodeFormat","convertSlateToLexical","converters","slateData","root","type","children","convertSlateNodesToLexical","canContainParagraphs","parentNodeType","slateNodes","direction","format","indent","version","length","unknownConverter","find","converter","nodeTypes","includes","flatMap","slateNode","i","convertParagraphNode","convertTextNode","childIndex","console","warn","node","textFormat","textStyle","detail","convertNodeToFormat","mode","style","text","bold","IS_BOLD","italic","IS_ITALIC","strikethrough","IS_STRIKETHROUGH","underline","IS_UNDERLINE","subscript","IS_SUBSCRIPT","superscript","IS_SUPERSCRIPT","code","IS_CODE"],"sources":["../../../../../src/features/migrations/slateToLexical/converter/index.ts"],"sourcesContent":["import type {\n  SerializedEditorState,\n  SerializedLexicalNode,\n  SerializedParagraphNode,\n  SerializedTextNode,\n} from 'lexical'\n\nimport type { SlateNode, SlateNodeConverter } from './types.js'\n\nimport { NodeFormat } from '../../../../lexical/utils/nodeFormat.js'\n\nexport function convertSlateToLexical({\n  converters,\n  slateData,\n}: {\n  converters: SlateNodeConverter[]\n  slateData: SlateNode[]\n}): SerializedEditorState {\n  return {\n    root: {\n      type: 'root',\n      children: convertSlateNodesToLexical({\n        canContainParagraphs: true,\n        converters,\n        parentNodeType: 'root',\n        slateNodes: slateData,\n      }),\n      direction: 'ltr',\n      format: '',\n      indent: 0,\n      version: 1,\n    },\n  }\n}\n\nexport function convertSlateNodesToLexical({\n  canContainParagraphs,\n  converters,\n  parentNodeType,\n  slateNodes,\n}: {\n  canContainParagraphs: boolean\n  converters: SlateNodeConverter[] | undefined\n  /**\n   * Type of the parent lexical node (not the type of the original, parent slate type)\n   */\n  parentNodeType: string\n  slateNodes: SlateNode[]\n}): SerializedLexicalNode[] {\n  if (!converters?.length || !slateNodes?.length) {\n    return []\n  }\n  const unknownConverter = converters.find((converter) => converter.nodeTypes.includes('unknown'))\n  // @ts-expect-error - vestiges of the migration to strict mode. Probably not important enough in this file to fix\n  return (\n    // Flatten in case we unwrap an array of child nodes\n    slateNodes.flatMap((slateNode, i) => {\n      if (!('type' in slateNode)) {\n        if (canContainParagraphs) {\n          // This is a paragraph node. They do not have a type property in Slate\n          return convertParagraphNode(converters, slateNode)\n        } else {\n          // Unwrap generic Slate nodes recursively since depth wasn't guaranteed by Slate, especially when copy + pasting rich text\n          // - If there are children and it can't be a paragraph in Lexical, assume that the generic node should be unwrapped until the text nodes, and only assume that its a text node when there are no more children\n          if (slateNode.children) {\n            return convertSlateNodesToLexical({\n              canContainParagraphs,\n              converters,\n              parentNodeType,\n              slateNodes: slateNode.children || [],\n            })\n          }\n          // This is a simple text node. canContainParagraphs may be false if this is nested inside a paragraph already, since paragraphs cannot contain paragraphs\n          return convertTextNode(slateNode)\n        }\n      }\n      if (slateNode.type === 'p') {\n        return convertParagraphNode(converters, slateNode)\n      }\n\n      const converter = converters.find((converter) =>\n        converter.nodeTypes.includes(slateNode.type!),\n      )\n\n      if (converter) {\n        return converter.converter({ childIndex: i, converters, parentNodeType, slateNode })\n      }\n\n      console.warn('slateToLexical > No converter found for node type: ' + slateNode.type)\n      return unknownConverter?.converter({\n        childIndex: i,\n        converters,\n        parentNodeType,\n        slateNode,\n      })\n    }) || []\n  )\n}\n\nexport function convertParagraphNode(\n  converters: SlateNodeConverter[],\n  node: SlateNode,\n): SerializedParagraphNode {\n  return {\n    type: 'paragraph',\n    children: convertSlateNodesToLexical({\n      canContainParagraphs: false,\n      converters,\n      parentNodeType: 'paragraph',\n      slateNodes: node.children || [],\n    }),\n    direction: 'ltr',\n    format: '',\n    indent: 0,\n    textFormat: 0,\n    textStyle: '',\n    version: 1,\n  }\n}\nexport function convertTextNode(node: SlateNode): SerializedTextNode {\n  return {\n    type: 'text',\n    detail: 0,\n    format: convertNodeToFormat(node),\n    mode: 'normal',\n    style: '',\n    text: node.text ?? '',\n    version: 1,\n  }\n}\n\nexport function convertNodeToFormat(node: SlateNode): number {\n  let format = 0\n  if (node.bold) {\n    format = format | NodeFormat.IS_BOLD\n  }\n  if (node.italic) {\n    format = format | NodeFormat.IS_ITALIC\n  }\n  if (node.strikethrough) {\n    format = format | NodeFormat.IS_STRIKETHROUGH\n  }\n  if (node.underline) {\n    format = format | NodeFormat.IS_UNDERLINE\n  }\n  if (node.subscript) {\n    format = format | NodeFormat.IS_SUBSCRIPT\n  }\n  if (node.superscript) {\n    format = format | NodeFormat.IS_SUPERSCRIPT\n  }\n  if (node.code) {\n    format = format | NodeFormat.IS_CODE\n  }\n  return format\n}\n"],"mappings":"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","ignoreList":[]}

package/dist/features/migrations/slateToLexical/converter/types.d.ts

@@ -1,16 +0,0 @@
-import type { SerializedLexicalNode } from 'lexical';
-export type SlateNodeConverter<T extends SerializedLexicalNode = SerializedLexicalNode> = {
-    converter: ({ childIndex, converters, parentNodeType, slateNode, }: {
-        childIndex: number;
-        converters: SlateNodeConverter[];
-        parentNodeType: string;
-        slateNode: SlateNode;
-    }) => T;
-    nodeTypes: string[];
-};
-export type SlateNode = {
-    [key: string]: any;
-    children?: SlateNode[];
-    type?: string;
-};
-//# sourceMappingURL=types.d.ts.map

package/dist/features/migrations/slateToLexical/converter/types.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../../src/features/migrations/slateToLexical/converter/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,SAAS,CAAA;AAEpD,MAAM,MAAM,kBAAkB,CAAC,CAAC,SAAS,qBAAqB,GAAG,qBAAqB,IAAI;IACxF,SAAS,EAAE,CAAC,EACV,UAAU,EACV,UAAU,EACV,cAAc,EACd,SAAS,GACV,EAAE;QACD,UAAU,EAAE,MAAM,CAAA;QAClB,UAAU,EAAE,kBAAkB,EAAE,CAAA;QAChC,cAAc,EAAE,MAAM,CAAA;QACtB,SAAS,EAAE,SAAS,CAAA;KACrB,KAAK,CAAC,CAAA;IACP,SAAS,EAAE,MAAM,EAAE,CAAA;CACpB,CAAA;AAED,MAAM,MAAM,SAAS,GAAG;IACtB,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,CAAA;IAClB,QAAQ,CAAC,EAAE,SAAS,EAAE,CAAA;IACtB,IAAI,CAAC,EAAE,MAAM,CAAA;CACd,CAAA"}

package/dist/features/migrations/slateToLexical/converter/types.js

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

package/dist/features/migrations/slateToLexical/converter/types.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"types.js","names":[],"sources":["../../../../../src/features/migrations/slateToLexical/converter/types.ts"],"sourcesContent":["import type { SerializedLexicalNode } from 'lexical'\n\nexport type SlateNodeConverter<T extends SerializedLexicalNode = SerializedLexicalNode> = {\n  converter: ({\n    childIndex,\n    converters,\n    parentNodeType,\n    slateNode,\n  }: {\n    childIndex: number\n    converters: SlateNodeConverter[]\n    parentNodeType: string\n    slateNode: SlateNode\n  }) => T\n  nodeTypes: string[]\n}\n\nexport type SlateNode = {\n  [key: string]: any\n  children?: SlateNode[]\n  type?: string // doesn't always have type, e.g. for paragraphs\n}\n"],"mappings":"AAiBA","ignoreList":[]}

package/dist/features/migrations/slateToLexical/feature.client.d.ts

@@ -1,2 +0,0 @@
-export declare const SlateToLexicalFeatureClient: import("../../typesClient.js").FeatureProviderProviderClient<undefined, undefined>;
-//# sourceMappingURL=feature.client.d.ts.map

package/dist/features/migrations/slateToLexical/feature.client.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"feature.client.d.ts","sourceRoot":"","sources":["../../../../src/features/migrations/slateToLexical/feature.client.tsx"],"names":[],"mappings":"AAKA,eAAO,MAAM,2BAA2B,oFAItC,CAAA"}

package/dist/features/migrations/slateToLexical/feature.client.js

@@ -1,10 +0,0 @@
-'use client';
-
-import { createClientFeature } from '../../../utilities/createClientFeature.js';
-import { UnknownConvertedNode } from './nodes/unknownConvertedNode/index.js';
-export const SlateToLexicalFeatureClient = createClientFeature(() => {
-  return {
-    nodes: [UnknownConvertedNode]
-  };
-});
-//# sourceMappingURL=feature.client.js.map

package/dist/features/migrations/slateToLexical/feature.client.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"feature.client.js","names":["createClientFeature","UnknownConvertedNode","SlateToLexicalFeatureClient","nodes"],"sources":["../../../../src/features/migrations/slateToLexical/feature.client.tsx"],"sourcesContent":["'use client'\n\nimport { createClientFeature } from '../../../utilities/createClientFeature.js'\nimport { UnknownConvertedNode } from './nodes/unknownConvertedNode/index.js'\n\nexport const SlateToLexicalFeatureClient = createClientFeature(() => {\n  return {\n    nodes: [UnknownConvertedNode],\n  }\n})\n"],"mappings":"AAAA;;AAEA,SAASA,mBAAmB,QAAQ;AACpC,SAASC,oBAAoB,QAAQ;AAErC,OAAO,MAAMC,2BAAA,GAA8BF,mBAAA,CAAoB;EAC7D,OAAO;IACLG,KAAA,EAAO,CAACF,oBAAA;EACV;AACF","ignoreList":[]}

package/dist/features/migrations/slateToLexical/feature.server.d.ts

@@ -1,40 +0,0 @@
-import type { SlateNodeConverter } from './converter/types.js';
-export type SlateToLexicalFeatureProps = {
-    /**
-     * Custom converters to transform Slate nodes to Lexical nodes.
-     * Can be an array of converters or a function that receives default converters and returns an array.
-     * @default defaultSlateConverters
-     */
-    converters?: (({ defaultConverters }: {
-        defaultConverters: SlateNodeConverter[];
-    }) => SlateNodeConverter[]) | SlateNodeConverter[];
-    /**
-     * When true, disables the afterRead hook that converts Slate data on-the-fly.
-     * Set this to true when running the migration script. That way, this feature is only used
-     * to "pass through" the converters to the migration script.
-     * @default false
-     */
-    disableHooks?: boolean;
-};
-/**
- * Enables on-the-fly conversion of Slate data to Lexical format through an afterRead hook.
- * Used for testing migrations before running the permanent migration script.
- * Only converts data that is in Slate format (arrays); Lexical data passes through unchanged.
- *
- * @example
- * ```ts
- * lexicalEditor({
- *   features: ({ defaultFeatures }) => [
- *     ...defaultFeatures,
- *     SlateToLexicalFeature({
- *       converters: [...defaultSlateConverters, MyCustomConverter],
- *       disableHooks: false, // Set to true during migration script
- *     }),
- *   ],
- * })
- * ```
- */
-export declare const SlateToLexicalFeature: import("../../typesServer.js").FeatureProviderProviderServer<SlateToLexicalFeatureProps, {
-    converters?: SlateNodeConverter[];
-}, undefined>;
-//# sourceMappingURL=feature.server.d.ts.map

package/dist/features/migrations/slateToLexical/feature.server.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"feature.server.d.ts","sourceRoot":"","sources":["../../../../src/features/migrations/slateToLexical/feature.server.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,CAAA;AAO9D,MAAM,MAAM,0BAA0B,GAAG;IACvC;;;;OAIG;IACH,UAAU,CAAC,EACP,CAAC,CAAC,EAAE,iBAAiB,EAAE,EAAE;QAAE,iBAAiB,EAAE,kBAAkB,EAAE,CAAA;KAAE,KAAK,kBAAkB,EAAE,CAAC,GAC9F,kBAAkB,EAAE,CAAA;IACxB;;;;;OAKG;IACH,YAAY,CAAC,EAAE,OAAO,CAAA;CACvB,CAAA;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,eAAO,MAAM,qBAAqB;iBAGjB,kBAAkB,EAAE;aAkDnC,CAAA"}