ts-mdast - Outils Typescript pour arbres syntaxiques abstraits Markdown

Ce paquet fourni des outils pour travailler avec des arbres syntaxiques abstraits de type Markdown (MDAST). Il contient :

des fonctions pour créer les différents types de nœuds (également utiles en pure Javascript) ;
des fonctions de contrôle de type et assertions pour garantir que le nœud est bien du type escompté (surtout utiles avec Typescript).

Ce paquet ré-exporte également tous les types de @types/mdast et les quelques types de @types/unist utiles pour Markdown. Il n'est donc pas nécessaire d'inclure ces paquets si vous utilisez celui-ci.

Langue

Les documents et messages, le code (y compris les noms de variable et commentaires), sont en anglais.

Cependant, Slune étant une entreprise française, tous les documents et messages importants doivent également être fournis en français. Les autres traductions sont bienvenues.

Installation

L’installation se fait avec la commande npm install :

$ npm install --save ts-mdast

Utilisation

Pour chaque type de nœud NodeType, le paquet contient :

une fonction assertNodeType(node: Node) qui lève une exception si node n'est pas de type NodeType ;
une fonction isNodeType(node: Node) qui renvoie true si node est de type NodeType ;
une fonction createNodeType(...) qui crée un nœud de type NodeType.

Les deux premières fonctions sont comprises par Typescript qui est donc capable par la suite de contrôler le type de nœud de façon appropriée.

La fonction de création s'utilise ainsi :

createNodeType(mandatory1, mandatory2 [, optional1 [, optional2 [, optional3]] | {optional1, optional2, optional3}] [, children])

où mandatory_ représentent les paramètres obligatoires, optional_ les paramètres optionnels et children un tableau avec les nœuds fils. Les appels suivants sont donc possibles :

createNodeType(mandatory1, mandatory2, optional1, [child1, child2])
createNodeType(mandatory1, mandatory2, optional1, optional2)
createNodeType(mandatory1, mandatory2, { optional1, optional3 })
createNodeType(mandatory1, mandatory2, { optional2, optional3 }, [child1, child2])
createNodeType(mandatory1, mandatory2, [child1, child2])

Le tableau contenant les fils est utilisé directement dans le nœud et peut donc être modifié après la création du nœud :

const children: Content[] = []
createNodeType(mandatory1, mandatory2, children)
children.push(createNodeType(mandatory1, mandatory2))

Notes :

La fonction createNodeType(...) n'existe que sur les nœuds concrêts (pas sur Content ni sur BlockContent par exemple).
Tous les types de nœud n'ont pas forcément de paramètres obligatoires, de paramètres optionnels ou de nœuds fils.

Nœuds

Parent

Référence : Parent

Assertion de type :

function assertParent(node: Node): asserts node is Parent

Contrôle de type :

function isParent(node: Node): node is Parent

Literal

Référence : Literal

Assertion de type :

function assertLiteral(node: Node): asserts node is Literal

Contrôle de type :

function isLiteral(node: Node): node is Literal

Content

Référence : Content

Assertion de type :

function assertContent(node: Node): asserts node is Content

Contrôle de type :

function isContent(node: Node): node is Content

TopLevelContent

Référence : TopLevelContent

Assertion de type :

function assertTopLevelContent(node: Node): asserts node is TopLevelContent

Contrôle de type :

function isTopLevelContent(node: Node): node is TopLevelContent

BlockContent

Référence : BlockContent

Assertion de type :

function assertBlockContent(node: Node): asserts node is BlockContent

Contrôle de type :

function isBlockContent(node: Node): node is BlockContent

FrontmatterContent

Référence : FrontmatterContent

Assertion de type :

function assertFrontmatterContent(node: Node): asserts node is FrontmatterContent

Contrôle de type :

function isFrontmatterContent(node: Node): node is FrontmatterContent

DefinitionContent

Référence : DefinitionContent

Assertion de type :

function assertDefinitionContent(node: Node): asserts node is DefinitionContent

Contrôle de type :

function isDefinitionContent(node: Node): node is DefinitionContent

ListContent

Référence : ListContent

Assertion de type :

function assertListContent(node: Node): asserts node is ListContent

Contrôle de type :

function isListContent(node: Node): node is ListContent

TableContent

Référence : TableContent

Assertion de type :

function assertTableContent(node: Node): asserts node is TableContent

Contrôle de type :

function isTableContent(node: Node): node is TableContent

RowContent

Référence : RowContent

Assertion de type :

function assertRowContent(node: Node): asserts node is RowContent

Contrôle de type :

function isRowContent(node: Node): node is RowContent

PhrasingContent

Référence : PhrasingContent

Assertion de type :

function assertPhrasingContent(node: Node): asserts node is PhrasingContent

Contrôle de type :

function isPhrasingContent(node: Node): node is PhrasingContent

StaticPhrasingContent

Référence : StaticPhrasingContent

Assertion de type :

function assertStaticPhrasingContent(node: Node): asserts node is StaticPhrasingContent

Contrôle de type :

