yaml 2.0.0-2 → 2.0.0-6

package/dist/stringify/stringify.js

@@ -1,81 +1,97 @@
 'use strict';
 
-var Alias = require('../ast/Alias.js');
-var Node = require('../ast/Node.js');
-var Pair = require('../ast/Pair.js');
-var Scalar = require('../ast/Scalar.js');
+var anchors = require('../doc/anchors.js');
+var Node = require('../nodes/Node.js');
 var stringifyString = require('./stringifyString.js');
-var stringifyTag = require('./stringifyTag.js');
 
+const createStringifyContext = (doc, options) => ({
+    anchors: new Set(),
+    doc,
+    indent: '',
+    indentStep: typeof options.indent === 'number' ? ' '.repeat(options.indent) : '  ',
+    options: Object.assign({
+        defaultKeyType: null,
+        defaultStringType: 'PLAIN',
+        directives: null,
+        doubleQuotedAsJSON: false,
+        doubleQuotedMinMultiLineLength: 40,
+        falseStr: 'false',
+        indentSeq: true,
+        lineWidth: 80,
+        minContentWidth: 20,
+        nullStr: 'null',
+        simpleKeys: false,
+        singleQuote: false,
+        trueStr: 'true',
+        verifyAliasOrder: true
+    }, options)
+});
 function getTagObject(tags, item) {
-  if (item instanceof Alias.Alias) return Alias.Alias;
-
-  if (item.tag) {
-    const match = tags.filter(t => t.tag === item.tag);
-    if (match.length > 0) return match.find(t => t.format === item.format) || match[0];
-  }
-
-  let tagObj, obj;
-
-  if (item instanceof Scalar.Scalar) {
-    obj = item.value;
-    const match = tags.filter(t => t.identify && t.identify(obj));
-    tagObj = match.find(t => t.format === item.format) || match.find(t => !t.format);
-  } else {
-    obj = item;
-    tagObj = tags.find(t => t.nodeClass && obj instanceof t.nodeClass);
-  }
-
-  if (!tagObj) {
-    const name = obj && obj.constructor ? obj.constructor.name : typeof obj;
-    throw new Error(`Tag not resolved for ${name} value`);
-  }
-
-  return tagObj;
-} // needs to be called before value stringifier to allow for circular anchor refs
-
-
-function stringifyProps(node, tagObj, {
-  anchors,
-  doc
-}) {
-  const props = [];
-  const anchor = doc.anchors.getName(node);
-
-  if (anchor) {
-    anchors[anchor] = node;
-    props.push(`&${anchor}`);
-  }
-
-  if (node.tag) {
-    props.push(stringifyTag.stringifyTag(doc, node.tag));
-  } else if (!tagObj.default) {
-    props.push(stringifyTag.stringifyTag(doc, tagObj.tag));
-  }
-
-  return props.join(' ');
+    if (item.tag) {
+        const match = tags.filter(t => t.tag === item.tag);
+        if (match.length > 0)
+            return match.find(t => t.format === item.format) || match[0];
+    }
+    let tagObj = undefined;
+    let obj;
+    if (Node.isScalar(item)) {
+        obj = item.value;
+        const match = tags.filter(t => t.identify && t.identify(obj));
+        tagObj =
+            match.find(t => t.format === item.format) || match.find(t => !t.format);
+    }
+    else {
+        obj = item;
+        tagObj = tags.find(t => t.nodeClass && obj instanceof t.nodeClass);
+    }
+    if (!tagObj) {
+        // @ts-ignore
+        const name = obj && obj.constructor ? obj.constructor.name : typeof obj;
+        throw new Error(`Tag not resolved for ${name} value`);
+    }
+    return tagObj;
+}
+// needs to be called before value stringifier to allow for circular anchor refs
+function stringifyProps(node, tagObj, { anchors: anchors$1, doc }) {
+    const props = [];
+    const anchor = (Node.isScalar(node) || Node.isCollection(node)) && node.anchor;
+    if (anchor && anchors.anchorIsValid(anchor)) {
+        anchors$1.add(anchor);
+        props.push(`&${anchor}`);
+    }
+    if (node.tag) {
+        props.push(doc.directives.tagString(node.tag));
+    }
+    else if (!tagObj.default) {
+        props.push(doc.directives.tagString(tagObj.tag));
+    }
+    return props.join(' ');
 }
