@nette/neon 0.0.0-stage → 1.0.0

package/dist/nodes.d.ts

@@ -0,0 +1,227 @@
+import { CommentPolicy, type PathSegment } from './editing.ts';
+import { setItems, setParent, setSlots } from './internal.ts';
+import { type Position, Token, type Trivia } from './token.ts';
+import { Entity, type NeonValue } from './values.ts';
+type Child = Node | Token;
+export type NodeClass<T extends Node> = abstract new (...args: any[]) => T;
+/** Base of all nodes of the syntax tree. */
+export declare abstract class Node {
+    #private;
+    get parent(): Node | null;
+    /** The slots in order, without nulls. */
+    abstract getChildren(): Child[];
+    /** A deep copy without a parent; tokens keep their origin. */
+    abstract clone(): Node;
+    getTokens(): Token[];
+    abstract getFirstToken(): Token;
+    abstract getLastToken(): Token;
+    /** Current position of the first token, computed by a walk from the root. */
+    getPosition(): Position | null;
+    /** The source text of the node, with the trivia of its tokens. */
+    print(): string;
+    toString(): string;
+    /** Whether the node spans more than one line, its outer trivia not counted. */
+    isMultiLine(): boolean;
+    hasLeadingComment(): boolean;
+    /** Comments in the leading trivia of the first token. */
+    getLeadingComments(): Trivia[];
+    /** Comments in the trailing trivia of the last token. */
+    getTrailingComments(): Trivia[];
+    findAncestor<T extends Node>(type: NodeClass<T>): T | null;
+    getNextSibling(): Node | null;
+    getPreviousSibling(): Node | null;
+    /** Descendants of the class, in document order. */
+    find<T extends Node>(type: NodeClass<T>, predicate?: (node: T) => boolean): T[];
+    findFirst<T extends Node>(type: NodeClass<T>, predicate?: (node: T) => boolean): T | null;
+    /** @internal */
+    [setParent](parent: Node | null): void;
+}
+/** A node that has a value. */
+export declare abstract class ValueNode extends Node {
+    abstract toValue(): NeonValue;
+    abstract clone(): ValueNode;
+    /** 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: ValueNode): void;
+    /** Takes the node out of the tree, with the trivia at its edges; the emptied slot gets null. */
+    detach(): this;
+}
+export declare class DocumentNode extends Node {
+    #private;
+    /** Whether removing the last item leaves null instead of an empty collection. */
+    nullable: boolean;
+    /** @internal */
+    constructor(value: ValueNode | null, endOfFile: Token);
+    get value(): ValueNode | null;
+    /** The same as setValue([], node): the node takes the place of the root, null empties the document. */
+    set value(node: ValueNode | null);
+    get endOfFile(): Token;
+    getChildren(): Child[];
+    getFirstToken(): Token;
+    getLastToken(): Token;
+    clone(): DocumentNode;
+    toValue(): NeonValue;
+    /** The item at the path of keys, the same keys decode() gives; a path continues into the attributes of an entity. */
+    findItem(path: readonly PathSegment[]): ArrayItemNode | null;
+    /** Writes the value at the path; a missing last key is added, unless create is false. */
+    setValue(path: readonly PathSegment[], value: unknown, options?: {
+        create?: boolean;
+    }): void;
+    /** Adds an item to the array at the path, without a key unless given one. */
+    addItem(path: readonly PathSegment[], value: unknown, options?: {
+        key?: string;
+        position?: number;
+    }): ArrayItemNode;
+    /** Removes the item at the path with the comments it owns. */
+    removeItem(path: readonly PathSegment[], options?: {
+        comments?: CommentPolicy;
+        nullable?: boolean;
+        mergeBlankLines?: boolean;
+    }): void;
+    /** Renames the key of the item at the path. */
+    setKey(path: readonly PathSegment[], key: string): void;
+    /** @internal Writes the slot as it is, for an edit that moves the trivia itself. */
+    [setSlots](slots: {
+        value: ValueNode | null;
+    }): void;
+}
+/** Base of the two kinds of arrays. */
+export declare abstract class ArrayNode extends ValueNode {
+    #private;
+    get items(): readonly ArrayItemNode[];
+    /** Whether the array without items is a map, `{}`. */
+    protected abstract isEmptyMap(): boolean;
+    /** @internal Replaces the list; items that leave it lose their parent, new ones must have none. */
+    [setItems](items: readonly ArrayItemNode[]): void;
+    /** The item with the canonical key, as decode() would find it. */
+    findItem(key: string | number): ArrayItemNode | null;
+    /** Adds an item built from the value, at the end or before the item at the position. */
+    addItem(value: unknown, options?: {
+        key?: string;
+        position?: number;
+    }): ArrayItemNode;
+    /** Removes the item with the comments it owns. */
+    removeItem(item: ArrayItemNode, comments?: CommentPolicy): void;
+    /** Inserts an item taken out of a tree by remove(), reindented to its new place, with its comments. */
+    insert(position: number, item: ArrayItemNode): void;
+    toValue(): NeonValue;
+}
+/** The key of each item, explicit or implicit. */
+export declare function itemKeys(items: readonly ArrayItemNode[]): string[];
+export declare class BlockArrayNode extends ArrayNode {
+    /** @internal */
+    constructor(items: readonly ArrayItemNode[]);
+    protected isEmptyMap(): boolean;
+    getChildren(): Child[];
+    getFirstToken(): Token;
+    getLastToken(): Token;
+    clone(): BlockArrayNode;
+}
+export declare class InlineArrayNode extends ArrayNode {
+    #private;
+    /** @internal */
+    constructor(openBracket: Token, items: readonly ArrayItemNode[], closeBracket: Token);
+    protected isEmptyMap(): boolean;
+    get openBracket(): Token;
+    get closeBracket(): Token;
+    getChildren(): Child[];
+    getFirstToken(): Token;
+    getLastToken(): Token;
+    clone(): InlineArrayNode;
+}
+export declare class ArrayItemNode extends Node {
+    #private;
+    /** Whether removing the last item of the value leaves null instead of an empty collection. */
+    nullable: boolean;
+    /** @internal */
+    constructor(bullet: Token | null, key: StringNode | LiteralNode | null, colon: Token | null, value: ValueNode | null, separator?: Token | null);
+    get bullet(): Token | null;
+    get key(): StringNode | LiteralNode | null;
+    get colon(): Token | null;
+    get value(): ValueNode | null;
+    /** The same as setValue(node) with a node: the node takes the place of the value, null empties it. */
+    set value(node: ValueNode | null);
+    get separator(): Token | null;
+    /** @internal Writes the slots as they are, for an edit that moves the trivia itself. */
+    [setSlots](slots: {
+        bullet?: Token | null;
+        key?: StringNode | LiteralNode | null;
+        colon?: Token | null;
+        value?: ValueNode | null;
+        separator?: Token | null;
+    }): void;
+    getChildren(): Child[];
+    getFirstToken(): Token;
+    getLastToken(): Token;
+    clone(): ArrayItemNode;
+    /** The canonical key, or null for an item without a key. */
+    getKeyValue(): string | null;
+    /** The value of the item, null without one. */
+    getValue(): NeonValue;
+    /** The indentation of the line the item starts on. */
+    getIndentation(): string;
+    /**
+     * 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: unknown): void;
+    /** Renames the key. */
+    setKey(key: string): void;
+    /** Removes the item from its array, with the comments it owns. */
+    remove(comments?: CommentPolicy, mergeBlankLines?: boolean): void;
+}
+export declare class EntityNode extends ValueNode {
+    #private;
+    /** @internal */
+    constructor(value: ValueNode, attributes: InlineArrayNode | null);
+    get value(): ValueNode;
+    get attributes(): InlineArrayNode | null;
+    /** @internal */
+    [setSlots](slots: {
+        value?: ValueNode;
+        attributes?: InlineArrayNode;
+    }): void;
+    getChildren(): Child[];
+    getFirstToken(): Token;
+    getLastToken(): Token;
+    clone(): EntityNode;
+    toValue(): Entity;
+}
+export declare class EntityChainNode extends ValueNode {
+    #private;
+    /** @internal */
+    constructor(entities: readonly EntityNode[]);
+    get entities(): readonly EntityNode[];
+    /** @internal */
+    [setSlots](slots: {
+        entities: readonly EntityNode[];
+    }): void;
+    getChildren(): Child[];
+    getFirstToken(): Token;
+    getLastToken(): Token;
+    clone(): EntityChainNode;
+    toValue(): Entity;
+}
+export declare class StringNode extends ValueNode {
+    #private;
+    /** @internal */
+    constructor(token: Token);
+    get token(): Token;
+    getChildren(): Child[];
+    getFirstToken(): Token;
+    getLastToken(): Token;
+    clone(): StringNode;
+    toValue(): string;
+}
+export declare class LiteralNode extends ValueNode {
+    #private;
+    /** @internal */
+    constructor(token: Token);
+    get token(): Token;
+    getChildren(): Child[];
+    getFirstToken(): Token;
+    getLastToken(): Token;
+    clone(): LiteralNode;
+    /** The value of the literal; a key keeps words and dates as strings. */
+    toValue(isKey?: boolean): NeonValue;
+}
+export {};