function isStaticPhrasingContent(node: Node): node is StaticPhrasingContent

Root

Référence : Root

Assertion de type :

function assertRoot(node: Node): asserts node is Root

Contrôle de type :

function isRoot(node: Node): node is Root

Création :

function createRoot(children?: Content[]): Root

Paragraph

Référence : Paragraph

Assertion de type :

function assertParagraph(node: Node): asserts node is Paragraph

Contrôle de type :

function isParagraph(node: Node): node is Paragraph

Création :

function createParagraph(children?: PhrasingContent[]): Paragraph

Heading

Référence : Heading

Assertion de type :

function assertHeading(node: Node): asserts node is Heading

Contrôle de type :

function isHeading(node: Node): node is Heading

Création :

function createHeading(depth: 1 | 2 | 3 | 4 | 5 | 6, children?: PhrasingContent[])

ThematicBreak

Référence : ThematicBreak

Assertion de type :

function assertThematicBreak(node: Node): asserts node is ThematicBreak

Contrôle de type :

function isThematicBreak(node: Node): node is ThematicBreak

Création :

function createThematicBreak(): ThematicBreak

Blockquote

Référence : Blockquote

Assertion de type :

function assertBlockquote(node: Node): asserts node is Blockquote

Contrôle de type :

function isBlockquote(node: Node): node is Blockquote

Création :

function createBlockquote(children?: BlockContent[]): Blockquote

List

Référence : List

Assertion de type :

function assertList(node: Node): asserts node is List

Contrôle de type :

function isList(node: Node): node is List

Création :

function createList(ordered: boolean, start: number, spread: boolean, children?: ListContent[]): List
function createList(ordered: boolean, start: number, children?: ListContent[]): List
function createList(ordered: boolean, children?: ListContent[]): List
function createList(children?: ListContent[]): List
function createList(
  options: { ordered?: boolean; start?: number; spread?: boolean },
  children?: ListContent[]
): List

ListItem

Référence : ListItem

Assertion de type :

function assertListItem(node: Node): asserts node is ListItem

Contrôle de type :

function isListItem(node: Node): node is ListItem

Création :

function createListItem(checked: boolean, spread: boolean, children?: BlockContent[]): ListItem
function createListItem(checked: boolean, children?: BlockContent[]): ListItem
function createListItem(children?: BlockContent[]): ListItem
function createListItem(
  options: { checked?: boolean; spread?: boolean },
  children?: BlockContent[]
): ListItem

Table

Référence : Table

Assertion de type :

function assertTable(node: Node): asserts node is Table

Contrôle de type :

function isTable(node: Node): node is Table

Création :

function createTable(align: AlignType[], children?: TableContent[]): Table
function createTable(children?: TableContent[]): Table
function createTable(options: { align?: AlignType[] }, children?: TableContent[]): Table

TableRow

Référence : TableRow

Assertion de type :

function assertTableRow(node: Node): asserts node is TableRow

Contrôle de type :

function isTableRow(node: Node): node is TableRow

Création :

function createTableRow(children?: RowContent[]): TableRow

TableCell

Référence : TableCell

Assertion de type :

function assertTableCell(node: Node): asserts node is TableCell

Contrôle de type :

function isTableCell(node: Node): node is TableCell

Création :

function createTableCell(children?: PhrasingContent[]): TableCell

HTML

Référence : HTML

Assertion de type :

function assertHTML(node: Node): asserts node is HTML

Contrôle de type :

function isHTML(node: Node): node is HTML

Création :

function createHTML(value: string): HTML

Code

Référence : Code

Assertion de type :

function assertCode(node: Node): asserts node is Code

Contrôle de type :

function isCode(node: Node): node is Code

Création :

function createCode(value: string, lang?: string, meta?: string): Code
function createCode(value: string, options: { lang?: string; meta?: string }): Code

YAML

Référence : YAML

Assertion de type :

function assertYAML(node: Node): asserts node is YAML

Contrôle de type :

function isYAML(node: Node): node is YAML

Création :

function createYAML(value: string): YAML

Definition

Référence : Definition

Assertion de type :

function assertDefinition(node: Node): asserts node is Definition

Contrôle de type :

function isDefinition(node: Node): node is Definition

Création :

function createDefinition(identifier: string, url: string, label?: string, title?: string): Definition
function createDefinition(
  identifier: string,
  url: string,
  options: { label?: string; title?: string }
): Definition

FootnoteDefinition

Référence : FootnoteDefinition

Assertion de type :

function assertFootnoteDefinition(node: Node): asserts node is FootnoteDefinition

Contrôle de type :

function isFootnoteDefinition(node: Node): node is FootnoteDefinition

Création :

function createFootnoteDefinition(
  identifier: string,
  label: string,
  children?: BlockContent[]
): FootnoteDefinition
function createFootnoteDefinition(identifier: string, children?: BlockContent[]): FootnoteDefinition
function createFootnoteDefinition(
  identifier: string,
  options: { label?: string },
  children?: BlockContent[]
): FootnoteDefinition