-
 function stringify(item, ctx, onComment, onChompKeep) {
-  const {
-    schema
-  } = ctx.doc;
-  let tagObj;
-
-  if (!(item instanceof Node.Node)) {
-    item = ctx.doc.createNode(item, {
-      onTagObj: o => tagObj = o,
-      wrapScalars: true
-    });
-  }
-
-  if (item instanceof Pair.Pair) return item.toString(ctx, onComment, onChompKeep);
-  if (!tagObj) tagObj = getTagObject(schema.tags, item);
-  const props = stringifyProps(item, tagObj, ctx);
-  if (props.length > 0) ctx.indentAtStart = (ctx.indentAtStart || 0) + props.length + 1;
-  const str = typeof tagObj.stringify === 'function' ? tagObj.stringify(item, ctx, onComment, onChompKeep) : item instanceof Scalar.Scalar ? stringifyString.stringifyString(item, ctx, onComment, onChompKeep) : item.toString(ctx, onComment, onChompKeep);
-  if (!props) return str;
-  return item instanceof Scalar.Scalar || str[0] === '{' || str[0] === '[' ? `${props} ${str}` : `${props}\n${ctx.indent}${str}`;
+    if (Node.isPair(item))
+        return item.toString(ctx, onComment, onChompKeep);
+    if (Node.isAlias(item))
+        return item.toString(ctx);
+    let tagObj = undefined;
+    const node = Node.isNode(item)
+        ? item
+        : ctx.doc.createNode(item, { onTagObj: o => (tagObj = o) });
+    if (!tagObj)
+        tagObj = getTagObject(ctx.doc.schema.tags, node);
+    const props = stringifyProps(node, tagObj, ctx);
+    if (props.length > 0)
+        ctx.indentAtStart = (ctx.indentAtStart || 0) + props.length + 1;
+    const str = typeof tagObj.stringify === 'function'
+        ? tagObj.stringify(node, ctx, onComment, onChompKeep)
+        : Node.isScalar(node)
+            ? stringifyString.stringifyString(node, ctx, onComment, onChompKeep)
+            : node.toString(ctx, onComment, onChompKeep);
+    if (!props)
+        return str;
+    return Node.isScalar(node) || str[0] === '{' || str[0] === '['
+        ? `${props} ${str}`
+        : `${props}\n${ctx.indent}${str}`;
 }
 
+exports.createStringifyContext = createStringifyContext;
 exports.stringify = stringify;

package/dist/stringify/stringifyCollection.d.ts

@@ -0,0 +1,21 @@
+import { Collection } from '../nodes/Collection.js';
+import { StringifyContext } from './stringify.js';
+declare type StringifyNode = {
+    comment: boolean;
+    str: string;
+};
+interface StringifyCollectionOptions {
+    blockItem(node: StringifyNode): string;
+    flowChars: {
+        start: '{';
+        end: '}';
+    } | {
+        start: '[';
+        end: ']';
+    };
+    itemIndent: string;
+    onChompKeep?: () => void;
+    onComment?: () => void;
+}
+export declare function stringifyCollection({ comment, flow, items }: Readonly<Collection>, ctx: StringifyContext, { blockItem, flowChars, itemIndent, onChompKeep, onComment }: StringifyCollectionOptions): string;
+export {};

package/dist/stringify/stringifyCollection.js

