@portabletext/editor 3.3.3 → 3.3.4

package/src/test/vitest/test-editor.tsx

@@ -1,198 +0,0 @@
-import {defineSchema, type SchemaDefinition} from '@portabletext/schema'
-import {createTestKeyGenerator} from '@portabletext/test'
-import type {PortableTextBlock} from '@sanity/types'
-import React from 'react'
-import {expect, vi} from 'vitest'
-import {render} from 'vitest-browser-react'
-import {page} from 'vitest/browser'
-import type {Editor} from '../../editor'
-import {
-  PortableTextEditable,
-  type PortableTextEditableProps,
-} from '../../editor/Editable'
-import {EditorProvider} from '../../editor/editor-provider'
-import type {EditorEmittedEvent} from '../../editor/relay-machine'
-import {EventListenerPlugin} from '../../plugins'
-import {EditorRefPlugin} from '../../plugins/plugin.editor-ref'
-import type {Context} from './step-context'
-
-type CreateTestEditorOptions = {
-  initialValue?: Array<PortableTextBlock>
-  keyGenerator?: () => string
-  schemaDefinition?: SchemaDefinition
-  children?: React.ReactNode
-  editableProps?: PortableTextEditableProps
-}
-
-/**
- * @internal
- */
-export async function createTestEditor(
-  options: CreateTestEditorOptions = {},
-): Promise<
-  Pick<Context, 'editor' | 'locator'> & {
-    rerender: (options?: CreateTestEditorOptions) => Promise<void>
-  }
-> {
-  const editorRef = React.createRef<Editor>()
-  const keyGenerator = options.keyGenerator ?? createTestKeyGenerator()
-  const renderResult = await render(
-    <EditorProvider
-      initialConfig={{
-        keyGenerator: keyGenerator,
-        schemaDefinition: options.schemaDefinition ?? defineSchema({}),
-        initialValue: options.initialValue,
-      }}
-    >
-      <EditorRefPlugin ref={editorRef} />
-      <PortableTextEditable {...options.editableProps} />
-      {options.children}
-    </EditorProvider>,
-  )
-
-  async function rerender(newOptions?: CreateTestEditorOptions) {
-    await (newOptions
-      ? renderResult.rerender(
-          <EditorProvider
-            initialConfig={{
-              keyGenerator: keyGenerator,
-              schemaDefinition: newOptions.schemaDefinition ?? defineSchema({}),
-              initialValue: newOptions.initialValue,
-            }}
-          >
-            <EditorRefPlugin ref={editorRef} />
-            <PortableTextEditable {...newOptions.editableProps} />
-            {newOptions.children}
-          </EditorProvider>,
-        )
-      : renderResult.rerender(
-          <EditorProvider
-            initialConfig={{
-              keyGenerator: keyGenerator,
-              schemaDefinition: options.schemaDefinition ?? defineSchema({}),
-              initialValue: options.initialValue,
-            }}
-          >
-            <EditorRefPlugin ref={editorRef} />
-            <PortableTextEditable {...options.editableProps} />
-            {options.children}
-          </EditorProvider>,
-        ))
-  }
-
-  const locator = page.getByRole('textbox')
-
-  await vi.waitFor(() => expect.element(locator).toBeInTheDocument())
-
-  return {
-    editor: editorRef.current!,
-    locator,
-    rerender,
-  }
-}
-
-/**
- * @internal
- */
-export async function createTestEditors(
-  options: CreateTestEditorOptions = {},
-): Promise<
-  Pick<Context, 'editor' | 'locator' | 'editorB' | 'locatorB'> & {
-    onEditorEvent: (event: EditorEmittedEvent) => void
-    onEditorBEvent: (event: EditorEmittedEvent) => void
-  }
-> {
-  const editorRef = React.createRef<Editor>()
-  const editorBRef = React.createRef<Editor>()
-
-  const keyGenerator = options.keyGenerator ?? createTestKeyGenerator('ea-')
-  const keyGeneratorB = options.keyGenerator ?? createTestKeyGenerator('eb-')
-  const onEditorEvent = vi.fn<(event: EditorEmittedEvent) => void>()
-  const onEditorBEvent = vi.fn<(event: EditorEmittedEvent) => void>()
-
-  render(
-    <>
-      <EditorProvider
-        initialConfig={{
-          keyGenerator: keyGenerator,
-          schemaDefinition: options.schemaDefinition ?? defineSchema({}),
-          initialValue: options.initialValue,
-        }}
-      >
-        <EditorRefPlugin ref={editorRef} />
-        <PortableTextEditable
-          {...options.editableProps}
-          data-testid="editor-a"
-        />
-        <EventListenerPlugin
-          on={(event) => {
-            onEditorEvent(event)
-            if (event.type === 'mutation') {
-              editorBRef.current?.send({
-                type: 'patches',
-                patches: event.patches.map((patch) => ({
-                  ...patch,
-                  origin: 'remote',
-                })),
-                snapshot: event.value,
-              })
-              editorBRef.current?.send({
-                type: 'update value',
-                value: event.value,
-              })
-            }
-          }}
-        />
-        {options.children}
-      </EditorProvider>
-      <EditorProvider
-        initialConfig={{
-          keyGenerator: keyGeneratorB,
-          schemaDefinition: options.schemaDefinition ?? defineSchema({}),
-          initialValue: options.initialValue,
-        }}
-      >
-        <EditorRefPlugin ref={editorBRef} />
-        <PortableTextEditable
-          {...options.editableProps}
-          data-testid="editor-b"
-        />
-        <EventListenerPlugin
-          on={(event) => {
-            onEditorBEvent(event)
-            if (event.type === 'mutation') {
-              editorRef.current?.send({
-                type: 'patches',
-                patches: event.patches.map((patch) => ({
-                  ...patch,
-                  origin: 'remote',
-                })),
-                snapshot: event.value,
-              })
-              editorRef.current?.send({
-                type: 'update value',
-                value: event.value,
-              })
-            }
-          }}
-        />
-        {options.children}
-      </EditorProvider>
-    </>,
-  )
-
-  const locator = page.getByTestId('editor-a')
-  const locatorB = page.getByTestId('editor-b')
-
-  await vi.waitFor(() => expect.element(locator).toBeInTheDocument())
-  await vi.waitFor(() => expect.element(locatorB).toBeInTheDocument())
-
-  return {
-    editor: editorRef.current!,
-    locator,
-    onEditorEvent,
-    editorB: editorBRef.current!,
-    locatorB,
-    onEditorBEvent,
-  }
-}

