@contember/react-client 1.3.0-alpha.6 → 1.3.0-alpha.8

package/src/components/RichTextRenderer/RichTextRenderMetadataContext.ts

@@ -1,20 +0,0 @@
-import { createContext, useContext } from 'react'
-import type { RichTextElement } from './RichTextElement'
-import type { RichTextLeaf } from './RichTextLeaf'
-import type { RichTextReference } from './RichTextReference'
-import type { RichTextRenderMetadata } from './RichTextRenderMetadata'
-
-export const RichTextRenderMetadataContext = createContext<RichTextRenderMetadata<any, any, any>>({
-	formatVersion: 0,
-	referencesField: undefined,
-	referenceDiscriminationField: undefined,
-	referenceRenderers: {},
-	references: undefined,
-})
-RichTextRenderMetadataContext.displayName = 'RichTextRenderMetadataContext'
-
-export const useRichTextRenderMetadata = <
-	CustomElements extends RichTextElement = never,
-	CustomLeaves extends RichTextLeaf = never,
-	Reference extends RichTextReference = RichTextReference,
->() => useContext(RichTextRenderMetadataContext) as RichTextRenderMetadata<CustomElements, CustomLeaves, Reference>

package/src/components/RichTextRenderer/RichTextRenderer.tsx

@@ -1,168 +0,0 @@
-import { ComponentType, createElement, memo, ReactElement, ReactNode, useMemo } from 'react'
-import { defaultDeserialize } from './defaultDeserialize'
-import type { RenderElement } from './ElementRenderer'
-import type { RenderLeaf } from './LeafRenderer'
-import type { NormalizedRichTextBlock } from './NormalizedRichTextBlock'
-import type { ReferenceRenderer } from './ReferenceRenderer'
-import { renderChildren } from './renderChildren'
-import type { RichTextBlock } from './RichTextBlock'
-import type { RichTextElement } from './RichTextElement'
-import type { RichTextLeaf } from './RichTextLeaf'
-import type { RichTextReference } from './RichTextReference'
-import { RichTextRendererError } from './RichTextRendererError'
-import { RichTextRenderMetadataContext } from './RichTextRenderMetadataContext'
-import type { RootEditorNode } from './RootEditorNode'
-
-export interface RichTextRendererFieldProps {
-	source: string | null
-}
-
-export interface RichTextRendererBlockProps<
-	CustomElements extends RichTextElement = never,
-	CustomLeaves extends RichTextLeaf = never,
-> {
-	blocks: readonly RichTextBlock[]
-	referenceRenderers?: Record<string, ReferenceRenderer<any, CustomElements, CustomLeaves>>
-	sourceField?: string
-	referencesField?: string
-	referenceDiscriminationField?: string
-}
-
-export type RichTextRendererProps<
-	CustomElements extends RichTextElement = never,
-	CustomLeaves extends RichTextLeaf = never,
-> = {
-	deserialize?: (source: string) => RootEditorNode<CustomElements, CustomLeaves>
-	renderElement?: RenderElement<CustomElements, CustomLeaves>
-	renderLeaf?: RenderLeaf<CustomLeaves>
-	attributeNamePrefix?: string
-	renderBlock?: ComponentType<{ block: unknown, children?: ReactNode }>
-} & (RichTextRendererFieldProps | RichTextRendererBlockProps<CustomElements, CustomLeaves>)
-
-/**
- * @group Content rendering
- */
-export const RichTextRenderer = memo(function RichTextRenderer<
-	CustomElements extends RichTextElement = never,
-	CustomLeaves extends RichTextLeaf = never,
->({
-	deserialize = defaultDeserialize,
-	renderElement,
-	renderLeaf,
-	renderBlock = ({ children }) => <>{children}</>,
-	attributeNamePrefix,
-	...sourceProps
-}: RichTextRendererProps<CustomElements, CustomLeaves>) {
-	const normalizedSource = useMemo<NormalizedRichTextBlock<CustomElements, CustomLeaves>[]>(() => {
-		if ('source' in sourceProps && !('blocks' in sourceProps)) {
-			return [
-				{
-					content: sourceProps.source
-						? deserialize(sourceProps.source)
-						: {
-							formatVersion: 0,
-							children: [],
-						},
-					id: undefined,
-					referencesField: undefined,
-					referenceDiscriminationField: undefined,
-					referenceRenderers: {},
-					references: undefined,
-				},
-			]
-		}
-		if (!('source' in sourceProps)) {
-			const sourceField = sourceProps.sourceField ?? 'source'
-			const referencesField = sourceProps.referencesField ?? 'references'
-			const referenceDiscriminationField = sourceProps.referenceDiscriminationField ?? 'type'
-
-			return sourceProps.blocks.map(block => {
-				if (!(sourceField in block)) {
-					throw new RichTextRendererError(
-						`Found a block without a '${sourceField}' field. ` +
-						(sourceProps.sourceField === undefined
-							? `The 'sourceField' prop has not been supplied, and so '${sourceField}' was used as a default.`
-							: `That is what the 'sourceField' prop has been set to, and so either this is a typo, ` +
-							`or the data supplied is invalid.`),
-					)
-				}
-				const source = block[sourceField]
-				if (typeof source !== 'string') {
-					throw new RichTextRendererError(`Found a block whose source is not a string.`)
-				}
-
-				if (sourceProps.referencesField !== undefined && !(referencesField in block)) {
-					throw new RichTextRendererError(
-						`The 'referencesField' prop is set to '${referencesField}' but a block without such field ` +
-						`has been encountered. Unless this is just a typo, ` +
-						`if you do not wish to use references, avoid supplying the 'referencesField' prop.`,
-					)
-				}
-				const references = block[referencesField]
-
-				let normalizedReferences: Map<string, RichTextReference> | undefined = undefined
-				if (references) {
-					if (typeof Object(references)[Symbol.iterator] !== 'function') {
-						throw new RichTextRendererError(`The set of references must be an iterable!`)
-					}
-
-					normalizedReferences = new Map()
-					for (const reference of references as Iterable<RichTextReference>) {
-						if (!('id' in reference)) {
-							throw new RichTextRendererError(`Found a reference without an id field.`)
-						}
-						if (!(referenceDiscriminationField in reference)) {
-							throw new RichTextRendererError(
-								`Found a reference without a '${referenceDiscriminationField}' field. ` +
-								(sourceProps.referenceDiscriminationField === undefined
-									? `The 'referenceDiscriminationField' prop has not been supplied, ` +
-									`and so '${referenceDiscriminationField}' was used as a default.`
-									: `That is what the 'referenceDiscriminationField' prop has been set to, ` +
-									`and so either this is a typo, or the data supplied is invalid.`),
-							)
-						}
-						normalizedReferences.set(reference.id, reference)
-					}
-				}
-				return {
-					id: typeof block.id === 'string' ? block.id : undefined,
-					content: deserialize(source),
-					referenceDiscriminationField,
-					referenceRenderers: sourceProps.referenceRenderers ?? {},
-					referencesField,
-					references: normalizedReferences,
-				}
-			})
-		}
-		throw new RichTextRendererError(`RichTextRenderer: invalid data supplied.`)
-	}, [deserialize, sourceProps])
-
-	return (
-		<>
-			{normalizedSource.map((block, i) => (
-				<RichTextRenderMetadataContext.Provider
-					key={block.id ?? i}
-					value={{
-						formatVersion: block.content.formatVersion,
-						referenceRenderers: block.referenceRenderers,
-						referencesField: block.referencesField,
-						referenceDiscriminationField: block.referenceDiscriminationField,
-						references: block.references,
-					}}
-				>
-					{createElement(
-						renderBlock, {
-						block,
-					}, renderChildren(block.content.children, {
-						renderLeaf,
-						renderElement,
-						attributeNamePrefix,
-					}),
-					)}
-				</RichTextRenderMetadataContext.Provider>
-			))}
-		</>
-	)
-}) as <CustomElements extends RichTextElement = never, CustomLeaves extends RichTextLeaf = never>(
-	props: RichTextRendererProps<CustomElements, CustomLeaves>,
-) => ReactElement

