@payloadcms/richtext-lexical 0.7.0 → 3.0.0-alpha.19

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

@@ -0,0 +1,6 @@
+/// <reference types="react" />
+export declare const UnorderedListConverterClient: import("react").FC<{
+    componentKey: string;
+    featureKey: string;
+}>;
+//# sourceMappingURL=client.d.ts.map

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

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

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

@@ -0,0 +1,6 @@
+'use client';
+import { createFeaturePropComponent } from '../../../../../createFeaturePropComponent';
+import { _SlateUnorderedListConverter } from './converter';
+export const UnorderedListConverterClient = createFeaturePropComponent(_SlateUnorderedListConverter);
+
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uL3NyYy9maWVsZC9mZWF0dXJlcy9taWdyYXRpb25zL3NsYXRlVG9MZXhpY2FsL2NvbnZlcnRlci9jb252ZXJ0ZXJzL3Vub3JkZXJlZExpc3QvY2xpZW50LnRzIl0sInNvdXJjZXNDb250ZW50IjpbIid1c2UgY2xpZW50J1xuXG5pbXBvcnQgeyBjcmVhdGVGZWF0dXJlUHJvcENvbXBvbmVudCB9IGZyb20gJy4uLy4uLy4uLy4uLy4uL2NyZWF0ZUZlYXR1cmVQcm9wQ29tcG9uZW50J1xuaW1wb3J0IHsgX1NsYXRlVW5vcmRlcmVkTGlzdENvbnZlcnRlciB9IGZyb20gJy4vY29udmVydGVyJ1xuXG5leHBvcnQgY29uc3QgVW5vcmRlcmVkTGlzdENvbnZlcnRlckNsaWVudCA9IGNyZWF0ZUZlYXR1cmVQcm9wQ29tcG9uZW50KF9TbGF0ZVVub3JkZXJlZExpc3RDb252ZXJ0ZXIpXG4iXSwibmFtZXMiOlsiY3JlYXRlRmVhdHVyZVByb3BDb21wb25lbnQiLCJfU2xhdGVVbm9yZGVyZWRMaXN0Q29udmVydGVyIiwiVW5vcmRlcmVkTGlzdENvbnZlcnRlckNsaWVudCJdLCJtYXBwaW5ncyI6IkFBQUE7QUFFQSxTQUFTQSwwQkFBMEIsUUFBUSw0Q0FBMkM7QUFDdEYsU0FBU0MsNEJBQTRCLFFBQVEsY0FBYTtBQUUxRCxPQUFPLE1BQU1DLCtCQUErQkYsMkJBQTJCQyw4QkFBNkIifQ==

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

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

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

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

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

