yaml 2.0.0-4 → 2.0.0-8

package/dist/nodes/Pair.js

@@ -1,11 +1,8 @@
 'use strict';
 
 var createNode = require('../doc/createNode.js');
-var log = require('../log.js');
-var addComment = require('../stringify/addComment.js');
-var stringify = require('../stringify/stringify.js');
-var Scalar = require('./Scalar.js');
-var toJS = require('./toJS.js');
+var stringifyPair = require('../stringify/stringifyPair.js');
+var addPairToJSMap = require('./addPairToJSMap.js');
 var Node = require('./Node.js');
 
 function createPair(key, value, ctx) {
@@ -13,241 +10,29 @@ function createPair(key, value, ctx) {
     const v = createNode.createNode(value, undefined, ctx);
     return new Pair(k, v);
 }
-const isMergeKey = (key) => key === Pair.MERGE_KEY ||
-    (Node.isScalar(key) &&
-        key.value === Pair.MERGE_KEY &&
-        (!key.type || key.type === Scalar.Scalar.PLAIN));
-// If the value associated with a merge key is a single mapping node, each of
-// its key/value pairs is inserted into the current mapping, unless the key
-// already exists in it. If the value associated with the merge key is a
-// sequence, then this sequence is expected to contain mapping nodes and each
-// of these nodes is merged in turn according to its order in the sequence.
-// Keys in mapping nodes earlier in the sequence override keys specified in
-// later mapping nodes. -- http://yaml.org/type/merge.html
-function mergeToJSMap(ctx, map, value) {
-    if (!Node.isAlias(value) || !Node.isMap(value.source))
-        throw new Error('Merge sources must be map aliases');
-    const srcMap = value.source.toJSON(null, ctx, Map);
-    for (const [key, value] of srcMap) {
-        if (map instanceof Map) {
-            if (!map.has(key))
-                map.set(key, value);
-        }
-        else if (map instanceof Set) {
-            map.add(key);
-        }
-        else if (!Object.prototype.hasOwnProperty.call(map, key)) {
-            Object.defineProperty(map, key, {
-                value,
-                writable: true,
-                enumerable: true,
-                configurable: true
-            });
-        }
-    }
-    return map;
-}
-class Pair extends Node.NodeBase {
+class Pair {
     constructor(key, value = null) {
-        super(Node.PAIR);
+        Object.defineProperty(this, Node.NODE_TYPE, { value: Node.PAIR });
         this.key = key;
         this.value = value;
     }
-    // @ts-ignore This is fine.
-    get commentBefore() {
-        return Node.isNode(this.key) ? this.key.commentBefore : undefined;
-    }
-    set commentBefore(cb) {
-        if (this.key == null)
-            this.key = new Scalar.Scalar(null); // FIXME
-        if (Node.isNode(this.key))
-            this.key.commentBefore = cb;
-        else {
-            const msg = 'Pair.commentBefore is an alias for Pair.key.commentBefore. To set it, the key must be a Node.';
-            throw new Error(msg);
-        }
-    }
-    // @ts-ignore This is fine.
-    get spaceBefore() {
-        return Node.isNode(this.key) ? this.key.spaceBefore : undefined;
-    }
-    set spaceBefore(sb) {
-        if (this.key == null)
-            this.key = new Scalar.Scalar(null); // FIXME
-        if (Node.isNode(this.key))
-            this.key.spaceBefore = sb;
-        else {
-            const msg = 'Pair.spaceBefore is an alias for Pair.key.spaceBefore. To set it, the key must be a Node.';
-            throw new Error(msg);
-        }
-    }
-    addToJSMap(ctx, map) {
-        if (ctx && ctx.doc.schema.merge && isMergeKey(this.key)) {
-            if (Node.isSeq(this.value))
-                for (const it of this.value.items)
-                    mergeToJSMap(ctx, map, it);
-            else if (Array.isArray(this.value))
-                for (const it of this.value)
-                    mergeToJSMap(ctx, map, it);
-            else
-                mergeToJSMap(ctx, map, this.value);
-        }
-        else {
-            const key = toJS.toJS(this.key, '', ctx);
-            if (map instanceof Map) {
-                const value = toJS.toJS(this.value, key, ctx);
-                map.set(key, value);
-            }
-            else if (map instanceof Set) {
-                map.add(key);
-            }
-            else {
-                const stringKey = stringifyKey(this.key, key, ctx);
-                const value = toJS.toJS(this.value, stringKey, ctx);
-                if (stringKey in map)
-                    Object.defineProperty(map, stringKey, {
-                        value,
-                        writable: true,
-                        enumerable: true,
-                        configurable: true
-                    });
-                else
-                    map[stringKey] = value;
-            }
-        }
-        return map;
+    clone(schema) {
+        let { key, value } = this;
+        if (Node.isNode(key))
+            key = key.clone(schema);
+        if (Node.isNode(value))
+            value = value.clone(schema);
+        return new Pair(key, value);
     }
     toJSON(_, ctx) {
         const pair = ctx && ctx.mapAsMap ? new Map() : {};
-        return this.addToJSMap(ctx, pair);
+        return addPairToJSMap.addPairToJSMap(ctx, pair, this);
     }
     toString(ctx, onComment, onChompKeep) {
-        if (!ctx || !ctx.doc)
-            return JSON.stringify(this);
-        const { allNullValues, doc, indent, indentStep, options: { indentSeq, simpleKeys } } = ctx;
-        let { key, value } = this;
-        let keyComment = (Node.isNode(key) && key.comment) || null;
-        if (simpleKeys) {
-            if (keyComment) {
-                throw new Error('With simple keys, key nodes cannot have comments');
-            }
-            if (Node.isCollection(key)) {
-                const msg = 'With simple keys, collection cannot be used as a key value';
-                throw new Error(msg);
-            }
-        }
-        let explicitKey = !simpleKeys &&
-            (!key ||
-                (keyComment && value == null) ||
-                Node.isCollection(key) ||
-                (Node.isScalar(key)
-                    ? key.type === Scalar.Scalar.BLOCK_FOLDED || key.type === Scalar.Scalar.BLOCK_LITERAL
-                    : typeof key === 'object'));
-        ctx = Object.assign({}, ctx, {
-            allNullValues: false,
-            implicitKey: !explicitKey && (simpleKeys || !allNullValues),
-            indent: indent + indentStep
-        });
-        let chompKeep = false;
-        let str = stringify.stringify(key, ctx, () => (keyComment = null), () => (chompKeep = true));
-        if (!explicitKey && !ctx.inFlow && str.length > 1024) {
-            if (simpleKeys)
-                throw new Error('With simple keys, single line scalar must not span more than 1024 characters');
-            explicitKey = true;
-        }
-        if ((allNullValues && (!simpleKeys || ctx.inFlow)) ||
-            (value == null && (explicitKey || ctx.inFlow))) {
-            str = addComment.addComment(str, ctx.indent, keyComment);
-            if (this.comment) {
-                if (keyComment && !this.comment.includes('\n'))
-                    str += `\n${ctx.indent || ''}#${this.comment}`;
-                else
-                    str = addComment.addComment(str, ctx.indent, this.comment);
-                if (onComment)
-                    onComment();
-            }
-            else if (chompKeep && !keyComment && onChompKeep)
-                onChompKeep();
-            return ctx.inFlow && !explicitKey ? str : `? ${str}`;
-        }
-        str = explicitKey
-            ? `? ${addComment.addComment(str, ctx.indent, keyComment)}\n${indent}:`
-            : addComment.addComment(`${str}:`, ctx.indent, keyComment);
-        if (this.comment) {
-            if (keyComment && !explicitKey && !this.comment.includes('\n'))
-                str += `\n${ctx.indent || ''}#${this.comment}`;
-            else
-                str = addComment.addComment(str, ctx.indent, this.comment);
-            if (onComment)
-                onComment();
-        }
-        let vcb = '';
-        let valueComment = null;
-        if (Node.isNode(value)) {
-            if (value.spaceBefore)
-                vcb = '\n';
-            if (value.commentBefore) {
-                const cs = value.commentBefore.replace(/^/gm, `${ctx.indent}#`);
-                vcb += `\n${cs}`;
-            }
-            valueComment = value.comment;
-        }
-        else if (value && typeof value === 'object') {
-            value = doc.createNode(value);
-        }
-        ctx.implicitKey = false;
-        if (!explicitKey && !keyComment && !this.comment && Node.isScalar(value))
-            ctx.indentAtStart = str.length + 1;
-        chompKeep = false;
-        if (!indentSeq &&
-            indentStep.length >= 2 &&
-            !ctx.inFlow &&
-            !explicitKey &&
-            Node.isSeq(value) &&
-            !value.flow &&
-            !value.tag &&
-            !doc.anchors.getName(value)) {
-            // If indentSeq === false, consider '- ' as part of indentation where possible
-            ctx.indent = ctx.indent.substr(2);
-        }
-        const valueStr = stringify.stringify(value, ctx, () => (valueComment = null), () => (chompKeep = true));
-        let ws = ' ';
-        if (vcb || keyComment || this.comment) {
-            ws = `${vcb}\n${ctx.indent}`;
-        }
-        else if (!explicitKey && Node.isCollection(value)) {
-            const flow = valueStr[0] === '[' || valueStr[0] === '{';
-            if (!flow || valueStr.includes('\n'))
-                ws = `\n${ctx.indent}`;
-        }
-        else if (valueStr[0] === '\n')
-            ws = '';
-        if (chompKeep && !valueComment && onChompKeep)
-            onChompKeep();
-        return addComment.addComment(str + ws + valueStr, ctx.indent, valueComment);
-    }
-}
-Pair.MERGE_KEY = '<<';
-function stringifyKey(key, jsKey, ctx) {
-    if (jsKey === null)
-        return '';
-    if (typeof jsKey !== 'object')
-        return String(jsKey);
-    if (Node.isNode(key) && ctx && ctx.doc) {
-        const strCtx = stringify.createStringifyContext(ctx.doc, {});
-        strCtx.inFlow = true;
-        strCtx.inStringifyKey = true;
-        const strKey = key.toString(strCtx);
-        if (!ctx.mapKeyWarned) {
-            let jsonStr = JSON.stringify(strKey);
-            if (jsonStr.length > 40)
-                jsonStr = jsonStr.substring(0, 36) + '..."';
-            log.warn(ctx.doc.options.logLevel, `Keys with collection values will be stringified due to JS Object restrictions: ${jsonStr}. Set mapAsMap: true to use object keys.`);
-            ctx.mapKeyWarned = true;
-        }
-        return strKey;
+        return ctx && ctx.doc
+            ? stringifyPair.stringifyPair(this, ctx, onComment, onChompKeep)
+            : JSON.stringify(this);
     }
-    return JSON.stringify(jsKey);
 }
 
 exports.Pair = Pair;

package/dist/nodes/Scalar.d.ts

@@ -1,9 +1,9 @@
-import { NodeBase } from './Node.js';
+import { NodeBase, Range } from './Node.js';
 import { ToJSContext } from './toJS.js';
 export declare const isScalarValue: (value: unknown) => boolean;
 export declare namespace Scalar {
     interface Parsed extends Scalar {
-        range: [number, number];
+        range: Range;
         source: string;
     }
     type BLOCK_FOLDED = 'BLOCK_FOLDED';
@@ -20,7 +20,8 @@ export declare class Scalar<T = unknown> extends NodeBase {
     static readonly QUOTE_DOUBLE = "QUOTE_DOUBLE";
     static readonly QUOTE_SINGLE = "QUOTE_SINGLE";
     value: T;
-    type?: Scalar.Type;
+    /** An optional anchor on this node. Used by alias nodes. */
+    anchor?: string;
     /**
      * By default (undefined), numbers use decimal notation.
      * The YAML 1.2 core schema only supports 'HEX' and 'OCT'.
@@ -31,6 +32,8 @@ export declare class Scalar<T = unknown> extends NodeBase {
     minFractionDigits?: number;
     /** Set during parsing to the source string value */
     source?: string;
+    /** The scalar style used for the node's string representation */
+    type?: Scalar.Type;
     constructor(value: T);
     toJSON(arg?: any, ctx?: ToJSContext): any;
     toString(): string;

package/dist/nodes/YAMLMap.d.ts

@@ -1,14 +1,14 @@
-import type { Schema } from '../doc/Schema.js';
+import type { Schema } from '../schema/Schema.js';
 import type { StringifyContext } from '../stringify/stringify.js';
 import { Collection } from './Collection.js';
-import { ParsedNode } from './Node.js';
+import { ParsedNode, Range } from './Node.js';
 import { Pair } from './Pair.js';
 import type { ToJSContext } from './toJS.js';
 export declare function findPair<K = unknown, V = unknown>(items: Iterable<Pair<K, V>>, key: unknown): Pair<K, V> | undefined;
 export declare namespace YAMLMap {
     interface Parsed<K extends ParsedNode = ParsedNode, V extends ParsedNode | null = ParsedNode | null> extends YAMLMap<K, V> {
         items: Pair<K, V>[];
-        range: [number, number];
+        range: Range;
     }
 }
 export declare class YAMLMap<K = unknown, V = unknown> extends Collection {

package/dist/nodes/YAMLMap.js

@@ -1,5 +1,7 @@
 'use strict';
 
+var stringifyCollection = require('../stringify/stringifyCollection.js');
+var addPairToJSMap = require('./addPairToJSMap.js');
 var Collection = require('./Collection.js');
 var Node = require('./Node.js');
 var Pair = require('./Pair.js');
@@ -91,7 +93,7 @@ class YAMLMap extends Collection.Collection {
         if (ctx && ctx.onCreate)
             ctx.onCreate(map);
         for (const item of this.items)
-            item.addToJSMap(ctx, map);
+            addPairToJSMap.addPairToJSMap(ctx, map, item);
         return map;
     }
     toString(ctx, onComment, onChompKeep) {
@@ -103,11 +105,13 @@ class YAMLMap extends Collection.Collection {
         }
         if (!ctx.allNullValues && this.hasAllNullValues(false))
             ctx = Object.assign({}, ctx, { allNullValues: true });
-        return super._toString(ctx, {
+        return stringifyCollection.stringifyCollection(this, ctx, {
             blockItem: n => n.str,
             flowChars: { start: '{', end: '}' },
-            itemIndent: ctx.indent || ''
-        }, onComment, onChompKeep);
+            itemIndent: ctx.indent || '',
+            onChompKeep,
+            onComment
+        });
     }
 }
 

package/dist/nodes/YAMLSeq.d.ts

@@ -1,13 +1,13 @@
-import type { Schema } from '../doc/Schema.js';
+import type { Schema } from '../schema/Schema.js';
 import type { StringifyContext } from '../stringify/stringify.js';
 import { Collection } from './Collection.js';
-import { ParsedNode } from './Node.js';
+import { ParsedNode, Range } from './Node.js';
 import type { Pair } from './Pair.js';
 import { ToJSContext } from './toJS.js';
 export declare namespace YAMLSeq {
     interface Parsed<T extends ParsedNode | Pair<ParsedNode, ParsedNode | null> = ParsedNode> extends YAMLSeq<T> {
         items: T[];
-        range: [number, number];
+        range: Range;
     }
 }
 export declare class YAMLSeq<T = unknown> extends Collection {

package/dist/nodes/YAMLSeq.js

@@ -1,5 +1,6 @@
 'use strict';
 
+var stringifyCollection = require('../stringify/stringifyCollection.js');
 var Collection = require('./Collection.js');
 var Node = require('./Node.js');
 var Scalar = require('./Scalar.js');
@@ -85,11 +86,13 @@ class YAMLSeq extends Collection.Collection {
     toString(ctx, onComment, onChompKeep) {
         if (!ctx)
             return JSON.stringify(this);
-        return super._toString(ctx, {
-            blockItem: n => (n.type === 'comment' ? n.str : `- ${n.str}`),
+        return stringifyCollection.stringifyCollection(this, ctx, {
+            blockItem: n => (n.comment ? n.str : `- ${n.str}`),
             flowChars: { start: '[', end: ']' },
-            itemIndent: (ctx.indent || '') + '  '
-        }, onComment, onChompKeep);
+            itemIndent: (ctx.indent || '') + '  ',
+            onChompKeep,
+            onComment
+        });
     }
 }
 function asItemIndex(key) {

package/dist/nodes/addPairToJSMap.d.ts

@@ -0,0 +1,3 @@
+import type { Pair } from './Pair.js';
+import { ToJSContext } from './toJS.js';
+export declare function addPairToJSMap(ctx: ToJSContext | undefined, map: Map<unknown, unknown> | Set<unknown> | Record<string | number | symbol, unknown>, { key, value }: Pair): Map<unknown, unknown> | Set<unknown> | Record<string | number | symbol, unknown>;

package/dist/nodes/addPairToJSMap.js

@@ -0,0 +1,105 @@
+'use strict';
+
+var log = require('../log.js');
+var stringify = require('../stringify/stringify.js');
+var Node = require('./Node.js');
+var Scalar = require('./Scalar.js');
+var toJS = require('./toJS.js');
+
+const MERGE_KEY = '<<';
+function addPairToJSMap(ctx, map, { key, value }) {
+    if (ctx && ctx.doc.schema.merge && isMergeKey(key)) {
+        if (Node.isSeq(value))
+            for (const it of value.items)
+                mergeToJSMap(ctx, map, it);
+        else if (Array.isArray(value))
+            for (const it of value)
+                mergeToJSMap(ctx, map, it);
+        else
+            mergeToJSMap(ctx, map, value);
+    }
+    else {
+        const jsKey = toJS.toJS(key, '', ctx);
+        if (map instanceof Map) {
+            map.set(jsKey, toJS.toJS(value, jsKey, ctx));
+        }
+        else if (map instanceof Set) {
+            map.add(jsKey);
+        }
+        else {
+            const stringKey = stringifyKey(key, jsKey, ctx);
+            const jsValue = toJS.toJS(value, stringKey, ctx);
+            if (stringKey in map)
+                Object.defineProperty(map, stringKey, {
+                    value: jsValue,
+                    writable: true,
+                    enumerable: true,
+                    configurable: true
+                });
+            else
+                map[stringKey] = jsValue;
+        }
+    }
+    return map;
+}
+const isMergeKey = (key) => key === MERGE_KEY ||
+    (Node.isScalar(key) &&
+        key.value === MERGE_KEY &&
+        (!key.type || key.type === Scalar.Scalar.PLAIN));
+// If the value associated with a merge key is a single mapping node, each of
+// its key/value pairs is inserted into the current mapping, unless the key
+// already exists in it. If the value associated with the merge key is a
+// sequence, then this sequence is expected to contain mapping nodes and each
+// of these nodes is merged in turn according to its order in the sequence.
+// Keys in mapping nodes earlier in the sequence override keys specified in
+// later mapping nodes. -- http://yaml.org/type/merge.html
+function mergeToJSMap(ctx, map, value) {
+    const source = ctx && Node.isAlias(value) ? value.resolve(ctx.doc) : value;
+    if (!Node.isMap(source))
+        throw new Error('Merge sources must be maps or map aliases');
+    const srcMap = source.toJSON(null, ctx, Map);
+    for (const [key, value] of srcMap) {
+        if (map instanceof Map) {
+            if (!map.has(key))
+                map.set(key, value);
+        }
+        else if (map instanceof Set) {
+            map.add(key);
+        }
+        else if (!Object.prototype.hasOwnProperty.call(map, key)) {
+            Object.defineProperty(map, key, {
+                value,
+                writable: true,
+                enumerable: true,
+                configurable: true
+            });
+        }
+    }
+    return map;
+}
+function stringifyKey(key, jsKey, ctx) {
+    if (jsKey === null)
+        return '';
+    if (typeof jsKey !== 'object')
+        return String(jsKey);
+    if (Node.isNode(key) && ctx && ctx.doc) {
+        const strCtx = stringify.createStringifyContext(ctx.doc, {});
+        strCtx.anchors = new Set();
+        for (const node of ctx.anchors.keys())
+            strCtx.anchors.add(node.anchor);
+        strCtx.inFlow = true;
+        strCtx.inStringifyKey = true;
+        const strKey = key.toString(strCtx);
+        if (!ctx.mapKeyWarned) {
+            let jsonStr = JSON.stringify(strKey);
+            if (jsonStr.length > 40)
+                jsonStr = jsonStr.substring(0, 36) + '..."';
+            log.warn(ctx.doc.options.logLevel, `Keys with collection values will be stringified due to JS Object restrictions: ${jsonStr}. Set mapAsMap: true to use object keys.`);
+            ctx.mapKeyWarned = true;
+        }
+        return strKey;
+    }
+    return JSON.stringify(jsKey);
+}
+
+exports.addPairToJSMap = addPairToJSMap;

package/dist/nodes/toJS.d.ts

@@ -1,14 +1,13 @@
 import type { Document } from '../doc/Document.js';
 import type { stringify } from '../stringify/stringify.js';
-import type { Node } from './Node.js';
-export interface ToJSAnchorValue {
-    alias: string[];
+import { Node } from './Node.js';
+export interface AnchorData {
     aliasCount: number;
     count: number;
-    res?: unknown;
+    res: unknown;
 }
 export interface ToJSContext {
-    anchors: Map<Node, ToJSAnchorValue> | null;
+    anchors: Map<Node, AnchorData>;
     doc: Document;
     keep: boolean;
     mapAsMap: boolean;

package/dist/nodes/toJS.js

@@ -1,5 +1,7 @@
 'use strict';
 
+var Node = require('./Node.js');
+
 /**
  * Recursively convert any node or its contents to native JavaScript
  *
@@ -14,20 +16,20 @@ function toJS(value, arg, ctx) {
     if (Array.isArray(value))
         return value.map((v, i) => toJS(v, String(i), ctx));
     if (value && typeof value.toJSON === 'function') {
-        if (!ctx)
-            return value.toJSON(arg);
-        const anchor = ctx.anchors && ctx.anchors.get(value);
-        if (anchor)
-            ctx.onCreate = res => {
-                anchor.res = res;
-                delete ctx.onCreate;
-            };
+        if (!ctx || !Node.hasAnchor(value))
+            return value.toJSON(arg, ctx);
+        const data = { aliasCount: 0, count: 1, res: undefined };
+        ctx.anchors.set(value, data);
+        ctx.onCreate = res => {
+            data.res = res;
+            delete ctx.onCreate;
+        };
         const res = value.toJSON(arg, ctx);
-        if (anchor && ctx.onCreate)
+        if (ctx.onCreate)
             ctx.onCreate(res);
         return res;
     }
-    if (!(ctx && ctx.keep) && typeof value === 'bigint')
+    if (typeof value === 'bigint' && !(ctx && ctx.keep))
         return Number(value);
     return value;
 }