@@ -0,0 +1,124 @@
+'use strict';
+
+var Collection = require('../nodes/Collection.js');
+var Node = require('../nodes/Node.js');
+var stringify = require('./stringify.js');
+var stringifyComment = require('./stringifyComment.js');
+
+function stringifyCollection({ comment, flow, items }, ctx, { blockItem, flowChars, itemIndent, onChompKeep, onComment }) {
+    const { indent, indentStep } = ctx;
+    const inFlow = flow || ctx.inFlow;
+    if (inFlow)
+        itemIndent += indentStep;
+    ctx = Object.assign({}, ctx, { indent: itemIndent, inFlow, type: null });
+    let singleLineOutput = true;
+    let chompKeep = false; // flag for the preceding node's status
+    const nodes = items.reduce((nodes, item, i) => {
+        let comment = null;
+        if (Node.isNode(item)) {
+            if (!chompKeep && item.spaceBefore)
+                nodes.push({ comment: true, str: '' });
+            let cb = item.commentBefore;
+            if (cb && chompKeep)
+                cb = cb.replace(/^\n+/, '');
+            if (cb) {
+                if (/^\n+$/.test(cb))
+                    cb = cb.substring(1);
+                // This match will always succeed on a non-empty string
+                for (const line of cb.match(/^.*$/gm)) {
+                    const str = line === ' ' ? '#' : line ? `#${line}` : '';
+                    nodes.push({ comment: true, str });
+                }
+            }
+            if (item.comment) {
+                comment = item.comment;
+                singleLineOutput = false;
+            }
+        }
+        else if (Node.isPair(item)) {
+            const ik = Node.isNode(item.key) ? item.key : null;
+            if (ik) {
+                if (!chompKeep && ik.spaceBefore)
+                    nodes.push({ comment: true, str: '' });
+                let cb = ik.commentBefore;
+                if (cb && chompKeep)
+                    cb = cb.replace(/^\n+/, '');
+                if (cb) {
+                    if (/^\n+$/.test(cb))
+                        cb = cb.substring(1);
+                    // This match will always succeed on a non-empty string
+                    for (const line of cb.match(/^.*$/gm)) {
+                        const str = line === ' ' ? '#' : line ? `#${line}` : '';
+                        nodes.push({ comment: true, str });
+                    }
+                }
+                if (ik.comment)
+                    singleLineOutput = false;
+            }
+            if (inFlow) {
+                const iv = Node.isNode(item.value) ? item.value : null;
+                if (iv) {
+                    if (iv.comment)
+                        comment = iv.comment;
+                    if (iv.comment || iv.commentBefore)
+                        singleLineOutput = false;
+                }
+                else if (item.value == null && ik && ik.comment) {
+                    comment = ik.comment;
+                }
+            }
+        }
+        chompKeep = false;
+        let str = stringify.stringify(item, ctx, () => (comment = null), () => (chompKeep = true));
+        if (inFlow && i < items.length - 1)
+            str += ',';
+        str = stringifyComment.addComment(str, itemIndent, comment);
+        if (chompKeep && (comment || inFlow))
+            chompKeep = false;
+        nodes.push({ comment: false, str });
+        return nodes;
+    }, []);
+    let str;
+    if (nodes.length === 0) {
+        str = flowChars.start + flowChars.end;
+    }
+    else if (inFlow) {
+        const { start, end } = flowChars;
+        const strings = nodes.map(n => n.str);
+        let singleLineLength = 2;
+        for (const node of nodes) {
+            if (node.comment || node.str.includes('\n')) {
+                singleLineOutput = false;
+                break;
+            }
+            singleLineLength += node.str.length + 2;
+        }
+        if (!singleLineOutput ||
+            singleLineLength > Collection.Collection.maxFlowStringSingleLineLength) {
+            str = start;
+            for (const s of strings) {
+                str += s ? `\n${indentStep}${indent}${s}` : '\n';
+            }
+            str += `\n${indent}${end}`;
+        }
+        else {
+            str = `${start} ${strings.join(' ')} ${end}`;
+        }
+    }
+    else {
+        const strings = nodes.map(blockItem);
+        str = strings.shift() || '';
+        for (const s of strings)
+            str += s ? `\n${indent}${s}` : '\n';
+    }
+    if (comment) {
+        str += '\n' + stringifyComment.stringifyComment(comment, indent);
+        if (onComment)
+            onComment();
+    }
+    else if (chompKeep && onChompKeep)
+        onChompKeep();
+    return str;
+}
+
+exports.stringifyCollection = stringifyCollection;

package/dist/stringify/stringifyComment.d.ts

@@ -0,0 +1,2 @@
+export declare const stringifyComment: (comment: string, indent: string) => string;
+export declare function addComment(str: string, indent: string, comment?: string | null): string;

package/dist/stringify/stringifyComment.js

@@ -0,0 +1,17 @@
+'use strict';
+
+const stringifyComment = (comment, indent) => /^\n+$/.test(comment)
+    ? comment.substring(1)
+    : comment.replace(/^(?!$)(?: $)?/gm, `${indent}#`);
+function addComment(str, indent, comment) {
+    return !comment
+        ? str
+        : comment.includes('\n')
+            ? `${str}\n` + stringifyComment(comment, indent)
+            : str.endsWith(' ')
+                ? `${str}#${comment}`
+                : `${str} #${comment}`;
+}
+
+exports.addComment = addComment;
+exports.stringifyComment = stringifyComment;