@@ -0,0 +1,26 @@
+import { convertSlateNodesToLexical } from '../..';
+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=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uL3NyYy9maWVsZC9mZWF0dXJlcy9taWdyYXRpb25zL3NsYXRlVG9MZXhpY2FsL2NvbnZlcnRlci9jb252ZXJ0ZXJzL3Vub3JkZXJlZExpc3QvY29udmVydGVyLnRzIl0sInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB0eXBlIHsgU2VyaWFsaXplZExpc3ROb2RlIH0gZnJvbSAnQGxleGljYWwvbGlzdCdcblxuaW1wb3J0IHR5cGUgeyBTbGF0ZU5vZGVDb252ZXJ0ZXIgfSBmcm9tICcuLi8uLi90eXBlcydcblxuaW1wb3J0IHsgY29udmVydFNsYXRlTm9kZXNUb0xleGljYWwgfSBmcm9tICcuLi8uLidcblxuZXhwb3J0IGNvbnN0IF9TbGF0ZVVub3JkZXJlZExpc3RDb252ZXJ0ZXI6IFNsYXRlTm9kZUNvbnZlcnRlciA9IHtcbiAgY29udmVydGVyKHsgY29udmVydGVycywgc2xhdGVOb2RlIH0pIHtcbiAgICByZXR1cm4ge1xuICAgICAgdHlwZTogJ2xpc3QnLFxuICAgICAgY2hpbGRyZW46IGNvbnZlcnRTbGF0ZU5vZGVzVG9MZXhpY2FsKHtcbiAgICAgICAgY2FuQ29udGFpblBhcmFncmFwaHM6IGZhbHNlLFxuICAgICAgICBjb252ZXJ0ZXJzLFxuICAgICAgICBwYXJlbnROb2RlVHlwZTogJ2xpc3QnLFxuICAgICAgICBzbGF0ZU5vZGVzOiBzbGF0ZU5vZGUuY2hpbGRyZW4sXG4gICAgICB9KSxcbiAgICAgIGRpcmVjdGlvbjogJ2x0cicsXG4gICAgICBmb3JtYXQ6ICcnLFxuICAgICAgaW5kZW50OiAwLFxuICAgICAgbGlzdFR5cGU6ICdidWxsZXQnLFxuICAgICAgc3RhcnQ6IDEsXG4gICAgICB0YWc6ICd1bCcsXG4gICAgICB2ZXJzaW9uOiAxLFxuICAgIH0gYXMgY29uc3QgYXMgU2VyaWFsaXplZExpc3ROb2RlXG4gIH0sXG4gIG5vZGVUeXBlczogWyd1bCddLFxufVxuIl0sIm5hbWVzIjpbImNvbnZlcnRTbGF0ZU5vZGVzVG9MZXhpY2FsIiwiX1NsYXRlVW5vcmRlcmVkTGlzdENvbnZlcnRlciIsImNvbnZlcnRlciIsImNvbnZlcnRlcnMiLCJzbGF0ZU5vZGUiLCJ0eXBlIiwiY2hpbGRyZW4iLCJjYW5Db250YWluUGFyYWdyYXBocyIsInBhcmVudE5vZGVUeXBlIiwic2xhdGVOb2RlcyIsImRpcmVjdGlvbiIsImZvcm1hdCIsImluZGVudCIsImxpc3RUeXBlIiwic3RhcnQiLCJ0YWciLCJ2ZXJzaW9uIiwibm9kZVR5cGVzIl0sIm1hcHBpbmdzIjoiQUFJQSxTQUFTQSwwQkFBMEIsUUFBUSxRQUFPO0FBRWxELE9BQU8sTUFBTUMsK0JBQW1EO0lBQzlEQyxXQUFVLEVBQUVDLFVBQVUsRUFBRUMsU0FBUyxFQUFFO1FBQ2pDLE9BQU87WUFDTEMsTUFBTTtZQUNOQyxVQUFVTiwyQkFBMkI7Z0JBQ25DTyxzQkFBc0I7Z0JBQ3RCSjtnQkFDQUssZ0JBQWdCO2dCQUNoQkMsWUFBWUwsVUFBVUUsUUFBUTtZQUNoQztZQUNBSSxXQUFXO1lBQ1hDLFFBQVE7WUFDUkMsUUFBUTtZQUNSQyxVQUFVO1lBQ1ZDLE9BQU87WUFDUEMsS0FBSztZQUNMQyxTQUFTO1FBQ1g7SUFDRjtJQUNBQyxXQUFXO1FBQUM7S0FBSztBQUNuQixFQUFDIn0=

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

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

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

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

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

@@ -0,0 +1,8 @@
+import { UnorderedListConverterClient } from './client';
+import { _SlateUnorderedListConverter } from './converter';
+export const SlateUnorderedListConverter = {
+    ClientComponent: UnorderedListConverterClient,
+    converter: _SlateUnorderedListConverter
+};
+
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uL3NyYy9maWVsZC9mZWF0dXJlcy9taWdyYXRpb25zL3NsYXRlVG9MZXhpY2FsL2NvbnZlcnRlci9jb252ZXJ0ZXJzL3Vub3JkZXJlZExpc3QvaW5kZXgudHMiXSwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHR5cGUgeyBTbGF0ZU5vZGVDb252ZXJ0ZXJQcm92aWRlciB9IGZyb20gJy4uLy4uL3R5cGVzJ1xuXG5pbXBvcnQgeyBVbm9yZGVyZWRMaXN0Q29udmVydGVyQ2xpZW50IH0gZnJvbSAnLi9jbGllbnQnXG5pbXBvcnQgeyBfU2xhdGVVbm9yZGVyZWRMaXN0Q29udmVydGVyIH0gZnJvbSAnLi9jb252ZXJ0ZXInXG5cbmV4cG9ydCBjb25zdCBTbGF0ZVVub3JkZXJlZExpc3RDb252ZXJ0ZXI6IFNsYXRlTm9kZUNvbnZlcnRlclByb3ZpZGVyID0ge1xuICBDbGllbnRDb21wb25lbnQ6IFVub3JkZXJlZExpc3RDb252ZXJ0ZXJDbGllbnQsXG4gIGNvbnZlcnRlcjogX1NsYXRlVW5vcmRlcmVkTGlzdENvbnZlcnRlcixcbn1cbiJdLCJuYW1lcyI6WyJVbm9yZGVyZWRMaXN0Q29udmVydGVyQ2xpZW50IiwiX1NsYXRlVW5vcmRlcmVkTGlzdENvbnZlcnRlciIsIlNsYXRlVW5vcmRlcmVkTGlzdENvbnZlcnRlciIsIkNsaWVudENvbXBvbmVudCIsImNvbnZlcnRlciJdLCJtYXBwaW5ncyI6IkFBRUEsU0FBU0EsNEJBQTRCLFFBQVEsV0FBVTtBQUN2RCxTQUFTQyw0QkFBNEIsUUFBUSxjQUFhO0FBRTFELE9BQU8sTUFBTUMsOEJBQTBEO0lBQ3JFQyxpQkFBaUJIO0lBQ2pCSSxXQUFXSDtBQUNiLEVBQUMifQ==

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