Text

Référence : Text

Assertion de type :

function assertText(node: Node): asserts node is Text

Contrôle de type :

function isText(node: Node): node is Text

Création :

function createText(value: string): Text

Emphasis

Référence : Emphasis

Assertion de type :

function assertEmphasis(node: Node): asserts node is Emphasis

Contrôle de type :

function isEmphasis(node: Node): node is Emphasis

Création :

function createEmphasis(children?: PhrasingContent[]): Emphasis

Strong

Référence : Strong

Assertion de type :

function assertStrong(node: Node): asserts node is Strong

Contrôle de type :

function isStrong(node: Node): node is Strong

Création :

function createStrong(children?: PhrasingContent[]): Strong

Delete

Référence : Delete

Assertion de type :

function assertDelete(node: Node): asserts node is Delete

Contrôle de type :

function isDelete(node: Node): node is Delete

Création :

function createDelete(children?: PhrasingContent[]): Delete

InlineCode

Référence : InlineCode

Assertion de type :

function assertInlineCode(node: Node): asserts node is InlineCode

Contrôle de type :

function isInlineCode(node: Node): node is InlineCode

Création :

function createInlineCode(value: string): InlineCode

Break

Référence : Break

Assertion de type :

function assertBreak(node: Node): asserts node is Break

Contrôle de type :

function isBreak(node: Node): node is Break

Création :

function createBreak(): Break

Link

Référence : Link

Assertion de type :

function assertLink(node: Node): asserts node is Link

Contrôle de type :

function isLink(node: Node): node is Link

Création :

function createLink(url: string, title: string, children?: StaticPhrasingContent[]): Link
function createLink(url: string, children?: StaticPhrasingContent[]): Link
function createLink(url: string, options: { title?: string }, children?: StaticPhrasingContent[]): Link

Image

Référence : Image

Assertion de type :

function assertImage(node: Node): asserts node is Image

Contrôle de type :

function isImage(node: Node): node is Image

Création :

function createImage(url: string, alt?: string, title?: string): Image
function createImage(url: string, options: { alt?: string; title?: string }): Image

LinkReference

Référence : LinkReference

Assertion de type :

function assertLinkReference(node: Node): asserts node is LinkReference

Contrôle de type :

function isLinkReference(node: Node): node is LinkReference

Création :

function createLinkReference(
  identifier: string,
  referenceType: ReferenceType,
  label: string,
  children?: StaticPhrasingContent[]
): LinkReference
function createLinkReference(
  identifier: string,
  referenceType: ReferenceType,
  children?: StaticPhrasingContent[]
): LinkReference
function createLinkReference(
  identifier: string,
  referenceType: ReferenceType,
  options: { label?: string },
  children?: StaticPhrasingContent[]
): LinkReference

ImageReference

Référence : ImageReference

Assertion de type :

function assertImageReference(node: Node): asserts node is ImageReference

Contrôle de type :

function isImageReference(node: Node): node is ImageReference

Création :

function createImageReference(
  identifier: string,
  referenceType: ReferenceType,
  alt?: string,
  label?: string
): ImageReference
function createImageReference(
  identifier: string,
  referenceType: ReferenceType,
  options: { alt?: string; label?: string }
): ImageReference

Footnote

Référence : Footnote

Assertion de type :

function assertFootnote(node: Node): asserts node is Footnote

Contrôle de type :

function isFootnote(node: Node): node is Footnote

Création :

function createFootnote(children?: PhrasingContent[]): Footnote

FootnoteReference

Référence : FootnoteReference

Assertion de type :

function assertFootnoteReference(node: Node): asserts node is FootnoteReference

Contrôle de type :

function isFootnoteReference(node: Node): node is FootnoteReference

Création :

function createFootnoteReference(identifier: string, label?: string): FootnoteReference
function createFootnoteReference(identifier: string, options: { label?: string }): FootnoteReference

Contribuer

Bien que nous ne puissions pas garantir un temps de réponse, n’hésitez pas à ouvrir un incident si vous avez une question ou un problème pour utiliser ce paquet.

Les Pull Requests sont bienvenues. Vous pouvez bien sûr soumettre des corrections ou améliorations de code, mais n’hésitez pas également à améliorer la documentation, même pour de petites fautes d’orthographe ou de grammaire.

Files

README.md

Latest commit

History

README.md

File metadata and controls

ts-mdast - Outils Typescript pour arbres syntaxiques abstraits Markdown

Langue

Installation

Utilisation

Nœuds

Parent

Literal

Content

TopLevelContent

BlockContent

FrontmatterContent

DefinitionContent

ListContent

TableContent

RowContent

PhrasingContent

StaticPhrasingContent

Root

Paragraph

Heading

ThematicBreak

Blockquote

List

ListItem

Table

TableRow

TableCell

HTML

Code

YAML

Definition

FootnoteDefinition

Text

Emphasis

Strong

Delete

InlineCode

Break

Link

Image

LinkReference

ImageReference

Footnote

FootnoteReference

Contribuer