package/dist/stringify/stringifyDocument.d.ts

@@ -0,0 +1,3 @@
+import { Document } from '../doc/Document.js';
+import { ToStringOptions } from '../options.js';
+export declare function stringifyDocument(doc: Readonly<Document>, options: ToStringOptions): string;

package/dist/stringify/stringifyDocument.js

@@ -0,0 +1,66 @@
+'use strict';
+
+var Node = require('../nodes/Node.js');
+var stringify = require('./stringify.js');
+var stringifyComment = require('./stringifyComment.js');
+
+function stringifyDocument(doc, options) {
+    const lines = [];
+    let hasDirectives = options.directives === true;
+    if (options.directives !== false) {
+        const dir = doc.directives.toString(doc);
+        if (dir) {
+            lines.push(dir);
+            hasDirectives = true;
+        }
+        else if (doc.directives.marker)
+            hasDirectives = true;
+    }
+    if (hasDirectives)
+        lines.push('---');
+    if (doc.commentBefore) {
+        if (lines.length !== 1)
+            lines.unshift('');
+        lines.unshift(stringifyComment.stringifyComment(doc.commentBefore, ''));
+    }
+    const ctx = stringify.createStringifyContext(doc, options);
+    let chompKeep = false;
+    let contentComment = null;
+    if (doc.contents) {
+        if (Node.isNode(doc.contents)) {
+            if (doc.contents.spaceBefore && hasDirectives)
+                lines.push('');
+            if (doc.contents.commentBefore)
+                lines.push(stringifyComment.stringifyComment(doc.contents.commentBefore, ''));
+            // top-level block scalars need to be indented if followed by a comment
+            ctx.forceBlockIndent = !!doc.comment;
+            contentComment = doc.contents.comment;
+        }
+        const onChompKeep = contentComment ? undefined : () => (chompKeep = true);
+        let body = stringify.stringify(doc.contents, ctx, () => (contentComment = null), onChompKeep);
+        if (contentComment)
+            body = stringifyComment.addComment(body, '', contentComment);
+        if ((body[0] === '|' || body[0] === '>') &&
+            lines[lines.length - 1] === '---') {
+            // Top-level block scalars with a preceding doc marker ought to use the
+            // same line for their header.
+            lines[lines.length - 1] = `--- ${body}`;
+        }
+        else
+            lines.push(body);
+    }
+    else {
+        lines.push(stringify.stringify(doc.contents, ctx));
+    }
+    let dc = doc.comment;
+    if (dc && chompKeep)
+        dc = dc.replace(/^\n+/, '');
+    if (dc) {
+        if ((!chompKeep || contentComment) && lines[lines.length - 1] !== '')
+            lines.push('');
+        lines.push(stringifyComment.stringifyComment(dc, ''));
+    }
+    return lines.join('\n') + '\n';
+}
+
+exports.stringifyDocument = stringifyDocument;

package/dist/stringify/stringifyNumber.d.ts

@@ -0,0 +1,2 @@
+import type { Scalar } from '../nodes/Scalar.js';
+export declare function stringifyNumber({ format, minFractionDigits, tag, value }: Scalar): string;

package/dist/stringify/stringifyNumber.js

@@ -1,29 +1,26 @@
 'use strict';
 
