@portabletext/markdown 1.0.2 → 1.0.4

package/src/from-portable-text/renderers/list-item.ts

@@ -1,32 +0,0 @@
-import type {PortableTextListItemRenderer} from '../types'
-
-/**
- * @public
- */
-export const DefaultListItemRenderer: PortableTextListItemRenderer = ({
-  children,
-  value,
-  listIndex,
-}) => {
-  const listStyle = value.listItem || 'bullet'
-  const level = value.level || 1
-
-  if (listStyle === 'number') {
-    const indent = '   '.repeat(level - 1)
-
-    return `${indent}${listIndex ?? 1}. ${children}`
-  }
-
-  const indent = '   '.repeat(level - 1)
-
-  return `${indent}- ${children}`
-}
-
-/**
- * @public
- */
-export const DefaultUnknownListItemRenderer: PortableTextListItemRenderer = ({
-  children,
-}) => {
-  return `- ${children}\n`
-}

package/src/from-portable-text/renderers/marks.ts

@@ -1,113 +0,0 @@
-import type {TypedObject} from '@portabletext/types'
-import type {PortableTextMarkRenderer} from '../types'
-
-/**
- * @public
- */
-export const DefaultEmRenderer: PortableTextMarkRenderer = ({children}) =>
-  `_${children}_`
-
-/**
- * @public
- */
-export const DefaultStrongRenderer: PortableTextMarkRenderer = ({children}) =>
-  `**${children}**`
-
-/**
- * @public
- */
-export const DefaultCodeRenderer: PortableTextMarkRenderer = ({children}) =>
-  `\`${children}\``
-
-/**
- * @public
- */
-export const DefaultUnderlineRenderer: PortableTextMarkRenderer = ({
-  children,
-}) => `<u>${children}</u>`
-
-/**
- * @public
- */
-export const DefaultStrikeThroughRenderer: PortableTextMarkRenderer = ({
-  children,
-}) => `~~${children}~~`
-
-interface DefaultLink extends TypedObject {
-  _type: 'link'
-  href: string
-  title: string | undefined
-}
-
-/**
- * @public
- */
-export const DefaultLinkRenderer: PortableTextMarkRenderer<DefaultLink> = ({
-  children,
-  value,
-}) => {
-  const href = value?.href || ''
-  const title = value?.title || ''
-  const looksSafe = uriLooksSafe(href)
-
-  if (looksSafe) {
-    // Check if the URL looks like an HTML injection attempt
-    // If it has quotes AND angle brackets, or other suspicious patterns, encode more aggressively
-    const looksLikeInjection = /["'][^"']*[<>]|[<>][^<>]*["']/.test(href)
-
-    if (looksLikeInjection) {
-      // Encode all special characters that could be used for injection
-      const encodedHref = href.replace(/["<>() ]/g, (char) => {
-        return `%${char.charCodeAt(0).toString(16).toUpperCase()}`
-      })
-      return `[${children}](${encodedHref})`
-    }
-
-    // For normal URLs, don't encode parentheses - Markdown handles balanced parens fine
-    return `[${children}](${href}${title ? ` "${title}"` : ''})`
-  }
-
-  // Return children without link when URL is unsafe
-  return children
-}
-
-function uriLooksSafe(uri: string): boolean {
-  const url = (uri || '').trim()
-  const first = url.charAt(0)
-
-  if (first === '#' || first === '/') {
-    return true
-  }
-
-  const colonIndex = url.indexOf(':')
-  if (colonIndex === -1) {
-    return true
-  }
-
-  const allowedProtocols = ['http', 'https', 'mailto', 'tel']
-  const proto = url.slice(0, colonIndex).toLowerCase()
-  if (allowedProtocols.indexOf(proto) !== -1) {
-    return true
-  }
-
-  const queryIndex = url.indexOf('?')
-  if (queryIndex !== -1 && colonIndex > queryIndex) {
-    return true
-  }
-
-  const hashIndex = url.indexOf('#')
-  if (hashIndex !== -1 && colonIndex > hashIndex) {
-    return true
-  }
-
-  return false
-}
-
-/**
- * @public
- */
-export const DefaultUnknownMarkRenderer: PortableTextMarkRenderer = ({
-  children,
-}) => {
-  return children
-}