package/src/components/RichTextRenderer/RichTextRendererError.ts

@@ -1 +0,0 @@
-export class RichTextRendererError extends Error {}

package/src/components/RichTextRenderer/RootEditorNode.ts

@@ -1,12 +0,0 @@
-import type { BuiltinElements } from './BuiltinElements'
-import type { BuiltinLeaves } from './BuiltinLeaves'
-import type { RichTextElement } from './RichTextElement'
-import type { RichTextLeaf } from './RichTextLeaf'
-
-export interface RootEditorNode<
-	CustomElements extends RichTextElement = never,
-	CustomLeaves extends RichTextLeaf = never,
-> {
-	formatVersion: number
-	children: Array<BuiltinElements<CustomElements, CustomLeaves> | CustomElements | BuiltinLeaves | CustomLeaves>
-}

package/src/components/RichTextRenderer/defaultDeserialize.ts

@@ -1,19 +0,0 @@
-import type { RichTextElement } from './RichTextElement'
-import type { RichTextLeaf } from './RichTextLeaf'
-import type { RootEditorNode } from './RootEditorNode'
-
-export const defaultDeserialize = <
-	CustomElements extends RichTextElement = never,
-	CustomLeaves extends RichTextLeaf = never,
->(
-	source: string,
-): RootEditorNode<CustomElements, CustomLeaves> => {
-	try {
-		return JSON.parse(source)
-	} catch (e) {
-		return {
-			formatVersion: 0,
-			children: [],
-		}
-	}
-}

package/src/components/RichTextRenderer/index.ts

