yaml 2.0.0-2 → 2.0.0-6

package/dist/doc/Document.js

@@ -1,374 +1,277 @@
 'use strict';
 
-var _rollupPluginBabelHelpers = require('../_virtual/_rollupPluginBabelHelpers.js');
-var Document$1 = require('../cst/Document.js');
-var constants = require('../constants.js');
-var errors = require('../errors.js');
+var Alias = require('../nodes/Alias.js');
+var Collection = require('../nodes/Collection.js');
+var Node = require('../nodes/Node.js');
+var Pair = require('../nodes/Pair.js');
+var toJS = require('../nodes/toJS.js');
 var options = require('../options.js');
-var addComment = require('../stringify/addComment.js');
+var Schema = require('../schema/Schema.js');
 var stringify = require('../stringify/stringify.js');
-var Anchors = require('./Anchors.js');
-var Schema = require('./Schema.js');
+var stringifyDocument = require('../stringify/stringifyDocument.js');
+var anchors = require('./anchors.js');
 var applyReviver = require('./applyReviver.js');
 var createNode = require('./createNode.js');
-var listTagNames = require('./listTagNames.js');
-var parseContents = require('./parseContents.js');
-var parseDirectives = require('./parseDirectives.js');
-var Pair = require('../ast/Pair.js');
-var Collection = require('../ast/Collection.js');
-var Scalar = require('../ast/Scalar.js');
-var toJS = require('../ast/toJS.js');
-var Node = require('../ast/Node.js');
-var Alias = require('../ast/Alias.js');
-
-function assertCollection(contents) {
-  if (contents instanceof Collection.Collection) return true;
-  throw new Error('Expected a YAML collection as document contents');
-}
+var directives = require('./directives.js');
 
 class Document {
-  constructor(value, replacer, options$1) {
-    if (options$1 === undefined && replacer && typeof replacer === 'object' && !Array.isArray(replacer)) {
-      options$1 = replacer;
-      replacer = undefined;
+    constructor(value, replacer, options$1) {
+        /** A comment before this Document */
+        this.commentBefore = null;
+        /** A comment immediately after this Document */
+        this.comment = null;
+        /** Errors encountered during parsing. */
+        this.errors = [];
+        /** Warnings encountered during parsing. */
+        this.warnings = [];
+        Object.defineProperty(this, Node.NODE_TYPE, { value: Node.DOC });
+        let _replacer = null;
+        if (typeof replacer === 'function' || Array.isArray(replacer)) {
+            _replacer = replacer;
+        }
+        else if (options$1 === undefined && replacer) {
+            options$1 = replacer;
+            replacer = undefined;
+        }
+        const opt = Object.assign({}, options.defaultOptions, options$1);
+        this.options = opt;
+        let { version } = opt;
+        if (options$1 === null || options$1 === void 0 ? void 0 : options$1.directives) {
+            this.directives = options$1.directives.atDocument();
+            if (this.directives.yaml.explicit)
+                version = this.directives.yaml.version;
+        }
+        else
+            this.directives = new directives.Directives({ version });
+        this.setSchema(version, options$1);
+        if (value === undefined)
+            this.contents = null;
+        else {
+            this.contents = this.createNode(value, _replacer, options$1);
+        }
     }
-
-    this.options = Object.assign({}, options.defaultOptions, options$1);
-    this.anchors = new Anchors.Anchors(this.options.anchorPrefix);
-    this.commentBefore = null;
-    this.comment = null;
-    this.directivesEndMarker = null;
-    this.errors = [];
-    this.schema = null;
-    this.tagPrefixes = [];
-    this.version = null;
-    this.warnings = [];
-
-    if (value === undefined) {
-      // note that this.schema is left as null here
-      this.contents = null;
-    } else if (value instanceof Document$1.Document) {
-      this.parse(value);
-    } else {
-      this.contents = this.createNode(value, {
-        replacer
-      });
+    /** Adds a value to the document. */
+    add(value) {
+        if (assertCollection(this.contents))
+            this.contents.add(value);
     }
-  }
-
-  add(value) {
-    assertCollection(this.contents);
-    return this.contents.add(value);
-  }
-
-  addIn(path, value) {
-    assertCollection(this.contents);
-    this.contents.addIn(path, value);
-  }
-
-  createNode(value, {
-    keepUndefined,
-    onTagObj,
-    replacer,
-    tag,
-    wrapScalars
-  } = {}) {
-    this.setSchema();
-    if (typeof replacer === 'function') value = replacer.call({
-      '': value
-    }, '', value);else if (Array.isArray(replacer)) {
-      const keyToStr = v => typeof v === 'number' || v instanceof String || v instanceof Number;
-
-      const asStr = replacer.filter(keyToStr).map(String);
-      if (asStr.length > 0) replacer = replacer.concat(asStr);
+    /** Adds a value to the document. */
+    addIn(path, value) {
+        if (assertCollection(this.contents))
+            this.contents.addIn(path, value);
     }
-    if (typeof keepUndefined !== 'boolean') keepUndefined = !!this.options.keepUndefined;
-    const aliasNodes = [];
-    const ctx = {
-      keepUndefined,
-
-      onAlias(source) {
-        const alias = new Alias.Alias(source);
-        aliasNodes.push(alias);
-        return alias;
-      },
-
-      onTagObj,
-      prevObjects: new Map(),
-      replacer,
-      schema: this.schema,
-      wrapScalars: wrapScalars !== false
-    };
-    const node = createNode.createNode(value, tag, ctx);
-
-    for (const alias of aliasNodes) {
-      // With circular references, the source node is only resolved after all of
-      // its child nodes are. This is why anchors are set only after all of the
-      // nodes have been created.
-      alias.source = alias.source.node;
-      let name = this.anchors.getName(alias.source);
-
-      if (!name) {
-        name = this.anchors.newName();
-        this.anchors.map[name] = alias.source;
-      }
+    /**
+     * Create a new `Alias` node, ensuring that the target `node` has the required anchor.
+     *
+     * If `node` already has an anchor, `name` is ignored.
+     * Otherwise, the `node.anchor` value will be set to `name`,
+     * or if an anchor with that name is already present in the document,
+     * `name` will be used as a prefix for a new unique anchor.
+     * If `name` is undefined, the generated anchor will use 'a' as a prefix.
+     */
+    createAlias(node, name) {
+        if (!node.anchor) {
+            const prev = anchors.anchorNames(this);
+            node.anchor =
+                !name || prev.has(name) ? anchors.findNewAnchor(name || 'a', prev) : name;
+        }
+        return new Alias.Alias(node.anchor);
     }
-
-    return node;
-  }
-
-  createPair(key, value, options = {}) {
-    const k = this.createNode(key, options);
-    const v = this.createNode(value, options);
-    return new Pair.Pair(k, v);
-  }
-
-  delete(key) {
-    assertCollection(this.contents);
-    return this.contents.delete(key);
-  }
-
-  deleteIn(path) {
-    if (Collection.isEmptyPath(path)) {
-      if (this.contents == null) return false;
-      this.contents = null;
-      return true;
+    createNode(value, replacer, options) {
+        let _replacer = undefined;
+        if (typeof replacer === 'function') {
+            value = replacer.call({ '': value }, '', value);
+            _replacer = replacer;
+        }
+        else if (Array.isArray(replacer)) {
+            const keyToStr = (v) => typeof v === 'number' || v instanceof String || v instanceof Number;
+            const asStr = replacer.filter(keyToStr).map(String);
+            if (asStr.length > 0)
+                replacer = replacer.concat(asStr);
+            _replacer = replacer;
+        }
+        else if (options === undefined && replacer) {
+            options = replacer;
+            replacer = undefined;
+        }
+        const { anchorPrefix, flow, keepUndefined, onTagObj, tag } = options || {};
+        const { onAnchor, setAnchors, sourceObjects } = anchors.createNodeAnchors(this, anchorPrefix || 'a');
+        const ctx = {
+            keepUndefined: keepUndefined !== null && keepUndefined !== void 0 ? keepUndefined : false,
+            onAnchor,
+            onTagObj,
+            replacer: _replacer,
+            schema: this.schema,
+            sourceObjects
+        };
+        const node = createNode.createNode(value, tag, ctx);
+        if (flow && Node.isCollection(node))
+            node.flow = true;
+        setAnchors();
+        return node;
     }
-
-    assertCollection(this.contents);
-    return this.contents.deleteIn(path);
-  }
-
-  getDefaults() {
-    return Document.defaults[this.version] || Document.defaults[this.options.version] || {};
-  }
-
-  get(key, keepScalar) {
-    return this.contents instanceof Collection.Collection ? this.contents.get(key, keepScalar) : undefined;
-  }
-
-  getIn(path, keepScalar) {
-    if (Collection.isEmptyPath(path)) return !keepScalar && this.contents instanceof Scalar.Scalar ? this.contents.value : this.contents;
-    return this.contents instanceof Collection.Collection ? this.contents.getIn(path, keepScalar) : undefined;
-  }
-
-  has(key) {
-    return this.contents instanceof Collection.Collection ? this.contents.has(key) : false;
-  }
-
-  hasIn(path) {
-    if (Collection.isEmptyPath(path)) return this.contents !== undefined;
-    return this.contents instanceof Collection.Collection ? this.contents.hasIn(path) : false;
-  }
-
-  set(key, value) {
-    if (this.contents == null) {
-      this.setSchema();
-      this.contents = Collection.collectionFromPath(this.schema, [key], value);
-    } else {
-      assertCollection(this.contents);
-      this.contents.set(key, value);
+    /**
+     * Convert a key and a value into a `Pair` using the current schema,
+     * recursively wrapping all values as `Scalar` or `Collection` nodes.
+     */
+    createPair(key, value, options = {}) {
+        const k = this.createNode(key, null, options);
+        const v = this.createNode(value, null, options);
+        return new Pair.Pair(k, v);
     }
-  }
-
-  setIn(path, value) {
-    if (Collection.isEmptyPath(path)) this.contents = value;else if (this.contents == null) {
-      this.setSchema();
-      this.contents = Collection.collectionFromPath(this.schema, path, value);
-    } else {
-      assertCollection(this.contents);
-      this.contents.setIn(path, value);
+    /**
+     * Removes a value from the document.
+     * @returns `true` if the item was found and removed.
+     */
+    delete(key) {
+        return assertCollection(this.contents) ? this.contents.delete(key) : false;
     }
-  }
-
-  setSchema(id, customTags) {
-    if (!id && !customTags && this.schema) return;
-    if (typeof id === 'number') id = id.toFixed(1);
-
-    if (id === '1.0' || id === '1.1' || id === '1.2') {
-      if (this.version) this.version = id;else this.options.version = id;
-      delete this.options.schema;
-    } else if (id && typeof id === 'string') {
-      this.options.schema = id;
+    /**
+     * Removes a value from the document.
+     * @returns `true` if the item was found and removed.
+     */
+    deleteIn(path) {
+        if (Collection.isEmptyPath(path)) {
+            if (this.contents == null)
+                return false;
+            this.contents = null;
+            return true;
+        }
+        return assertCollection(this.contents)
+            ? this.contents.deleteIn(path)
+            : false;
     }
-
-    if (Array.isArray(customTags)) this.options.customTags = customTags;
-    const opt = Object.assign({}, this.getDefaults(), this.options);
-    this.schema = new Schema.Schema(opt);
-  }
-
-  parse(node, prevDoc) {
-    if (this.options.keepCstNodes) this.cstNode = node;
-    if (this.options.keepNodeTypes) this.type = 'DOCUMENT';
-    const {
-      directives = [],
-      contents = [],
-      directivesEndMarker,
-      error,
-      valueRange
-    } = node;
-
-    if (error) {
-      if (!error.source) error.source = this;
-      this.errors.push(error);
+    /**
+     * Returns item at `key`, or `undefined` if not found. By default unwraps
+     * scalar values from their surrounding node; to disable set `keepScalar` to
+     * `true` (collections are always returned intact).
+     */
+    get(key, keepScalar) {
+        return Node.isCollection(this.contents)
+            ? this.contents.get(key, keepScalar)
+            : undefined;
     }
-
-    parseDirectives.parseDirectives(this, directives, prevDoc);
-    if (directivesEndMarker) this.directivesEndMarker = true;
-    this.range = valueRange ? [valueRange.start, valueRange.end] : null;
-    this.setSchema();
-    this.anchors._cstAliases = [];
-    parseContents.parseContents(this, contents);
-    this.anchors.resolveNodes();
-
-    if (this.options.prettyErrors) {
-      for (const error of this.errors) if (error instanceof errors.YAMLError) error.makePretty();
-
-      for (const warn of this.warnings) if (warn instanceof errors.YAMLError) warn.makePretty();
+    /**
+     * Returns item at `path`, or `undefined` if not found. By default unwraps
+     * scalar values from their surrounding node; to disable set `keepScalar` to
+     * `true` (collections are always returned intact).
+     */
+    getIn(path, keepScalar) {
+        if (Collection.isEmptyPath(path))
+            return !keepScalar && Node.isScalar(this.contents)
+                ? this.contents.value
+                : this.contents;
+        return Node.isCollection(this.contents)
+            ? this.contents.getIn(path, keepScalar)
+            : undefined;
     }
-
-    return this;
-  }
-
-  listNonDefaultTags() {
-    return listTagNames.listTagNames(this.contents).filter(t => t.indexOf(constants.defaultTagPrefix) !== 0);
-  }
-
-  setTagPrefix(handle, prefix) {
-    if (handle[0] !== '!' || handle[handle.length - 1] !== '!') throw new Error('Handle must start and end with !');
-
-    if (prefix) {
-      const prev = this.tagPrefixes.find(p => p.handle === handle);
-      if (prev) prev.prefix = prefix;else this.tagPrefixes.push({
-        handle,
-        prefix
-      });
-    } else {
-      this.tagPrefixes = this.tagPrefixes.filter(p => p.handle !== handle);
+    /**
+     * Checks if the document includes a value with the key `key`.
+     */
+    has(key) {
+        return Node.isCollection(this.contents) ? this.contents.has(key) : false;
     }
-  }
-
-  toJS({
-    json,
-    jsonArg,
-    mapAsMap,
-    onAnchor,
-    reviver
-  } = {}) {
-    const anchorNodes = Object.values(this.anchors.map).map(node => [node, {
-      alias: [],
-      aliasCount: 0,
-      count: 1
-    }]);
-    const anchors = anchorNodes.length > 0 ? new Map(anchorNodes) : null;
-    const ctx = {
-      anchors,
-      doc: this,
-      indentStep: '  ',
-      keep: !json,
-      mapAsMap: typeof mapAsMap === 'boolean' ? mapAsMap : !!this.options.mapAsMap,
-      mapKeyWarned: false,
-      maxAliasCount: this.options.maxAliasCount,
-      stringify: stringify.stringify // Requiring directly in Pair would create circular dependencies
-
-    };
-    const res = toJS.toJS(this.contents, jsonArg || '', ctx);
-    if (typeof onAnchor === 'function' && anchors) for (const {
-      count,
-      res
-    } of anchors.values()) onAnchor(res, count);
-    return typeof reviver === 'function' ? applyReviver.applyReviver(reviver, {
-      '': res
-    }, '', res) : res;
-  }
-
-  toJSON(jsonArg, onAnchor) {
-    return this.toJS({
-      json: true,
-      jsonArg,
-      mapAsMap: false,
-      onAnchor
-    });
-  }
-
-  toString() {
-    if (this.errors.length > 0) throw new Error('Document with errors cannot be stringified');
-    const indentSize = this.options.indent;
-
-    if (!Number.isInteger(indentSize) || indentSize <= 0) {
-      const s = JSON.stringify(indentSize);
-      throw new Error(`"indent" option must be a positive integer, not ${s}`);
+    /**
+     * Checks if the document includes a value at `path`.
+     */
+    hasIn(path) {
+        if (Collection.isEmptyPath(path))
+            return this.contents !== undefined;
+        return Node.isCollection(this.contents) ? this.contents.hasIn(path) : false;
     }
-
-    this.setSchema();
-    const lines = [];
-    let hasDirectives = false;
-
-    if (this.version) {
-      let vd = '%YAML 1.2';
-
-      if (this.schema.name === 'yaml-1.1') {
-        if (this.version === '1.0') vd = '%YAML:1.0';else if (this.version === '1.1') vd = '%YAML 1.1';
-      }
-
-      lines.push(vd);
-      hasDirectives = true;
+    /**
+     * Sets a value in this document. For `!!set`, `value` needs to be a
+     * boolean to add/remove the item from the set.
+     */
+    set(key, value) {
+        if (this.contents == null) {
+            this.contents = Collection.collectionFromPath(this.schema, [key], value);
+        }
+        else if (assertCollection(this.contents)) {
+            this.contents.set(key, value);
+        }
     }
-
-    const tagNames = this.listNonDefaultTags();
-    this.tagPrefixes.forEach(({
-      handle,
-      prefix
-    }) => {
-      if (tagNames.some(t => t.indexOf(prefix) === 0)) {
-        lines.push(`%TAG ${handle} ${prefix}`);
-        hasDirectives = true;
-      }
-    });
-    if (hasDirectives || this.directivesEndMarker) lines.push('---');
-
-    if (this.commentBefore) {
-      if (hasDirectives || !this.directivesEndMarker) lines.unshift('');
-      lines.unshift(this.commentBefore.replace(/^/gm, '#'));
+    /**
+     * Sets a value in this document. For `!!set`, `value` needs to be a
+     * boolean to add/remove the item from the set.
+     */
+    setIn(path, value) {
+        if (Collection.isEmptyPath(path))
+            this.contents = value;
+        else if (this.contents == null) {
+            this.contents = Collection.collectionFromPath(this.schema, Array.from(path), value);
+        }
+        else if (assertCollection(this.contents)) {
+            this.contents.setIn(path, value);
+        }
     }
-
-    const ctx = {
-      anchors: Object.create(null),
-      doc: this,
-      indent: '',
-      indentStep: ' '.repeat(indentSize),
-      stringify: stringify.stringify // Requiring directly in nodes would create circular dependencies
-
-    };
-    let chompKeep = false;
-    let contentComment = null;
-
-    if (this.contents) {
-      if (this.contents instanceof Node.Node) {
-        if (this.contents.spaceBefore && (hasDirectives || this.directivesEndMarker)) lines.push('');
-        if (this.contents.commentBefore) lines.push(this.contents.commentBefore.replace(/^/gm, '#')); // top-level block scalars need to be indented if followed by a comment
-
-        ctx.forceBlockIndent = !!this.comment;
-        contentComment = this.contents.comment;
-      }
-
-      const onChompKeep = contentComment ? null : () => chompKeep = true;
-      const body = stringify.stringify(this.contents, ctx, () => contentComment = null, onChompKeep);
-      lines.push(addComment.addComment(body, '', contentComment));
-    } else {
-      lines.push(stringify.stringify(this.contents, ctx));
+    /**
+     * Change the YAML version and schema used by the document.
+     *
+     * Overrides all previously set schema options
+     */
+    setSchema(version, options) {
+        let _options;
+        switch (String(version)) {
+            case '1.1':
+                this.directives.yaml.version = '1.1';
+                _options = Object.assign({ merge: true, resolveKnownTags: false, schema: 'yaml-1.1' }, options);
+                break;
+            case '1.2':
+                this.directives.yaml.version = '1.2';
+                _options = Object.assign({ merge: false, resolveKnownTags: true, schema: 'core' }, options);
+                break;
+            default: {
+                const sv = JSON.stringify(version);
+                throw new Error(`Expected '1.1' or '1.2' as version, but found: ${sv}`);
+            }
+        }
+        this.schema = new Schema.Schema(_options);
     }
-
-    if (this.comment) {
-      if ((!chompKeep || contentComment) && lines[lines.length - 1] !== '') lines.push('');
-      lines.push(this.comment.replace(/^/gm, '#'));
+    // json & jsonArg are only used from toJSON()
+    toJS({ json, jsonArg, mapAsMap, maxAliasCount, onAnchor, reviver } = {}) {
+        const ctx = {
+            anchors: new Map(),
+            doc: this,
+            keep: !json,
+            mapAsMap: mapAsMap === true,
+            mapKeyWarned: false,
+            maxAliasCount: typeof maxAliasCount === 'number' ? maxAliasCount : 100,
+            stringify: stringify.stringify
+        };
+        const res = toJS.toJS(this.contents, jsonArg || '', ctx);
+        if (typeof onAnchor === 'function')
+            for (const { count, res } of ctx.anchors.values())
+                onAnchor(res, count);
+        return typeof reviver === 'function'
+            ? applyReviver.applyReviver(reviver, { '': res }, '', res)
+            : res;
+    }
+    /**
+     * A JSON representation of the document `contents`.
+     *
+     * @param jsonArg Used by `JSON.stringify` to indicate the array index or
+     *   property name.
+     */
+    toJSON(jsonArg, onAnchor) {
+        return this.toJS({ json: true, jsonArg, mapAsMap: false, onAnchor });
+    }
+    /** A YAML representation of the document. */
+    toString(options = {}) {
+        if (this.errors.length > 0)
+            throw new Error('Document with errors cannot be stringified');
+        if ('indent' in options &&
+            (!Number.isInteger(options.indent) || Number(options.indent) <= 0)) {
+            const s = JSON.stringify(options.indent);
+            throw new Error(`"indent" option must be a positive integer, not ${s}`);
+        }
+        return stringifyDocument.stringifyDocument(this, options);
     }
-
-    return lines.join('\n') + '\n';
-  }
-
 }
-
-_rollupPluginBabelHelpers.defineProperty(Document, "defaults", options.documentOptions);
+function assertCollection(contents) {
+    if (Node.isCollection(contents))
+        return true;
+    throw new Error('Expected a YAML collection as document contents');
+}
 
 exports.Document = Document;

package/dist/doc/anchors.d.ts

@@ -0,0 +1,24 @@
+import { Node } from '../nodes/Node.js';
+import type { Document } from './Document.js';
+/**
+ * Verify that the input string is a valid anchor.
+ *
+ * Will throw on errors.
+ */
+export declare function anchorIsValid(anchor: string): true;
+export declare function anchorNames(root: Document | Node): Set<string>;
+/** Find a new anchor name with the given `prefix` and a one-indexed suffix. */
+export declare function findNewAnchor(prefix: string, exclude: Set<string>): string;
+export declare function createNodeAnchors(doc: Document, prefix: string): {
+    onAnchor(source: unknown): string;
+    /**
+     * With circular references, the source node is only resolved after all
+     * of its child nodes are. This is why anchors are set only after all of
+     * the nodes have been created.
+     */
+    setAnchors(): void;
+    sourceObjects: Map<unknown, {
+        anchor: string | null;
+        node: Node | null;
+    }>;
+};