package/src/from-portable-text/renderers/style.ts

@@ -1,79 +0,0 @@
-import type {PortableTextBlock} from '@portabletext/types'
-import type {PortableTextRenderer} from '../types'
-
-type PortableTextBlockRenderer = PortableTextRenderer<PortableTextBlock>
-
-/**
- * @public
- */
-export const DefaultNormalRenderer: PortableTextBlockRenderer = ({
-  children,
-}) => {
-  // Empty blocks should not add extra spacing
-  if (!children || children.trim() === '') {
-    return ''
-  }
-
-  return children
-}
-
-/**
- * @public
- */
-export const DefaultBlockquoteRenderer: PortableTextBlockRenderer = ({
-  children,
-}) => {
-  // Prefix each line with "> " for proper blockquote formatting
-  // This handles multi-line content and preserves empty lines
-  if (!children) return '>'
-
-  return children
-    .split('\n')
-    .map((line) => `> ${line}`)
-    .join('\n')
-}
-
-/**
- * @public
- */
-export const DefaultH1Renderer: PortableTextBlockRenderer = ({children}) =>
-  `# ${children}`
-
-/**
- * @public
- */
-export const DefaultH2Renderer: PortableTextBlockRenderer = ({children}) =>
-  `## ${children}`
-
-/**
- * @public
- */
-export const DefaultH3Renderer: PortableTextBlockRenderer = ({children}) =>
-  `### ${children}`
-
-/**
- * @public
- */
-export const DefaultH4Renderer: PortableTextBlockRenderer = ({children}) =>
-  `#### ${children}`
-
-/**
- * @public
- */
-export const DefaultH5Renderer: PortableTextBlockRenderer = ({children}) =>
-  `##### ${children}`
-
-/**
- * @public
- */
-export const DefaultH6Renderer: PortableTextBlockRenderer = ({children}) =>
-  `###### ${children}`
-
-/**
- * @public
- */
-export const DefaultUnknownStyleRenderer: PortableTextBlockRenderer = ({
-  children,
-}) => {
-  return children ?? ''
-}

package/src/from-portable-text/renderers/type.ts