package/src/type-utils.ts

@@ -1,29 +0,0 @@
-/**
- * @internal
- */
-export type PickFromUnion<
-  TUnion,
-  TTagKey extends keyof TUnion,
-  TPickedTags extends TUnion[TTagKey],
-> = TUnion extends Record<TTagKey, TPickedTags> ? TUnion : never
-
-/**
- * @internal
- */
-export type OmitFromUnion<
-  TUnion,
-  TTagKey extends keyof TUnion,
-  TOmittedTags extends TUnion[TTagKey],
-> = TUnion extends Record<TTagKey, TOmittedTags> ? never : TUnion
-
-export type NamespaceEvent<TEvent, TNamespace extends string> = TEvent extends {
-  type: infer TEventType
-}
-  ? {
-      [K in keyof TEvent]: K extends 'type'
-        ? `${TNamespace}.${TEventType & string}`
-        : TEvent[K]
-    }
-  : never
-
-export type StrictExtract<T, U extends T> = U

package/src/types/block-offset.ts

@@ -1,9 +0,0 @@
-import type {BlockPath} from './paths'
-
-/**
- * @beta
- */
-export type BlockOffset = {
-  path: BlockPath
-  offset: number
-}

package/src/types/block-with-optional-key.ts

@@ -1,25 +0,0 @@
-import type {
-  PortableTextObject,
-  PortableTextSpan,
-  PortableTextTextBlock,
-} from '@portabletext/schema'
-
-export type TextBlockWithOptionalKey = Omit<PortableTextTextBlock, '_key'> & {
-  _key?: PortableTextTextBlock['_key']
-}
-
-export type ObjectBlockWithOptionalKey = Omit<PortableTextObject, '_key'> & {
-  _key?: PortableTextObject['_key']
-}
-
-export type BlockWithOptionalKey =
-  | TextBlockWithOptionalKey
-  | ObjectBlockWithOptionalKey
-
-export type SpanWithOptionalKey = Omit<PortableTextSpan, '_key'> & {
-  _key?: PortableTextSpan['_key']
-}
-
-export type ChildWithOptionalKey =
-  | SpanWithOptionalKey
-  | ObjectBlockWithOptionalKey