• Version 0.0.43
  • Published
  • 414 kB
  • No dependencies
  • Apache-2.0 license


npm i yaml-ast-parser
yarn add yaml-ast-parser
pnpm add yaml-ast-parser


[![Build Status](https://travis-ci.org/mulesoft-labs/yaml-ast-parser.svg?branch=master)](https://travis-ci.org/mulesoft-labs/yaml-ast-parser)



function determineScalarType

determineScalarType: (node: YAMLScalar) => ScalarType;

    function dump

    dump: (input: any, options: any) => string;

      function load

      load: (input: string, options?: LoadOptions) => ast.YAMLNode;

        function loadAll

        loadAll: (
        input: string,
        iterator: (document: ast.YAMLNode) => void,
        options?: LoadOptions
        ) => void;

          function newAnchorRef

          newAnchorRef: (
          key: string,
          start: number,
          end: number,
          value: YAMLNode
          ) => YAMLAnchorReference;

            function newItems

            newItems: () => YAMLSequence;

              function newMap

              newMap: (mappings?: YAMLMapping[]) => YamlMap;

                function newMapping

                newMapping: (key: YAMLScalar, value: YAMLNode) => YAMLMapping;

                  function newScalar

                  newScalar: (v?: string | boolean | number) => YAMLScalar;

                    function newSeq

                    newSeq: () => YAMLSequence;

                      function parseYamlBoolean

                      parseYamlBoolean: (input: string) => boolean;

                        function parseYamlFloat

                        parseYamlFloat: (input: string) => number;

                          function parseYamlInteger

                          parseYamlInteger: (input: string) => number;

                            function safeDump

                            safeDump: (input: any, options: any) => string;

                              function safeLoad

                              safeLoad: (input: string, options?: LoadOptions) => ast.YAMLNode;

                                function safeLoadAll

                                safeLoadAll: (
                                input: string,
                                output: (document: ast.YAMLNode) => void,
                                options?: LoadOptions
                                ) => void;


                                  interface LoadOptions

                                  interface LoadOptions {}

                                    property allowAnyEscape

                                    allowAnyEscape?: boolean;

                                      property filename

                                      filename?: string;

                                        property ignoreDuplicateKeys

                                        ignoreDuplicateKeys?: boolean;

                                          property legacy

                                          legacy?: boolean;

                                            property onWarning

                                            onWarning?: () => any;

                                              property schema

                                              schema?: any;

                                                interface YAMLAnchorReference

                                                interface YAMLAnchorReference extends YAMLNode {}

                                                  property referencesAnchor

                                                  referencesAnchor: string;

                                                    property value

                                                    value: YAMLNode;

                                                      interface YAMLDocument

                                                      interface YAMLDocument {}

                                                        property endPosition

                                                        endPosition: number;

                                                          property errors

                                                          errors: YAMLException[];

                                                            property startPosition

                                                            startPosition: number;

                                                              interface YamlMap

                                                              interface YamlMap extends YAMLNode {}

                                                                property mappings

                                                                mappings: YAMLMapping[];

                                                                  interface YAMLMapping

                                                                  interface YAMLMapping extends YAMLNode {}

                                                                    property key

                                                                    key: YAMLScalar;

                                                                      property value

                                                                      value: YAMLNode;

                                                                        interface YAMLNode

                                                                        interface YAMLNode extends YAMLDocument {}

                                                                          property anchorId

                                                                          anchorId?: string;

                                                                            property endPosition

                                                                            endPosition: number;

                                                                              property errors

                                                                              errors: YAMLException[];

                                                                                property key

                                                                                key?: any;

                                                                                  property kind

                                                                                  kind: Kind;

                                                                                    property mappings

                                                                                    mappings?: any;

                                                                                      property parent

                                                                                      parent: YAMLNode;

                                                                                        property startPosition

                                                                                        startPosition: number;

                                                                                          property value

                                                                                          value?: any;

                                                                                            property valueObject

                                                                                            valueObject?: any;

                                                                                              interface YAMLScalar

                                                                                              interface YAMLScalar extends YAMLNode {}

                                                                                                property doubleQuoted

                                                                                                doubleQuoted?: boolean;

                                                                                                  property plainScalar

                                                                                                  plainScalar?: boolean;

                                                                                                    property rawValue

                                                                                                    rawValue: string;

                                                                                                      property singleQuoted

                                                                                                      singleQuoted?: boolean;

                                                                                                        property value

                                                                                                        value: string;

                                                                                                          interface YAMLSequence

                                                                                                          interface YAMLSequence extends YAMLNode {}

                                                                                                            property items

                                                                                                            items: YAMLNode[];


                                                                                                              enum Kind

                                                                                                              enum Kind {
                                                                                                              SCALAR = 0,
                                                                                                              MAPPING = 1,
                                                                                                              MAP = 2,
                                                                                                              SEQ = 3,
                                                                                                              ANCHOR_REF = 4,
                                                                                                              INCLUDE_REF = 5,

                                                                                                                member ANCHOR_REF

                                                                                                                ANCHOR_REF = 4

                                                                                                                  member INCLUDE_REF

                                                                                                                  INCLUDE_REF = 5

                                                                                                                    member MAP

                                                                                                                    MAP = 2

                                                                                                                      member MAPPING

                                                                                                                      MAPPING = 1

                                                                                                                        member SCALAR

                                                                                                                        SCALAR = 0

                                                                                                                          member SEQ

                                                                                                                          SEQ = 3

                                                                                                                            enum ScalarType

                                                                                                                            enum ScalarType {
                                                                                                                            null = 0,
                                                                                                                            bool = 1,
                                                                                                                            int = 2,
                                                                                                                            float = 3,
                                                                                                                            string = 4,

                                                                                                                              member bool

                                                                                                                              bool = 1

                                                                                                                                member float

                                                                                                                                float = 3

                                                                                                                                  member int

                                                                                                                                  int = 2

                                                                                                                                    member null

                                                                                                                                    null = 0

                                                                                                                                      member string

                                                                                                                                      string = 4

                                                                                                                                        Type Aliases

                                                                                                                                        type Error

                                                                                                                                        type Error = YAMLException;

                                                                                                                                          Package Files (5)

                                                                                                                                          Dependencies (0)

                                                                                                                                          No dependencies.

                                                                                                                                          Dev Dependencies (8)

                                                                                                                                          Peer Dependencies (0)

                                                                                                                                          No peer dependencies.


                                                                                                                                          To add a badge like this onejsDocs.io badgeto your package's README, use the codes available below.

                                                                                                                                          You may also use Shields.io to create a custom badge linking to https://www.jsdocs.io/package/yaml-ast-parser.

                                                                                                                                          • Markdown
                                                                                                                                          • HTML
                                                                                                                                            <a href="https://www.jsdocs.io/package/yaml-ast-parser"><img src="https://img.shields.io/badge/jsDocs.io-reference-blue" alt="jsDocs.io"></a>