@@ -1,126 +0,0 @@
-import type {PortableTextBlock} from '@portabletext/types'
-import type {PortableTextTypeRenderer} from '../types'
-
-/**
- * @public
- */
-export const DefaultCodeBlockRenderer: PortableTextTypeRenderer<{
-  _type: 'code'
-  code: string
-  language: string | undefined
-}> = ({value}) => {
-  return `\`\`\`${value.language ?? ''}\n${value.code}\n\`\`\``
-}
-
-/**
- * @public
- */
-export const DefaultHorizontalRuleRenderer: PortableTextTypeRenderer = () => {
-  return '---'
-}
-
-/**
- * @public
- */
-export const DefaultHtmlRenderer: PortableTextTypeRenderer<{
-  _type: 'html'
-  html: string
-}> = ({value}) => {
-  return value.html
-}
-
-/**
- * @public
- */
-export const DefaultImageRenderer: PortableTextTypeRenderer<{
-  _type: 'image'
-  src: string
-  alt: string | undefined
-  title: string | undefined
-}> = ({value}) => {
-  const alt = value.alt ?? ''
-  const title = value.title ? ` "${value.title}"` : ''
-  return `![${alt}](${value.src}${title})`
-}
-
-/**
- * @public
- */
-export const DefaultTableRenderer: PortableTextTypeRenderer<{
-  _type: 'table'
-  headerRows: number | undefined
-  rows: Array<{
-    _key: string
-    cells: Array<{
-      _key: string
-      value: Array<PortableTextBlock>
-    }>
-  }>
-}> = ({value, renderNode}) => {
-  const headerRows = value.headerRows || 0
-  const rows = value.rows as Array<{
-    _key: string
-    _type: 'row'
-    cells: Array<{
-      _type: 'cell'
-      _key: string
-      value: Array<{_type: string; children?: Array<unknown>}>
-    }>
-  }>
-  const lines: string[] = []
-
-  // Helper to extract text from cell blocks
-  const getCellText = (
-    cellBlocks: Array<{_type: string; children?: Array<unknown>}>,
-  ): string => {
-    return cellBlocks
-      .map((block, index) =>
-        renderNode({
-          node: block as {_type: string},
-          index,
-          isInline: false,
-          renderNode,
-        }),
-      )
-      .join(' ')
-      .trim()
-  }
-
-  // Add header rows
-  for (let i = 0; i < headerRows; i++) {
-    const row = rows[i]
-    if (row) {
-      const cellTexts = row.cells.map((cell) => getCellText(cell.value))
-      lines.push(`| ${cellTexts.join(' | ')} |`)
-    }
-  }
-
-  // Add separator line if there are headers
-  if (headerRows > 0 && rows[0]) {
-    const separators = rows[0].cells.map(() => ' --- ')
-    lines.push(`|${separators.join('|')}|`)
-  }
-
-  // Add body rows
-  for (let i = headerRows; i < rows.length; i++) {
-    const row = rows[i]
-    if (row) {
-      const cellTexts = row.cells.map((cell) => getCellText(cell.value))
-      lines.push(`| ${cellTexts.join(' | ')} |`)
-    }
-  }
-
-  return lines.join('\n')
-}
-
-/**
- * @public
- */
-export const DefaultUnknownTypeRenderer: PortableTextTypeRenderer = ({
-  value,
-  isInline,
-}) => {
-  const json = `\`\`\`json\n${JSON.stringify(value, null, 2)}\n\`\`\``
-  // For inline unknown types, add newlines to break them out of the text flow
-  return isInline ? `\n${json}\n` : json
-}

package/src/from-portable-text/types.ts

