beancount 0.1.0 → 0.2.0

package/build/src/classes/ParseResult.mjs

@@ -1,165 +1,165 @@
 import { Temporal } from '@js-temporal/polyfill';
-import { entryTypeToClass } from '../entryTypeToClass.mjs';
+import { nodeTypeToClass } from '../nodeTypeToClass.mjs';
 export const defaultFormatOptions = {
     currencyColumn: 59,
 };
 /**
- * Container class for parsed Beancount entries.
- * Provides methods for converting entries back to string format.
+ * Container class for the result of a parse.
+ * Provides methods for converting node back to string format.
  */
 export class ParseResult {
     /**
      * Creates a new ParseResult instance.
-     * @param entries - Array of parsed Entry objects
+     * @param nodes - Array of parsed nodes
      */
-    constructor(entries) {
-        this.entries = entries;
+    constructor(nodes) {
+        this.nodes = nodes;
     }
     /**
-     * Gets all transaction entries from the parsed entries.
-     * @returns Array of entries that are transactions
+     * Gets all transaction nodes from the parsed nodes.
+     * @returns Array of nodes that correspond to transaction directives
      */
     get transactions() {
-        return this.entries.filter((entry) => entry.type === 'transaction');
+        return this.nodes.filter((node) => node.type === 'transaction');
     }
     /**
-     * Gets all balance entries from the parsed entries.
-     * @returns Array of entries that are balance directives
+     * Gets all balance nodes from the parsed nodes.
+     * @returns Array of nodes that correspond to balance directives
      */
     get balance() {
-        return this.entries.filter((entry) => entry.type === 'balance');
+        return this.nodes.filter((node) => node.type === 'balance');
     }
     /**
-     * Gets all close entries from the parsed entries.
-     * @returns Array of entries that are close directives
+     * Gets all close nodes from the parsed nodes.
+     * @returns Array of nodes that correspond to close directives
      */
     get close() {
-        return this.entries.filter((entry) => entry.type === 'close');
+        return this.nodes.filter((node) => node.type === 'close');
     }
     /**
-     * Gets all commodity entries from the parsed entries.
-     * @returns Array of entries that are commodity directives
+     * Gets all commodity nodes from the parsed nodes.
+     * @returns Array of nodes that correspond to commodity directives
      */
     get commodity() {
-        return this.entries.filter((entry) => entry.type === 'commodity');
+        return this.nodes.filter((node) => node.type === 'commodity');
     }
     /**
-     * Gets all custom entries from the parsed entries.
-     * @returns Array of entries that are custom directives
+     * Gets all custom nodes from the parsed nodes.
+     * @returns Array of nodes that correspond to custom directives
      */
     get custom() {
-        return this.entries.filter((entry) => entry.type === 'custom');
+        return this.nodes.filter((node) => node.type === 'custom');
     }
     /**
-     * Gets all document entries from the parsed entries.
-     * @returns Array of entries that are document directives
+     * Gets all document nodes from the parsed nodes.
+     * @returns Array of nodes that correspond to document directives
      */
     get document() {
-        return this.entries.filter((entry) => entry.type === 'document');
+        return this.nodes.filter((node) => node.type === 'document');
     }
     /**
-     * Gets all event entries from the parsed entries.
-     * @returns Array of entries that are event directives
+     * Gets all event nodes from the parsed nodes.
+     * @returns Array of nodes that correspond to event directives
      */
     get event() {
-        return this.entries.filter((entry) => entry.type === 'event');
+        return this.nodes.filter((node) => node.type === 'event');
     }
     /**
-     * Gets all include entries from the parsed entries.
-     * @returns Array of entries that are include directives
+     * Gets all include nodes from the parsed nodes.
+     * @returns Array of nodes that correspond to include directives
      */
     get include() {
-        return this.entries.filter((entry) => entry.type === 'include');
+        return this.nodes.filter((node) => node.type === 'include');
     }
     /**
-     * Gets all note entries from the parsed entries.
-     * @returns Array of entries that are note directives
+     * Gets all note nodes from the parsed nodes.
+     * @returns Array of nodes that correspond to note directives
      */
     get note() {
-        return this.entries.filter((entry) => entry.type === 'note');
+        return this.nodes.filter((node) => node.type === 'note');
     }
     /**
-     * Gets all open entries from the parsed entries.
-     * @returns Array of entries that are open directives
+     * Gets all open nodes from the parsed nodes.
+     * @returns Array of nodes that correspond to open directives
      */
     get open() {
-        return this.entries.filter((entry) => entry.type === 'open');
+        return this.nodes.filter((node) => node.type === 'open');
     }
     /**
-     * Gets all option entries from the parsed entries.
-     * @returns Array of entries that are option directives
+     * Gets all option nodes from the parsed nodes.
+     * @returns Array of nodes that correspond to option directives
      */
     get option() {
-        return this.entries.filter((entry) => entry.type === 'option');
+        return this.nodes.filter((node) => node.type === 'option');
     }
     /**
-     * Gets all pad entries from the parsed entries.
-     * @returns Array of entries that are pad directives
+     * Gets all pad nodes from the parsed nodes.
+     * @returns Array of nodes that correspond to pad directives
      */
     get pad() {
-        return this.entries.filter((entry) => entry.type === 'pad');
+        return this.nodes.filter((node) => node.type === 'pad');
     }
     /**
-     * Gets all plugin entries from the parsed entries.
-     * @returns Array of entries that are plugin directives
+     * Gets all plugin nodes from the parsed nodes.
+     * @returns Array of nodes that correspond to plugin directives
      */
     get plugin() {
-        return this.entries.filter((entry) => entry.type === 'plugin');
+        return this.nodes.filter((node) => node.type === 'plugin');
     }
     /**
-     * Gets all poptag entries from the parsed entries.
-     * @returns Array of entries that are poptag directives
+     * Gets all poptag nodes from the parsed nodes.
+     * @returns Array of nodes that correspond to poptag directives
      */
     get poptag() {
-        return this.entries.filter((entry) => entry.type === 'poptag');
+        return this.nodes.filter((node) => node.type === 'poptag');
     }
     /**
-     * Gets all price entries from the parsed entries.
-     * @returns Array of entries that are price directives
+     * Gets all price nodes from the parsed nodes.
+     * @returns Array of nodes that correspond to price directives
      */
     get price() {
-        return this.entries.filter((entry) => entry.type === 'price');
+        return this.nodes.filter((node) => node.type === 'price');
     }
     /**
-     * Gets all pushtag entries from the parsed entries.
-     * @returns Array of entries that are pushtag directives
+     * Gets all pushtag nodes from the parsed nodes.
+     * @returns Array of nodes that correspond to pushtag directives
      */
     get pushtag() {
-        return this.entries.filter((entry) => entry.type === 'pushtag');
+        return this.nodes.filter((node) => node.type === 'pushtag');
     }
     /**
-     * Gets all query entries from the parsed entries.
-     * @returns Array of entries that are query directives
+     * Gets all query nodes from the parsed nodes.
+     * @returns Array of nodes that correspond to query directives
      */
     get query() {
-        return this.entries.filter((entry) => entry.type === 'query');
+        return this.nodes.filter((node) => node.type === 'query');
     }
     /**
-     * Gets all comment entries from the parsed entries.
-     * @returns Array of entries that are comments
+     * Gets all comment nodes from the parsed nodes.
+     * @returns Array of nodes that correspond to a comments
      */
     get comment() {
-        return this.entries.filter((entry) => entry.type === 'comment');
+        return this.nodes.filter((node) => node.type === 'comment');
     }
     /**
-     * Gets all blankline entries from the parsed entries.
-     * @returns Array of entries that are blank lines
+     * Gets all blankline nodes from the parsed nodes.
+     * @returns Array of nodes that correspond to a blank line
      */
     get blankline() {
-        return this.entries.filter((entry) => entry.type === 'blankline');
+        return this.nodes.filter((node) => node.type === 'blankline');
     }
     /**
-     * Gets all unique account names used across all entries.
+     * Gets all unique account names used across all directives.
      * Extracts accounts from transactions (via postings), open, close,
-     * balance, pad, note, and document entries.
+     * balance, pad, note, and document nodes.
      * @returns Set of unique account names
      */
     get accounts() {
         const accountSet = new Set();
-        for (const entry of this.entries) {
-            switch (entry.type) {
+        for (const node of this.nodes) {
+            switch (node.type) {
                 case 'transaction':
-                    for (const posting of entry.postings) {
+                    for (const posting of node.postings) {
                         accountSet.add(posting.account);
                     }
                     break;
@@ -168,10 +168,10 @@ export class ParseResult {
                 case 'balance':
                 case 'note':
                 case 'document':
-                    accountSet.add(entry.account);
+                    accountSet.add(node.account);
                     break;
                 case 'pad': {
-                    const pad = entry;
+                    const pad = node;
                     accountSet.add(pad.account);
                     accountSet.add(pad.accountPad);
                     break;
@@ -192,13 +192,13 @@ export class ParseResult {
     accountsActiveAt(date) {
         const openedAccounts = new Map();
         const closedAccounts = new Map();
-        for (const entry of this.entries) {
-            if (entry.type === 'open') {
-                const open = entry;
+        for (const node of this.nodes) {
+            if (node.type === 'open') {
+                const open = node;
                 openedAccounts.set(open.account, open.date);
             }
-            else if (entry.type === 'close') {
-                const close = entry;
+            else if (node.type === 'close') {
+                const close = node;
                 closedAccounts.set(close.account, close.date);
             }
         }
@@ -214,25 +214,23 @@ export class ParseResult {
         return activeSet;
     }
     /**
-     * Converts all entries to their string representation.
-     * Each entry is converted using its toString() method and joined with newlines.
+     * Converts all nodes to their string representation.
+     * Each node is converted using its toString() method and joined with newlines.
      * @returns The complete Beancount file content as a string
      */
     toString() {
         // eslint-disable-next-line @typescript-eslint/no-base-to-string
-        return this.entries.map((e) => e.toString()).join('\n');
+        return this.nodes.map((e) => e.toString()).join('\n');
     }
     /**
-     * Converts all entries to a formatted string with aligned columns.
-     * Uses each entry's toFormattedString() method for consistent formatting.
+     * Converts all nodes to a formatted string with aligned columns.
+     * Uses each node's toFormattedString() method for consistent formatting.
      * @param formatOptions - Formatting options
      *
      * @returns The formatted Beancount file content as a string
      */
     toFormattedString(formatOptions = defaultFormatOptions) {
-        return this.entries
-            .map((e) => e.toFormattedString(formatOptions))
-            .join('\n');
+        return this.nodes.map((e) => e.toFormattedString(formatOptions)).join('\n');
     }
     /**
      * Creates an ParseResult instance from JSON data.
@@ -247,27 +245,27 @@ export class ParseResult {
     }
     /**
      * Creates a ParseResult instance from a plain JavaScript object.
-     * Deserializes each entry by mapping it to the appropriate Entry class based on its type.
+     * Deserializes each node by mapping it to the appropriate Node class based on its type.
      *
      * @param obj - Plain object representation of a ParseResult
-     * @returns A new ParseResult instance with deserialized entries
-     * @throws {Error} If an entry has an unknown type with no corresponding entry class
+     * @returns A new ParseResult instance with deserialized nodes
+     * @throws {Error} If an node has an unknown type with no corresponding node class
      * @remarks **Warning:** No validation is performed on the input object. We assume the object is valid and well-formed.
      */
     static fromJSONData(obj) {
-        const objEntries = obj.entries;
-        const entries = objEntries.map((objEntry) => {
-            const { type } = objEntry;
-            const EntryClass = entryTypeToClass[type];
-            if (!EntryClass) {
-                throw new Error(`No entryclass found for type ${type}`);
+        const nodeObjects = obj.nodes;
+        const nodes = nodeObjects.map((nodeObj) => {
+            const { type } = nodeObj;
+            const NodeClass = nodeTypeToClass[type];
+            if (!NodeClass) {
+                throw new Error(`No class found for type ${type} while creating nodes`);
             }
-            // Type assertion needed because TypeScript can't verify that all entry classes
+            // Type assertion needed because TypeScript can't verify that all node classes
             // in the union type have compatible constructor signatures
             // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-call, @typescript-eslint/no-unsafe-member-access
-            return EntryClass.fromJSONData(objEntry);
+            return NodeClass.fromJSONData(nodeObj);
         });
-        return new ParseResult(entries);
+        return new ParseResult(nodes);
     }
     /**
      * Calculates the optimal currency column position for formatting.
@@ -303,10 +301,10 @@ export class ParseResult {
         if (transactions.length === 0) {
             return defaultFormatOptions.currencyColumn;
         }
-        // Extract all postings
+        // Extract all postings from the transactions
         const allPostings = [];
-        for (const entry of transactions) {
-            allPostings.push(...entry.postings);
+        for (const transaction of transactions) {
+            allPostings.push(...transaction.postings);
         }
         // Edge case: No postings
         if (allPostings.length === 0) {

package/build/src/classes/nodes/Balance.d.mts

@@ -0,0 +1,32 @@
+import type { GenericParseResultWithDate } from '../../genericParse.mjs';
+import { DatedNode } from '../DatedNode.mjs';
+import { FormatOptions } from '../ParseResult.mjs';
+/**
+ * Represents a Balance assertion node.
+ * Balance directives assert that an account has a specific balance at a given date.
+ */
+export declare class Balance extends DatedNode {
+    /** @inheritdoc */
+    type: "balance";
+    /** The account name for the balance assertion */
+    account: string;
+    /** The expected amount */
+    amount: string;
+    /** The currency of the amount */
+    currency: string;
+    /**
+     * Gets the formatted price string (amount + currency).
+     * @returns The formatted price string
+     */
+    get price(): string | undefined;
+    /**
+     * Creates a Balance instance from a generic parse result.
+     * @param genericParseResult - The parsed balance entry data
+     * @returns A new Balance instance
+     */
+    static fromGenericParseResult(genericParseResult: GenericParseResultWithDate): Balance;
+    /** @inheritdoc */
+    toString(): string;
+    /** @inheritdoc */
+    toFormattedString(formatOptions?: FormatOptions): string;
+}

package/build/src/classes/nodes/Balance.mjs

@@ -0,0 +1,50 @@
+import { assertNodeConstructor } from '../Node.mjs';
+import { DatedNode } from '../DatedNode.mjs';
+import { simpleParseLine } from '../../utils/simpleParseLine.mjs';
+import { formatPrice } from '../../utils/formatPrice.mjs';
+import { defaultFormatOptions } from '../ParseResult.mjs';
+/**
+ * Represents a Balance assertion node.
+ * Balance directives assert that an account has a specific balance at a given date.
+ */
+export class Balance extends DatedNode {
+    constructor() {
+        super(...arguments);
+        /** @inheritdoc */
+        this.type = 'balance';
+    }
+    /**
+     * Gets the formatted price string (amount + currency).
+     * @returns The formatted price string
+     */
+    get price() {
+        return formatPrice(this.amount, this.currency);
+    }
+    /**
+     * Creates a Balance instance from a generic parse result.
+     * @param genericParseResult - The parsed balance entry data
+     * @returns A new Balance instance
+     */
+    static fromGenericParseResult(genericParseResult) {
+        const [account, amount, currency] = simpleParseLine(genericParseResult.header);
+        return new Balance({
+            ...genericParseResult.props,
+            account,
+            amount,
+            currency,
+        });
+    }
+    /** @inheritdoc */
+    toString() {
+        return this.toFormattedString({ currencyColumn: 0 });
+    }
+    /** @inheritdoc */
+    toFormattedString(formatOptions = defaultFormatOptions) {
+        const firstPart = `${this.getDateTypePrefix()} ${this.account}`;
+        const paddingLength = formatOptions.currencyColumn - firstPart.length - this.amount.length - 2; // not sure what this is for
+        const padding = ' '.repeat(Math.max(1, paddingLength));
+        return [firstPart, padding, this.price, this.getMetaDataString()].join('');
+    }
+}
+// Ensure class conforms to NodeConstructor pattern
+assertNodeConstructor(Balance);

package/build/src/classes/nodes/Blankline.d.mts

@@ -0,0 +1,23 @@
+import type { GenericParseResult } from '../../genericParse.mjs';
+import { Node, NodeConstructor } from '../Node.mjs';
+/**
+ * Represents a blank line in a Beancount file.
+ */
+export declare class Blankline extends Node {
+    /** @inheritdoc */
+    type: "blankline";
+    /**
+     * Creates a Blankline instance from a generic parse result.
+     * @param _genericParseResult - Unused, blank lines have no content
+     * @returns A new Blankline instance
+     */
+    static fromGenericParseResult(_genericParseResult: GenericParseResult): Blankline;
+    /** @inheritdoc */
+    toString(): string;
+    /**
+     * Creates a Blankline instance from a string.
+     * @param _input - Unused, blank lines have no content
+     * @returns A new Blankline instance
+     */
+    static fromString<T extends Node>(this: NodeConstructor<T>, _input: string): T;
+}

package/build/src/classes/nodes/Blankline.mjs

@@ -0,0 +1,37 @@
+import { assertNodeConstructor, Node } from '../Node.mjs';
+/**
+ * Represents a blank line in a Beancount file.
+ */
+export class Blankline extends Node {
+    constructor() {
+        super(...arguments);
+        /** @inheritdoc */
+        this.type = 'blankline';
+    }
+    /**
+     * Creates a Blankline instance from a generic parse result.
+     * @param _genericParseResult - Unused, blank lines have no content
+     * @returns A new Blankline instance
+     */
+    static fromGenericParseResult(
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    _genericParseResult) {
+        return new Blankline({});
+    }
+    /** @inheritdoc */
+    toString() {
+        return '';
+    }
+    /**
+     * Creates a Blankline instance from a string.
+     * @param _input - Unused, blank lines have no content
+     * @returns A new Blankline instance
+     */
+    static fromString(
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    _input) {
+        return this.fromGenericParseResult({});
+    }
+}
+// Ensure class conforms to NodeConstructor pattern
+assertNodeConstructor(Blankline);

package/build/src/classes/nodes/Close.d.mts

@@ -0,0 +1,20 @@
+import type { GenericParseResultWithDate } from '../../genericParse.mjs';
+import { DatedNode } from '../DatedNode.mjs';
+/**
+ * Represents a Close node that closes an account.
+ * Close directives mark the end of an account's lifespan.
+ */
+export declare class Close extends DatedNode {
+    /** @inheritdoc */
+    type: "close";
+    /** The account name being closed */
+    account: string;
+    /**
+     * Creates a Close instance from a generic parse result.
+     * @param genericParseResult - The parsed close node data
+     * @returns A new Close instance
+     */
+    static fromGenericParseResult(genericParseResult: GenericParseResultWithDate): Close;
+    /** @inheritdoc */
+    toString(): string;
+}

package/build/src/classes/nodes/Close.mjs

@@ -0,0 +1,31 @@
+import { assertNodeConstructor } from '../Node.mjs';
+import { DatedNode } from '../DatedNode.mjs';
+/**
+ * Represents a Close node that closes an account.
+ * Close directives mark the end of an account's lifespan.
+ */
+export class Close extends DatedNode {
+    constructor() {
+        super(...arguments);
+        /** @inheritdoc */
+        this.type = 'close';
+    }
+    /**
+     * Creates a Close instance from a generic parse result.
+     * @param genericParseResult - The parsed close node data
+     * @returns A new Close instance
+     */
+    static fromGenericParseResult(genericParseResult) {
+        const account = genericParseResult.header.trim();
+        return new Close({
+            ...genericParseResult.props,
+            account,
+        });
+    }
+    /** @inheritdoc */
+    toString() {
+        return `${this.getDateTypePrefix()} ${this.account}${this.getMetaDataString()}`;
+    }
+}
+// Ensure class conforms to NodeConstructor pattern
+assertNodeConstructor(Close);

package/build/src/classes/nodes/Comment.d.mts

@@ -0,0 +1,25 @@
+import type { GenericParseResult } from '../../genericParse.mjs';
+import { Node, NodeConstructor } from '../Node.mjs';
+/**
+ * Represents a Comment line in a Beancount file.
+ * Comments are lines that start with a semicolon or hash and are ignored by the parser.
+ */
+export declare class Comment extends Node {
+    /** @inheritdoc */
+    type: "comment";
+    /**
+     * Creates a Comment instance from a generic parse result.
+     * Note: This doesn't use a real GenericParseResult structure.
+     * @param genericParseResult - The parsed comment data
+     * @returns A new Comment instance
+     */
+    static fromGenericParseResult(genericParseResult: GenericParseResult): Comment;
+    /** @inheritdoc */
+    toString(): string | undefined;
+    /**
+     * Creates a Comment instance directly from a string.
+     * @param input - The comment text
+     * @returns A new Comment instance
+     */
+    static fromString<T extends Node>(this: NodeConstructor<T>, input: string): T;
+}

package/build/src/classes/nodes/Comment.mjs

@@ -0,0 +1,42 @@
+import { assertNodeConstructor, Node } from '../Node.mjs';
+/**
+ * Represents a Comment line in a Beancount file.
+ * Comments are lines that start with a semicolon or hash and are ignored by the parser.
+ */
+export class Comment extends Node {
+    constructor() {
+        super(...arguments);
+        /** @inheritdoc */
+        this.type = 'comment';
+    }
+    /**
+     * Creates a Comment instance from a generic parse result.
+     * Note: This doesn't use a real GenericParseResult structure.
+     * @param genericParseResult - The parsed comment data
+     * @returns A new Comment instance
+     */
+    static fromGenericParseResult(genericParseResult) {
+        return new Comment({
+            comment: genericParseResult.header,
+        });
+    }
+    /** @inheritdoc */
+    toString() {
+        return this.comment;
+    }
+    /**
+     * Creates a Comment instance directly from a string.
+     * @param input - The comment text
+     * @returns A new Comment instance
+     */
+    static fromString(input) {
+        return this.fromGenericParseResult({
+            type: 'comment',
+            header: input,
+            props: {},
+            synthetic: true,
+        });
+    }
+}
+// Ensure class conforms to NodeConstructor pattern
+assertNodeConstructor(Comment);

package/build/src/classes/nodes/Commodity.d.mts

@@ -0,0 +1,20 @@
+import type { GenericParseResultWithDate } from '../../genericParse.mjs';
+import { DatedNode } from '../DatedNode.mjs';
+/**
+ * Represents a Commodity declaration node.
+ * Commodity directives declare the existence of a commodity/currency with metadata.
+ */
+export declare class Commodity extends DatedNode {
+    /** @inheritdoc */
+    type: "commodity";
+    /** The currency/commodity code being declared */
+    currency: string;
+    /**
+     * Creates a Commodity instance from a generic parse result.
+     * @param genericParseResult - The parsed commodity node data
+     * @returns A new Commodity instance
+     */
+    static fromGenericParseResult(genericParseResult: GenericParseResultWithDate): Commodity;
+    /** @inheritdoc */
+    toString(): string;
+}