@@ -0,0 +1,6 @@
+/// <reference types="react" />
+export declare const UploadConverterClient: import("react").FC<{
+    componentKey: string;
+    featureKey: string;
+}>;
+//# sourceMappingURL=client.d.ts.map

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

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

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

@@ -0,0 +1,6 @@
+'use client';
+import { createFeaturePropComponent } from '../../../../../createFeaturePropComponent';
+import { _SlateUploadConverter } from './converter';
+export const UploadConverterClient = createFeaturePropComponent(_SlateUploadConverter);
+
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uL3NyYy9maWVsZC9mZWF0dXJlcy9taWdyYXRpb25zL3NsYXRlVG9MZXhpY2FsL2NvbnZlcnRlci9jb252ZXJ0ZXJzL3VwbG9hZC9jbGllbnQudHMiXSwic291cmNlc0NvbnRlbnQiOlsiJ3VzZSBjbGllbnQnXG5cbmltcG9ydCB7IGNyZWF0ZUZlYXR1cmVQcm9wQ29tcG9uZW50IH0gZnJvbSAnLi4vLi4vLi4vLi4vLi4vY3JlYXRlRmVhdHVyZVByb3BDb21wb25lbnQnXG5pbXBvcnQgeyBfU2xhdGVVcGxvYWRDb252ZXJ0ZXIgfSBmcm9tICcuL2NvbnZlcnRlcidcblxuZXhwb3J0IGNvbnN0IFVwbG9hZENvbnZlcnRlckNsaWVudCA9IGNyZWF0ZUZlYXR1cmVQcm9wQ29tcG9uZW50KF9TbGF0ZVVwbG9hZENvbnZlcnRlcilcbiJdLCJuYW1lcyI6WyJjcmVhdGVGZWF0dXJlUHJvcENvbXBvbmVudCIsIl9TbGF0ZVVwbG9hZENvbnZlcnRlciIsIlVwbG9hZENvbnZlcnRlckNsaWVudCJdLCJtYXBwaW5ncyI6IkFBQUE7QUFFQSxTQUFTQSwwQkFBMEIsUUFBUSw0Q0FBMkM7QUFDdEYsU0FBU0MscUJBQXFCLFFBQVEsY0FBYTtBQUVuRCxPQUFPLE1BQU1DLHdCQUF3QkYsMkJBQTJCQyx1QkFBc0IifQ==

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

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

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

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

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