@@ -1,240 +0,0 @@
-import type {
-  ArbitraryTypedObject,
-  PortableTextBlock,
-  PortableTextBlockStyle,
-  PortableTextListItemBlock,
-  PortableTextListItemType,
-  TypedObject,
-} from '@portabletext/types'
-
-/**
- * Generic type for portable text renderers that takes blocks/inline blocks
- *
- * @public
- */
-export type PortableTextRenderer<N> = (
-  options: PortableTextRendererOptions<N>,
-) => string
-
-/**
- * Renderer function type for rendering portable text blocks (paragraphs, headings, blockquotes etc)
- *
- * @public
- */
-export type PortableTextBlockRenderer = PortableTextRenderer<PortableTextBlock>
-
-/**
- * Renderer function type for rendering portable text list items
- *
- * @public
- */
-export type PortableTextListItemRenderer =
-  PortableTextRenderer<PortableTextListItemBlock>
-
-/**
- * Renderer function type for rendering portable text marks and/or decorators
- *
- * @public
- */
-export type PortableTextMarkRenderer<M extends TypedObject = any> = (
-  options: PortableTextMarkRendererOptions<M>,
-) => string
-
-/**
- * @public
- */
-export type PortableTextTypeRenderer<V extends TypedObject = any> = (
-  options: PortableTextTypeRendererOptions<V>,
-) => string
-
-/**
- * Object defining the different renderer functions to use for rendering various aspects
- * of Portable Text and user-provided types to Markdown.
- *
- * @public
- */
-export interface PortableTextRenderers {
-  /**
-   * Object of renderer functions for different types of objects that might appear
-   * both as part of the blocks array, or as inline objects _inside_ of a block,
-   * alongside text spans.
-   *
-   * Use the `isInline` property to check whether or not this is an inline object or a block.
-   *
-   * The object has the shape `{typeName: RendererFn}`, where `typeName` is the value set
-   * in individual `_type` attributes.
-   */
-  types: Record<string, PortableTextTypeRenderer | undefined>
-
-  /**
-   * Object of renderer functions for different types of marks that might appear in spans.
-   *
-   * The object has the shape `{markName: RendererFn}`, where `markName` is the value set
-   * in individual `_type` attributes, values being stored in the parent blocks `markDefs`.
-   */
-  marks: Record<string, PortableTextMarkRenderer | undefined>
-
-  /**
-   * Object of renderer functions for blocks with different `style` properties.
-   *
-   * The object has the shape `{styleName: RendererFn}`, where `styleName` is the value set
-   * in individual `style` attributes on blocks.
-   *
-   * Can also be set to a single renderer function, which would handle block styles of _any_ type.
-   */
-  block:
-    | Record<PortableTextBlockStyle, PortableTextBlockRenderer | undefined>
-    | PortableTextBlockRenderer
-
-  /**
-   * Object of renderer functions used to render different list item styles.
-   *
-   * The object has the shape `{listItemType: RendererFn}`, where `listItemType` is the value
-   * set in individual `listItem` attributes on blocks.
-   *
-   * Can also be set to a single renderer function, which would handle list items of _any_ type.
-   */
-  listItem:
-    | Record<PortableTextListItemType, PortableTextListItemRenderer | undefined>
-    | PortableTextListItemRenderer
-
-  /**
-   * Renderer for "hard breaks", eg `\n` inside of text spans.
-   * By default renders as Markdown hard break (`  \n` - two trailing spaces).
-   */
-  hardBreak: () => string
-
-  /**
-   * Renderer function used when encountering a mark type there is no registered renderer for
-   * in the `marks` option.
-   */
-  unknownMark: PortableTextMarkRenderer
-
-  /**
-   * Renderer function used when encountering an object type there is no registered renderer for
-   * in the `types` option.
-   */
-  unknownType: PortableTextRenderer<UnknownNodeType>
-
-  /**
-   * Renderer function used when encountering a block style there is no registered renderer for
-   * in the `block` option. Only used if `block` is an object.
-   */
-  unknownBlockStyle: PortableTextRenderer<PortableTextBlock>
-
-  /**
-   * Renderer function used when encountering a list item style there is no registered renderer for
-   * in the `listItem` option. Only used if `listItem` is an object.
-   */
-  unknownListItem: PortableTextRenderer<PortableTextListItemBlock>
-}
-
-/**
- * Options received by most Portable Text renderers
- *
- * @public
- */
-export interface PortableTextRendererOptions<T> {
-  /**
-   * Data associated with this portable text node, eg the raw JSON value of a block/type
-   */
-  value: T
-
-  /**
-   * Index within its parent
-   */
-  index: number
-
-  /**
-   * Index of a list item
-   */
-  listIndex?: number | undefined
-
-  /**
-   * Whether or not this node is "inline" - ie as a child of a text block,
-   * alongside text spans, or a block in and of itself.
-   */
-  isInline: boolean
-
-  /**
-   * Serialized Markdown of child nodes of this block/type
-   */
-  children?: string
-
-  /**
-   * Function used to render any node that might appear in a portable text array or block,
-   * including virtual "toolkit"-nodes like lists and nested spans. You will rarely need
-   * to use this.
-   */
-  renderNode: RenderNode
-}
-
-/**
- * Options received by any user-defined type renderer in the input array that is not a text block
- *
- * @public
- */
-export type PortableTextTypeRendererOptions<T> = Omit<
-  PortableTextRendererOptions<T>,
-  'children'
->
-
-/**
- * Options received by Portable Text mark renderers
- *
- * @public
- */
-export interface PortableTextMarkRendererOptions<
-  M extends TypedObject = ArbitraryTypedObject,
-> {
-  /**
-   * Mark definition, eg the actual data of the annotation. If the mark is a simple decorator, this will be `undefined`
-   */
-  value?: M
-
-  /**
-   * Text content of this mark
-   */
-  text: string
-
-  /**
-   * Key for this mark. The same key can be used amongst multiple text spans within the same block, so don't rely on this to be unique.
-   */
-  markKey: string | undefined
-
-  /**
-   * Type of mark - ie value of `_type` in the case of annotations, or the name of the decorator otherwise - eg `em`, `italic`.
-   */
-  markType: string
-
-  /**
-   * Serialized Markdown of child nodes of this mark
-   */
-  children: string
-
-  /**
-   * Function used to render any node that might appear in a portable text array or block,
-   * including virtual "toolkit"-nodes like lists and nested spans. You will rarely need
-   * to use this.
-   */
-  renderNode: RenderNode
-}
-
-/**
- * Any node type that we can't identify - eg it has an `_type`,
- * but we don't know anything about its other properties
- */
-export type UnknownNodeType =
-  | {[key: string]: unknown; _type: string}
-  | TypedObject
-
-export type RenderNode = <T extends TypedObject>(
-  options: Serializable<T>,
-) => string
-
-export interface Serializable<T> {
-  node: T
-  index: number
-  isInline: boolean
-  renderNode: RenderNode
-}

