Yet Another YAML Parser (yayp)

This library is fully written in TypeScript, but not is the main maotivation. The motivation is the "event" based parsing with reasonable performance plus freer type handling.

Installation

No dependencies, just run this:

npm i yayp

Basic usage

API

import { load, loadAll, YamlError } from "yayp"

load(data: string, options: LoadOptions)

Load only one document from the given data. If more documents found in the given data the error is raised.

loadAll(data: string, options: LoadOptions)

Load all document from the given data, and always return an Array of items.

LoadOptions

all options are optional

• defaultVersion (float): If YAML document dont specifiy the version with directive, the Loader use this version.
• forcedVersion (float): The loader always use this version to load documents from the data
• extraSchema (ISchema): Use this additional schema plus the version schema ( SCHEMA_V11, SCHEMA_V12 )
• schema (ISchema): Use this schema only, no additional schemas
• needComments (boolean): Control parser to call the Loader.onComment method or not
• document (YamlDocument class): Loader use this class to construct a new decoument
• filename (string): This filename appears in the error messages

Example

console.log(load("Hello World")) // prints 'Hello World'

Advanced usage

API

Create a custom type

The main interfaces found in handler.ts and the abstract TypeFactory class is the base of the all custom types.

Foo type can handle strings, and prefix all strings with foo- (totally scrap type, but this si a demonstration).

import { TypeFactory } from "yayp"

class Foo extends TypeFactory {
    onScalar(offset, value) {
        return `foo-${value}`
    }

    onQuotedString(offset, value) {
        return `foo-${value}`
    }

    onBlockString(offset, value) {
        return `foo-${value}`
    }
}

More examples in builtin types

Create a Schema

Instantiate the Schema class with the right paramteres, like this:

const MySchema = new Schema({
    "!foo": new Foo
    // or a fully qualified name
    "zozzz/yayp/foo": new Foo
})

And we can load the following YAML file:

---
hello: !foo ok # result is {"hello": "foo-ok"}
...

%TAG !z! zozzz/yayp/
---
hello: !z!foo ok # result is {"hello": "foo-ok"}
...

---
hello: !<zozzz/yayp/foo> ok # result is {"hello": "foo-ok"}
...

Load YAML documents with a custom schema

import { loadAll } from "yayp"

loadAll("...", { extraSchema: MySchema })

Maybe this SchemaCollection class is usefull, when you want combine more schemas.