@@ -0,0 +1,21 @@
+export const _SlateUploadConverter = {
+    converter ({ slateNode }) {
+        return {
+            type: 'upload',
+            fields: {
+                ...slateNode.fields
+            },
+            format: '',
+            relationTo: slateNode.relationTo,
+            value: {
+                id: slateNode.value?.id || ''
+            },
+            version: 1
+        };
+    },
+    nodeTypes: [
+        'upload'
+    ]
+};
+
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uL3NyYy9maWVsZC9mZWF0dXJlcy9taWdyYXRpb25zL3NsYXRlVG9MZXhpY2FsL2NvbnZlcnRlci9jb252ZXJ0ZXJzL3VwbG9hZC9jb252ZXJ0ZXIudHMiXSwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHR5cGUgeyBTZXJpYWxpemVkVXBsb2FkTm9kZSB9IGZyb20gJy4uLy4uLy4uLy4uLy4uL3VwbG9hZC9ub2Rlcy9VcGxvYWROb2RlJ1xuaW1wb3J0IHR5cGUgeyBTbGF0ZU5vZGVDb252ZXJ0ZXIgfSBmcm9tICcuLi8uLi90eXBlcydcblxuZXhwb3J0IGNvbnN0IF9TbGF0ZVVwbG9hZENvbnZlcnRlcjogU2xhdGVOb2RlQ29udmVydGVyID0ge1xuICBjb252ZXJ0ZXIoeyBzbGF0ZU5vZGUgfSkge1xuICAgIHJldHVybiB7XG4gICAgICB0eXBlOiAndXBsb2FkJyxcbiAgICAgIGZpZWxkczoge1xuICAgICAgICAuLi5zbGF0ZU5vZGUuZmllbGRzLFxuICAgICAgfSxcbiAgICAgIGZvcm1hdDogJycsXG4gICAgICByZWxhdGlvblRvOiBzbGF0ZU5vZGUucmVsYXRpb25UbyxcbiAgICAgIHZhbHVlOiB7XG4gICAgICAgIGlkOiBzbGF0ZU5vZGUudmFsdWU/LmlkIHx8ICcnLFxuICAgICAgfSxcbiAgICAgIHZlcnNpb246IDEsXG4gICAgfSBhcyBjb25zdCBhcyBTZXJpYWxpemVkVXBsb2FkTm9kZVxuICB9LFxuICBub2RlVHlwZXM6IFsndXBsb2FkJ10sXG59XG4iXSwibmFtZXMiOlsiX1NsYXRlVXBsb2FkQ29udmVydGVyIiwiY29udmVydGVyIiwic2xhdGVOb2RlIiwidHlwZSIsImZpZWxkcyIsImZvcm1hdCIsInJlbGF0aW9uVG8iLCJ2YWx1ZSIsImlkIiwidmVyc2lvbiIsIm5vZGVUeXBlcyJdLCJtYXBwaW5ncyI6IkFBR0EsT0FBTyxNQUFNQSx3QkFBNEM7SUFDdkRDLFdBQVUsRUFBRUMsU0FBUyxFQUFFO1FBQ3JCLE9BQU87WUFDTEMsTUFBTTtZQUNOQyxRQUFRO2dCQUNOLEdBQUdGLFVBQVVFLE1BQU07WUFDckI7WUFDQUMsUUFBUTtZQUNSQyxZQUFZSixVQUFVSSxVQUFVO1lBQ2hDQyxPQUFPO2dCQUNMQyxJQUFJTixVQUFVSyxLQUFLLEVBQUVDLE1BQU07WUFDN0I7WUFDQUMsU0FBUztRQUNYO0lBQ0Y7SUFDQUMsV0FBVztRQUFDO0tBQVM7QUFDdkIsRUFBQyJ9

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

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

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

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

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

@@ -0,0 +1,8 @@
+import { UploadConverterClient } from './client';
+import { _SlateUploadConverter } from './converter';
+export const SlateUploadConverter = {
+    ClientComponent: UploadConverterClient,
+    converter: _SlateUploadConverter
+};
+
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uL3NyYy9maWVsZC9mZWF0dXJlcy9taWdyYXRpb25zL3NsYXRlVG9MZXhpY2FsL2NvbnZlcnRlci9jb252ZXJ0ZXJzL3VwbG9hZC9pbmRleC50cyJdLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgdHlwZSB7IFNsYXRlTm9kZUNvbnZlcnRlclByb3ZpZGVyIH0gZnJvbSAnLi4vLi4vdHlwZXMnXG5cbmltcG9ydCB7IFVwbG9hZENvbnZlcnRlckNsaWVudCB9IGZyb20gJy4vY2xpZW50J1xuaW1wb3J0IHsgX1NsYXRlVXBsb2FkQ29udmVydGVyIH0gZnJvbSAnLi9jb252ZXJ0ZXInXG5cbmV4cG9ydCBjb25zdCBTbGF0ZVVwbG9hZENvbnZlcnRlcjogU2xhdGVOb2RlQ29udmVydGVyUHJvdmlkZXIgPSB7XG4gIENsaWVudENvbXBvbmVudDogVXBsb2FkQ29udmVydGVyQ2xpZW50LFxuICBjb252ZXJ0ZXI6IF9TbGF0ZVVwbG9hZENvbnZlcnRlcixcbn1cbiJdLCJuYW1lcyI6WyJVcGxvYWRDb252ZXJ0ZXJDbGllbnQiLCJfU2xhdGVVcGxvYWRDb252ZXJ0ZXIiLCJTbGF0ZVVwbG9hZENvbnZlcnRlciIsIkNsaWVudENvbXBvbmVudCIsImNvbnZlcnRlciJdLCJtYXBwaW5ncyI6IkFBRUEsU0FBU0EscUJBQXFCLFFBQVEsV0FBVTtBQUNoRCxTQUFTQyxxQkFBcUIsUUFBUSxjQUFhO0FBRW5ELE9BQU8sTUFBTUMsdUJBQW1EO0lBQzlEQyxpQkFBaUJIO0lBQ2pCSSxXQUFXSDtBQUNiLEVBQUMifQ==

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

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

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

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

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

