Nuanced Pumpkin Mavens

    TypeScript icon, indicating that this package has built-in type declarations

    2.0.4 • Public • Published


    A set of Typescript types and helpers to work with DatoCMS Structured Text fields.


    Using npm:

    npm install datocms-structured-text-utils

    Using yarn:

    yarn add datocms-structured-text-utils

    dast document validation

    You can use the validate() function to check if an object is compatible with the dast specification:

    import { validate } from 'datocms-structured-text-utils';
    const structuredText = {
      value: {
        schema: 'dast',
        document: {
          type: 'root',
          children: [
              type: 'heading',
              level: 1,
              children: [
                  type: 'span',
                  value: 'Hello!',
                  marks: ['foobar'],
    const result = validate(structuredText);
    if (!result.valid) {
      console.error(result.message); // "span has an invalid mark "foobar"

    dast format specs

    The package exports a number of constants that represents the rules of the dast specification.

    Take a look a the definitions.ts file for their definition:

    const blockquoteNodeType = 'blockquote';
    const blockNodeType = 'block';
    const codeNodeType = 'code';
    const headingNodeType = 'heading';
    const inlineItemNodeType = 'inlineItem';
    const itemLinkNodeType = 'itemLink';
    const linkNodeType = 'link';
    const listItemNodeType = 'listItem';
    const listNodeType = 'list';
    const paragraphNodeType = 'paragraph';
    const rootNodeType = 'root';
    const spanNodeType = 'span';
    const allowedNodeTypes = [
      // ...
    const allowedChildren = {
      paragraph: 'inlineNodes',
      list: ['listItem'],
      // ...
    const inlineNodeTypes = [
      // ...
    const allowedAttributes = {
      heading: ['level', 'children'],
      // ...
    const allowedMarks = [
      // ...

    Typescript Types

    The package exports Typescript types for all the different nodes that a dast document can contain.

    Take a look a the types.ts file for their definition:

    type Node
    type BlockNode
    type InlineNode
    type RootType
    type Root
    type ParagraphType
    type Paragraph
    type HeadingType
    type Heading
    type ListType
    type List
    type ListItemType
    type ListItem
    type CodeType
    type Code
    type BlockquoteType
    type Blockquote
    type BlockType
    type Block
    type SpanType
    type Mark
    type Span
    type LinkType
    type Link
    type ItemLinkType
    type ItemLink
    type InlineItemType
    type InlineItem
    type WithChildrenNode
    type Document
    type NodeType
    type StructuredText
    type Record

    Typescript Type guards

    It also exports all a number of type guards that you can use to guarantees the type of a node in some scope.

    Take a look a the guards.ts file for their definition:

    function hasChildren(node: Node): node is WithChildrenNode {}
    function isInlineNode(node: Node): node is InlineNode {}
    function isHeading(node: Node): node is Heading {}
    function isSpan(node: Node): node is Span {}
    function isRoot(node: Node): node is Root {}
    function isParagraph(node: Node): node is Paragraph {}
    function isList(node: Node): node is List {}
    function isListItem(node: Node): node is ListItem {}
    function isBlockquote(node: Node): node is Blockquote {}
    function isBlock(node: Node): node is Block {}
    function isCode(node: Node): node is Code {}
    function isLink(node: Node): node is Link {}
    function isItemLink(node: Node): node is ItemLink {}
    function isInlineItem(node: Node): node is InlineItem {}
    function isStructuredText(object: any): object is StructuredText {}


    npm i datocms-structured-text-utils

    DownloadsWeekly Downloads






    Unpacked Size

    108 kB

    Total Files


    Last publish


    • marcelofinamorvieira
    • stefanoverna
    • delphaber
    • mat_jack1
    • souljuse