Parser

Index

Constructors

• constructor

Properties

• allowed
• banned
• blocked
• container
• content
• filters
• keyIndex
• matchers
• props

Methods

• applyAttributeFilters
• applyMatchers
• applyNodeFilters
• canRenderChild
• convertLineBreaks
• createContainer
• extractAttributes
• extractStyleAttribute
• getTagConfig
• isSafe
• isTagAllowed
• parse
• parseNode
• replaceTokens

Constructors

constructor

• new Parser(markup: string, props?: ParserProps, matchers?: MatcherInterface<any>[], filters?: FilterInterface[]): Parser

Properties

allowed

allowed: Set<string>

banned

banned: Set<string>

blocked

blocked: Set<string>

optionalcontainer

container?: HTMLElement

content

content: Node[] = []

filters

filters: FilterInterface[]

keyIndex

keyIndex: number

matchers

matchers: MatcherInterface<any>[]

props

props: ParserProps

Methods

applyAttributeFilters

• applyAttributeFilters<K>(name: K, value: ElementAttributes[K]): ElementAttributes[K]

• Loop through and apply all registered attribute filters.

  ---

  Type parameters

  • K: keyof ElementAttributes

applyMatchers

• applyMatchers(string: string, parentConfig: NodeConfig): ChildrenNode

• Loop through and apply all registered matchers to the string. If a match is found, create a React element, and build a new array. This array allows React to interpolate and render accordingly.

applyNodeFilters

• applyNodeFilters(name: string, node: null | HTMLElement): null | HTMLElement

• Loop through and apply all registered node filters.

canRenderChild

• canRenderChild(parentConfig: NodeConfig, childConfig: NodeConfig): boolean

• Determine whether the child can be rendered within the parent.

convertLineBreaks

• convertLineBreaks(markup: string): string

• Convert line breaks in a string to HTML <br/> tags. If the string contains HTML, we should not convert anything, as line breaks should be handled by <br/>s in the markup itself.

createContainer

• createContainer(markup: string): undefined | HTMLElement

• Create a detached HTML document that allows for easy HTML parsing while not triggering scripts or loading external resources.

extractAttributes

• extractAttributes(node: HTMLElement): null | Attributes

• Convert an elements attribute map to an object map. Returns null if no attributes are defined.

extractStyleAttribute

• extractStyleAttribute(node: HTMLElement): object

• Extract the style attribute as an object and remove values that allow for attack vectors.

getTagConfig

• getTagConfig(tagName: string): NodeConfig

• Return configuration for a specific tag.

isSafe

• isSafe(node: HTMLElement): boolean

• Verify that a node is safe from XSS and injection attacks.

isTagAllowed

• isTagAllowed(tagName: string): boolean

• Verify that an HTML tag is allowed to render.

parse

• parse(): Node[]

• Parse the markup by injecting it into a detached document, while looping over all child nodes and generating an array to interpolate into JSX.

parseNode

• parseNode(parentNode: HTMLElement, parentConfig: NodeConfig): Node[]

• Loop over the nodes children and generate a list of text nodes and React elements.

replaceTokens

• replaceTokens(tokenizedString: string, elements: MatcherElementsMap): ChildrenNode

• Deconstruct the string into an array, by replacing custom tokens with React elements, so that React can render it correctly.