npm - @payloadcms/richtext-lexical - Versions diffs - 3.0.0-beta.52 → 3.0.0-beta.53 - Mend

@payloadcms/richtext-lexical 3.0.0-beta.52 → 3.0.0-beta.53

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (1958) hide show

package/dist/features/migrations/lexicalPluginToLexical/feature.client.js.map ADDED Viewed

@@ -0,0 +1 @@

+ {"version":3,"sources":["../../../../src/features/migrations/lexicalPluginToLexical/feature.client.tsx"],"sourcesContent":["'use client'\n\nimport type { FeatureProviderProviderClient } from '../../types.js'\nimport type { LexicalPluginNodeConverter, PayloadPluginLexicalData } from './converter/types.js'\n\nimport { createClientComponent } from '../../createClientComponent.js'\nimport { convertLexicalPluginToLexical } from './converter/index.js'\nimport { UnknownConvertedNode } from './nodes/unknownConvertedNode/index.js'\n\nconst LexicalPluginToLexicalFeatureClient: FeatureProviderProviderClient<null> = (props) => {\n return {\n clientFeatureProps: props,\n feature: ({ clientFunctions, resolvedFeatures }) => {\n const converters: LexicalPluginNodeConverter[] = Object.values(clientFunctions)\n\n return {\n clientFeatureProps: props,\n hooks: {\n load({ incomingEditorState }) {\n if (!incomingEditorState || !('jsonContent' in incomingEditorState)) {\n // incomingEditorState null or not from Lexical Plugin\n return incomingEditorState\n }\n // Lexical Plugin => convert to lexical\n\n return convertLexicalPluginToLexical({\n converters,\n lexicalPluginData: incomingEditorState as unknown as PayloadPluginLexicalData,\n })\n },\n },\n nodes: [UnknownConvertedNode],\n }\n },\n }\n}\n\nexport const LexicalPluginToLexicalFeatureClientComponent = createClientComponent(\n LexicalPluginToLexicalFeatureClient,\n)\n"],"names":["createClientComponent","convertLexicalPluginToLexical","UnknownConvertedNode","LexicalPluginToLexicalFeatureClient","props","clientFeatureProps","feature","clientFunctions","resolvedFeatures","converters","Object","values","hooks","load","incomingEditorState","lexicalPluginData","nodes","LexicalPluginToLexicalFeatureClientComponent"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"AAAA;AAKA,SAASA,qBAAqB,QAAQ,iCAAgC;AACtE,SAASC,6BAA6B,QAAQ,uBAAsB;AACpE,SAASC,oBAAoB,QAAQ,wCAAuC;AAE5E,MAAMC,sCAA2E,CAACC;IAChF,OAAO;QACLC,oBAAoBD;QACpBE,SAAS,CAAC,EAAEC,eAAe,EAAEC,gBAAgB,EAAE;YAC7C,MAAMC,aAA2CC,OAAOC,MAAM,CAACJ;YAE/D,OAAO;gBACLF,oBAAoBD;gBACpBQ,OAAO;oBACLC,MAAK,EAAEC,mBAAmB,EAAE;wBAC1B,IAAI,CAACA,uBAAuB,CAAE,CAAA,iBAAiBA,mBAAkB,GAAI;4BACnE,sDAAsD;4BACtD,OAAOA;wBACT;wBACA,uCAAuC;wBAEvC,OAAOb,8BAA8B;4BACnCQ;4BACAM,mBAAmBD;wBACrB;oBACF;gBACF;gBACAE,OAAO;oBAACd;iBAAqB;YAC/B;QACF;IACF;AACF;AAEA,OAAO,MAAMe,+CAA+CjB,sBAC1DG,qCACD"}

package/dist/features/migrations/lexicalPluginToLexical/feature.server.d.ts.map ADDED Viewed

@@ -0,0 +1 @@

+ {"version":3,"file":"feature.server.d.ts","sourceRoot":"","sources":["../../../../src/features/migrations/lexicalPluginToLexical/feature.server.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,6BAA6B,EAAE,MAAM,gBAAgB,CAAA;AACnE,OAAO,KAAK,EAAE,kCAAkC,EAAE,MAAM,sBAAsB,CAAA;AAO9E,MAAM,MAAM,kCAAkC,GAAG;IAC/C,UAAU,CAAC,EACP,CAAC,CAAC,EACA,iBAAiB,GAClB,EAAE;QACD,iBAAiB,EAAE,kCAAkC,EAAE,CAAA;KACxD,KAAK,kCAAkC,EAAE,CAAC,GAC3C,kCAAkC,EAAE,CAAA;CACzC,CAAA;AAED,eAAO,MAAM,6BAA6B,EAAE,6BAA6B,CACvE,kCAAkC,EAClC,IAAI,CAgDL,CAAA"}

package/dist/features/migrations/lexicalPluginToLexical/feature.server.js ADDED Viewed

@@ -0,0 +1,48 @@
+// eslint-disable-next-line payload/no-imports-from-exports-dir
+import { LexicalPluginToLexicalFeatureClientComponent } from '../../../exports/client/index.js';
+import { defaultConverters } from './converter/defaultConverters.js';
+import { UnknownConvertedNode } from './nodes/unknownConvertedNode/index.js';
+export const LexicalPluginToLexicalFeature = (props)=>{
+    if (!props) {
+        props = {};
+    }
+    let converters = [];
+    if (props?.converters && typeof props?.converters === 'function') {
+        converters = props.converters({
+            defaultConverters
+        });
+    } else if (props.converters && typeof props?.converters !== 'function') {
+        converters = props.converters;
+    } else {
+        converters = defaultConverters;
+    }
+    props.converters = converters;
+    return {
+        feature: ()=>{
+            return {
+                ClientComponent: LexicalPluginToLexicalFeatureClientComponent,
+                clientFeatureProps: null,
+                generateComponentMap: ()=>{
+                    const map = {};
+                    for (const converter of converters){
+                        if (converter.ClientComponent) {
+                            const key = converter.converter.nodeTypes.join('-');
+                            map[key] = converter.ClientComponent;
+                        }
+                    }
+                    return map;
+                },
+                nodes: [
+                    {
+                        node: UnknownConvertedNode
+                    }
+                ],
+                serverFeatureProps: props
+            };
+        },
+        key: 'lexicalPluginToLexical',
+        serverFeatureProps: props
+    };
+};
+//# sourceMappingURL=feature.server.js.map

package/dist/features/migrations/lexicalPluginToLexical/feature.server.js.map ADDED Viewed

@@ -0,0 +1 @@

+ {"version":3,"sources":["../../../../src/features/migrations/lexicalPluginToLexical/feature.server.ts"],"sourcesContent":["import type React from 'react'\n\nimport type { FeatureProviderProviderServer } from '../../types.js'\nimport type { LexicalPluginNodeConverterProvider } from './converter/types.js'\n\n// eslint-disable-next-line payload/no-imports-from-exports-dir\nimport { LexicalPluginToLexicalFeatureClientComponent } from '../../../exports/client/index.js'\nimport { defaultConverters } from './converter/defaultConverters.js'\nimport { UnknownConvertedNode } from './nodes/unknownConvertedNode/index.js'\n\nexport type LexicalPluginToLexicalFeatureProps = {\n converters?:\n | (({\n defaultConverters,\n }: {\n defaultConverters: LexicalPluginNodeConverterProvider[]\n }) => LexicalPluginNodeConverterProvider[])\n | LexicalPluginNodeConverterProvider[]\n}\n\nexport const LexicalPluginToLexicalFeature: FeatureProviderProviderServer<\n LexicalPluginToLexicalFeatureProps,\n null\n> = (props) => {\n if (!props) {\n props = {}\n }\n\n let converters: LexicalPluginNodeConverterProvider[] = []\n\n if (props?.converters && typeof props?.converters === 'function') {\n converters = props.converters({ defaultConverters })\n } else if (props.converters && typeof props?.converters !== 'function') {\n converters = props.converters\n } else {\n converters = defaultConverters\n }\n\n props.converters = converters\n\n return {\n feature: () => {\n return {\n ClientComponent: LexicalPluginToLexicalFeatureClientComponent,\n clientFeatureProps: null,\n generateComponentMap: () => {\n const map: {\n [key: string]: React.FC\n } = {}\n\n for (const converter of converters) {\n if (converter.ClientComponent) {\n const key = converter.converter.nodeTypes.join('-')\n map[key] = converter.ClientComponent\n }\n }\n\n return map\n },\n nodes: [\n {\n node: UnknownConvertedNode,\n },\n ],\n serverFeatureProps: props,\n }\n },\n key: 'lexicalPluginToLexical',\n serverFeatureProps: props,\n }\n}\n"],"names":["LexicalPluginToLexicalFeatureClientComponent","defaultConverters","UnknownConvertedNode","LexicalPluginToLexicalFeature","props","converters","feature","ClientComponent","clientFeatureProps","generateComponentMap","map","converter","key","nodeTypes","join","nodes","node","serverFeatureProps"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"AAKA,+DAA+D;AAC/D,SAASA,4CAA4C,QAAQ,mCAAkC;AAC/F,SAASC,iBAAiB,QAAQ,mCAAkC;AACpE,SAASC,oBAAoB,QAAQ,wCAAuC;AAY5E,OAAO,MAAMC,gCAGT,CAACC;IACH,IAAI,CAACA,OAAO;QACVA,QAAQ,CAAC;IACX;IAEA,IAAIC,aAAmD,EAAE;IAEzD,IAAID,OAAOC,cAAc,OAAOD,OAAOC,eAAe,YAAY;QAChEA,aAAaD,MAAMC,UAAU,CAAC;YAAEJ;QAAkB;IACpD,OAAO,IAAIG,MAAMC,UAAU,IAAI,OAAOD,OAAOC,eAAe,YAAY;QACtEA,aAAaD,MAAMC,UAAU;IAC/B,OAAO;QACLA,aAAaJ;IACf;IAEAG,MAAMC,UAAU,GAAGA;IAEnB,OAAO;QACLC,SAAS;YACP,OAAO;gBACLC,iBAAiBP;gBACjBQ,oBAAoB;gBACpBC,sBAAsB;oBACpB,MAAMC,MAEF,CAAC;oBAEL,KAAK,MAAMC,aAAaN,WAAY;wBAClC,IAAIM,UAAUJ,eAAe,EAAE;4BAC7B,MAAMK,MAAMD,UAAUA,SAAS,CAACE,SAAS,CAACC,IAAI,CAAC;4BAC/CJ,GAAG,CAACE,IAAI,GAAGD,UAAUJ,eAAe;wBACtC;oBACF;oBAEA,OAAOG;gBACT;gBACAK,OAAO;oBACL;wBACEC,MAAMd;oBACR;iBACD;gBACDe,oBAAoBb;YACtB;QACF;QACAQ,KAAK;QACLK,oBAAoBb;IACtB;AACF,EAAC"}

package/dist/features/migrations/lexicalPluginToLexical/nodes/unknownConvertedNode/Component.d.ts.map ADDED Viewed

@@ -0,0 +1 @@

+ {"version":3,"file":"Component.d.ts","sourceRoot":"","sources":["../../../../../../src/features/migrations/lexicalPluginToLexical/nodes/unknownConvertedNode/Component.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,OAAO,CAAA;AAEzB,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,YAAY,CAAA;AAE1D,OAAO,cAAc,CAAA;AAErB,KAAK,KAAK,GAAG;IACX,IAAI,EAAE,wBAAwB,CAAA;CAC/B,CAAA;AAED,eAAO,MAAM,6BAA6B,EAAE,KAAK,CAAC,EAAE,CAAC,KAAK,CAQzD,CAAA"}

package/dist/features/migrations/lexicalPluginToLexical/nodes/unknownConvertedNode/Component.js.map ADDED Viewed

@@ -0,0 +1 @@

+ {"version":3,"sources":["../../../../../../src/features/migrations/lexicalPluginToLexical/nodes/unknownConvertedNode/Component.tsx"],"sourcesContent":["import React from 'react'\n\nimport type { UnknownConvertedNodeData } from './index.js'\n\nimport './index.scss'\n\ntype Props = {\n data: UnknownConvertedNodeData\n}\n\nexport const UnknownConvertedNodeComponent: React.FC<Props> = (props) => {\n const { data } = props\n\n return (\n <div>\n Unknown converted payload-plugin-lexical node: <strong>{data?.nodeType}</strong>\n </div>\n )\n}\n"],"names":["React","UnknownConvertedNodeComponent","props","data","div","strong","nodeType"],"rangeMappings":";;;;;;;;;;;;","mappings":";AAAA,OAAOA,WAAW,QAAO;AAUzB,OAAO,MAAMC,gCAAiD,CAACC;IAC7D,MAAM,EAAEC,IAAI,EAAE,GAAGD;IAEjB,qBACE,MAACE;;YAAI;0BAC4C,KAACC;0BAAQF,MAAMG;;;;AAGpE,EAAC"}

package/dist/features/migrations/lexicalPluginToLexical/nodes/unknownConvertedNode/index.d.ts.map ADDED Viewed

@@ -0,0 +1 @@

+ {"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../src/features/migrations/lexicalPluginToLexical/nodes/unknownConvertedNode/index.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,WAAW,EAAE,OAAO,EAAE,qBAAqB,EAAE,MAAM,EAAE,MAAM,SAAS,CAAA;AAChG,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,OAAO,CAAA;AAGhC,OAAO,EAAE,aAAa,EAAE,MAAM,SAAS,CAAA;AAGvC,MAAM,MAAM,wBAAwB,GAAG;IACrC,QAAQ,EAAE,OAAO,CAAA;IACjB,QAAQ,EAAE,MAAM,CAAA;CACjB,CAAA;AAED,MAAM,MAAM,8BAA8B,GAAG,MAAM,CACjD;IACE,IAAI,EAAE,wBAAwB,CAAA;CAC/B,EACD,qBAAqB,CACtB,CAAA;AAQD,oBAAoB;AACpB,qBAAa,oBAAqB,SAAQ,aAAa,CAAC,GAAG,CAAC,OAAO,CAAC;IAClE,MAAM,EAAE,wBAAwB,CAAA;gBAEpB,EAAE,IAAI,EAAE,GAAG,EAAE,EAAE;QAAE,IAAI,EAAE,wBAAwB,CAAC;QAAC,GAAG,CAAC,EAAE,OAAO,CAAA;KAAE;IAK5E,MAAM,CAAC,KAAK,CAAC,IAAI,EAAE,oBAAoB,GAAG,oBAAoB;IAO9D,MAAM,CAAC,OAAO,IAAI,MAAM;IAIxB,MAAM,CAAC,UAAU,CAAC,cAAc,EAAE,8BAA8B,GAAG,oBAAoB;IAKvF,kBAAkB,IAAI,IAAI;IAI1B,mBAAmB,IAAI,IAAI;IAI3B,SAAS,CAAC,MAAM,EAAE,YAAY,GAAG,WAAW;IAM5C,QAAQ,IAAI,GAAG,CAAC,OAAO,GAAG,IAAI;IAI9B,UAAU,IAAI,8BAA8B;IAU5C,QAAQ,IAAI,OAAO;IAInB,SAAS,CAAC,QAAQ,EAAE,oBAAoB,EAAE,GAAG,EAAE,WAAW,GAAG,OAAO;CAGrE;AAED,wBAAgB,2BAA2B,CAAC,EAC1C,IAAI,GACL,EAAE;IACD,IAAI,EAAE,wBAAwB,CAAA;CAC/B,GAAG,oBAAoB,CAIvB;AAED,wBAAgB,uBAAuB,CACrC,IAAI,EAAE,WAAW,GAAG,IAAI,GAAG,SAAS,GACnC,IAAI,IAAI,oBAAoB,CAE9B"}

package/dist/features/migrations/lexicalPluginToLexical/nodes/unknownConvertedNode/index.js.map ADDED Viewed

@@ -0,0 +1 @@

+ {"version":3,"sources":["../../../../../../src/features/migrations/lexicalPluginToLexical/nodes/unknownConvertedNode/index.tsx"],"sourcesContent":["import type { EditorConfig, LexicalNode, NodeKey, SerializedLexicalNode, Spread } from 'lexical'\nimport type { JSX } from 'react'\n\nimport { addClassNamesToElement } from '@lexical/utils'\nimport { DecoratorNode } from 'lexical'\nimport * as React from 'react'\n\nexport type UnknownConvertedNodeData = {\n nodeData: unknown\n nodeType: string\n}\n\nexport type SerializedUnknownConvertedNode = Spread<\n {\n data: UnknownConvertedNodeData\n },\n SerializedLexicalNode\n>\n\nconst Component = React.lazy(() =>\n import('./Component.js').then((module) => ({\n default: module.UnknownConvertedNodeComponent,\n })),\n)\n\n/** @noInheritDoc */\nexport class UnknownConvertedNode extends DecoratorNode<JSX.Element> {\n __data: UnknownConvertedNodeData\n\n constructor({ data, key }: { data: UnknownConvertedNodeData; key?: NodeKey }) {\n super(key)\n this.__data = data\n }\n\n static clone(node: UnknownConvertedNode): UnknownConvertedNode {\n return new UnknownConvertedNode({\n data: node.__data,\n key: node.__key,\n })\n }\n\n static getType(): string {\n return 'unknownConverted'\n }\n\n static importJSON(serializedNode: SerializedUnknownConvertedNode): UnknownConvertedNode {\n const node = $createUnknownConvertedNode({ data: serializedNode.data })\n return node\n }\n\n canInsertTextAfter(): true {\n return true\n }\n\n canInsertTextBefore(): true {\n return true\n }\n\n createDOM(config: EditorConfig): HTMLElement {\n const element = document.createElement('span')\n addClassNamesToElement(element, 'unknownConverted')\n return element\n }\n\n decorate(): JSX.Element | null {\n return <Component data={this.__data} />\n }\n\n exportJSON(): SerializedUnknownConvertedNode {\n return {\n type: this.getType(),\n data: this.__data,\n version: 1,\n }\n }\n\n // Mutation\n\n isInline(): boolean {\n return true\n }\n\n updateDOM(prevNode: UnknownConvertedNode, dom: HTMLElement): boolean {\n return false\n }\n}\n\nexport function $createUnknownConvertedNode({\n data,\n}: {\n data: UnknownConvertedNodeData\n}): UnknownConvertedNode {\n return new UnknownConvertedNode({\n data,\n })\n}\n\nexport function $isUnknownConvertedNode(\n node: LexicalNode | null | undefined,\n): node is UnknownConvertedNode {\n return node instanceof UnknownConvertedNode\n}\n"],"names":["addClassNamesToElement","DecoratorNode","React","Component","lazy","then","module","default","UnknownConvertedNodeComponent","UnknownConvertedNode","__data","constructor","data","key","clone","node","__key","getType","importJSON","serializedNode","$createUnknownConvertedNode","canInsertTextAfter","canInsertTextBefore","createDOM","config","element","document","createElement","decorate","exportJSON","type","version","isInline","updateDOM","prevNode","dom","$isUnknownConvertedNode"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":";AAGA,SAASA,sBAAsB,QAAQ,iBAAgB;AACvD,SAASC,aAAa,QAAQ,UAAS;AACvC,YAAYC,WAAW,QAAO;AAc9B,MAAMC,0BAAYD,MAAME,IAAI,CAAC,IAC3B,MAAM,CAAC,kBAAkBC,IAAI,CAAC,CAACC,SAAY,CAAA;YACzCC,SAASD,OAAOE,6BAA6B;QAC/C,CAAA;AAGF,kBAAkB,GAClB,OAAO,MAAMC,6BAA6BR;IACxCS,OAAgC;IAEhCC,YAAY,EAAEC,IAAI,EAAEC,GAAG,EAAqD,CAAE;QAC5E,KAAK,CAACA;QACN,IAAI,CAACH,MAAM,GAAGE;IAChB;IAEA,OAAOE,MAAMC,IAA0B,EAAwB;QAC7D,OAAO,IAAIN,qBAAqB;YAC9BG,MAAMG,KAAKL,MAAM;YACjBG,KAAKE,KAAKC,KAAK;QACjB;IACF;IAEA,OAAOC,UAAkB;QACvB,OAAO;IACT;IAEA,OAAOC,WAAWC,cAA8C,EAAwB;QACtF,MAAMJ,OAAOK,4BAA4B;YAAER,MAAMO,eAAeP,IAAI;QAAC;QACrE,OAAOG;IACT;IAEAM,qBAA2B;QACzB,OAAO;IACT;IAEAC,sBAA4B;QAC1B,OAAO;IACT;IAEAC,UAAUC,MAAoB,EAAe;QAC3C,MAAMC,UAAUC,SAASC,aAAa,CAAC;QACvC3B,uBAAuByB,SAAS;QAChC,OAAOA;IACT;IAEAG,WAA+B;QAC7B,qBAAO,KAACzB;YAAUS,MAAM,IAAI,CAACF,MAAM;;IACrC;IAEAmB,aAA6C;QAC3C,OAAO;YACLC,MAAM,IAAI,CAACb,OAAO;YAClBL,MAAM,IAAI,CAACF,MAAM;YACjBqB,SAAS;QACX;IACF;IAEA,WAAW;IAEXC,WAAoB;QAClB,OAAO;IACT;IAEAC,UAAUC,QAA8B,EAAEC,GAAgB,EAAW;QACnE,OAAO;IACT;AACF;AAEA,OAAO,SAASf,4BAA4B,EAC1CR,IAAI,EAGL;IACC,OAAO,IAAIH,qBAAqB;QAC9BG;IACF;AACF;AAEA,OAAO,SAASwB,wBACdrB,IAAoC;IAEpC,OAAOA,gBAAgBN;AACzB"}

package/dist/features/migrations/slateToLexical/converter/converters/blockquote/client.d.ts.map ADDED Viewed

	@@ -0,0 +1 @@
1	+ {"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../../../../../../../src/features/migrations/slateToLexical/converter/converters/blockquote/client.ts"],"names":[],"mappings":";AAKA,eAAO,MAAM,yBAAyB;;;EAAwD,CAAA"}

package/dist/features/migrations/slateToLexical/converter/converters/blockquote/client.js.map ADDED Viewed

@@ -0,0 +1 @@

+ {"version":3,"sources":["../../../../../../../src/features/migrations/slateToLexical/converter/converters/blockquote/client.ts"],"sourcesContent":["'use client'\n\nimport { createFeaturePropComponent } from '../../../../../createFeaturePropComponent.js'\nimport { _SlateBlockquoteConverter } from './converter.js'\n\nexport const BlockquoteConverterClient = createFeaturePropComponent(_SlateBlockquoteConverter)\n"],"names":["createFeaturePropComponent","_SlateBlockquoteConverter","BlockquoteConverterClient"],"rangeMappings":";;;","mappings":"AAAA;AAEA,SAASA,0BAA0B,QAAQ,+CAA8C;AACzF,SAASC,yBAAyB,QAAQ,iBAAgB;AAE1D,OAAO,MAAMC,4BAA4BF,2BAA2BC,2BAA0B"}

package/dist/features/migrations/slateToLexical/converter/converters/blockquote/converter.d.ts.map ADDED Viewed

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

package/dist/features/migrations/slateToLexical/converter/converters/blockquote/converter.js.map ADDED Viewed

@@ -0,0 +1 @@

+ {"version":3,"sources":["../../../../../../../src/features/migrations/slateToLexical/converter/converters/blockquote/converter.ts"],"sourcesContent":["import type { SerializedQuoteNode } from '@lexical/rich-text'\n\nimport type { SlateNodeConverter } from '../../types.js'\n\nimport { convertSlateNodesToLexical } from '../../index.js'\n\nexport const _SlateBlockquoteConverter: SlateNodeConverter = {\n converter({ converters, slateNode }) {\n return {\n type: 'quote',\n children: convertSlateNodesToLexical({\n canContainParagraphs: false,\n converters,\n parentNodeType: 'quote',\n slateNodes: slateNode.children,\n }),\n direction: 'ltr',\n format: '',\n indent: 0,\n version: 1,\n } as const as SerializedQuoteNode\n },\n nodeTypes: ['blockquote'],\n}\n"],"names":["convertSlateNodesToLexical","_SlateBlockquoteConverter","converter","converters","slateNode","type","children","canContainParagraphs","parentNodeType","slateNodes","direction","format","indent","version","nodeTypes"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;","mappings":"AAIA,SAASA,0BAA0B,QAAQ,iBAAgB;AAE3D,OAAO,MAAMC,4BAAgD;IAC3DC,WAAU,EAAEC,UAAU,EAAEC,SAAS,EAAE;QACjC,OAAO;YACLC,MAAM;YACNC,UAAUN,2BAA2B;gBACnCO,sBAAsB;gBACtBJ;gBACAK,gBAAgB;gBAChBC,YAAYL,UAAUE,QAAQ;YAChC;YACAI,WAAW;YACXC,QAAQ;YACRC,QAAQ;YACRC,SAAS;QACX;IACF;IACAC,WAAW;QAAC;KAAa;AAC3B,EAAC"}

package/dist/features/migrations/slateToLexical/converter/converters/blockquote/index.d.ts.map ADDED Viewed

	@@ -0,0 +1 @@
1	+ {"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../../src/features/migrations/slateToLexical/converter/converters/blockquote/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,gBAAgB,CAAA;AAKhE,eAAO,MAAM,wBAAwB,EAAE,0BAGtC,CAAA"}

package/dist/features/migrations/slateToLexical/converter/converters/blockquote/index.js.map ADDED Viewed

@@ -0,0 +1 @@

+ {"version":3,"sources":["../../../../../../../src/features/migrations/slateToLexical/converter/converters/blockquote/index.ts"],"sourcesContent":["import type { SlateNodeConverterProvider } from '../../types.js'\n\nimport { BlockquoteConverterClient } from './client.js'\nimport { _SlateBlockquoteConverter } from './converter.js'\n\nexport const SlateBlockquoteConverter: SlateNodeConverterProvider = {\n ClientComponent: BlockquoteConverterClient,\n converter: _SlateBlockquoteConverter,\n}\n"],"names":["BlockquoteConverterClient","_SlateBlockquoteConverter","SlateBlockquoteConverter","ClientComponent","converter"],"rangeMappings":";;;;;","mappings":"AAEA,SAASA,yBAAyB,QAAQ,cAAa;AACvD,SAASC,yBAAyB,QAAQ,iBAAgB;AAE1D,OAAO,MAAMC,2BAAuD;IAClEC,iBAAiBH;IACjBI,WAAWH;AACb,EAAC"}

package/dist/features/migrations/slateToLexical/converter/converters/heading/client.d.ts.map ADDED Viewed

	@@ -0,0 +1 @@
1	+ {"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../../../../../../../src/features/migrations/slateToLexical/converter/converters/heading/client.ts"],"names":[],"mappings":";AAIA,eAAO,MAAM,sBAAsB;;;EAAqD,CAAA"}

package/dist/features/migrations/slateToLexical/converter/converters/heading/client.js.map ADDED Viewed

@@ -0,0 +1 @@

+ {"version":3,"sources":["../../../../../../../src/features/migrations/slateToLexical/converter/converters/heading/client.ts"],"sourcesContent":["'use client'\nimport { createFeaturePropComponent } from '../../../../../createFeaturePropComponent.js'\nimport { _SlateHeadingConverter } from './converter.js'\n\nexport const HeadingConverterClient = createFeaturePropComponent(_SlateHeadingConverter)\n"],"names":["createFeaturePropComponent","_SlateHeadingConverter","HeadingConverterClient"],"rangeMappings":";;;","mappings":"AAAA;AACA,SAASA,0BAA0B,QAAQ,+CAA8C;AACzF,SAASC,sBAAsB,QAAQ,iBAAgB;AAEvD,OAAO,MAAMC,yBAAyBF,2BAA2BC,wBAAuB"}

package/dist/features/migrations/slateToLexical/converter/converters/heading/converter.d.ts.map ADDED Viewed

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

package/dist/features/migrations/slateToLexical/converter/converters/heading/converter.js.map ADDED Viewed

@@ -0,0 +1 @@

+ {"version":3,"sources":["../../../../../../../src/features/migrations/slateToLexical/converter/converters/heading/converter.ts"],"sourcesContent":["import type { SerializedHeadingNode } from '@lexical/rich-text'\n\nimport type { SlateNodeConverter } from '../../types.js'\n\nimport { convertSlateNodesToLexical } from '../../index.js'\n\nexport const _SlateHeadingConverter: SlateNodeConverter = {\n converter({ converters, slateNode }) {\n return {\n type: 'heading',\n children: convertSlateNodesToLexical({\n canContainParagraphs: false,\n converters,\n parentNodeType: 'heading',\n slateNodes: slateNode.children,\n }),\n direction: 'ltr',\n format: '',\n indent: 0,\n tag: slateNode.type as 'h1' | 'h2' | 'h3' | 'h4' | 'h5' | 'h6', // Slate puts the tag (h1 / h2 / ...) inside of node.type\n version: 1,\n } as const as SerializedHeadingNode\n },\n nodeTypes: ['h1', 'h2', 'h3', 'h4', 'h5', 'h6'],\n}\n"],"names":["convertSlateNodesToLexical","_SlateHeadingConverter","converter","converters","slateNode","type","children","canContainParagraphs","parentNodeType","slateNodes","direction","format","indent","tag","version","nodeTypes"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"AAIA,SAASA,0BAA0B,QAAQ,iBAAgB;AAE3D,OAAO,MAAMC,yBAA6C;IACxDC,WAAU,EAAEC,UAAU,EAAEC,SAAS,EAAE;QACjC,OAAO;YACLC,MAAM;YACNC,UAAUN,2BAA2B;gBACnCO,sBAAsB;gBACtBJ;gBACAK,gBAAgB;gBAChBC,YAAYL,UAAUE,QAAQ;YAChC;YACAI,WAAW;YACXC,QAAQ;YACRC,QAAQ;YACRC,KAAKT,UAAUC,IAAI;YACnBS,SAAS;QACX;IACF;IACAC,WAAW;QAAC;QAAM;QAAM;QAAM;QAAM;QAAM;KAAK;AACjD,EAAC"}

package/dist/features/migrations/slateToLexical/converter/converters/heading/index.d.ts.map ADDED Viewed

	@@ -0,0 +1 @@
1	+ {"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../../src/features/migrations/slateToLexical/converter/converters/heading/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,gBAAgB,CAAA;AAKhE,eAAO,MAAM,qBAAqB,EAAE,0BAGnC,CAAA"}

package/dist/features/migrations/slateToLexical/converter/converters/heading/index.js.map ADDED Viewed

@@ -0,0 +1 @@

+ {"version":3,"sources":["../../../../../../../src/features/migrations/slateToLexical/converter/converters/heading/index.ts"],"sourcesContent":["import type { SlateNodeConverterProvider } from '../../types.js'\n\nimport { HeadingConverterClient } from './client.js'\nimport { _SlateHeadingConverter } from './converter.js'\n\nexport const SlateHeadingConverter: SlateNodeConverterProvider = {\n ClientComponent: HeadingConverterClient,\n converter: _SlateHeadingConverter,\n}\n"],"names":["HeadingConverterClient","_SlateHeadingConverter","SlateHeadingConverter","ClientComponent","converter"],"rangeMappings":";;;;;","mappings":"AAEA,SAASA,sBAAsB,QAAQ,cAAa;AACpD,SAASC,sBAAsB,QAAQ,iBAAgB;AAEvD,OAAO,MAAMC,wBAAoD;IAC/DC,iBAAiBH;IACjBI,WAAWH;AACb,EAAC"}

package/dist/features/migrations/slateToLexical/converter/converters/indent/client.d.ts.map ADDED Viewed

	@@ -0,0 +1 @@
1	+ {"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../../../../../../../src/features/migrations/slateToLexical/converter/converters/indent/client.ts"],"names":[],"mappings":";AAKA,eAAO,MAAM,qBAAqB;;;EAAoD,CAAA"}

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

@@ -0,0 +1 @@

+ {"version":3,"sources":["../../../../../../../src/features/migrations/slateToLexical/converter/converters/indent/client.ts"],"sourcesContent":["'use client'\n\nimport { createFeaturePropComponent } from '../../../../../createFeaturePropComponent.js'\nimport { _SlateIndentConverter } from './converter.js'\n\nexport const IndentConverterClient = createFeaturePropComponent(_SlateIndentConverter)\n"],"names":["createFeaturePropComponent","_SlateIndentConverter","IndentConverterClient"],"rangeMappings":";;;","mappings":"AAAA;AAEA,SAASA,0BAA0B,QAAQ,+CAA8C;AACzF,SAASC,qBAAqB,QAAQ,iBAAgB;AAEtD,OAAO,MAAMC,wBAAwBF,2BAA2BC,uBAAsB"}

package/dist/features/migrations/slateToLexical/converter/converters/indent/converter.d.ts.map ADDED Viewed

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

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

@@ -0,0 +1 @@

+ {"version":3,"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"],"names":["convertSlateNodesToLexical","_SlateIndentConverter","converter","converters","slateNode","convertChildren","node","indentLevel","type","children","text","canContainParagraphs","parentNodeType","slateNodes","indent","map","child","direction","format","version","nodeTypes"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"AAIA,SAASA,0BAA0B,QAAQ,iBAAgB;AAE3D,OAAO,MAAMC,wBAA4C;IACvDC,WAAU,EAAEC,UAAU,EAAEC,SAAS,EAAE;QACjC,MAAMC,kBAAkB,CAACC,MAAWC,cAAsB,CAAC;YACzD,IACE,AAACD,MAAME,QAAS,CAAA,CAACF,KAAKG,QAAQ,IAAIH,KAAKE,IAAI,KAAK,QAAO,KACtD,CAACF,MAAME,QAAQF,MAAMI,MACtB;gBACA,OAAO;oBACL,GAAGV,2BAA2B;wBAC5BW,sBAAsB;wBACtBR;wBACAS,gBAAgB;wBAChBC,YAAY;4BAACP;yBAAK;oBACpB,EAAE,CAAC,EAAE;oBACLQ,QAAQP;gBACV;YACF;YAEA,MAAME,WAAWH,KAAKG,QAAQ,CAACM,GAAG,CAAC,CAACC,QAAeX,gBAAgBW,OAAOT,cAAc;YACxF,OAAO;gBACLC,MAAM;gBACNC;gBACAQ,WAAW;gBACXC,QAAQ;gBACRJ,QAAQP;gBACRY,SAAS;YACX;QACF;QAEA,OAAOd,gBAAgBD;IACzB;IACAgB,WAAW;QAAC;KAAS;AACvB,EAAC"}

package/dist/features/migrations/slateToLexical/converter/converters/indent/index.d.ts.map ADDED Viewed

	@@ -0,0 +1 @@
1	+ {"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../../src/features/migrations/slateToLexical/converter/converters/indent/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,gBAAgB,CAAA;AAKhE,eAAO,MAAM,oBAAoB,EAAE,0BAGlC,CAAA"}

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

@@ -0,0 +1 @@

+ {"version":3,"sources":["../../../../../../../src/features/migrations/slateToLexical/converter/converters/indent/index.ts"],"sourcesContent":["import type { SlateNodeConverterProvider } from '../../types.js'\n\nimport { IndentConverterClient } from './client.js'\nimport { _SlateIndentConverter } from './converter.js'\n\nexport const SlateIndentConverter: SlateNodeConverterProvider = {\n ClientComponent: IndentConverterClient,\n converter: _SlateIndentConverter,\n}\n"],"names":["IndentConverterClient","_SlateIndentConverter","SlateIndentConverter","ClientComponent","converter"],"rangeMappings":";;;;;","mappings":"AAEA,SAASA,qBAAqB,QAAQ,cAAa;AACnD,SAASC,qBAAqB,QAAQ,iBAAgB;AAEtD,OAAO,MAAMC,uBAAmD;IAC9DC,iBAAiBH;IACjBI,WAAWH;AACb,EAAC"}

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

	@@ -0,0 +1 @@
1	+ {"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../../../../../../../src/features/migrations/slateToLexical/converter/converters/link/client.ts"],"names":[],"mappings":";AAKA,eAAO,MAAM,mBAAmB;;;EAAkD,CAAA"}

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

@@ -0,0 +1 @@

+ {"version":3,"sources":["../../../../../../../src/features/migrations/slateToLexical/converter/converters/link/client.ts"],"sourcesContent":["'use client'\n\nimport { createFeaturePropComponent } from '../../../../../createFeaturePropComponent.js'\nimport { _SlateLinkConverter } from './converter.js'\n\nexport const LinkConverterClient = createFeaturePropComponent(_SlateLinkConverter)\n"],"names":["createFeaturePropComponent","_SlateLinkConverter","LinkConverterClient"],"rangeMappings":";;;","mappings":"AAAA;AAEA,SAASA,0BAA0B,QAAQ,+CAA8C;AACzF,SAASC,mBAAmB,QAAQ,iBAAgB;AAEpD,OAAO,MAAMC,sBAAsBF,2BAA2BC,qBAAoB"}

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

	@@ -0,0 +1 @@
1	+ {"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,mBAAmB,EAAE,kBAwBjC,CAAA"}

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

@@ -0,0 +1 @@

+ {"version":3,"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.url || undefined,\n },\n format: '',\n indent: 0,\n version: 2,\n } as const as SerializedLinkNode\n },\n nodeTypes: ['link'],\n}\n"],"names":["convertSlateNodesToLexical","_SlateLinkConverter","converter","converters","slateNode","type","children","canContainParagraphs","parentNodeType","slateNodes","direction","fields","doc","linkType","newTab","url","undefined","format","indent","version","nodeTypes"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"AAGA,SAASA,0BAA0B,QAAQ,iBAAgB;AAE3D,OAAO,MAAMC,sBAA0C;IACrDC,WAAU,EAAEC,UAAU,EAAEC,SAAS,EAAE;QACjC,OAAO;YACLC,MAAM;YACNC,UAAUN,2BAA2B;gBACnCO,sBAAsB;gBACtBJ;gBACAK,gBAAgB;gBAChBC,YAAYL,UAAUE,QAAQ;YAChC;YACAI,WAAW;YACXC,QAAQ;gBACN,GAAIP,UAAUO,MAAM,IAAI,CAAC,CAAC;gBAC1BC,KAAKR,UAAUQ,GAAG,IAAI;gBACtBC,UAAUT,UAAUS,QAAQ,IAAI;gBAChCC,QAAQV,UAAUU,MAAM,IAAI;gBAC5BC,KAAKX,UAAUW,GAAG,IAAIC;YACxB;YACAC,QAAQ;YACRC,QAAQ;YACRC,SAAS;QACX;IACF;IACAC,WAAW;QAAC;KAAO;AACrB,EAAC"}

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

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

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

@@ -0,0 +1 @@

+ {"version":3,"sources":["../../../../../../../src/features/migrations/slateToLexical/converter/converters/link/index.ts"],"sourcesContent":["import type { SlateNodeConverterProvider } from '../../types.js'\n\nimport { LinkConverterClient } from './client.js'\nimport { _SlateLinkConverter } from './converter.js'\n\nexport const SlateLinkConverter: SlateNodeConverterProvider = {\n ClientComponent: LinkConverterClient,\n converter: _SlateLinkConverter,\n}\n"],"names":["LinkConverterClient","_SlateLinkConverter","SlateLinkConverter","ClientComponent","converter"],"rangeMappings":";;;;;","mappings":"AAEA,SAASA,mBAAmB,QAAQ,cAAa;AACjD,SAASC,mBAAmB,QAAQ,iBAAgB;AAEpD,OAAO,MAAMC,qBAAiD;IAC5DC,iBAAiBH;IACjBI,WAAWH;AACb,EAAC"}

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

	@@ -0,0 +1 @@
1	+ {"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../../../../../../../src/features/migrations/slateToLexical/converter/converters/listItem/client.ts"],"names":[],"mappings":";AAKA,eAAO,MAAM,uBAAuB;;;EAAsD,CAAA"}

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

@@ -0,0 +1 @@

+ {"version":3,"sources":["../../../../../../../src/features/migrations/slateToLexical/converter/converters/listItem/client.ts"],"sourcesContent":["'use client'\n\nimport { createFeaturePropComponent } from '../../../../../createFeaturePropComponent.js'\nimport { _SlateListItemConverter } from './converter.js'\n\nexport const ListItemConverterClient = createFeaturePropComponent(_SlateListItemConverter)\n"],"names":["createFeaturePropComponent","_SlateListItemConverter","ListItemConverterClient"],"rangeMappings":";;;","mappings":"AAAA;AAEA,SAASA,0BAA0B,QAAQ,+CAA8C;AACzF,SAASC,uBAAuB,QAAQ,iBAAgB;AAExD,OAAO,MAAMC,0BAA0BF,2BAA2BC,yBAAwB"}

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

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

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

@@ -0,0 +1 @@

+ {"version":3,"sources":["../../../../../../../src/features/migrations/slateToLexical/converter/converters/listItem/converter.ts"],"sourcesContent":["import type { SerializedListItemNode } from '@lexical/list'\n\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"],"names":["convertSlateNodesToLexical","_SlateListItemConverter","converter","childIndex","converters","slateNode","type","checked","undefined","children","canContainParagraphs","parentNodeType","slateNodes","direction","format","indent","value","version","nodeTypes"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;","mappings":"AAIA,SAASA,0BAA0B,QAAQ,iBAAgB;AAE3D,OAAO,MAAMC,0BAA8C;IACzDC,WAAU,EAAEC,UAAU,EAAEC,UAAU,EAAEC,SAAS,EAAE;QAC7C,OAAO;YACLC,MAAM;YACNC,SAASC;YACTC,UAAUT,2BAA2B;gBACnCU,sBAAsB;gBACtBN;gBACAO,gBAAgB;gBAChBC,YAAYP,UAAUI,QAAQ;YAChC;YACAI,WAAW;YACXC,QAAQ;YACRC,QAAQ;YACRC,OAAOb,aAAa;YACpBc,SAAS;QACX;IACF;IACAC,WAAW;QAAC;KAAK;AACnB,EAAC"}

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

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

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

@@ -0,0 +1 @@

+ {"version":3,"sources":["../../../../../../../src/features/migrations/slateToLexical/converter/converters/listItem/index.ts"],"sourcesContent":["import type { SlateNodeConverterProvider } from '../../types.js'\n\nimport { ListItemConverterClient } from './client.js'\nimport { _SlateListItemConverter } from './converter.js'\n\nexport const SlateListItemConverter: SlateNodeConverterProvider = {\n ClientComponent: ListItemConverterClient,\n converter: _SlateListItemConverter,\n}\n"],"names":["ListItemConverterClient","_SlateListItemConverter","SlateListItemConverter","ClientComponent","converter"],"rangeMappings":";;;;;","mappings":"AAEA,SAASA,uBAAuB,QAAQ,cAAa;AACrD,SAASC,uBAAuB,QAAQ,iBAAgB;AAExD,OAAO,MAAMC,yBAAqD;IAChEC,iBAAiBH;IACjBI,WAAWH;AACb,EAAC"}

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

	@@ -0,0 +1 @@
1	+ {"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../../../../../../../src/features/migrations/slateToLexical/converter/converters/orderedList/client.ts"],"names":[],"mappings":";AAKA,eAAO,MAAM,0BAA0B;;;EAAyD,CAAA"}

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

@@ -0,0 +1 @@

+ {"version":3,"sources":["../../../../../../../src/features/migrations/slateToLexical/converter/converters/orderedList/client.ts"],"sourcesContent":["'use client'\n\nimport { createFeaturePropComponent } from '../../../../../createFeaturePropComponent.js'\nimport { _SlateOrderedListConverter } from './converter.js'\n\nexport const OrderedListConverterClient = createFeaturePropComponent(_SlateOrderedListConverter)\n"],"names":["createFeaturePropComponent","_SlateOrderedListConverter","OrderedListConverterClient"],"rangeMappings":";;;","mappings":"AAAA;AAEA,SAASA,0BAA0B,QAAQ,+CAA8C;AACzF,SAASC,0BAA0B,QAAQ,iBAAgB;AAE3D,OAAO,MAAMC,6BAA6BF,2BAA2BC,4BAA2B"}

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

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

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

@@ -0,0 +1 @@

+ {"version":3,"sources":["../../../../../../../src/features/migrations/slateToLexical/converter/converters/orderedList/converter.ts"],"sourcesContent":["import type { SerializedListNode } from '@lexical/list'\n\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"],"names":["convertSlateNodesToLexical","_SlateOrderedListConverter","converter","converters","slateNode","type","children","canContainParagraphs","parentNodeType","slateNodes","direction","format","indent","listType","start","tag","version","nodeTypes"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;","mappings":"AAIA,SAASA,0BAA0B,QAAQ,iBAAgB;AAE3D,OAAO,MAAMC,6BAAiD;IAC5DC,WAAU,EAAEC,UAAU,EAAEC,SAAS,EAAE;QACjC,OAAO;YACLC,MAAM;YACNC,UAAUN,2BAA2B;gBACnCO,sBAAsB;gBACtBJ;gBACAK,gBAAgB;gBAChBC,YAAYL,UAAUE,QAAQ;YAChC;YACAI,WAAW;YACXC,QAAQ;YACRC,QAAQ;YACRC,UAAU;YACVC,OAAO;YACPC,KAAK;YACLC,SAAS;QACX;IACF;IACAC,WAAW;QAAC;KAAK;AACnB,EAAC"}

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

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

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

@@ -0,0 +1 @@

+ {"version":3,"sources":["../../../../../../../src/features/migrations/slateToLexical/converter/converters/orderedList/index.ts"],"sourcesContent":["import type { SlateNodeConverterProvider } from '../../types.js'\n\nimport { OrderedListConverterClient } from './client.js'\nimport { _SlateOrderedListConverter } from './converter.js'\n\nexport const SlateOrderedListConverter: SlateNodeConverterProvider = {\n ClientComponent: OrderedListConverterClient,\n converter: _SlateOrderedListConverter,\n}\n"],"names":["OrderedListConverterClient","_SlateOrderedListConverter","SlateOrderedListConverter","ClientComponent","converter"],"rangeMappings":";;;;;","mappings":"AAEA,SAASA,0BAA0B,QAAQ,cAAa;AACxD,SAASC,0BAA0B,QAAQ,iBAAgB;AAE3D,OAAO,MAAMC,4BAAwD;IACnEC,iBAAiBH;IACjBI,WAAWH;AACb,EAAC"}

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

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

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

@@ -0,0 +1 @@

+ {"version":3,"sources":["../../../../../../../src/features/migrations/slateToLexical/converter/converters/relationship/client.ts"],"sourcesContent":["'use client'\n\nimport { createFeaturePropComponent } from '../../../../../createFeaturePropComponent.js'\nimport { _SlateRelationshipConverter } from './converter.js'\n\nexport const RelationshipConverterClient = createFeaturePropComponent(_SlateRelationshipConverter)\n"],"names":["createFeaturePropComponent","_SlateRelationshipConverter","RelationshipConverterClient"],"rangeMappings":";;;","mappings":"AAAA;AAEA,SAASA,0BAA0B,QAAQ,+CAA8C;AACzF,SAASC,2BAA2B,QAAQ,iBAAgB;AAE5D,OAAO,MAAMC,8BAA8BF,2BAA2BC,6BAA4B"}

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

	@@ -0,0 +1 @@
1	+ {"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,2BAA2B,EAAE,kBAWzC,CAAA"}

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

@@ -0,0 +1 @@

+ {"version":3,"sources":["../../../../../../../src/features/migrations/slateToLexical/converter/converters/relationship/converter.ts"],"sourcesContent":["import type { SerializedRelationshipNode } from '../../../../../relationship/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"],"names":["_SlateRelationshipConverter","converter","slateNode","type","format","relationTo","value","id","version","nodeTypes"],"rangeMappings":";;;;;;;;;;;;;","mappings":"AAGA,OAAO,MAAMA,8BAAkD;IAC7DC,WAAU,EAAEC,SAAS,EAAE;QACrB,OAAO;YACLC,MAAM;YACNC,QAAQ;YACRC,YAAYH,UAAUG,UAAU;YAChCC,OAAOJ,WAAWI,OAAOC,MAAM;YAC/BC,SAAS;QACX;IACF;IACAC,WAAW;QAAC;KAAe;AAC7B,EAAC"}

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

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

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

@@ -0,0 +1 @@

+ {"version":3,"sources":["../../../../../../../src/features/migrations/slateToLexical/converter/converters/relationship/index.ts"],"sourcesContent":["import type { SlateNodeConverterProvider } from '../../types.js'\n\nimport { RelationshipConverterClient } from './client.js'\nimport { _SlateRelationshipConverter } from './converter.js'\n\nexport const SlateRelationshipConverter: SlateNodeConverterProvider = {\n ClientComponent: RelationshipConverterClient,\n converter: _SlateRelationshipConverter,\n}\n"],"names":["RelationshipConverterClient","_SlateRelationshipConverter","SlateRelationshipConverter","ClientComponent","converter"],"rangeMappings":";;;;;","mappings":"AAEA,SAASA,2BAA2B,QAAQ,cAAa;AACzD,SAASC,2BAA2B,QAAQ,iBAAgB;AAE5D,OAAO,MAAMC,6BAAyD;IACpEC,iBAAiBH;IACjBI,WAAWH;AACb,EAAC"}

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

	@@ -0,0 +1 @@
1	+ {"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../../../../../../../src/features/migrations/slateToLexical/converter/converters/unknown/client.ts"],"names":[],"mappings":";AAKA,eAAO,MAAM,sBAAsB;;;EAAqD,CAAA"}

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

@@ -0,0 +1 @@

+ {"version":3,"sources":["../../../../../../../src/features/migrations/slateToLexical/converter/converters/unknown/client.ts"],"sourcesContent":["'use client'\n\nimport { createFeaturePropComponent } from '../../../../../createFeaturePropComponent.js'\nimport { _SlateUnknownConverter } from './converter.js'\n\nexport const UnknownConverterClient = createFeaturePropComponent(_SlateUnknownConverter)\n"],"names":["createFeaturePropComponent","_SlateUnknownConverter","UnknownConverterClient"],"rangeMappings":";;;","mappings":"AAAA;AAEA,SAASA,0BAA0B,QAAQ,+CAA8C;AACzF,SAASC,sBAAsB,QAAQ,iBAAgB;AAEvD,OAAO,MAAMC,yBAAyBF,2BAA2BC,wBAAuB"}

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

	@@ -0,0 +1 @@
1	+ {"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,sBAAsB,EAAE,kBAqBpC,CAAA"}

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

@@ -0,0 +1 @@

+ {"version":3,"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"],"names":["convertSlateNodesToLexical","_SlateUnknownConverter","converter","converters","slateNode","type","children","canContainParagraphs","parentNodeType","slateNodes","data","nodeData","nodeType","direction","format","indent","version","nodeTypes"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;","mappings":"AAGA,SAASA,0BAA0B,QAAQ,iBAAgB;AAE3D,OAAO,MAAMC,yBAA6C;IACxDC,WAAU,EAAEC,UAAU,EAAEC,SAAS,EAAE;QACjC,OAAO;YACLC,MAAM;YACNC,UAAUN,2BAA2B;gBACnCO,sBAAsB;gBACtBJ;gBACAK,gBAAgB;gBAChBC,YAAYL,UAAUE,QAAQ;YAChC;YACAI,MAAM;gBACJC,UAAUP;gBACVQ,UAAUR,UAAUC,IAAI;YAC1B;YACAQ,WAAW;YACXC,QAAQ;YACRC,QAAQ;YACRC,SAAS;QACX;IACF;IACAC,WAAW;QAAC;KAAU;AACxB,EAAC"}

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

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

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

@@ -0,0 +1 @@

+ {"version":3,"sources":["../../../../../../../src/features/migrations/slateToLexical/converter/converters/unknown/index.ts"],"sourcesContent":["import type { SlateNodeConverterProvider } from '../../types.js'\n\nimport { UnknownConverterClient } from './client.js'\nimport { _SlateUnknownConverter } from './converter.js'\n\nexport const SlateUnknownConverter: SlateNodeConverterProvider = {\n ClientComponent: UnknownConverterClient,\n converter: _SlateUnknownConverter,\n}\n"],"names":["UnknownConverterClient","_SlateUnknownConverter","SlateUnknownConverter","ClientComponent","converter"],"rangeMappings":";;;;;","mappings":"AAEA,SAASA,sBAAsB,QAAQ,cAAa;AACpD,SAASC,sBAAsB,QAAQ,iBAAgB;AAEvD,OAAO,MAAMC,wBAAoD;IAC/DC,iBAAiBH;IACjBI,WAAWH;AACb,EAAC"}

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

	@@ -0,0 +1 @@
1	+ {"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../../../../../../../src/features/migrations/slateToLexical/converter/converters/unorderedList/client.ts"],"names":[],"mappings":";AAKA,eAAO,MAAM,4BAA4B;;;EAA2D,CAAA"}

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

@@ -0,0 +1 @@

+ {"version":3,"sources":["../../../../../../../src/features/migrations/slateToLexical/converter/converters/unorderedList/client.ts"],"sourcesContent":["'use client'\n\nimport { createFeaturePropComponent } from '../../../../../createFeaturePropComponent.js'\nimport { _SlateUnorderedListConverter } from './converter.js'\n\nexport const UnorderedListConverterClient = createFeaturePropComponent(_SlateUnorderedListConverter)\n"],"names":["createFeaturePropComponent","_SlateUnorderedListConverter","UnorderedListConverterClient"],"rangeMappings":";;;","mappings":"AAAA;AAEA,SAASA,0BAA0B,QAAQ,+CAA8C;AACzF,SAASC,4BAA4B,QAAQ,iBAAgB;AAE7D,OAAO,MAAMC,+BAA+BF,2BAA2BC,8BAA6B"}

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

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

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

@@ -0,0 +1 @@

+ {"version":3,"sources":["../../../../../../../src/features/migrations/slateToLexical/converter/converters/unorderedList/converter.ts"],"sourcesContent":["import type { SerializedListNode } from '@lexical/list'\n\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"],"names":["convertSlateNodesToLexical","_SlateUnorderedListConverter","converter","converters","slateNode","type","children","canContainParagraphs","parentNodeType","slateNodes","direction","format","indent","listType","start","tag","version","nodeTypes"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;","mappings":"AAIA,SAASA,0BAA0B,QAAQ,iBAAgB;AAE3D,OAAO,MAAMC,+BAAmD;IAC9DC,WAAU,EAAEC,UAAU,EAAEC,SAAS,EAAE;QACjC,OAAO;YACLC,MAAM;YACNC,UAAUN,2BAA2B;gBACnCO,sBAAsB;gBACtBJ;gBACAK,gBAAgB;gBAChBC,YAAYL,UAAUE,QAAQ;YAChC;YACAI,WAAW;YACXC,QAAQ;YACRC,QAAQ;YACRC,UAAU;YACVC,OAAO;YACPC,KAAK;YACLC,SAAS;QACX;IACF;IACAC,WAAW;QAAC;KAAK;AACnB,EAAC"}

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

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

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

@@ -0,0 +1 @@

+ {"version":3,"sources":["../../../../../../../src/features/migrations/slateToLexical/converter/converters/unorderedList/index.ts"],"sourcesContent":["import type { SlateNodeConverterProvider } from '../../types.js'\n\nimport { UnorderedListConverterClient } from './client.js'\nimport { _SlateUnorderedListConverter } from './converter.js'\n\nexport const SlateUnorderedListConverter: SlateNodeConverterProvider = {\n ClientComponent: UnorderedListConverterClient,\n converter: _SlateUnorderedListConverter,\n}\n"],"names":["UnorderedListConverterClient","_SlateUnorderedListConverter","SlateUnorderedListConverter","ClientComponent","converter"],"rangeMappings":";;;;;","mappings":"AAEA,SAASA,4BAA4B,QAAQ,cAAa;AAC1D,SAASC,4BAA4B,QAAQ,iBAAgB;AAE7D,OAAO,MAAMC,8BAA0D;IACrEC,iBAAiBH;IACjBI,WAAWH;AACb,EAAC"}

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

	@@ -0,0 +1 @@
1	+ {"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../../../../../../../src/features/migrations/slateToLexical/converter/converters/upload/client.ts"],"names":[],"mappings":";AAKA,eAAO,MAAM,qBAAqB;;;EAAoD,CAAA"}

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

@@ -0,0 +1 @@

+ {"version":3,"sources":["../../../../../../../src/features/migrations/slateToLexical/converter/converters/upload/client.ts"],"sourcesContent":["'use client'\n\nimport { createFeaturePropComponent } from '../../../../../createFeaturePropComponent.js'\nimport { _SlateUploadConverter } from './converter.js'\n\nexport const UploadConverterClient = createFeaturePropComponent(_SlateUploadConverter)\n"],"names":["createFeaturePropComponent","_SlateUploadConverter","UploadConverterClient"],"rangeMappings":";;;","mappings":"AAAA;AAEA,SAASA,0BAA0B,QAAQ,+CAA8C;AACzF,SAASC,qBAAqB,QAAQ,iBAAgB;AAEtD,OAAO,MAAMC,wBAAwBF,2BAA2BC,uBAAsB"}

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

	@@ -0,0 +1 @@
1	+ {"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,qBAAqB,EAAE,kBAcnC,CAAA"}

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

@@ -0,0 +1 @@

+ {"version":3,"sources":["../../../../../../../src/features/migrations/slateToLexical/converter/converters/upload/converter.ts"],"sourcesContent":["import type { SerializedUploadNode } from '../../../../../upload/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"],"names":["_SlateUploadConverter","converter","slateNode","type","fields","format","relationTo","value","id","version","nodeTypes"],"rangeMappings":";;;;;;;;;;;;;;;;","mappings":"AAGA,OAAO,MAAMA,wBAA4C;IACvDC,WAAU,EAAEC,SAAS,EAAE;QACrB,OAAO;YACLC,MAAM;YACNC,QAAQ;gBACN,GAAGF,UAAUE,MAAM;YACrB;YACAC,QAAQ;YACRC,YAAYJ,UAAUI,UAAU;YAChCC,OAAOL,UAAUK,KAAK,EAAEC,MAAM;YAC9BC,SAAS;QACX;IACF;IACAC,WAAW;QAAC;KAAS;AACvB,EAAC"}

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

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

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

@@ -0,0 +1 @@

+ {"version":3,"sources":["../../../../../../../src/features/migrations/slateToLexical/converter/converters/upload/index.ts"],"sourcesContent":["import type { SlateNodeConverterProvider } from '../../types.js'\n\nimport { UploadConverterClient } from './client.js'\nimport { _SlateUploadConverter } from './converter.js'\n\nexport const SlateUploadConverter: SlateNodeConverterProvider = {\n ClientComponent: UploadConverterClient,\n converter: _SlateUploadConverter,\n}\n"],"names":["UploadConverterClient","_SlateUploadConverter","SlateUploadConverter","ClientComponent","converter"],"rangeMappings":";;;;;","mappings":"AAEA,SAASA,qBAAqB,QAAQ,cAAa;AACnD,SAASC,qBAAqB,QAAQ,iBAAgB;AAEtD,OAAO,MAAMC,uBAAmD;IAC9DC,iBAAiBH;IACjBI,WAAWH;AACb,EAAC"}

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

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

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

@@ -0,0 +1 @@

+ {"version":3,"sources":["../../../../../src/features/migrations/slateToLexical/converter/defaultConverters.ts"],"sourcesContent":["import type { SlateNodeConverterProvider } from './types.js'\n\nimport { SlateBlockquoteConverter } from './converters/blockquote/index.js'\nimport { SlateHeadingConverter } from './converters/heading/index.js'\nimport { SlateIndentConverter } from './converters/indent/index.js'\nimport { SlateLinkConverter } from './converters/link/index.js'\nimport { SlateListItemConverter } from './converters/listItem/index.js'\nimport { SlateOrderedListConverter } from './converters/orderedList/index.js'\nimport { SlateRelationshipConverter } from './converters/relationship/index.js'\nimport { SlateUnknownConverter } from './converters/unknown/index.js'\nimport { SlateUnorderedListConverter } from './converters/unorderedList/index.js'\nimport { SlateUploadConverter } from './converters/upload/index.js'\n\nexport const defaultSlateConverters: SlateNodeConverterProvider[] = [\n SlateBlockquoteConverter,\n SlateHeadingConverter,\n SlateIndentConverter,\n SlateLinkConverter,\n SlateListItemConverter,\n SlateOrderedListConverter,\n SlateRelationshipConverter,\n SlateUnorderedListConverter,\n SlateUploadConverter,\n SlateUnknownConverter,\n]\n"],"names":["SlateBlockquoteConverter","SlateHeadingConverter","SlateIndentConverter","SlateLinkConverter","SlateListItemConverter","SlateOrderedListConverter","SlateRelationshipConverter","SlateUnknownConverter","SlateUnorderedListConverter","SlateUploadConverter","defaultSlateConverters"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;","mappings":"AAEA,SAASA,wBAAwB,QAAQ,mCAAkC;AAC3E,SAASC,qBAAqB,QAAQ,gCAA+B;AACrE,SAASC,oBAAoB,QAAQ,+BAA8B;AACnE,SAASC,kBAAkB,QAAQ,6BAA4B;AAC/D,SAASC,sBAAsB,QAAQ,iCAAgC;AACvE,SAASC,yBAAyB,QAAQ,oCAAmC;AAC7E,SAASC,0BAA0B,QAAQ,qCAAoC;AAC/E,SAASC,qBAAqB,QAAQ,gCAA+B;AACrE,SAASC,2BAA2B,QAAQ,sCAAqC;AACjF,SAASC,oBAAoB,QAAQ,+BAA8B;AAEnE,OAAO,MAAMC,yBAAuD;IAClEV;IACAC;IACAC;IACAC;IACAC;IACAC;IACAC;IACAE;IACAC;IACAF;CACD,CAAA"}

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

@@ -0,0 +1 @@

+ {"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,CAmC1B;AAED,wBAAgB,oBAAoB,CAClC,UAAU,EAAE,kBAAkB,EAAE,EAChC,IAAI,EAAE,SAAS,GACd,uBAAuB,CAezB;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.map ADDED Viewed

@@ -0,0 +1 @@

+ {"version":3,"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) {\n return []\n }\n const unknownConverter = converters.find((converter) => converter.nodeTypes.includes('unknown'))\n return (\n slateNodes.map((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 // 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) => converter.nodeTypes.includes(slateNode.type))\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 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"],"names":["NodeFormat","convertSlateToLexical","converters","slateData","root","type","children","convertSlateNodesToLexical","canContainParagraphs","parentNodeType","slateNodes","direction","format","indent","version","length","unknownConverter","find","converter","nodeTypes","includes","map","slateNode","i","convertParagraphNode","convertTextNode","childIndex","console","warn","node","textFormat","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"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"AASA,SAASA,UAAU,QAAQ,0CAAyC;AAEpE,OAAO,SAASC,sBAAsB,EACpCC,UAAU,EACVC,SAAS,EAIV;IACC,OAAO;QACLC,MAAM;YACJC,MAAM;YACNC,UAAUC,2BAA2B;gBACnCC,sBAAsB;gBACtBN;gBACAO,gBAAgB;gBAChBC,YAAYP;YACd;YACAQ,WAAW;YACXC,QAAQ;YACRC,QAAQ;YACRC,SAAS;QACX;IACF;AACF;AAEA,OAAO,SAASP,2BAA2B,EACzCC,oBAAoB,EACpBN,UAAU,EACVO,cAAc,EACdC,UAAU,EASX;IACC,IAAI,CAACR,YAAYa,QAAQ;QACvB,OAAO,EAAE;IACX;IACA,MAAMC,mBAAmBd,WAAWe,IAAI,CAAC,CAACC,YAAcA,UAAUC,SAAS,CAACC,QAAQ,CAAC;IACrF,OACEV,WAAWW,GAAG,CAAC,CAACC,WAAWC;QACzB,IAAI,CAAE,CAAA,UAAUD,SAAQ,GAAI;YAC1B,IAAId,sBAAsB;gBACxB,sEAAsE;gBACtE,OAAOgB,qBAAqBtB,YAAYoB;YAC1C,OAAO;gBACL,yJAAyJ;gBACzJ,OAAOG,gBAAgBH;YACzB;QACF;QACA,IAAIA,UAAUjB,IAAI,KAAK,KAAK;YAC1B,OAAOmB,qBAAqBtB,YAAYoB;QAC1C;QAEA,MAAMJ,YAAYhB,WAAWe,IAAI,CAAC,CAACC,YAAcA,UAAUC,SAAS,CAACC,QAAQ,CAACE,UAAUjB,IAAI;QAE5F,IAAIa,WAAW;YACb,OAAOA,UAAUA,SAAS,CAAC;gBAAEQ,YAAYH;gBAAGrB;gBAAYO;gBAAgBa;YAAU;QACpF;QAEAK,QAAQC,IAAI,CAAC,wDAAwDN,UAAUjB,IAAI;QACnF,OAAOW,kBAAkBE,UAAU;YACjCQ,YAAYH;YACZrB;YACAO;YACAa;QACF;IACF,MAAM,EAAE;AAEZ;AAEA,OAAO,SAASE,qBACdtB,UAAgC,EAChC2B,IAAe;IAEf,OAAO;QACLxB,MAAM;QACNC,UAAUC,2BAA2B;YACnCC,sBAAsB;YACtBN;YACAO,gBAAgB;YAChBC,YAAYmB,KAAKvB,QAAQ,IAAI,EAAE;QACjC;QACAK,WAAW;QACXC,QAAQ;QACRC,QAAQ;QACRiB,YAAY;QACZhB,SAAS;IACX;AACF;AACA,OAAO,SAASW,gBAAgBI,IAAe;IAC7C,OAAO;QACLxB,MAAM;QACN0B,QAAQ;QACRnB,QAAQoB,oBAAoBH;QAC5BI,MAAM;QACNC,OAAO;QACPC,MAAMN,KAAKM,IAAI;QACfrB,SAAS;IACX;AACF;AAEA,OAAO,SAASkB,oBAAoBH,IAAe;IACjD,IAAIjB,SAAS;IACb,IAAIiB,KAAKO,IAAI,EAAE;QACbxB,SAASA,SAASZ,WAAWqC,OAAO;IACtC;IACA,IAAIR,KAAKS,MAAM,EAAE;QACf1B,SAASA,SAASZ,WAAWuC,SAAS;IACxC;IACA,IAAIV,KAAKW,aAAa,EAAE;QACtB5B,SAASA,SAASZ,WAAWyC,gBAAgB;IAC/C;IACA,IAAIZ,KAAKa,SAAS,EAAE;QAClB9B,SAASA,SAASZ,WAAW2C,YAAY;IAC3C;IACA,IAAId,KAAKe,SAAS,EAAE;QAClBhC,SAASA,SAASZ,WAAW6C,YAAY;IAC3C;IACA,IAAIhB,KAAKiB,WAAW,EAAE;QACpBlC,SAASA,SAASZ,WAAW+C,cAAc;IAC7C;IACA,IAAIlB,KAAKmB,IAAI,EAAE;QACbpC,SAASA,SAASZ,WAAWiD,OAAO;IACtC;IACA,OAAOrC;AACT"}

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

@@ -0,0 +1 @@

+ {"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;AACpD,OAAO,KAAK,KAAK,MAAM,OAAO,CAAA;AAE9B,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;AAED,MAAM,MAAM,iCAAiC,GAAG,KAAK,CAAC,EAAE,CAAC;IACvD,YAAY,EAAE,MAAM,CAAA;IACpB,UAAU,EAAE,MAAM,CAAA;CACnB,CAAC,CAAA;AAEF,MAAM,MAAM,0BAA0B,GAAG;IACvC,eAAe,EAAE,iCAAiC,CAAA;IAClD,SAAS,EAAE,kBAAkB,CAAA;CAC9B,CAAA"}

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

@@ -0,0 +1 @@

+ {"version":3,"sources":["../../../../../src/features/migrations/slateToLexical/converter/types.ts"],"sourcesContent":["import type { SerializedLexicalNode } from 'lexical'\nimport type React from 'react'\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\nexport type SlateNodeConverterClientComponent = React.FC<{\n componentKey: string\n featureKey: string\n}>\n\nexport type SlateNodeConverterProvider = {\n ClientComponent: SlateNodeConverterClientComponent\n converter: SlateNodeConverter\n}\n"],"names":[],"rangeMappings":"","mappings":"AA6BA,WAGC"}

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

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

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

@@ -0,0 +1 @@

+ {"version":3,"sources":["../../../../src/features/migrations/slateToLexical/feature.client.tsx"],"sourcesContent":["'use client'\n\nimport type { FeatureProviderProviderClient } from '../../types.js'\nimport type { SlateNodeConverter } from './converter/types.js'\n\nimport { createClientComponent } from '../../createClientComponent.js'\nimport { convertSlateToLexical } from './converter/index.js'\nimport { UnknownConvertedNode } from './nodes/unknownConvertedNode/index.js'\n\nconst SlateToLexicalFeatureClient: FeatureProviderProviderClient<undefined> = (props) => {\n return {\n clientFeatureProps: props,\n feature: ({ clientFunctions }) => {\n const converters: SlateNodeConverter[] = Object.values(clientFunctions)\n\n return {\n clientFeatureProps: props,\n hooks: {\n load({ incomingEditorState }) {\n if (\n !incomingEditorState ||\n !Array.isArray(incomingEditorState) ||\n 'root' in incomingEditorState\n ) {\n // incomingEditorState null or not from Slate\n return incomingEditorState\n }\n // Slate => convert to lexical\n\n return convertSlateToLexical({\n converters,\n slateData: incomingEditorState,\n })\n },\n },\n nodes: [UnknownConvertedNode],\n }\n },\n }\n}\n\nexport const SlateToLexicalFeatureClientComponent = createClientComponent(\n SlateToLexicalFeatureClient,\n)\n"],"names":["createClientComponent","convertSlateToLexical","UnknownConvertedNode","SlateToLexicalFeatureClient","props","clientFeatureProps","feature","clientFunctions","converters","Object","values","hooks","load","incomingEditorState","Array","isArray","slateData","nodes","SlateToLexicalFeatureClientComponent"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"AAAA;AAKA,SAASA,qBAAqB,QAAQ,iCAAgC;AACtE,SAASC,qBAAqB,QAAQ,uBAAsB;AAC5D,SAASC,oBAAoB,QAAQ,wCAAuC;AAE5E,MAAMC,8BAAwE,CAACC;IAC7E,OAAO;QACLC,oBAAoBD;QACpBE,SAAS,CAAC,EAAEC,eAAe,EAAE;YAC3B,MAAMC,aAAmCC,OAAOC,MAAM,CAACH;YAEvD,OAAO;gBACLF,oBAAoBD;gBACpBO,OAAO;oBACLC,MAAK,EAAEC,mBAAmB,EAAE;wBAC1B,IACE,CAACA,uBACD,CAACC,MAAMC,OAAO,CAACF,wBACf,UAAUA,qBACV;4BACA,6CAA6C;4BAC7C,OAAOA;wBACT;wBACA,8BAA8B;wBAE9B,OAAOZ,sBAAsB;4BAC3BO;4BACAQ,WAAWH;wBACb;oBACF;gBACF;gBACAI,OAAO;oBAACf;iBAAqB;YAC/B;QACF;IACF;AACF;AAEA,OAAO,MAAMgB,uCAAuClB,sBAClDG,6BACD"}

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

@@ -0,0 +1 @@

+ {"version":3,"file":"feature.server.d.ts","sourceRoot":"","sources":["../../../../src/features/migrations/slateToLexical/feature.server.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,6BAA6B,EAAE,MAAM,gBAAgB,CAAA;AACnE,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,sBAAsB,CAAA;AAOtE,MAAM,MAAM,0BAA0B,GAAG;IACvC,UAAU,CAAC,EACP,CAAC,CAAC,EACA,iBAAiB,GAClB,EAAE;QACD,iBAAiB,EAAE,0BAA0B,EAAE,CAAA;KAChD,KAAK,0BAA0B,EAAE,CAAC,GACnC,0BAA0B,EAAE,CAAA;CACjC,CAAA;AAED,eAAO,MAAM,qBAAqB,EAAE,6BAA6B,CAC/D,0BAA0B,EAC1B,SAAS,CA+CV,CAAA"}

package/dist/features/migrations/slateToLexical/feature.server.js ADDED Viewed

@@ -0,0 +1,48 @@
+// eslint-disable-next-line payload/no-imports-from-exports-dir
+import { SlateToLexicalFeatureClientComponent } from '../../../exports/client/index.js';
+import { defaultSlateConverters } from './converter/defaultConverters.js';
+import { UnknownConvertedNode } from './nodes/unknownConvertedNode/index.js';
+export const SlateToLexicalFeature = (props)=>{
+    if (!props) {
+        props = {};
+    }
+    let converters = [];
+    if (props?.converters && typeof props?.converters === 'function') {
+        converters = props.converters({
+            defaultConverters: defaultSlateConverters
+        });
+    } else if (props.converters && typeof props?.converters !== 'function') {
+        converters = props.converters;
+    } else {
+        converters = defaultSlateConverters;
+    }
+    props.converters = converters;
+    return {
+        feature: ()=>{
+            return {
+                ClientComponent: SlateToLexicalFeatureClientComponent,
+                clientFeatureProps: null,
+                generateComponentMap: ()=>{
+                    const map = {};
+                    for (const converter of converters){
+                        if (converter.ClientComponent) {
+                            const key = converter.converter.nodeTypes.join('-');
+                            map[key] = converter.ClientComponent;
+                        }
+                    }
+                    return map;
+                },
+                nodes: [
+                    {
+                        node: UnknownConvertedNode
+                    }
+                ],
+                serverFeatureProps: props
+            };
+        },
+        key: 'slateToLexical',
+        serverFeatureProps: props
+    };
+};
+//# sourceMappingURL=feature.server.js.map

package/dist/features/migrations/slateToLexical/feature.server.js.map ADDED Viewed

@@ -0,0 +1 @@

+ {"version":3,"sources":["../../../../src/features/migrations/slateToLexical/feature.server.ts"],"sourcesContent":["import type React from 'react'\n\nimport type { FeatureProviderProviderServer } from '../../types.js'\nimport type { SlateNodeConverterProvider } from './converter/types.js'\n\n// eslint-disable-next-line payload/no-imports-from-exports-dir\nimport { SlateToLexicalFeatureClientComponent } from '../../../exports/client/index.js'\nimport { defaultSlateConverters } from './converter/defaultConverters.js'\nimport { UnknownConvertedNode } from './nodes/unknownConvertedNode/index.js'\n\nexport type SlateToLexicalFeatureProps = {\n converters?:\n | (({\n defaultConverters,\n }: {\n defaultConverters: SlateNodeConverterProvider[]\n }) => SlateNodeConverterProvider[])\n | SlateNodeConverterProvider[]\n}\n\nexport const SlateToLexicalFeature: FeatureProviderProviderServer<\n SlateToLexicalFeatureProps,\n undefined\n> = (props) => {\n if (!props) {\n props = {}\n }\n\n let converters: SlateNodeConverterProvider[] = []\n if (props?.converters && typeof props?.converters === 'function') {\n converters = props.converters({ defaultConverters: defaultSlateConverters })\n } else if (props.converters && typeof props?.converters !== 'function') {\n converters = props.converters\n } else {\n converters = defaultSlateConverters\n }\n\n props.converters = converters\n\n return {\n feature: () => {\n return {\n ClientComponent: SlateToLexicalFeatureClientComponent,\n clientFeatureProps: null,\n generateComponentMap: () => {\n const map: {\n [key: string]: React.FC\n } = {}\n\n for (const converter of converters) {\n if (converter.ClientComponent) {\n const key = converter.converter.nodeTypes.join('-')\n map[key] = converter.ClientComponent\n }\n }\n\n return map\n },\n nodes: [\n {\n node: UnknownConvertedNode,\n },\n ],\n serverFeatureProps: props,\n }\n },\n key: 'slateToLexical',\n serverFeatureProps: props,\n }\n}\n"],"names":["SlateToLexicalFeatureClientComponent","defaultSlateConverters","UnknownConvertedNode","SlateToLexicalFeature","props","converters","defaultConverters","feature","ClientComponent","clientFeatureProps","generateComponentMap","map","converter","key","nodeTypes","join","nodes","node","serverFeatureProps"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"AAKA,+DAA+D;AAC/D,SAASA,oCAAoC,QAAQ,mCAAkC;AACvF,SAASC,sBAAsB,QAAQ,mCAAkC;AACzE,SAASC,oBAAoB,QAAQ,wCAAuC;AAY5E,OAAO,MAAMC,wBAGT,CAACC;IACH,IAAI,CAACA,OAAO;QACVA,QAAQ,CAAC;IACX;IAEA,IAAIC,aAA2C,EAAE;IACjD,IAAID,OAAOC,cAAc,OAAOD,OAAOC,eAAe,YAAY;QAChEA,aAAaD,MAAMC,UAAU,CAAC;YAAEC,mBAAmBL;QAAuB;IAC5E,OAAO,IAAIG,MAAMC,UAAU,IAAI,OAAOD,OAAOC,eAAe,YAAY;QACtEA,aAAaD,MAAMC,UAAU;IAC/B,OAAO;QACLA,aAAaJ;IACf;IAEAG,MAAMC,UAAU,GAAGA;IAEnB,OAAO;QACLE,SAAS;YACP,OAAO;gBACLC,iBAAiBR;gBACjBS,oBAAoB;gBACpBC,sBAAsB;oBACpB,MAAMC,MAEF,CAAC;oBAEL,KAAK,MAAMC,aAAaP,WAAY;wBAClC,IAAIO,UAAUJ,eAAe,EAAE;4BAC7B,MAAMK,MAAMD,UAAUA,SAAS,CAACE,SAAS,CAACC,IAAI,CAAC;4BAC/CJ,GAAG,CAACE,IAAI,GAAGD,UAAUJ,eAAe;wBACtC;oBACF;oBAEA,OAAOG;gBACT;gBACAK,OAAO;oBACL;wBACEC,MAAMf;oBACR;iBACD;gBACDgB,oBAAoBd;YACtB;QACF;QACAS,KAAK;QACLK,oBAAoBd;IACtB;AACF,EAAC"}

package/dist/features/migrations/slateToLexical/nodes/unknownConvertedNode/Component.d.ts.map ADDED Viewed

@@ -0,0 +1 @@

+ {"version":3,"file":"Component.d.ts","sourceRoot":"","sources":["../../../../../../src/features/migrations/slateToLexical/nodes/unknownConvertedNode/Component.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,OAAO,CAAA;AAEzB,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,YAAY,CAAA;AAE1D,OAAO,cAAc,CAAA;AAErB,KAAK,KAAK,GAAG;IACX,IAAI,EAAE,wBAAwB,CAAA;CAC/B,CAAA;AAED,eAAO,MAAM,6BAA6B,EAAE,KAAK,CAAC,EAAE,CAAC,KAAK,CAQzD,CAAA"}

package/dist/features/migrations/slateToLexical/nodes/unknownConvertedNode/Component.js.map ADDED Viewed

@@ -0,0 +1 @@

+ {"version":3,"sources":["../../../../../../src/features/migrations/slateToLexical/nodes/unknownConvertedNode/Component.tsx"],"sourcesContent":["import React from 'react'\n\nimport type { UnknownConvertedNodeData } from './index.js'\n\nimport './index.scss'\n\ntype Props = {\n data: UnknownConvertedNodeData\n}\n\nexport const UnknownConvertedNodeComponent: React.FC<Props> = (props) => {\n const { data } = props\n\n return (\n <div>\n Unknown converted Slate node: <strong>{data?.nodeType}</strong>\n </div>\n )\n}\n"],"names":["React","UnknownConvertedNodeComponent","props","data","div","strong","nodeType"],"rangeMappings":";;;;;;;;;;;;","mappings":";AAAA,OAAOA,WAAW,QAAO;AAUzB,OAAO,MAAMC,gCAAiD,CAACC;IAC7D,MAAM,EAAEC,IAAI,EAAE,GAAGD;IAEjB,qBACE,MAACE;;YAAI;0BAC2B,KAACC;0BAAQF,MAAMG;;;;AAGnD,EAAC"}

package/dist/features/migrations/slateToLexical/nodes/unknownConvertedNode/index.d.ts.map ADDED Viewed

@@ -0,0 +1 @@

+ {"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../src/features/migrations/slateToLexical/nodes/unknownConvertedNode/index.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,WAAW,EAAE,OAAO,EAAE,qBAAqB,EAAE,MAAM,EAAE,MAAM,SAAS,CAAA;AAChG,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,OAAO,CAAA;AAGhC,OAAO,EAAE,aAAa,EAAE,MAAM,SAAS,CAAA;AAGvC,MAAM,MAAM,wBAAwB,GAAG;IACrC,QAAQ,EAAE,OAAO,CAAA;IACjB,QAAQ,EAAE,MAAM,CAAA;CACjB,CAAA;AAED,MAAM,MAAM,8BAA8B,GAAG,MAAM,CACjD;IACE,IAAI,EAAE,wBAAwB,CAAA;CAC/B,EACD,qBAAqB,CACtB,CAAA;AAQD,oBAAoB;AACpB,qBAAa,oBAAqB,SAAQ,aAAa,CAAC,GAAG,CAAC,OAAO,CAAC;IAClE,MAAM,EAAE,wBAAwB,CAAA;gBAEpB,EAAE,IAAI,EAAE,GAAG,EAAE,EAAE;QAAE,IAAI,EAAE,wBAAwB,CAAC;QAAC,GAAG,CAAC,EAAE,OAAO,CAAA;KAAE;IAK5E,MAAM,CAAC,KAAK,CAAC,IAAI,EAAE,oBAAoB,GAAG,oBAAoB;IAO9D,MAAM,CAAC,OAAO,IAAI,MAAM;IAIxB,MAAM,CAAC,UAAU,CAAC,cAAc,EAAE,8BAA8B,GAAG,oBAAoB;IAKvF,kBAAkB,IAAI,IAAI;IAI1B,mBAAmB,IAAI,IAAI;IAI3B,SAAS,CAAC,MAAM,EAAE,YAAY,GAAG,WAAW;IAM5C,QAAQ,IAAI,GAAG,CAAC,OAAO,GAAG,IAAI;IAI9B,UAAU,IAAI,8BAA8B;IAU5C,QAAQ,IAAI,OAAO;IAInB,SAAS,CAAC,QAAQ,EAAE,oBAAoB,EAAE,GAAG,EAAE,WAAW,GAAG,OAAO;CAGrE;AAED,wBAAgB,2BAA2B,CAAC,EAC1C,IAAI,GACL,EAAE;IACD,IAAI,EAAE,wBAAwB,CAAA;CAC/B,GAAG,oBAAoB,CAIvB;AAED,wBAAgB,uBAAuB,CACrC,IAAI,EAAE,WAAW,GAAG,IAAI,GAAG,SAAS,GACnC,IAAI,IAAI,oBAAoB,CAE9B"}

package/dist/features/migrations/slateToLexical/nodes/unknownConvertedNode/index.js.map ADDED Viewed

@@ -0,0 +1 @@

+ {"version":3,"sources":["../../../../../../src/features/migrations/slateToLexical/nodes/unknownConvertedNode/index.tsx"],"sourcesContent":["import type { EditorConfig, LexicalNode, NodeKey, SerializedLexicalNode, Spread } from 'lexical'\nimport type { JSX } from 'react'\n\nimport { addClassNamesToElement } from '@lexical/utils'\nimport { DecoratorNode } from 'lexical'\nimport * as React from 'react'\n\nexport type UnknownConvertedNodeData = {\n nodeData: unknown\n nodeType: string\n}\n\nexport type SerializedUnknownConvertedNode = Spread<\n {\n data: UnknownConvertedNodeData\n },\n SerializedLexicalNode\n>\n\nconst Component = React.lazy(() =>\n import('./Component.js').then((module) => ({\n default: module.UnknownConvertedNodeComponent,\n })),\n)\n\n/** @noInheritDoc */\nexport class UnknownConvertedNode extends DecoratorNode<JSX.Element> {\n __data: UnknownConvertedNodeData\n\n constructor({ data, key }: { data: UnknownConvertedNodeData; key?: NodeKey }) {\n super(key)\n this.__data = data\n }\n\n static clone(node: UnknownConvertedNode): UnknownConvertedNode {\n return new UnknownConvertedNode({\n data: node.__data,\n key: node.__key,\n })\n }\n\n static getType(): string {\n return 'unknownConverted'\n }\n\n static importJSON(serializedNode: SerializedUnknownConvertedNode): UnknownConvertedNode {\n const node = $createUnknownConvertedNode({ data: serializedNode.data })\n return node\n }\n\n canInsertTextAfter(): true {\n return true\n }\n\n canInsertTextBefore(): true {\n return true\n }\n\n createDOM(config: EditorConfig): HTMLElement {\n const element = document.createElement('span')\n addClassNamesToElement(element, 'unknownConverted')\n return element\n }\n\n decorate(): JSX.Element | null {\n return <Component data={this.__data} />\n }\n\n exportJSON(): SerializedUnknownConvertedNode {\n return {\n type: this.getType(),\n data: this.__data,\n version: 1,\n }\n }\n\n // Mutation\n\n isInline(): boolean {\n return true\n }\n\n updateDOM(prevNode: UnknownConvertedNode, dom: HTMLElement): boolean {\n return false\n }\n}\n\nexport function $createUnknownConvertedNode({\n data,\n}: {\n data: UnknownConvertedNodeData\n}): UnknownConvertedNode {\n return new UnknownConvertedNode({\n data,\n })\n}\n\nexport function $isUnknownConvertedNode(\n node: LexicalNode | null | undefined,\n): node is UnknownConvertedNode {\n return node instanceof UnknownConvertedNode\n}\n"],"names":["addClassNamesToElement","DecoratorNode","React","Component","lazy","then","module","default","UnknownConvertedNodeComponent","UnknownConvertedNode","__data","constructor","data","key","clone","node","__key","getType","importJSON","serializedNode","$createUnknownConvertedNode","canInsertTextAfter","canInsertTextBefore","createDOM","config","element","document","createElement","decorate","exportJSON","type","version","isInline","updateDOM","prevNode","dom","$isUnknownConvertedNode"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":";AAGA,SAASA,sBAAsB,QAAQ,iBAAgB;AACvD,SAASC,aAAa,QAAQ,UAAS;AACvC,YAAYC,WAAW,QAAO;AAc9B,MAAMC,0BAAYD,MAAME,IAAI,CAAC,IAC3B,MAAM,CAAC,kBAAkBC,IAAI,CAAC,CAACC,SAAY,CAAA;YACzCC,SAASD,OAAOE,6BAA6B;QAC/C,CAAA;AAGF,kBAAkB,GAClB,OAAO,MAAMC,6BAA6BR;IACxCS,OAAgC;IAEhCC,YAAY,EAAEC,IAAI,EAAEC,GAAG,EAAqD,CAAE;QAC5E,KAAK,CAACA;QACN,IAAI,CAACH,MAAM,GAAGE;IAChB;IAEA,OAAOE,MAAMC,IAA0B,EAAwB;QAC7D,OAAO,IAAIN,qBAAqB;YAC9BG,MAAMG,KAAKL,MAAM;YACjBG,KAAKE,KAAKC,KAAK;QACjB;IACF;IAEA,OAAOC,UAAkB;QACvB,OAAO;IACT;IAEA,OAAOC,WAAWC,cAA8C,EAAwB;QACtF,MAAMJ,OAAOK,4BAA4B;YAAER,MAAMO,eAAeP,IAAI;QAAC;QACrE,OAAOG;IACT;IAEAM,qBAA2B;QACzB,OAAO;IACT;IAEAC,sBAA4B;QAC1B,OAAO;IACT;IAEAC,UAAUC,MAAoB,EAAe;QAC3C,MAAMC,UAAUC,SAASC,aAAa,CAAC;QACvC3B,uBAAuByB,SAAS;QAChC,OAAOA;IACT;IAEAG,WAA+B;QAC7B,qBAAO,KAACzB;YAAUS,MAAM,IAAI,CAACF,MAAM;;IACrC;IAEAmB,aAA6C;QAC3C,OAAO;YACLC,MAAM,IAAI,CAACb,OAAO;YAClBL,MAAM,IAAI,CAACF,MAAM;YACjBqB,SAAS;QACX;IACF;IAEA,WAAW;IAEXC,WAAoB;QAClB,OAAO;IACT;IAEAC,UAAUC,QAA8B,EAAEC,GAAgB,EAAW;QACnE,OAAO;IACT;AACF;AAEA,OAAO,SAASf,4BAA4B,EAC1CR,IAAI,EAGL;IACC,OAAO,IAAIH,qBAAqB;QAC9BG;IACF;AACF;AAEA,OAAO,SAASwB,wBACdrB,IAAoC;IAEpC,OAAOA,gBAAgBN;AACzB"}

package/dist/features/paragraph/feature.client.d.ts.map ADDED Viewed

	@@ -0,0 +1 @@
1	+ {"version":3,"file":"feature.client.d.ts","sourceRoot":"","sources":["../../../src/features/paragraph/feature.client.tsx"],"names":[],"mappings":";AA8EA,eAAO,MAAM,+BAA+B;;;EAAgD,CAAA"}