package/src/index.ts

@@ -1,51 +0,0 @@
-export {portableTextToMarkdown} from './from-portable-text/portable-text-to-markdown'
-export {
-  DefaultBlockSpacingRenderer,
-  type BlockSpacingRenderer,
-} from './from-portable-text/renderers/block-spacing'
-export {DefaultHardBreakRenderer} from './from-portable-text/renderers/hard-break'
-export {DefaultListItemRenderer} from './from-portable-text/renderers/list-item'
-export {
-  DefaultBlockquoteRenderer,
-  DefaultH1Renderer,
-  DefaultH2Renderer,
-  DefaultH3Renderer,
-  DefaultH4Renderer,
-  DefaultH5Renderer,
-  DefaultH6Renderer,
-  DefaultNormalRenderer,
-} from './from-portable-text/renderers/style'
-export {
-  DefaultCodeRenderer,
-  DefaultEmRenderer,
-  DefaultLinkRenderer,
-  DefaultStrikeThroughRenderer,
-  DefaultStrongRenderer,
-  DefaultUnderlineRenderer,
-} from './from-portable-text/renderers/marks'
-export {
-  DefaultCodeBlockRenderer,
-  DefaultHorizontalRuleRenderer,
-  DefaultHtmlRenderer,
-  DefaultImageRenderer,
-  DefaultTableRenderer,
-} from './from-portable-text/renderers/type'
-export type {
-  PortableTextBlockRenderer,
-  PortableTextListItemRenderer,
-  PortableTextMarkRenderer,
-  PortableTextMarkRendererOptions,
-  PortableTextRenderer,
-  PortableTextRendererOptions,
-  PortableTextRenderers,
-  PortableTextTypeRenderer,
-  PortableTextTypeRendererOptions,
-} from './from-portable-text/types'
-export {markdownToPortableText} from './to-portable-text/markdown-to-portable-text'
-export type {
-  AnnotationMatcher,
-  DecoratorMatcher,
-  ListItemMatcher,
-  ObjectMatcher,
-  StyleMatcher,
-} from './to-portable-text/matchers'

package/src/key-generator.ts

@@ -1,32 +0,0 @@
-export function defaultKeyGenerator() {
-  return randomKey(12)
-}
-
-const getByteHexTable = (() => {
-  let table: any[]
-  return () => {
-    if (table) {
-      return table
-    }
-
-    table = []
-    for (let i = 0; i < 256; ++i) {
-      table[i] = (i + 0x100).toString(16).slice(1)
-    }
-    return table
-  }
-})()
-
-// WHATWG crypto RNG - https://w3c.github.io/webcrypto/Overview.html
-function whatwgRNG(length = 16) {
-  const rnds8 = new Uint8Array(length)
-  crypto.getRandomValues(rnds8)
-  return rnds8
-}
-
-function randomKey(length?: number): string {
-  const table = getByteHexTable()
-  return whatwgRNG(length)
-    .reduce((str, n) => str + table[n], '')
-    .slice(0, length)
-}