@@ -0,0 +1,24 @@
+import { SlateBlockquoteConverter } from './converters/blockquote';
+import { SlateHeadingConverter } from './converters/heading';
+import { SlateIndentConverter } from './converters/indent';
+import { SlateLinkConverter } from './converters/link';
+import { SlateListItemConverter } from './converters/listItem';
+import { SlateOrderedListConverter } from './converters/orderedList';
+import { SlateRelationshipConverter } from './converters/relationship';
+import { SlateUnknownConverter } from './converters/unknown';
+import { SlateUnorderedListConverter } from './converters/unorderedList';
+import { SlateUploadConverter } from './converters/upload';
+export const defaultSlateConverters = [
+    SlateBlockquoteConverter,
+    SlateHeadingConverter,
+    SlateIndentConverter,
+    SlateLinkConverter,
+    SlateListItemConverter,
+    SlateOrderedListConverter,
+    SlateRelationshipConverter,
+    SlateUnorderedListConverter,
+    SlateUploadConverter,
+    SlateUnknownConverter
+];
+
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,19 @@
+import type { SerializedEditorState, SerializedLexicalNode, SerializedParagraphNode, SerializedTextNode } from 'lexical';
+import type { SlateNode, SlateNodeConverter } from './types';
+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/field/features/migrations/slateToLexical/converter/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../src/field/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,SAAS,CAAA;AAI5D,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,CAczB;AACD,wBAAgB,eAAe,CAAC,IAAI,EAAE,SAAS,GAAG,kBAAkB,CAUnE;AAED,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,SAAS,GAAG,MAAM,CAwB3D"}

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

