@nette/neon 0.0.0-stage → 1.0.1

package/dist/nodes.js

@@ -0,0 +1,635 @@
+var _a;
+import { NeonError } from "./errors.js";
+import { arrayOf, addItem, CommentPolicy, detachNode, insertItem, removeByPath, removeItem, replaceNode, resolvePath, setByPath, setDocumentNode, setItemKey, setItemNode, setItemValue, } from "./editing.js";
+import { atomic, record, setItems, setParent, setSlots } from "./internal.js";
+import { Token } from "./token.js";
+import { Chain, Entity, EscapeError, evaluateString as evaluateStringText, evaluateLiteral, evaluateNumber, Int64Max, isIntegerKey, literalKey, } from "./values.js";
+/** Base of all nodes of the syntax tree. */
+export class Node {
+    #parent = null;
+    get parent() {
+        return this.#parent;
+    }
+    getTokens() {
+        const res = [];
+        const collect = (node) => {
+            for (const child of node.getChildren()) {
+                if (child instanceof _a) {
+                    collect(child);
+                }
+                else {
+                    res.push(child);
+                }
+            }
+        };
+        collect(this);
+        return res;
+    }
+    /** Current position of the first token, computed by a walk from the root. */
+    getPosition() {
+        return this.getFirstToken().getPosition();
+    }
+    /** The source text of the node, with the trivia of its tokens. */
+    print() {
+        return this.getTokens().map(String).join('');
+    }
+    toString() {
+        return this.print();
+    }
+    /** Whether the node spans more than one line, its outer trivia not counted. */
+    isMultiLine() {
+        const tokens = this.getTokens();
+        return tokens.some((token, i) => (i > 0 && token.leadingTrivia.some((t) => t.kind === 'LineEnding'))
+            || /\n/.test(token.text)
+            || (i < tokens.length - 1 && token.trailingTrivia.some((t) => t.kind === 'LineEnding')));
+    }
+    hasLeadingComment() {
+        return this.getLeadingComments().length > 0;
+    }
+    /** Comments in the leading trivia of the first token. */
+    getLeadingComments() {
+        return this.getFirstToken().leadingTrivia.filter((t) => t.kind === 'Comment');
+    }
+    /** Comments in the trailing trivia of the last token. */
+    getTrailingComments() {
+        return this.getLastToken().trailingTrivia.filter((t) => t.kind === 'Comment');
+    }
+    findAncestor(type) {
+        for (let node = this.#parent; node; node = node.parent) {
+            if (node instanceof type) {
+                return node;
+            }
+        }
+        return null;
+    }
+    getNextSibling() {
+        const siblings = this.#siblings();
+        return siblings[siblings.indexOf(this) + 1] ?? null;
+    }
+    getPreviousSibling() {
+        const siblings = this.#siblings();
+        return siblings[siblings.indexOf(this) - 1] ?? null;
+    }
+    #siblings() {
+        return this.#parent?.getChildren().filter((child) => child instanceof _a) ?? [];
+    }
+    /** Descendants of the class, in document order. */
+    find(type, predicate) {
+        const res = [];
+        this.#walk((node) => {
+            if (node instanceof type && (!predicate || predicate(node))) {
+                res.push(node);
+            }
+            return false;
+        });
+        return res;
+    }
+    findFirst(type, predicate) {
+        let res = null;
+        this.#walk((node) => {
+            if (node instanceof type && (!predicate || predicate(node))) {
+                res = node;
+                return true;
+            }
+            return false;
+        });
+        return res;
+    }
+    /** Visits the descendants in document order until the visitor returns true. */
+    #walk(visitor) {
+        for (const child of this.getChildren()) {
+            if (child instanceof _a && (visitor(child) || child.#walk(visitor))) {
+                return true;
+            }
+        }
+        return false;
+    }
+    /** @internal */
+    [setParent](parent) {
+        const old = this.#parent;
+        record(() => this.#parent = old);
+        this.#parent = parent;
+    }
+}
+_a = Node;
+/** A node that has a value. */
+export class ValueNode extends Node {
+    /** Puts the node into the slot of this one, which decides what that means; the node gets the trivia at the edges of this one in place of its own. */
+    replaceWith(node) {
+        atomic(() => replaceNode(this, node));
+    }
+    /** Takes the node out of the tree, with the trivia at its edges; the emptied slot gets null. */
+    detach() {
+        atomic(() => detachNode(this));
+        return this;
+    }
+}
+/** Puts a child into a slot of the parent and releases the previous one. */
+function adopt(parent, child, previous = null) {
+    if (child === previous) {
+        return child;
+    }
+    else if (child) {
+        if (child.parent) {
+            throw new Error('The node already has a parent, detach() or clone() it first.');
+        }
+        for (let node = parent; node; node = node.parent) {
+            if (node === child) {
+                throw new Error('A node cannot be put into its own subtree.');
+            }
+        }
+        child[setParent](parent);
+    }
+    previous?.[setParent](null);
+    return child;
+}
+export class DocumentNode extends Node {
+    #value = null;
+    #endOfFile;
+    /** Whether removing the last item leaves null instead of an empty collection. */
+    nullable = false;
+    /** @internal */
+    constructor(value, endOfFile) {
+        super();
+        this.#value = adopt(this, value);
+        this.#endOfFile = adopt(this, endOfFile);
+    }
+    get value() {
+        return this.#value;
+    }
+    /** The same as setValue([], node): the node takes the place of the root, null empties the document. */
+    set value(node) {
+        atomic(() => setDocumentNode(this, node));
+    }
+    get endOfFile() {
+        return this.#endOfFile;
+    }
+    getChildren() {
+        return this.#value ? [this.#value, this.#endOfFile] : [this.#endOfFile];
+    }
+    getFirstToken() {
+        return this.#value?.getFirstToken() ?? this.#endOfFile;
+    }
+    getLastToken() {
+        return this.#endOfFile;
+    }
+    clone() {
+        const res = new DocumentNode(this.#value?.clone() ?? null, this.#endOfFile.clone());
+        res.nullable = this.nullable;
+        return res;
+    }
+    toValue() {
+        return this.#value?.toValue() ?? null;
+    }
+    /** The item at the path of keys, the same keys decode() gives; a path continues into the attributes of an entity. */
+    findItem(path) {
+        try {
+            return path.length ? resolvePath(this, path) : null;
+        }
+        catch (e) {
+            if (e instanceof NeonError) {
+                return null;
+            }
+            throw e;
+        }
+    }
+    /** Writes the value at the path; a missing last key is added, unless create is false. */
+    setValue(path, value, options = {}) {
+        atomic(() => setByPath(this, path, value, options.create ?? true));
+    }
+    /** Adds an item to the array at the path, without a key unless given one. */
+    addItem(path, value, options = {}) {
+        return atomic(() => {
+            const owner = path.length ? resolvePath(this, path) : null;
+            const container = owner ? owner.value : this.#value;
+            const array = arrayOf(container);
+            if (array) {
+                return addItem(array, options.key ?? null, value, options.position);
+            }
+            else if (container === null) {
+                if (options.position !== undefined && options.position !== 0) {
+                    throw new RangeError(`Position ${options.position} is out of the array.`);
+                }
+                const key = options.key ?? null;
+                const placeholder = value instanceof ValueNode ? null : value; // a node comes into the item as into any other
+                setByPath(this, path, key === null ? [placeholder] : new Map([[key, placeholder]]), true);
+                const item = arrayOf(owner ? owner.value : this.#value).items[0];
+                if (value instanceof ValueNode) {
+                    item.setValue(value);
+                }
+                return item;
+            }
+            throw new NeonError(`The value at ${path.join('.')} is not an array`);
+        });
+    }
+    /** Removes the item at the path with the comments it owns. */
+    removeItem(path, options = {}) {
+        atomic(() => removeByPath(this, path, options.comments ?? CommentPolicy.Drop, options.nullable, options.mergeBlankLines));
+    }
+    /** Renames the key of the item at the path. */
+    setKey(path, key) {
+        atomic(() => setItemKey(resolvePath(this, path), key));
+    }
+    /** @internal Writes the slot as it is, for an edit that moves the trivia itself. */
+    [setSlots](slots) {
+        const old = this.#value;
+        this.#value = adopt(this, slots.value, old);
+        record(() => this.#value = old);
+    }
+}
+/** Base of the two kinds of arrays. */
+export class ArrayNode extends ValueNode {
+    #items = [];
+    get items() {
+        return this.#items;
+    }
+    /** @internal Replaces the list; items that leave it lose their parent, new ones must have none. */
+    [setItems](items) {
+        const old = this.#items;
+        const kept = new Set(items);
+        const present = new Set(old);
+        for (const item of old) {
+            if (!kept.has(item)) {
+                item[setParent](null);
+            }
+        }
+        for (const item of items) {
+            if (!present.has(item)) {
+                adopt(this, item);
+            }
+        }
+        this.#items = Object.freeze([...items]);
+        record(() => this.#items = old);
+    }
+    /** The item with the canonical key, as decode() would find it. */
+    findItem(key) {
+        const map = resolveKeys(this.items);
+        return map.get(String(key)) ?? null;
+    }
+    /** Adds an item built from the value, at the end or before the item at the position. */
+    addItem(value, options = {}) {
+        return atomic(() => addItem(this, options.key ?? null, value, options.position));
+    }
+    /** Removes the item with the comments it owns. */
+    removeItem(item, comments = CommentPolicy.Drop) {
+        if (item.parent !== this) {
+            throw new Error('The item is not in this array.');
+        }
+        atomic(() => removeItem(item, comments));
+    }
+    /** Inserts an item taken out of a tree by remove(), reindented to its new place, with its comments. */
+    insert(position, item) {
+        atomic(() => insertItem(this, item, position));
+    }
+    toValue() {
+        const entries = (new Map);
+        for (const [key, item] of resolveKeys(this.items)) {
+            entries.set(key, item.getValue());
+        }
+        const keys = [...entries.keys()];
+        if (!keys.length) {
+            return this.isEmptyMap() ? {} : [];
+        }
+        else if (keys.every((key, i) => key === String(i))) {
+            return [...entries.values()];
+        }
+        const res = {};
+        for (const [key, value] of entries) {
+            Object.defineProperty(res, key, { value, writable: true, enumerable: true, configurable: true });
+        }
+        return res;
+    }
+}
+/** Keys of the items with implicit keys assigned; for overwritten keys the winning item, at the first position. */
+function resolveKeys(items) {
+    const keys = itemKeys(items);
+    return new Map(items.map((item, i) => [keys[i], item]));
+}
+/** The key of each item, explicit or implicit. */
+export function itemKeys(items) {
+    let max = null;
+    return items.map((item) => {
+        let key = item.getKeyValue();
+        if (key === null) {
+            const next = max === null ? 0n : max + 1n;
+            if (next > Int64Max) {
+                throw new NeonError('Implicit key overflow', item.getPosition());
+            }
+            key = String(next);
+        }
+        if (isIntegerKey(key)) {
+            const n = BigInt(key);
+            max = max === null || n > max ? n : max;
+        }
+        return key;
+    });
+}
+export class BlockArrayNode extends ArrayNode {
+    /** @internal */
+    constructor(items) {
+        super();
+        this[setItems](items);
+    }
+    isEmptyMap() {
+        return false;
+    }
+    getChildren() {
+        return [...this.items];
+    }
+    getFirstToken() {
+        return this.items[0].getFirstToken();
+    }
+    getLastToken() {
+        return this.items.at(-1).getLastToken();
+    }
+    clone() {
+        return new BlockArrayNode(this.items.map((item) => item.clone()));
+    }
+}
+export class InlineArrayNode extends ArrayNode {
+    #openBracket;
+    #closeBracket;
+    /** @internal */
+    constructor(openBracket, items, closeBracket) {
+        super();
+        this.#openBracket = adopt(this, openBracket);
+        this[setItems](items);
+        this.#closeBracket = adopt(this, closeBracket);
+    }
+    isEmptyMap() {
+        return this.#openBracket.kind === 'OpenBrace';
+    }
+    get openBracket() {
+        return this.#openBracket;
+    }
+    get closeBracket() {
+        return this.#closeBracket;
+    }
+    getChildren() {
+        return [this.#openBracket, ...this.items, this.#closeBracket];
+    }
+    getFirstToken() {
+        return this.#openBracket;
+    }
+    getLastToken() {
+        return this.#closeBracket;
+    }
+    clone() {
+        return new InlineArrayNode(this.#openBracket.clone(), this.items.map((item) => item.clone()), this.#closeBracket.clone());
+    }
+}
+export class ArrayItemNode extends Node {
+    #bullet;
+    #key;
+    #colon;
+    #value;
+    #separator;
+    /** Whether removing the last item of the value leaves null instead of an empty collection. */
+    nullable = false;
+    /** @internal */
+    constructor(bullet, key, colon, value, separator = null) {
+        super();
+        this.#bullet = adopt(this, bullet);
+        this.#key = adopt(this, key);
+        this.#colon = adopt(this, colon);
+        this.#value = adopt(this, value);
+        this.#separator = adopt(this, separator);
+    }
+    get bullet() {
+        return this.#bullet;
+    }
+    get key() {
+        return this.#key;
+    }
+    get colon() {
+        return this.#colon;
+    }
+    get value() {
+        return this.#value;
+    }
+    /** The same as setValue(node) with a node: the node takes the place of the value, null empties it. */
+    set value(node) {
+        atomic(() => setItemNode(this, node));
+    }
+    get separator() {
+        return this.#separator;
+    }
+    /** @internal Writes the slots as they are, for an edit that moves the trivia itself. */
+    [setSlots](slots) {
+        const old = [this.#bullet, this.#key, this.#colon, this.#value, this.#separator];
+        record(() => [this.#bullet, this.#key, this.#colon, this.#value, this.#separator] = old);
+        if (slots.bullet !== undefined) {
+            this.#bullet = adopt(this, slots.bullet, this.#bullet);
+        }
+        if (slots.key !== undefined) {
+            this.#key = adopt(this, slots.key, this.#key);
+        }
+        if (slots.colon !== undefined) {
+            this.#colon = adopt(this, slots.colon, this.#colon);
+        }
+        if (slots.value !== undefined) {
+            this.#value = adopt(this, slots.value, this.#value);
+        }
+        if (slots.separator !== undefined) {
+            this.#separator = adopt(this, slots.separator, this.#separator);
+        }
+    }
+    getChildren() {
+        return [this.#bullet, this.#key, this.#colon, this.#value, this.#separator].filter((child) => child !== null);
+    }
+    getFirstToken() {
+        return this.#bullet ?? this.#key?.getFirstToken() ?? this.#value.getFirstToken();
+    }
+    getLastToken() {
+        return this.#separator ?? this.#value?.getLastToken() ?? this.#colon ?? this.#bullet;
+    }
+    clone() {
+        const res = new ArrayItemNode(this.#bullet?.clone() ?? null, this.#key?.clone() ?? null, this.#colon?.clone() ?? null, this.#value?.clone() ?? null, this.#separator?.clone() ?? null);
+        res.nullable = this.nullable;
+        return res;
+    }
+    /** The canonical key, or null for an item without a key. */
+    getKeyValue() {
+        const key = this.#key;
+        return key instanceof StringNode
+            ? key.toValue()
+            : key ? literalKey(key.token.text) : null;
+    }
+    /** The value of the item, null without one. */
+    getValue() {
+        return this.#value?.toValue() ?? null;
+    }
+    /** The indentation of the line the item starts on. */
+    getIndentation() {
+        const trivia = this.getFirstToken().leadingTrivia.at(-1);
+        return trivia?.kind === 'Whitespace' ? trivia.text : '';
+    }
+    /**
+     * Writes the value: a value of the host or a node. Writing an equal value changes nothing; a new
+     * scalar keeps the style of the old one where it can.
+     */
+    setValue(value) {
+        atomic(() => setItemValue(this, value));
+    }
+    /** Renames the key. */
+    setKey(key) {
+        atomic(() => setItemKey(this, key));
+    }
+    /** Removes the item from its array, with the comments it owns. */
+    remove(comments = CommentPolicy.Drop, mergeBlankLines = false) {
+        atomic(() => removeItem(this, comments, undefined, mergeBlankLines));
+    }
+}
+export class EntityNode extends ValueNode {
+    #value;
+    #attributes;
+    /** @internal */
+    constructor(value, attributes) {
+        super();
+        this.#value = adopt(this, value);
+        this.#attributes = adopt(this, attributes);
+    }
+    get value() {
+        return this.#value;
+    }
+    get attributes() {
+        return this.#attributes;
+    }
+    /** @internal */
+    [setSlots](slots) {
+        const old = [this.#value, this.#attributes];
+        record(() => [this.#value, this.#attributes] = old);
+        if (slots.value) {
+            this.#value = adopt(this, slots.value, this.#value);
+        }
+        if (slots.attributes) {
+            this.#attributes = adopt(this, slots.attributes, this.#attributes);
+        }
+    }
+    getChildren() {
+        return this.#attributes ? [this.#value, this.#attributes] : [this.#value];
+    }
+    getFirstToken() {
+        return this.#value.getFirstToken();
+    }
+    getLastToken() {
+        return this.#attributes?.closeBracket ?? this.#value.getLastToken();
+    }
+    clone() {
+        return new EntityNode(this.#value.clone(), this.#attributes?.clone() ?? null);
+    }
+    toValue() {
+        const attributes = this.#attributes?.toValue() ?? [];
+        return new Entity(this.#value.toValue(), attributes);
+    }
+}
+export class EntityChainNode extends ValueNode {
+    #entities;
+    /** @internal */
+    constructor(entities) {
+        super();
+        this.#entities = Object.freeze([...entities]);
+        for (const entity of entities) {
+            adopt(this, entity);
+        }
+    }
+    get entities() {
+        return this.#entities;
+    }
+    /** @internal */
+    [setSlots](slots) {
+        const old = this.#entities;
+        for (const entity of old) {
+            if (!slots.entities.includes(entity)) {
+                entity[setParent](null);
+            }
+        }
+        for (const entity of slots.entities) {
+            if (!old.includes(entity)) {
+                adopt(this, entity);
+            }
+        }
+        this.#entities = Object.freeze([...slots.entities]);
+        record(() => this.#entities = old);
+    }
+    getChildren() {
+        return [...this.#entities];
+    }
+    getFirstToken() {
+        return this.#entities[0].getFirstToken();
+    }
+    getLastToken() {
+        return this.#entities.at(-1).getLastToken();
+    }
+    clone() {
+        return new EntityChainNode(this.#entities.map((entity) => entity.clone()));
+    }
+    toValue() {
+        return new Entity(Chain, this.#entities.map((entity) => entity.toValue()));
+    }
+}
+export class StringNode extends ValueNode {
+    #token;
+    /** @internal */
+    constructor(token) {
+        super();
+        this.#token = adopt(this, token);
+    }
+    get token() {
+        return this.#token;
+    }
+    getChildren() {
+        return [this.#token];
+    }
+    getFirstToken() {
+        return this.#token;
+    }
+    getLastToken() {
+        return this.#token;
+    }
+    clone() {
+        return new StringNode(this.#token.clone());
+    }
+    toValue() {
+        return evaluateStringToken(this.#token);
+    }
+}
+export class LiteralNode extends ValueNode {
+    #token;
+    /** @internal */
+    constructor(token) {
+        super();
+        this.#token = adopt(this, token);
+    }
+    get token() {
+        return this.#token;
+    }
+    getChildren() {
+        return [this.#token];
+    }
+    getFirstToken() {
+        return this.#token;
+    }
+    getLastToken() {
+        return this.#token;
+    }
+    clone() {
+        return new LiteralNode(this.#token.clone());
+    }
+    /** The value of the literal; a key keeps words and dates as strings. */
+    toValue(isKey = false) {
+        const text = this.#token.text;
+        return isKey ? evaluateNumber(text) ?? text : evaluateLiteral(text);
+    }
+}
+function evaluateStringToken(token) {
+    try {
+        return evaluateStringText(token.text);
+    }
+    catch (e) {
+        if (e instanceof EscapeError) {
+            throw new NeonError(e.message, token.getPosition() ?? token.origin);
+        }
+        throw e;
+    }
+}

package/dist/parser.d.ts

@@ -0,0 +1,3 @@
+import { DocumentNode } from './nodes.ts';
+/** Parses NEON into the lossless syntax tree. */
+export declare function parse(input: string): DocumentNode;