tabshift/payload
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

feat(richtext-lexical): slateToLexicalFeature

Browse Source
This commit is contained in:
Alessio Gravili
2024-03-01 13:38:39 -05:00
parent 1a4b6a66ae
commit 27ea4f76f0
39 changed files with 312 additions and 156 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
packages/richtext-lexical/src/field/features/migrations/lexicalPluginToLexical/feature.client.tsx
View File

@@ -1,7 +1,7 @@
'use client'
import type { FeatureProviderProviderClient } from '../../types'
import type { PayloadPluginLexicalData } from './converter/types'
import type { LexicalPluginNodeConverter, PayloadPluginLexicalData } from './converter/types'
import { createClientComponent } from '../../createClientComponent'
import { convertLexicalPluginToLexical } from './converter'
@@ -11,7 +11,7 @@ const LexicalPluginToLexicalFeatureClient: FeatureProviderProviderClient<null> =
return {
clientFeatureProps: props,
feature: ({ clientFunctions, resolvedFeatures }) => {
const converters = Object.values(clientFunctions)
const converters: LexicalPluginNodeConverter[] = Object.values(clientFunctions)
return {
clientFeatureProps: props,

4
packages/richtext-lexical/src/field/features/migrations/lexicalPluginToLexical/feature.server.ts
View File

@@ -29,7 +29,9 @@ export const LexicalPluginToLexicalFeature: FeatureProviderProviderServer<
if (props?.converters && typeof props?.converters === 'function') {
converters = props.converters({ defaultConverters })
} else if (!props?.converters) {
} else if (props.converters && typeof props?.converters !== 'function') {
converters = props.converters
} else {
converters = defaultConverters
}

6
packages/richtext-lexical/src/field/features/migrations/slateToLexical/converter/converters/blockquote/client.ts Normal file
View File

@@ -0,0 +1,6 @@
'use client'
import { createFeaturePropComponent } from '../../../../../createFeaturePropComponent'
import { _SlateBlockquoteConverter } from './converter'
export const BlockQuoteConverterClient = createFeaturePropComponent(_SlateBlockquoteConverter)

8
packages/richtext-lexical/src/field/features/migrations/slateToLexical/converter/converters/blockquote.ts → packages/richtext-lexical/src/field/features/migrations/slateToLexical/converter/converters/blockquote/converter.ts
View File

@@ -1,10 +1,10 @@
import type { SerializedQuoteNode } from '@lexical/rich-text'
import type { SlateNodeConverter } from '../types'
import type { SlateNodeConverter } from '../../types'
import { convertSlateNodesToLexical } from '../index'
import { convertSlateNodesToLexical } from '../..'
export const SlateBlockquoteConverter: SlateNodeConverter = {
export const _SlateBlockquoteConverter: SlateNodeConverter = {
converter({ converters, slateNode }) {
return {
type: 'quote',
@@ -12,7 +12,7 @@ export const SlateBlockquoteConverter: SlateNodeConverter = {
canContainParagraphs: false,
converters,
parentNodeType: 'quote',
slateNodes: slateNode.children || [],
slateNodes: slateNode.children,
}),
direction: 'ltr',
format: '',

9
packages/richtext-lexical/src/field/features/migrations/slateToLexical/converter/converters/blockquote/index.ts Normal file
View File

@@ -0,0 +1,9 @@
import type { SlateNodeConverterProvider } from '../../types'
import { BlockQuoteConverterClient } from './client'
import { _SlateBlockquoteConverter } from './converter'
export const SlateBlockquoteConverter: SlateNodeConverterProvider = {
ClientComponent: BlockQuoteConverterClient,
converter: _SlateBlockquoteConverter,
}

5
packages/richtext-lexical/src/field/features/migrations/slateToLexical/converter/converters/heading/client.ts Normal file
View File

@@ -0,0 +1,5 @@
'use client'
import { createFeaturePropComponent } from '../../../../../createFeaturePropComponent'
import { _SlateHeadingConverter } from './converter'
export const HeadingConverterClient = createFeaturePropComponent(_SlateHeadingConverter)

8
packages/richtext-lexical/src/field/features/migrations/slateToLexical/converter/converters/heading.ts → packages/richtext-lexical/src/field/features/migrations/slateToLexical/converter/converters/heading/converter.ts
View File

@@ -1,10 +1,10 @@
import type { SerializedHeadingNode } from '@lexical/rich-text'
import type { SlateNodeConverter } from '../types'
import type { SlateNodeConverter } from '../../types'
import { convertSlateNodesToLexical } from '..'
import { convertSlateNodesToLexical } from '../..'
export const SlateHeadingConverter: SlateNodeConverter = {
export const _SlateHeadingConverter: SlateNodeConverter = {
converter({ converters, slateNode }) {
return {
type: 'heading',
@@ -12,7 +12,7 @@ export const SlateHeadingConverter: SlateNodeConverter = {
canContainParagraphs: false,
converters,
parentNodeType: 'heading',
slateNodes: slateNode.children || [],
slateNodes: slateNode.children,
}),
direction: 'ltr',
format: '',

9
packages/richtext-lexical/src/field/features/migrations/slateToLexical/converter/converters/heading/index.ts Normal file
View File

@@ -0,0 +1,9 @@
import type { SlateNodeConverterProvider } from '../../types'
import { HeadingConverterClient } from './client'
import { _SlateHeadingConverter } from './converter'
export const SlateHeadingConverter: SlateNodeConverterProvider = {
ClientComponent: HeadingConverterClient,
converter: _SlateHeadingConverter,
}

65
packages/richtext-lexical/src/field/features/migrations/slateToLexical/converter/converters/indent.ts
View File

@@ -1,65 +0,0 @@
import type { SerializedLexicalNode, SerializedParagraphNode } from 'lexical'
import type { SlateNodeConverter } from '../types'
import { convertSlateNodesToLexical } from '..'
export const SlateIndentConverter: SlateNodeConverter = {
converter({ converters, slateNode }) {
console.log('slateToLexical > IndentConverter > converter', JSON.stringify(slateNode, null, 2))
const convertChildren = (node: any, indentLevel: number = 0): SerializedLexicalNode => {
if (
(node?.type && (!node.children || node.type !== 'indent')) ||
(!node?.type && node?.text)
) {
console.log(
'slateToLexical > IndentConverter > convertChildren > node',
JSON.stringify(node, null, 2),
)
console.log(
'slateToLexical > IndentConverter > convertChildren > nodeOutput',
JSON.stringify(
convertSlateNodesToLexical({
canContainParagraphs: false,
converters,
parentNodeType: 'indent',
slateNodes: [node],
}),
null,
2,
),
)
return {
...convertSlateNodesToLexical({
canContainParagraphs: false,
converters,
parentNodeType: 'indent',
slateNodes: [node],
})[0],
indent: indentLevel,
} as const as SerializedLexicalNode
}
const children = node.children.map((child: any) => convertChildren(child, indentLevel + 1))
console.log('slateToLexical > IndentConverter > children', JSON.stringify(children, null, 2))
return {
type: 'paragraph',
children: children,
direction: 'ltr',
format: '',
indent: indentLevel,
version: 1,
} as const as SerializedParagraphNode
}
console.log(
'slateToLexical > IndentConverter > output',
JSON.stringify(convertChildren(slateNode), null, 2),
)
return convertChildren(slateNode)
},
nodeTypes: ['indent'],
}

6
packages/richtext-lexical/src/field/features/migrations/slateToLexical/converter/converters/indent/client.ts Normal file
View File

@@ -0,0 +1,6 @@
'use client'
import { createFeaturePropComponent } from '../../../../../createFeaturePropComponent'
import { _SlateIndentConverter } from './converter'
export const IndentConverterClient = createFeaturePropComponent(_SlateIndentConverter)

39
packages/richtext-lexical/src/field/features/migrations/slateToLexical/converter/converters/indent/converter.ts Normal file
View File

@@ -0,0 +1,39 @@
import type { SerializedLexicalNode, SerializedParagraphNode } from 'lexical'
import type { SlateNodeConverter } from '../../types'
import { convertSlateNodesToLexical } from '../..'
export const _SlateIndentConverter: SlateNodeConverter = {
converter({ converters, slateNode }) {
const convertChildren = (node: any, indentLevel: number = 0): SerializedLexicalNode => {
if (
(node?.type && (!node.children || node.type !== 'indent')) ||
(!node?.type && node?.text)
) {
return {
...convertSlateNodesToLexical({
canContainParagraphs: false,
converters,
parentNodeType: 'indent',
slateNodes: [node],
})[0],
indent: indentLevel,
} as const as SerializedLexicalNode
}
const children = node.children.map((child: any) => convertChildren(child, indentLevel + 1))
return {
type: 'paragraph',
children,
direction: 'ltr',
format: '',
indent: indentLevel,
version: 1,
} as const as SerializedParagraphNode
}
return convertChildren(slateNode)
},
nodeTypes: ['indent'],
}

9
packages/richtext-lexical/src/field/features/migrations/slateToLexical/converter/converters/indent/index.ts Normal file
View File

@@ -0,0 +1,9 @@
import type { SlateNodeConverterProvider } from '../../types'
import { IndentConverterClient } from './client'
import { _SlateIndentConverter } from './converter'
export const SlateIndentConverter: SlateNodeConverterProvider = {
ClientComponent: IndentConverterClient,
converter: _SlateIndentConverter,
}

6
packages/richtext-lexical/src/field/features/migrations/slateToLexical/converter/converters/link/client.ts Normal file
View File

@@ -0,0 +1,6 @@
'use client'
import { createFeaturePropComponent } from '../../../../../createFeaturePropComponent'
import { _SlateLinkConverter } from './converter'
export const LinkConverterClient = createFeaturePropComponent(_SlateLinkConverter)

10
packages/richtext-lexical/src/field/features/migrations/slateToLexical/converter/converters/link.ts → packages/richtext-lexical/src/field/features/migrations/slateToLexical/converter/converters/link/converter.ts
View File

@@ -1,9 +1,9 @@
import type { SerializedLinkNode } from '../../../../link/nodes/LinkNode'
import type { SlateNodeConverter } from '../types'
import type { SerializedLinkNode } from '../../../../../link/nodes/types'
import type { SlateNodeConverter } from '../../types'
import { convertSlateNodesToLexical } from '..'
import { convertSlateNodesToLexical } from '../..'
export const SlateLinkConverter: SlateNodeConverter = {
export const _SlateLinkConverter: SlateNodeConverter = {
converter({ converters, slateNode }) {
return {
type: 'link',
@@ -11,7 +11,7 @@ export const SlateLinkConverter: SlateNodeConverter = {
canContainParagraphs: false,
converters,
parentNodeType: 'link',
slateNodes: slateNode.children || [],
slateNodes: slateNode.children,
}),
direction: 'ltr',
fields: {

9
packages/richtext-lexical/src/field/features/migrations/slateToLexical/converter/converters/link/index.ts Normal file
View File

@@ -0,0 +1,9 @@
import type { SlateNodeConverterProvider } from '../../types'
import { LinkConverterClient } from './client'
import { _SlateLinkConverter } from './converter'
export const SlateLinkConverter: SlateNodeConverterProvider = {
ClientComponent: LinkConverterClient,
converter: _SlateLinkConverter,
}

6
packages/richtext-lexical/src/field/features/migrations/slateToLexical/converter/converters/listItem/client.ts Normal file
View File

@@ -0,0 +1,6 @@
'use client'
import { createFeaturePropComponent } from '../../../../../createFeaturePropComponent'
import { _SlateListItemConverter } from './converter'
export const ListItemConverterClient = createFeaturePropComponent(_SlateListItemConverter)

8
packages/richtext-lexical/src/field/features/migrations/slateToLexical/converter/converters/listItem.ts → packages/richtext-lexical/src/field/features/migrations/slateToLexical/converter/converters/listItem/converter.ts
View File

@@ -1,10 +1,10 @@
import type { SerializedListItemNode } from '@lexical/list'
import type { SlateNodeConverter } from '../types'
import type { SlateNodeConverter } from '../../types'
import { convertSlateNodesToLexical } from '..'
import { convertSlateNodesToLexical } from '../..'
export const SlateListItemConverter: SlateNodeConverter = {
export const _SlateListItemConverter: SlateNodeConverter = {
converter({ childIndex, converters, slateNode }) {
return {
type: 'listitem',
@@ -13,7 +13,7 @@ export const SlateListItemConverter: SlateNodeConverter = {
canContainParagraphs: false,
converters,
parentNodeType: 'listitem',
slateNodes: slateNode.children || [],
slateNodes: slateNode.children,
}),
direction: 'ltr',
format: '',

9
packages/richtext-lexical/src/field/features/migrations/slateToLexical/converter/converters/listItem/index.ts Normal file
View File

@@ -0,0 +1,9 @@
import type { SlateNodeConverterProvider } from '../../types'
import { ListItemConverterClient } from './client'
import { _SlateListItemConverter } from './converter'
export const SlateListItemConverter: SlateNodeConverterProvider = {
ClientComponent: ListItemConverterClient,
converter: _SlateListItemConverter,
}

6
packages/richtext-lexical/src/field/features/migrations/slateToLexical/converter/converters/orderedList/client.ts Normal file
View File

@@ -0,0 +1,6 @@
'use client'
import { createFeaturePropComponent } from '../../../../../createFeaturePropComponent'
import { _SlateOrderedListConverter } from './converter'
export const OrderedListConverterClient = createFeaturePropComponent(_SlateOrderedListConverter)

8
packages/richtext-lexical/src/field/features/migrations/slateToLexical/converter/converters/orderedList.ts → packages/richtext-lexical/src/field/features/migrations/slateToLexical/converter/converters/orderedList/converter.ts
View File

@@ -1,10 +1,10 @@
import type { SerializedListNode } from '@lexical/list'
import type { SlateNodeConverter } from '../types'
import type { SlateNodeConverter } from '../../types'
import { convertSlateNodesToLexical } from '..'
import { convertSlateNodesToLexical } from '../..'
export const SlateOrderedListConverter: SlateNodeConverter = {
export const _SlateOrderedListConverter: SlateNodeConverter = {
converter({ converters, slateNode }) {
return {
type: 'list',
@@ -12,7 +12,7 @@ export const SlateOrderedListConverter: SlateNodeConverter = {
canContainParagraphs: false,
converters,
parentNodeType: 'list',
slateNodes: slateNode.children || [],
slateNodes: slateNode.children,
}),
direction: 'ltr',
format: '',

9
packages/richtext-lexical/src/field/features/migrations/slateToLexical/converter/converters/orderedList/index.ts Normal file
View File

@@ -0,0 +1,9 @@
import type { SlateNodeConverterProvider } from '../../types'
import { OrderedListConverterClient } from './client'
import { _SlateOrderedListConverter } from './converter'
export const SlateOrderedListConverter: SlateNodeConverterProvider = {
ClientComponent: OrderedListConverterClient,
converter: _SlateOrderedListConverter,
}

6
packages/richtext-lexical/src/field/features/migrations/slateToLexical/converter/converters/relationship/client.ts Normal file
View File

@@ -0,0 +1,6 @@
'use client'
import { createFeaturePropComponent } from '../../../../../createFeaturePropComponent'
import { _SlateRelationshipConverter } from './converter'
export const RelationshipConverterClient = createFeaturePropComponent(_SlateRelationshipConverter)

6
packages/richtext-lexical/src/field/features/migrations/slateToLexical/converter/converters/relationship.ts → packages/richtext-lexical/src/field/features/migrations/slateToLexical/converter/converters/relationship/converter.ts
View File

@@ -1,7 +1,7 @@
import type { SerializedRelationshipNode } from '../../../../../..'
import type { SlateNodeConverter } from '../types'
import type { SerializedRelationshipNode } from '../../../../../relationship/nodes/RelationshipNode'
import type { SlateNodeConverter } from '../../types'
export const SlateRelationshipConverter: SlateNodeConverter = {
export const _SlateRelationshipConverter: SlateNodeConverter = {
converter({ slateNode }) {
return {
type: 'relationship',

9
packages/richtext-lexical/src/field/features/migrations/slateToLexical/converter/converters/relationship/index.ts Normal file
View File

@@ -0,0 +1,9 @@
import type { SlateNodeConverterProvider } from '../../types'
import { RelationshipConverterClient } from './client'
import { _SlateRelationshipConverter } from './converter'
export const SlateRelationshipConverter: SlateNodeConverterProvider = {
ClientComponent: RelationshipConverterClient,
converter: _SlateRelationshipConverter,
}

6
packages/richtext-lexical/src/field/features/migrations/slateToLexical/converter/converters/unknown/client.ts Normal file
View File

@@ -0,0 +1,6 @@
'use client'
import { createFeaturePropComponent } from '../../../../../createFeaturePropComponent'
import { _SlateUnknownConverter } from './converter'
export const UnknownConverterClient = createFeaturePropComponent(_SlateUnknownConverter)

10
packages/richtext-lexical/src/field/features/migrations/slateToLexical/converter/converters/unknown.ts → packages/richtext-lexical/src/field/features/migrations/slateToLexical/converter/converters/unknown/converter.ts
View File

@@ -1,9 +1,9 @@
import type { SerializedUnknownConvertedNode } from '../../nodes/unknownConvertedNode'
import type { SlateNodeConverter } from '../types'
import type { SerializedUnknownConvertedNode } from '../../../nodes/unknownConvertedNode'
import type { SlateNodeConverter } from '../../types'
import { convertSlateNodesToLexical } from '..'
import { convertSlateNodesToLexical } from '../..'
export const SlateUnknownConverter: SlateNodeConverter = {
export const _SlateUnknownConverter: SlateNodeConverter = {
converter({ converters, slateNode }) {
return {
type: 'unknownConverted',
@@ -11,7 +11,7 @@ export const SlateUnknownConverter: SlateNodeConverter = {
canContainParagraphs: false,
converters,
parentNodeType: 'unknownConverted',
slateNodes: slateNode.children || [],
slateNodes: slateNode.children,
}),
data: {
nodeData: slateNode,

9
packages/richtext-lexical/src/field/features/migrations/slateToLexical/converter/converters/unknown/index.ts Normal file
View File

@@ -0,0 +1,9 @@
import type { SlateNodeConverterProvider } from '../../types'
import { UnknownConverterClient } from './client'
import { _SlateUnknownConverter } from './converter'
export const SlateUnknownConverter: SlateNodeConverterProvider = {
ClientComponent: UnknownConverterClient,
converter: _SlateUnknownConverter,
}

6
packages/richtext-lexical/src/field/features/migrations/slateToLexical/converter/converters/unorderedList/client.ts Normal file
View File

@@ -0,0 +1,6 @@
'use client'
import { createFeaturePropComponent } from '../../../../../createFeaturePropComponent'
import { _SlateUnorderedListConverter } from './converter'
export const UnorderedListConverterClient = createFeaturePropComponent(_SlateUnorderedListConverter)

8
packages/richtext-lexical/src/field/features/migrations/slateToLexical/converter/converters/unorderedList.ts → packages/richtext-lexical/src/field/features/migrations/slateToLexical/converter/converters/unorderedList/converter.ts
View File

@@ -1,10 +1,10 @@
import type { SerializedListNode } from '@lexical/list'
import type { SlateNodeConverter } from '../types'
import type { SlateNodeConverter } from '../../types'
import { convertSlateNodesToLexical } from '..'
import { convertSlateNodesToLexical } from '../..'
export const SlateUnorderedListConverter: SlateNodeConverter = {
export const _SlateUnorderedListConverter: SlateNodeConverter = {
converter({ converters, slateNode }) {
return {
type: 'list',
@@ -12,7 +12,7 @@ export const SlateUnorderedListConverter: SlateNodeConverter = {
canContainParagraphs: false,
converters,
parentNodeType: 'list',
slateNodes: slateNode.children || [],
slateNodes: slateNode.children,
}),
direction: 'ltr',
format: '',

9
packages/richtext-lexical/src/field/features/migrations/slateToLexical/converter/converters/unorderedList/index.ts Normal file
View File

@@ -0,0 +1,9 @@
import type { SlateNodeConverterProvider } from '../../types'
import { UnorderedListConverterClient } from './client'
import { _SlateUnorderedListConverter } from './converter'
export const SlateUnorderedListConverter: SlateNodeConverterProvider = {
ClientComponent: UnorderedListConverterClient,
converter: _SlateUnorderedListConverter,
}

6
packages/richtext-lexical/src/field/features/migrations/slateToLexical/converter/converters/upload/client.ts Normal file
View File

@@ -0,0 +1,6 @@
'use client'
import { createFeaturePropComponent } from '../../../../../createFeaturePropComponent'
import { _SlateUploadConverter } from './converter'
export const UploadConverterClient = createFeaturePropComponent(_SlateUploadConverter)

6
packages/richtext-lexical/src/field/features/migrations/slateToLexical/converter/converters/upload.ts → packages/richtext-lexical/src/field/features/migrations/slateToLexical/converter/converters/upload/converter.ts
View File

@@ -1,7 +1,7 @@
import type { SerializedUploadNode } from '../../../../../..'
import type { SlateNodeConverter } from '../types'
import type { SerializedUploadNode } from '../../../../../upload/nodes/UploadNode'
import type { SlateNodeConverter } from '../../types'
export const SlateUploadConverter: SlateNodeConverter = {
export const _SlateUploadConverter: SlateNodeConverter = {
converter({ slateNode }) {
return {
type: 'upload',

9
packages/richtext-lexical/src/field/features/migrations/slateToLexical/converter/converters/upload/index.ts Normal file
View File

@@ -0,0 +1,9 @@
import type { SlateNodeConverterProvider } from '../../types'
import { UploadConverterClient } from './client'
import { _SlateUploadConverter } from './converter'
export const SlateUploadConverter: SlateNodeConverterProvider = {
ClientComponent: UploadConverterClient,
converter: _SlateUploadConverter,
}

18
packages/richtext-lexical/src/field/features/migrations/slateToLexical/converter/defaultConverters.ts
View File

@@ -1,4 +1,4 @@
import type { SlateNodeConverter } from './types'
import type { SlateNodeConverterProvider } from './types'
import { SlateBlockquoteConverter } from './converters/blockquote'
import { SlateHeadingConverter } from './converters/heading'
@@ -11,15 +11,15 @@ import { SlateUnknownConverter } from './converters/unknown'
import { SlateUnorderedListConverter } from './converters/unorderedList'
import { SlateUploadConverter } from './converters/upload'
export const defaultSlateConverters: SlateNodeConverter[] = [
SlateUnknownConverter,
SlateUploadConverter,
SlateUnorderedListConverter,
SlateOrderedListConverter,
SlateRelationshipConverter,
SlateListItemConverter,
SlateLinkConverter,
export const defaultSlateConverters: SlateNodeConverterProvider[] = [
SlateBlockquoteConverter,
SlateHeadingConverter,
SlateIndentConverter,
SlateLinkConverter,
SlateListItemConverter,
SlateOrderedListConverter,
SlateRelationshipConverter,
SlateUnorderedListConverter,
SlateUploadConverter,
SlateUnknownConverter,
]

5
packages/richtext-lexical/src/field/features/migrations/slateToLexical/converter/index.ts
View File

@@ -40,13 +40,16 @@ export function convertSlateNodesToLexical({
slateNodes,
}: {
canContainParagraphs: boolean
converters: SlateNodeConverter[]
converters: SlateNodeConverter[] | undefined
/**
* Type of the parent lexical node (not the type of the original, parent slate type)
*/
parentNodeType: string
slateNodes: SlateNode[]
}): SerializedLexicalNode[] {
if (!converters?.length) {
return []
}
const unknownConverter = converters.find((converter) => converter.nodeTypes.includes('unknown'))
return (
slateNodes.map((slateNode, i) => {

11
packages/richtext-lexical/src/field/features/migrations/slateToLexical/converter/types.ts
View File

@@ -1,4 +1,5 @@
import type { SerializedLexicalNode } from 'lexical'
import type React from 'react'
export type SlateNodeConverter<T extends SerializedLexicalNode = SerializedLexicalNode> = {
converter: ({
@@ -20,3 +21,13 @@ export type SlateNode = {
children?: SlateNode[]
type?: string // doesn't always have type, e.g. for paragraphs
}
export type SlateNodeConverterClientComponent = React.FC<{
componentKey: string
featureKey: string
}>
export type SlateNodeConverterProvider = {
ClientComponent: SlateNodeConverterClientComponent
converter: SlateNodeConverter
}

18
packages/richtext-lexical/src/field/features/migrations/slateToLexical/feature.client.tsx
View File

@@ -7,16 +7,13 @@ import { createClientComponent } from '../../createClientComponent'
import { convertSlateToLexical } from './converter'
import { UnknownConvertedNode } from './nodes/unknownConvertedNode'
export type SlateToLexicalFeatureClientProps = {
converters: SlateNodeConverter[]
}
const SlateToLexicalFeatureClient: FeatureProviderProviderClient<
SlateToLexicalFeatureClientProps
> = (props) => {
const SlateToLexicalFeatureClient: FeatureProviderProviderClient<undefined> = (props) => {
return {
clientFeatureProps: props,
feature: () => ({
feature: ({ clientFunctions }) => {
const converters: SlateNodeConverter[] = Object.values(clientFunctions)
return {
clientFeatureProps: props,
hooks: {
load({ incomingEditorState }) {
@@ -31,13 +28,14 @@ const SlateToLexicalFeatureClient: FeatureProviderProviderClient<
// Slate => convert to lexical
return convertSlateToLexical({
converters: props.converters,
converters,
slateData: incomingEditorState,
})
},
},
nodes: [UnknownConvertedNode],
}),
}
},
}
}

47
packages/richtext-lexical/src/field/features/migrations/slateToLexical/feature.server.ts
View File

@@ -1,6 +1,7 @@
import type React from 'react'
import type { FeatureProviderProviderServer } from '../../types'
import type { SlateNodeConverter } from './converter/types'
import type { SlateToLexicalFeatureClientProps } from './feature.client'
import type { SlateNodeConverterProvider } from './converter/types'
import { defaultSlateConverters } from './converter/defaultConverters'
import { SlateToLexicalFeatureClientComponent } from './feature.client'
@@ -8,32 +9,52 @@ import { UnknownConvertedNode } from './nodes/unknownConvertedNode'
export type SlateToLexicalFeatureProps = {
converters?:
| (({ defaultConverters }: { defaultConverters: SlateNodeConverter[] }) => SlateNodeConverter[])
| SlateNodeConverter[]
| (({
defaultConverters,
}: {
defaultConverters: SlateNodeConverterProvider[]
}) => SlateNodeConverterProvider[])
| SlateNodeConverterProvider[]
}
export const SlateToLexicalFeature: FeatureProviderProviderServer<
SlateToLexicalFeatureProps,
SlateToLexicalFeatureClientProps
undefined
> = (props) => {
if (!props) {
props = {}
}
props.converters =
props?.converters && typeof props?.converters === 'function'
? props.converters({ defaultConverters: defaultSlateConverters })
: (props?.converters as SlateNodeConverter[]) || defaultSlateConverters
const clientProps: SlateToLexicalFeatureClientProps = {
converters: props.converters,
let converters: SlateNodeConverterProvider[] = []
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: clientProps,
clientFeatureProps: null,
generateComponentMap: () => {
const map: {
[key: string]: React.FC
} = {}
for (const converter of converters) {
if (converter.ClientComponent) {
const key = converter.converter.nodeTypes.join('-')
map[key] = converter.ClientComponent
}
}
return map
},
nodes: [
{
node: UnknownConvertedNode,

2
test/buildConfigWithDefaults.ts
View File

@@ -8,7 +8,6 @@ import {
IndentFeature,
InlineCodeFeature,
ItalicFeature,
LexicalPluginToLexicalFeature,
LinkFeature,
OrderedListFeature,
StrikethroughFeature,
@@ -108,7 +107,6 @@ export function buildConfigWithDefaults(testConfig?: Partial<Config>): Promise<S
SuperscriptFeature(),
InlineCodeFeature(),
TreeViewFeature(),
LexicalPluginToLexicalFeature(),
HeadingFeature(),
IndentFeature(),
BlocksFeature({