@@ -0,0 +1,107 @@
+import { NodeFormat } from '../../../../lexical/utils/nodeFormat';
+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) {
+        return [];
+    }
+    const unknownConverter = converters.find((converter)=>converter.nodeTypes.includes('unknown'));
+    return slateNodes.map((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 {
+                // This is a simple text node. canContainParagraphs may be false if this is nested inside of 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,
+        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=data:application/json;base64,{"version":3,"sources":["../../../../../../src/field/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'\n\nimport { NodeFormat } from '../../../../lexical/utils/nodeFormat'\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 of 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    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","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"],"mappings":"AASA,SAASA,UAAU,QAAQ,uCAAsC;AAEjE,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,4JAA4J;gBAC5J,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;QACRC,SAAS;IACX;AACF;AACA,OAAO,SAASW,gBAAgBI,IAAe;IAC7C,OAAO;QACLxB,MAAM;QACNyB,QAAQ;QACRlB,QAAQmB,oBAAoBF;QAC5BG,MAAM;QACNC,OAAO;QACPC,MAAML,KAAKK,IAAI;QACfpB,SAAS;IACX;AACF;AAEA,OAAO,SAASiB,oBAAoBF,IAAe;IACjD,IAAIjB,SAAS;IACb,IAAIiB,KAAKM,IAAI,EAAE;QACbvB,SAASA,SAASZ,WAAWoC,OAAO;IACtC;IACA,IAAIP,KAAKQ,MAAM,EAAE;QACfzB,SAASA,SAASZ,WAAWsC,SAAS;IACxC;IACA,IAAIT,KAAKU,aAAa,EAAE;QACtB3B,SAASA,SAASZ,WAAWwC,gBAAgB;IAC/C;IACA,IAAIX,KAAKY,SAAS,EAAE;QAClB7B,SAASA,SAASZ,WAAW0C,YAAY;IAC3C;IACA,IAAIb,KAAKc,SAAS,EAAE;QAClB/B,SAASA,SAASZ,WAAW4C,YAAY;IAC3C;IACA,IAAIf,KAAKgB,WAAW,EAAE;QACpBjC,SAASA,SAASZ,WAAW8C,cAAc;IAC7C;IACA,IAAIjB,KAAKkB,IAAI,EAAE;QACbnC,SAASA,SAASZ,WAAWgD,OAAO;IACtC;IACA,OAAOpC;AACT"}

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

@@ -0,0 +1,25 @@
+import type { SerializedLexicalNode } from 'lexical';
+import type React from 'react';
+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;
+};
+export type SlateNodeConverterClientComponent = React.FC<{
+    componentKey: string;
+    featureKey: string;
+}>;
+export type SlateNodeConverterProvider = {
+    ClientComponent: SlateNodeConverterClientComponent;
+    converter: SlateNodeConverter;
+};
+//# sourceMappingURL=types.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../../../src/field/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/field/features/migrations/slateToLexical/converter/types.js

@@ -0,0 +1,3 @@
+export { };
+
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL3NyYy9maWVsZC9mZWF0dXJlcy9taWdyYXRpb25zL3NsYXRlVG9MZXhpY2FsL2NvbnZlcnRlci90eXBlcy50cyJdLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgdHlwZSB7IFNlcmlhbGl6ZWRMZXhpY2FsTm9kZSB9IGZyb20gJ2xleGljYWwnXG5pbXBvcnQgdHlwZSBSZWFjdCBmcm9tICdyZWFjdCdcblxuZXhwb3J0IHR5cGUgU2xhdGVOb2RlQ29udmVydGVyPFQgZXh0ZW5kcyBTZXJpYWxpemVkTGV4aWNhbE5vZGUgPSBTZXJpYWxpemVkTGV4aWNhbE5vZGU+ID0ge1xuICBjb252ZXJ0ZXI6ICh7XG4gICAgY2hpbGRJbmRleCxcbiAgICBjb252ZXJ0ZXJzLFxuICAgIHBhcmVudE5vZGVUeXBlLFxuICAgIHNsYXRlTm9kZSxcbiAgfToge1xuICAgIGNoaWxkSW5kZXg6IG51bWJlclxuICAgIGNvbnZlcnRlcnM6IFNsYXRlTm9kZUNvbnZlcnRlcltdXG4gICAgcGFyZW50Tm9kZVR5cGU6IHN0cmluZ1xuICAgIHNsYXRlTm9kZTogU2xhdGVOb2RlXG4gIH0pID0+IFRcbiAgbm9kZVR5cGVzOiBzdHJpbmdbXVxufVxuXG5leHBvcnQgdHlwZSBTbGF0ZU5vZGUgPSB7XG4gIFtrZXk6IHN0cmluZ106IGFueVxuICBjaGlsZHJlbj86IFNsYXRlTm9kZVtdXG4gIHR5cGU/OiBzdHJpbmcgLy8gZG9lc24ndCBhbHdheXMgaGF2ZSB0eXBlLCBlLmcuIGZvciBwYXJhZ3JhcGhzXG59XG5cbmV4cG9ydCB0eXBlIFNsYXRlTm9kZUNvbnZlcnRlckNsaWVudENvbXBvbmVudCA9IFJlYWN0LkZDPHtcbiAgY29tcG9uZW50S2V5OiBzdHJpbmdcbiAgZmVhdHVyZUtleTogc3RyaW5nXG59PlxuXG5leHBvcnQgdHlwZSBTbGF0ZU5vZGVDb252ZXJ0ZXJQcm92aWRlciA9IHtcbiAgQ2xpZW50Q29tcG9uZW50OiBTbGF0ZU5vZGVDb252ZXJ0ZXJDbGllbnRDb21wb25lbnRcbiAgY29udmVydGVyOiBTbGF0ZU5vZGVDb252ZXJ0ZXJcbn1cbiJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUE2QkEsV0FHQyJ9

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

@@ -0,0 +1,3 @@
+/// <reference types="react" />
+export declare const SlateToLexicalFeatureClientComponent: import("react").FC<undefined>;
+//# sourceMappingURL=feature.client.d.ts.map

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

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

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

@@ -0,0 +1,34 @@
+'use client';
+import { createClientComponent } from '../../createClientComponent';
+import { convertSlateToLexical } from './converter';
+import { UnknownConvertedNode } from './nodes/unknownConvertedNode';
+const SlateToLexicalFeatureClient = (props)=>{
+    return {
+        clientFeatureProps: props,
+        feature: ({ clientFunctions })=>{
+            const converters = Object.values(clientFunctions);
+            return {
+                clientFeatureProps: props,
+                hooks: {
+                    load ({ incomingEditorState }) {
+                        if (!incomingEditorState || !Array.isArray(incomingEditorState) || 'root' in incomingEditorState) {
+                            // incomingEditorState null or not from Slate
+                            return incomingEditorState;
+                        }
+                        // Slate => convert to lexical
+                        return convertSlateToLexical({
+                            converters,
+                            slateData: incomingEditorState
+                        });
+                    }
+                },
+                nodes: [
+                    UnknownConvertedNode
+                ]
+            };
+        }
+    };
+};
+export const SlateToLexicalFeatureClientComponent = createClientComponent(SlateToLexicalFeatureClient);
+
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,9 @@
+import type { FeatureProviderProviderServer } from '../../types';
+import type { SlateNodeConverterProvider } from './converter/types';
+export type SlateToLexicalFeatureProps = {
+    converters?: (({ defaultConverters, }: {
+        defaultConverters: SlateNodeConverterProvider[];
+    }) => SlateNodeConverterProvider[]) | SlateNodeConverterProvider[];
+};
+export declare const SlateToLexicalFeature: FeatureProviderProviderServer<SlateToLexicalFeatureProps, undefined>;
+//# sourceMappingURL=feature.server.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"feature.server.d.ts","sourceRoot":"","sources":["../../../../../src/field/features/migrations/slateToLexical/feature.server.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,6BAA6B,EAAE,MAAM,aAAa,CAAA;AAChE,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,mBAAmB,CAAA;AAMnE,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/field/features/migrations/slateToLexical/feature.server.js

@@ -0,0 +1,47 @@
+import { defaultSlateConverters } from './converter/defaultConverters';
+import { SlateToLexicalFeatureClientComponent } from './feature.client';
+import { UnknownConvertedNode } from './nodes/unknownConvertedNode';
+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=data:application/json;base64,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

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

@@ -0,0 +1 @@
+{"version":3,"file":"Component.d.ts","sourceRoot":"","sources":["../../../../../../../src/field/features/migrations/slateToLexical/nodes/unknownConvertedNode/Component.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,OAAO,CAAA;AAEzB,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,SAAS,CAAA;AAEvD,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/field/features/migrations/slateToLexical/nodes/unknownConvertedNode/Component.js

@@ -0,0 +1,8 @@
+import React from 'react';
+import './index.scss';
+export const UnknownConvertedNodeComponent = (props)=>{
+    const { data } = props;
+    return /*#__PURE__*/ React.createElement("div", null, "Unknown converted Slate node: ", /*#__PURE__*/ React.createElement("strong", null, data?.nodeType));
+};
+
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uL3NyYy9maWVsZC9mZWF0dXJlcy9taWdyYXRpb25zL3NsYXRlVG9MZXhpY2FsL25vZGVzL3Vua25vd25Db252ZXJ0ZWROb2RlL0NvbXBvbmVudC50c3giXSwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IFJlYWN0IGZyb20gJ3JlYWN0J1xuXG5pbXBvcnQgdHlwZSB7IFVua25vd25Db252ZXJ0ZWROb2RlRGF0YSB9IGZyb20gJy4vaW5kZXgnXG5cbmltcG9ydCAnLi9pbmRleC5zY3NzJ1xuXG50eXBlIFByb3BzID0ge1xuICBkYXRhOiBVbmtub3duQ29udmVydGVkTm9kZURhdGFcbn1cblxuZXhwb3J0IGNvbnN0IFVua25vd25Db252ZXJ0ZWROb2RlQ29tcG9uZW50OiBSZWFjdC5GQzxQcm9wcz4gPSAocHJvcHMpID0+IHtcbiAgY29uc3QgeyBkYXRhIH0gPSBwcm9wc1xuXG4gIHJldHVybiAoXG4gICAgPGRpdj5cbiAgICAgIFVua25vd24gY29udmVydGVkIFNsYXRlIG5vZGU6IDxzdHJvbmc+e2RhdGE/Lm5vZGVUeXBlfTwvc3Ryb25nPlxuICAgIDwvZGl2PlxuICApXG59XG4iXSwibmFtZXMiOlsiUmVhY3QiLCJVbmtub3duQ29udmVydGVkTm9kZUNvbXBvbmVudCIsInByb3BzIiwiZGF0YSIsImRpdiIsInN0cm9uZyIsIm5vZGVUeXBlIl0sIm1hcHBpbmdzIjoiQUFBQSxPQUFPQSxXQUFXLFFBQU87QUFJekIsT0FBTyxlQUFjO0FBTXJCLE9BQU8sTUFBTUMsZ0NBQWlELENBQUNDO0lBQzdELE1BQU0sRUFBRUMsSUFBSSxFQUFFLEdBQUdEO0lBRWpCLHFCQUNFLG9CQUFDRSxhQUFJLGdEQUMyQixvQkFBQ0MsZ0JBQVFGLE1BQU1HO0FBR25ELEVBQUMifQ==

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../../src/field/features/migrations/slateToLexical/nodes/unknownConvertedNode/index.tsx"],"names":[],"mappings":";AAAA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,EAAE,MAAM,SAAS,CAAA;AAG5D,OAAO,EAAE,aAAa,EAAE,KAAK,YAAY,EAAE,KAAK,WAAW,EAAE,KAAK,OAAO,EAAE,MAAM,SAAS,CAAA;AAG1F,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;AASD,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/field/features/migrations/slateToLexical/nodes/unknownConvertedNode/index.js

@@ -0,0 +1,69 @@
+import { addClassNamesToElement } from '@lexical/utils';
+import { DecoratorNode } from 'lexical';
+import * as React from 'react';
+const Component = /*#__PURE__*/ React.lazy(()=>// @ts-expect-error-next-line TypeScript being dumb
+    import('./Component').then((module)=>({
+            default: module.UnknownConvertedNodeComponent
+        })));
+/** @noInheritDoc */ export class UnknownConvertedNode extends DecoratorNode {
+    __data;
+    constructor({ data, key }){
+        super(key);
+        this.__data = data;
+    }
+    static clone(node) {
+        return new UnknownConvertedNode({
+            data: node.__data,
+            key: node.__key
+        });
+    }
+    static getType() {
+        return 'unknownConverted';
+    }
+    static importJSON(serializedNode) {
+        const node = $createUnknownConvertedNode({
+            data: serializedNode.data
+        });
+        return node;
+    }
+    canInsertTextAfter() {
+        return true;
+    }
+    canInsertTextBefore() {
+        return true;
+    }
+    createDOM(config) {
+        const element = document.createElement('span');
+        addClassNamesToElement(element, 'unknownConverted');
+        return element;
+    }
+    decorate() {
+        return /*#__PURE__*/ React.createElement(Component, {
+            data: this.__data
+        });
+    }
+    exportJSON() {
+        return {
+            type: this.getType(),
+            data: this.__data,
+            version: 1
+        };
+    }
+    // Mutation
+    isInline() {
+        return true;
+    }
+    updateDOM(prevNode, dom) {
+        return false;
+    }
+}
+export function $createUnknownConvertedNode({ data }) {
+    return new UnknownConvertedNode({
+        data
+    });
+}
+export function $isUnknownConvertedNode(node) {
+    return node instanceof UnknownConvertedNode;
+}
+
+//# sourceMappingURL=data:application/json;base64,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

package/dist/field/features/migrations/slateToLexical/nodes/unknownConvertedNode/index.scss

@@ -0,0 +1,14 @@
+span.unknownConverted {
+  text-transform: uppercase;
+  font-family: 'Roboto Mono', monospace;
+  letter-spacing: 2px;
+  font-size: calc(var(--base) * 0.5);
+  margin: 0 0 var(--base);
+  background: red;
+  color: white;
+  display: inline-block;
+
+  div {
+    background: red;
+  }
+}