@portabletext/block-tools 4.1.8 → 4.1.9

package/src/rules/index.ts

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

package/src/schema-matchers.ts

@@ -1,41 +0,0 @@
-import type {Schema} from '@portabletext/schema'
-import type {ArbitraryTypedObject} from './types'
-
-/**
- * Use the current `Schema` as well as the potential element props to determine
- * what Portable Text Object to use to represent the element.
- */
-type ObjectSchemaMatcher<TProps extends Record<string, unknown>> = ({
-  context,
-  props,
-}: {
-  context: {schema: Schema; keyGenerator: () => string}
-  props: TProps
-}) => ArbitraryTypedObject | undefined
-
-/**
- * Use the current `Schema` as well as the potential img element props to
- * determine what Portable Text Object to use to represent the image.
- * @beta
- */
-export type ImageSchemaMatcher = ObjectSchemaMatcher<{
-  src?: string
-  alt?: string
-  [key: string]: string | undefined
-}>
-
-/**
- * @beta
- */
-export type SchemaMatchers = {
-  /**
-   * Called whenever the HTML parsing encounters an `<img>` element that is
-   * inferred to be a block element.
-   */
-  image?: ImageSchemaMatcher
-  /**
-   * Called whenever the HTML parsing encounters an `<img>` element that is
-   * inferred to be an inline element.
-   */
-  inlineImage?: ImageSchemaMatcher
-}

package/src/types.ts

@@ -1,100 +0,0 @@
-import type {PortableTextObject} from '@portabletext/schema'
-import type {SchemaMatchers} from './schema-matchers'
-
-/**
- * @public
- */
-export interface TypedObject {
-  _type: string
-  _key?: string
-}
-
-/**
- * @public
- */
-export interface ArbitraryTypedObject extends TypedObject {
-  [key: string]: unknown
-}
-
-export function isArbitraryTypedObject(
-  object: unknown,
-): object is ArbitraryTypedObject {
-  return isRecord(object) && typeof object._type === 'string'
-}
-
-function isRecord(value: unknown): value is Record<string, unknown> {
-  return !!value && (typeof value === 'object' || typeof value === 'function')
-}
-
-export interface MinimalSpan {
-  _type: 'span'
-  _key?: string
-  text: string
-  marks?: string[]
-}
-
-export interface MinimalBlock extends TypedObject {
-  _type: 'block'
-  children: TypedObject[]
-  markDefs?: TypedObject[]
-  style?: string
-  level?: number
-  listItem?: string
-}
-
-export interface PlaceholderDecorator {
-  _type: '__decorator'
-  name: string
-  children: TypedObject[]
-}
-
-export interface PlaceholderAnnotation {
-  _type: '__annotation'
-  markDef: PortableTextObject
-  children: TypedObject[]
-}
-
-/**
- * @public
- */
-export type HtmlParser = (html: string) => Document
-
-/**
- * @public
- */
-export type WhiteSpacePasteMode = 'preserve' | 'remove' | 'normalize'
-
-/**
- * @public
- */
-export interface HtmlDeserializerOptions {
-  keyGenerator?: () => string
-  rules?: DeserializerRule[]
-  parseHtml?: HtmlParser
-  unstable_whitespaceOnPasteMode?: WhiteSpacePasteMode
-  /**
-   * Custom schema matchers to use when deserializing HTML to Portable Text.
-   * @beta
-   */
-  matchers?: SchemaMatchers
-}
-
-export interface HtmlPreprocessorOptions {
-  unstable_whitespaceOnPasteMode?: WhiteSpacePasteMode
-}
-
-/**
- * @public
- */
-export interface DeserializerRule {
-  deserialize: (
-    el: Node,
-    next: (
-      elements: Node | Node[] | NodeList,
-    ) => TypedObject | TypedObject[] | undefined,
-    createBlock: (props: ArbitraryTypedObject) => {
-      _type: string
-      block: ArbitraryTypedObject
-    },
-  ) => TypedObject | TypedObject[] | undefined
-}

package/src/util/findBlockType.ts

@@ -1,13 +0,0 @@
-import type {BlockSchemaType, SchemaType} from '@sanity/types'
-
-export function findBlockType(type: SchemaType): type is BlockSchemaType {
-  if (type.type) {
-    return findBlockType(type.type)
-  }
-
-  if (type.name === 'block') {
-    return true
-  }
-
-  return false
-}

package/src/util/normalizeBlock.ts