@@ -1,15 +0,0 @@
-export * from './BuiltinElements'
-export * from './BuiltinLeaves'
-export * from './ReferenceRenderer'
-export * from './RichTextBlock'
-export * from './RichTextElement'
-export * from './RichTextElementMetadata'
-export * from './RichTextLeaf'
-export * from './RichTextLeafMetadata'
-export * from './RichTextReference'
-export * from './RichTextRenderer'
-export * from './RichTextRendererError'
-export * from './RootEditorNode'
-export type { RenderChildrenOptions } from './renderChildren'
-export type { RenderElement } from './ElementRenderer'
-export type { RenderLeaf } from './LeafRenderer'

package/src/components/RichTextRenderer/renderChildren.tsx

@@ -1,50 +0,0 @@
-import type { ReactElement } from 'react'
-import type { BuiltinElements } from './BuiltinElements'
-import type { BuiltinLeaves } from './BuiltinLeaves'
-import { ElementRenderer, RenderElement } from './ElementRenderer'
-import { LeafRenderer, RenderLeaf } from './LeafRenderer'
-import type { RichTextElement } from './RichTextElement'
-import type { RichTextLeaf } from './RichTextLeaf'
-
-export interface RenderChildrenOptions<
-	CustomElements extends RichTextElement = never,
-	CustomLeaves extends RichTextLeaf = never,
-> {
-	renderElement?: RenderElement<CustomElements, CustomLeaves>
-	renderLeaf?: RenderLeaf<CustomLeaves>
-	attributeNamePrefix?: string
-}
-
-export const renderChildren = <
-	CustomElements extends RichTextElement = never,
-	CustomLeaves extends RichTextLeaf = never,
->(
-	children:
-		| CustomElements
-		| BuiltinElements<CustomElements, CustomLeaves>
-		| CustomLeaves
-		| BuiltinLeaves
-		| Array<CustomElements | BuiltinElements<CustomElements, CustomLeaves> | CustomLeaves | BuiltinLeaves>,
-	options: RenderChildrenOptions<CustomElements, CustomLeaves>,
-): ReactElement => {
-	if (!Array.isArray(children)) {
-		children = [children]
-	}
-	return (
-		<>
-			{children.map((child, i) => {
-				if ('text' in child) {
-					return <LeafRenderer<CustomLeaves> key={i} leaf={child} renderLeaf={options.renderLeaf} />
-				}
-				if ('children' in child) {
-					return (
-						<ElementRenderer<CustomElements, CustomLeaves> key={i} element={child} options={options}>
-							{renderChildren<CustomElements, CustomLeaves>(child.children as typeof children, options)}
-						</ElementRenderer>
-					)
-				}
-				return null // Throw?
-			})}
-		</>
-	)
-}

package/src/components/RichTextRenderer/resolveRichTextElementMetadata.ts

@@ -1,50 +0,0 @@
-import type { BuiltinElements } from './BuiltinElements'
-import type { ReferenceRenderer } from './ReferenceRenderer'
-import type { RichTextElement } from './RichTextElement'
-import type { RichTextElementMetadata } from './RichTextElementMetadata'
-import type { RichTextLeaf } from './RichTextLeaf'
-import type { RichTextReference } from './RichTextReference'
-import { RichTextRendererError } from './RichTextRendererError'
-import type { RichTextRenderMetadata } from './RichTextRenderMetadata'
-
-export const resolveRichTextElementMetadata = <
-	CustomElements extends RichTextElement = never,
-	CustomLeaves extends RichTextLeaf = never,
-	Reference extends RichTextReference = RichTextReference,
->(
-	element: CustomElements | BuiltinElements<CustomElements, CustomLeaves>,
-	metadata: RichTextRenderMetadata<CustomElements, CustomLeaves, Reference>,
-): RichTextElementMetadata<CustomElements, CustomLeaves, Reference> => {
-	let reference: Reference | undefined = undefined
-
-	if ('referenceId' in element && typeof element['referenceId'] === 'string') {
-		const resolved = metadata.references?.get(element['referenceId'])
-
-		if (resolved === undefined) {
-			throw new RichTextRendererError(
-				`Cannot find reference id '${element['referenceId']}'` +
-					(metadata.references === undefined
-						? ` because its containing block's lacks the '${metadata.referencesField}' field. `
-						: `.`),
-			)
-		}
-		reference = resolved as Reference
-	}
-
-	let referenceRenderer: ReferenceRenderer<Reference, CustomElements, CustomLeaves> | undefined = undefined
-	let referenceType: string | undefined = undefined
-
-	if (reference && metadata.referenceDiscriminationField) {
-		referenceType = (reference as Reference & Record<typeof metadata.referenceDiscriminationField, string>)[
-			metadata.referenceDiscriminationField
-		]
-		referenceRenderer = metadata.referenceRenderers[referenceType]
-	}
-
-	return {
-		formatVersion: metadata.formatVersion,
-		reference,
-		referenceType,
-		referenceRenderer,
-	}
-}

package/src/components/index.ts

@@ -1 +0,0 @@
-export * from './RichTextRenderer'