-function stringifyNumber({
-  format,
-  minFractionDigits,
-  tag,
-  value
-}) {
-  if (typeof value === 'bigint') return String(value);
-  if (!isFinite(value)) return isNaN(value) ? '.nan' : value < 0 ? '-.inf' : '.inf';
-  let n = JSON.stringify(value);
-
-  if (!format && minFractionDigits && (!tag || tag === 'tag:yaml.org,2002:float') && /^\d/.test(n)) {
-    let i = n.indexOf('.');
-
-    if (i < 0) {
-      i = n.length;
-      n += '.';
+function stringifyNumber({ format, minFractionDigits, tag, value }) {
+    if (typeof value === 'bigint')
+        return String(value);
+    const num = typeof value === 'number' ? value : Number(value);
+    if (!isFinite(num))
+        return isNaN(num) ? '.nan' : num < 0 ? '-.inf' : '.inf';
+    let n = JSON.stringify(value);
+    if (!format &&
+        minFractionDigits &&
+        (!tag || tag === 'tag:yaml.org,2002:float') &&
+        /^\d/.test(n)) {
+        let i = n.indexOf('.');
+        if (i < 0) {
+            i = n.length;
+            n += '.';
+        }
+        let d = minFractionDigits - (n.length - i - 1);
+        while (d-- > 0)
+            n += '0';
     }
-
-    let d = minFractionDigits - (n.length - i - 1);
-
-    while (d-- > 0) n += '0';
-  }
-
-  return n;
+    return n;
 }
 
 exports.stringifyNumber = stringifyNumber;

package/dist/stringify/stringifyPair.d.ts

@@ -0,0 +1,3 @@
+import type { Pair } from '../nodes/Pair.js';
+import { StringifyContext } from './stringify.js';
+export declare function stringifyPair({ key, value }: Readonly<Pair>, ctx: StringifyContext, onComment?: () => void, onChompKeep?: () => void): string;

package/dist/stringify/stringifyPair.js

@@ -0,0 +1,113 @@
+'use strict';
+
+var Node = require('../nodes/Node.js');
+var Scalar = require('../nodes/Scalar.js');
+var stringify = require('./stringify.js');
+var stringifyComment = require('./stringifyComment.js');
+
+function stringifyPair({ key, value }, ctx, onComment, onChompKeep) {
+    const { allNullValues, doc, indent, indentStep, options: { indentSeq, simpleKeys } } = ctx;
+    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 && !ctx.inFlow) ||
+            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 keyCommentDone = false;
+    let chompKeep = false;
+    let str = stringify.stringify(key, ctx, () => (keyCommentDone = true), () => (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 (ctx.inFlow) {
+        if (allNullValues || value == null) {
+            if (keyCommentDone && onComment)
+                onComment();
+            return explicitKey ? `? ${str}` : str;
+        }
+    }
+    else if ((allNullValues && !simpleKeys) || (value == null && explicitKey)) {
+        if (keyCommentDone)
+            keyComment = null;
+        if (chompKeep && !keyComment && onChompKeep)
+            onChompKeep();
+        return stringifyComment.addComment(`? ${str}`, ctx.indent, keyComment);
+    }
+    if (keyCommentDone)
+        keyComment = null;
+    str = explicitKey
+        ? `? ${stringifyComment.addComment(str, ctx.indent, keyComment)}\n${indent}:`
+        : stringifyComment.addComment(`${str}:`, ctx.indent, keyComment);
+    let vcb = '';
+    let valueComment = null;
+    if (Node.isNode(value)) {
+        if (value.spaceBefore)
+            vcb = '\n';
+        if (value.commentBefore)
+            vcb += `\n${stringifyComment.stringifyComment(value.commentBefore, ctx.indent)}`;
+        valueComment = value.comment;
+    }
+    else if (value && typeof value === 'object') {
+        value = doc.createNode(value);
+    }
+    ctx.implicitKey = false;
+    if (!explicitKey && !keyComment && 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 &&
+        !value.anchor) {
+        // If indentSeq === false, consider '- ' as part of indentation where possible
+        ctx.indent = ctx.indent.substr(2);
+    }
+    let valueCommentDone = false;
+    const valueStr = stringify.stringify(value, ctx, () => (valueCommentDone = true), () => (chompKeep = true));
+    let ws = ' ';
+    if (vcb || keyComment) {
+        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 (ctx.inFlow) {
+        if (valueCommentDone && onComment)
+            onComment();
+        return str + ws + valueStr;
+    }
+    else {
+        if (valueCommentDone)
+            valueComment = null;
+        if (chompKeep && !valueComment && onChompKeep)
+            onChompKeep();
+        return stringifyComment.addComment(str + ws + valueStr, ctx.indent, valueComment);
+    }
+}
+
+exports.stringifyPair = stringifyPair;

package/dist/stringify/stringifyString.d.ts

@@ -0,0 +1,3 @@
+import { Scalar } from '../nodes/Scalar.js';
+import type { StringifyContext } from './stringify.js';
+export declare function stringifyString(item: Scalar, ctx: StringifyContext, onComment?: () => void, onChompKeep?: () => void): string;