@@ -1,171 +0,0 @@
-import type {Schema} from '@portabletext/schema'
-import {
-  isSpan,
-  type PortableTextSpan,
-  type PortableTextTextBlock,
-} from '@portabletext/schema'
-import {isEqual} from 'lodash'
-import type {TypedObject} from '../types'
-import {keyGenerator} from './randomKey'
-
-/**
- * Block normalization options
- *
- * @public
- */
-export interface BlockNormalizationOptions {
-  /**
-   * Decorator names that are allowed within portable text blocks, eg `em`, `strong`
-   */
-  allowedDecorators?: string[]
-
-  /**
-   * Name of the portable text block type, if not `block`
-   */
-  blockTypeName?: string
-
-  /**
-   * Custom key generator function
-   */
-  keyGenerator?: () => string
-}
-
-/**
- * Normalizes a block by ensuring it has a `_key` property. If the block is a
- * portable text block, additional normalization is applied:
- *
- * - Ensures it has `children` and `markDefs` properties
- * - Ensures it has at least one child (adds an empty span if empty)
- * - Joins sibling spans that has the same marks
- * - Removes decorators that are not allowed according to the schema
- * - Removes marks that have no annotation definition
- *
- * @param node - The block to normalize
- * @param options - Options for normalization process. See {@link BlockNormalizationOptions}
- * @returns Normalized block
- * @public
- */
-export function normalizeBlock(
-  node: TypedObject,
-  options: BlockNormalizationOptions = {},
-): Omit<
-  TypedObject | PortableTextTextBlock<TypedObject | PortableTextSpan>,
-  '_key'
-> & {
-  _key: string
-} {
-  const schema: Schema = {
-    block: {
-      name: options.blockTypeName || 'block',
-    },
-    span: {
-      name: 'span',
-    },
-    styles: [],
-    lists: [],
-    decorators: [],
-    annotations: [],
-    blockObjects: [],
-    inlineObjects: [],
-  }
-
-  if (node._type !== (options.blockTypeName || 'block')) {
-    return '_key' in node
-      ? (node as TypedObject & {_key: string})
-      : {
-          ...node,
-          _key: options.keyGenerator ? options.keyGenerator() : keyGenerator(),
-        }
-  }
-
-  const block: Omit<
-    PortableTextTextBlock<TypedObject | PortableTextSpan>,
-    'style'
-  > = {
-    _key: options.keyGenerator ? options.keyGenerator() : keyGenerator(),
-    children: [],
-    markDefs: [],
-    ...node,
-  }
-
-  const lastChild = block.children[block.children.length - 1]
-
-  if (!lastChild) {
-    // A block must at least have an empty span type child
-    block.children = [
-      {
-        _type: 'span',
-        _key: options.keyGenerator ? options.keyGenerator() : keyGenerator(),
-        text: '',
-        marks: [],
-      },
-    ]
-    return block
-  }
-
-  const usedMarkDefs: string[] = []
-  const allowedDecorators =
-    options.allowedDecorators && Array.isArray(options.allowedDecorators)
-      ? options.allowedDecorators
-      : false
-
-  block.children = block.children
-    .reduce(
-      (acc, child) => {
-        const previousChild = acc[acc.length - 1]
-        if (
-          previousChild &&
-          isSpan({schema}, child) &&
-          isSpan({schema}, previousChild) &&
-          isEqual(previousChild.marks, child.marks)
-        ) {
-          if (
-            lastChild &&
-            lastChild === child &&
-            child.text === '' &&
-            block.children.length > 1
-          ) {
-            return acc
-          }
-
-          previousChild.text += child.text
-          return acc
-        }
-        acc.push(child)
-        return acc
-      },
-      [] as (TypedObject | PortableTextSpan)[],
-    )
-    .map((child) => {
-      if (!child) {
-        throw new Error('missing child')
-      }
-
-      child._key = options.keyGenerator
-        ? options.keyGenerator()
-        : keyGenerator()
-
-      if (isSpan({schema}, child)) {
-        if (!child.marks) {
-          child.marks = []
-        } else if (allowedDecorators) {
-          child.marks = child.marks.filter((mark) => {
-            const isAllowed = allowedDecorators.includes(mark)
-            const isUsed = block.markDefs?.some((def) => def._key === mark)
-            return isAllowed || isUsed
-          })
-        }
-
-        usedMarkDefs.push(...child.marks)
-      }
-
-      return child
-    })
-
-  // Remove leftover (unused) markDefs
-  block.markDefs = (block.markDefs || []).filter((markDef) =>
-    usedMarkDefs.includes(markDef._key),
-  )
-
-  return block
-}

package/src/util/randomKey.ts

@@ -1,28 +0,0 @@
-export function keyGenerator() {
-  return randomKey(12)
-}
-
-// WHATWG crypto RNG - https://w3c.github.io/webcrypto/Overview.html
-function whatwgRNG(length = 16) {
-  const rnds8 = new Uint8Array(length)
-  crypto.getRandomValues(rnds8)
-  return rnds8
-}
-
-const byteToHex: string[] = []
-for (let i = 0; i < 256; ++i) {
-  byteToHex[i] = (i + 0x100).toString(16).slice(1)
-}
-
-/**
- * Generate a random key of the given length
- *
- * @param length - Length of string to generate
- * @returns A string of the given length
- * @public
- */
-export function randomKey(length: number): string {
-  return whatwgRNG(length)
-    .reduce((str, n) => str + byteToHex[n], '')
-    .slice(0, length)
-}

package/src/util/resolveJsType.ts

@@ -1,44 +0,0 @@
-const objectToString = Object.prototype.toString
-
-// Copied from https://github.com/ForbesLindesay/type-of
-// but inlined to have fine grained control
-export function resolveJsType(val: unknown) {
-  switch (objectToString.call(val)) {
-    case '[object Function]':
-      return 'function'
-    case '[object Date]':
-      return 'date'
-    case '[object RegExp]':
-      return 'regexp'
-    case '[object Arguments]':
-      return 'arguments'
-    case '[object Array]':
-      return 'array'
-    case '[object String]':
-      return 'string'
-    default:
-  }
-
-  if (val === null) {
-    return 'null'
-  }
-
-  if (val === undefined) {
-    return 'undefined'
-  }
-
-  if (
-    val &&
-    typeof val === 'object' &&
-    'nodeType' in val &&
-    (val as {nodeType: unknown}).nodeType === 1
-  ) {
-    return 'element'
-  }
-
-  if (val === Object(val)) {
-    return 'object'
-  }
-
-  return typeof val
-}