beancount 0.0.31 → 0.2.0

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;
+}

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

@@ -0,0 +1,31 @@
+import { assertNodeConstructor } from '../Node.mjs';
+import { DatedNode } from '../DatedNode.mjs';
+/**
+ * Represents a Commodity declaration node.
+ * Commodity directives declare the existence of a commodity/currency with metadata.
+ */
+export class Commodity extends DatedNode {
+    constructor() {
+        super(...arguments);
+        /** @inheritdoc */
+        this.type = 'commodity';
+    }
+    /**
+     * Creates a Commodity instance from a generic parse result.
+     * @param genericParseResult - The parsed commodity node data
+     * @returns A new Commodity instance
+     */
+    static fromGenericParseResult(genericParseResult) {
+        const currency = genericParseResult.header.trim();
+        return new Commodity({
+            ...genericParseResult.props,
+            currency,
+        });
+    }
+    /** @inheritdoc */
+    toString() {
+        return `${this.getDateTypePrefix()} ${this.currency}${this.getMetaDataString()}`;
+    }
+}
+// Ensure class conforms to NodeConstructor pattern
+assertNodeConstructor(Commodity);

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

@@ -0,0 +1,23 @@
+import type { GenericParseResultWithDate } from '../../genericParse.mjs';
+import { DatedNode } from '../DatedNode.mjs';
+import { Value } from '../Value.mjs';
+/**
+ * Represents a Custom node for user-defined directives.
+ * Custom directives allow for extensibility with arbitrary types and values.
+ */
+export declare class Custom extends DatedNode {
+    /** @inheritdoc */
+    type: "custom";
+    /** The custom directive type */
+    customType: Value;
+    /** Optional array of values associated with the custom directive */
+    values?: Value[];
+    /**
+     * Creates a Custom instance from a generic parse result.
+     * @param genericParseResult - The parsed custom node data
+     * @returns A new Custom instance
+     */
+    static fromGenericParseResult(genericParseResult: GenericParseResultWithDate): Custom;
+    /** @inheritdoc */
+    toString(): string;
+}

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

@@ -0,0 +1,38 @@
+import { assertNodeConstructor } from '../Node.mjs';
+import { DatedNode } from '../DatedNode.mjs';
+import { simpleParseLine } from '../../utils/simpleParseLine.mjs';
+import { Value } from '../Value.mjs';
+/**
+ * Represents a Custom node for user-defined directives.
+ * Custom directives allow for extensibility with arbitrary types and values.
+ */
+export class Custom extends DatedNode {
+    constructor() {
+        super(...arguments);
+        /** @inheritdoc */
+        this.type = 'custom';
+    }
+    /**
+     * Creates a Custom instance from a generic parse result.
+     * @param genericParseResult - The parsed custom node data
+     * @returns A new Custom instance
+     */
+    static fromGenericParseResult(genericParseResult) {
+        const [customType, ...others] = simpleParseLine(genericParseResult.header);
+        return new Custom({
+            ...genericParseResult.props,
+            customType: Value.fromString(customType),
+            values: others.length > 0 ? others.map((o) => Value.fromString(o)) : undefined,
+        });
+    }
+    /** @inheritdoc */
+    toString() {
+        const parts = [`${this.getDateTypePrefix()} ${this.customType.toString()}`];
+        if (this.values !== undefined) {
+            parts.push(...this.values.map((v) => v.toString()));
+        }
+        return parts.join(' ') + this.getMetaDataString();
+    }
+}
+// Ensure class conforms to NodeConstructor pattern
+assertNodeConstructor(Custom);

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

@@ -0,0 +1,22 @@
+import type { GenericParseResultWithDate } from '../../genericParse.mjs';
+import { DatedNode } from '../DatedNode.mjs';
+/**
+ * Represents a Document node that links an external file to an account.
+ * Document directives associate receipts, statements, or other files with accounts.
+ */
+export declare class Document extends DatedNode {
+    /** @inheritdoc */
+    type: "document";
+    /** The account the document is associated with */
+    account: string;
+    /** The file path to the document */
+    pathToDocument: string;
+    /**
+     * Creates a Document instance from a generic parse result.
+     * @param genericParseResult - The parsed document node data
+     * @returns A new Document instance
+     */
+    static fromGenericParseResult(genericParseResult: GenericParseResultWithDate): Document;
+    /** @inheritdoc */
+    toString(): string;
+}

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

@@ -0,0 +1,34 @@
+import { assertNodeConstructor } from '../Node.mjs';
+import { DatedNode } from '../DatedNode.mjs';
+import { parseString } from '../Value.mjs';
+import { stringAwareParseLine } from '../../utils/stringAwareParseLine.mjs';
+/**
+ * Represents a Document node that links an external file to an account.
+ * Document directives associate receipts, statements, or other files with accounts.
+ */
+export class Document extends DatedNode {
+    constructor() {
+        super(...arguments);
+        /** @inheritdoc */
+        this.type = 'document';
+    }
+    /**
+     * Creates a Document instance from a generic parse result.
+     * @param genericParseResult - The parsed document node data
+     * @returns A new Document instance
+     */
+    static fromGenericParseResult(genericParseResult) {
+        const [account, pathToDocument] = stringAwareParseLine(genericParseResult.header);
+        return new Document({
+            ...genericParseResult.props,
+            account,
+            pathToDocument: parseString(pathToDocument),
+        });
+    }
+    /** @inheritdoc */
+    toString() {
+        return `${this.getDateTypePrefix()} ${this.account} "${this.pathToDocument}"${this.getMetaDataString()}`;
+    }
+}
+// Ensure class conforms to NodeConstructor pattern
+assertNodeConstructor(Document);

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

@@ -0,0 +1,23 @@
+import type { GenericParseResultWithDate } from '../../genericParse.mjs';
+import { DatedNode } from '../DatedNode.mjs';
+import { Value } from '../Value.mjs';
+/**
+ * Represents an Event node that records a named event with a value.
+ * Event directives track occurrences of specific events over time.
+ */
+export declare class Event extends DatedNode {
+    /** @inheritdoc */
+    type: "event";
+    /** The name of the event */
+    name: string;
+    /** The value associated with the event */
+    value: Value;
+    /**
+     * Creates an Event instance from a generic parse result.
+     * @param genericParseResult - The parsed event node data
+     * @returns A new Event instance
+     */
+    static fromGenericParseResult(genericParseResult: GenericParseResultWithDate): Event;
+    /** @inheritdoc */
+    toString(): string;
+}

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

@@ -0,0 +1,34 @@
+import { assertNodeConstructor } from '../Node.mjs';
+import { DatedNode } from '../DatedNode.mjs';
+import { parseString, Value } from '../Value.mjs';
+import { stringAwareParseLine } from '../../utils/stringAwareParseLine.mjs';
+/**
+ * Represents an Event node that records a named event with a value.
+ * Event directives track occurrences of specific events over time.
+ */
+export class Event extends DatedNode {
+    constructor() {
+        super(...arguments);
+        /** @inheritdoc */
+        this.type = 'event';
+    }
+    /**
+     * Creates an Event instance from a generic parse result.
+     * @param genericParseResult - The parsed event node data
+     * @returns A new Event instance
+     */
+    static fromGenericParseResult(genericParseResult) {
+        const [name, value] = stringAwareParseLine(genericParseResult.header);
+        return new Event({
+            ...genericParseResult.props,
+            name: parseString(name),
+            value: Value.fromString(value),
+        });
+    }
+    /** @inheritdoc */
+    toString() {
+        return `${this.getDateTypePrefix()} "${this.name}" ${this.value.toString()}${this.getMetaDataString()}`;
+    }
+}
+// Ensure class conforms to NodeConstructor pattern
+assertNodeConstructor(Event);

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

@@ -0,0 +1,20 @@
+import type { GenericParseResult } from '../../genericParse.mjs';
+import { Node } from '../Node.mjs';
+/**
+ * Represents an Include node that includes another Beancount file.
+ * Include directives allow splitting ledgers across multiple files.
+ */
+export declare class Include extends Node {
+    /** @inheritdoc */
+    type: "include";
+    /** The filename/path of the file to include */
+    filename: string;
+    /**
+     * Creates an Include instance from a generic parse result.
+     * @param genericParseResult - The parsed include node data
+     * @returns A new Include instance
+     */
+    static fromGenericParseResult(genericParseResult: GenericParseResult): Include;
+    /** @inheritdoc */
+    toString(): string;
+}

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

@@ -0,0 +1,31 @@
+import { parseString } from '../Value.mjs';
+import { stringAwareParseLine } from '../../utils/stringAwareParseLine.mjs';
+import { assertNodeConstructor, Node } from '../Node.mjs';
+/**
+ * Represents an Include node that includes another Beancount file.
+ * Include directives allow splitting ledgers across multiple files.
+ */
+export class Include extends Node {
+    constructor() {
+        super(...arguments);
+        /** @inheritdoc */
+        this.type = 'include';
+    }
+    /**
+     * Creates an Include instance from a generic parse result.
+     * @param genericParseResult - The parsed include node data
+     * @returns A new Include instance
+     */
+    static fromGenericParseResult(genericParseResult) {
+        const [filename] = stringAwareParseLine(genericParseResult.header);
+        return new Include({
+            filename: parseString(filename),
+        });
+    }
+    /** @inheritdoc */
+    toString() {
+        return `${this.type} "${this.filename}"`;
+    }
+}
+// Ensure class conforms to NodeConstructor pattern
+assertNodeConstructor(Include);

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

@@ -0,0 +1,22 @@
+import type { GenericParseResultWithDate } from '../../genericParse.mjs';
+import { DatedNode } from '../DatedNode.mjs';
+/**
+ * Represents a Note node that attaches a comment to an account.
+ * Note directives associate free-form text descriptions with accounts at specific dates.
+ */
+export declare class Note extends DatedNode {
+    /** @inheritdoc */
+    type: "note";
+    /** The account the note is attached to */
+    account: string;
+    /** The note description text */
+    description: string;
+    /**
+     * Creates a Note instance from a generic parse result.
+     * @param genericParseResult - The parsed note node data
+     * @returns A new Note instance
+     */
+    static fromGenericParseResult(genericParseResult: GenericParseResultWithDate): Note;
+    /** @inheritdoc */
+    toString(): string;
+}

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

@@ -0,0 +1,34 @@
+import { assertNodeConstructor } from '../Node.mjs';
+import { DatedNode } from '../DatedNode.mjs';
+import { parseString } from '../Value.mjs';
+import { stringAwareParseLine } from '../../utils/stringAwareParseLine.mjs';
+/**
+ * Represents a Note node that attaches a comment to an account.
+ * Note directives associate free-form text descriptions with accounts at specific dates.
+ */
+export class Note extends DatedNode {
+    constructor() {
+        super(...arguments);
+        /** @inheritdoc */
+        this.type = 'note';
+    }
+    /**
+     * Creates a Note instance from a generic parse result.
+     * @param genericParseResult - The parsed note node data
+     * @returns A new Note instance
+     */
+    static fromGenericParseResult(genericParseResult) {
+        const [account, description] = stringAwareParseLine(genericParseResult.header);
+        return new Note({
+            ...genericParseResult.props,
+            account,
+            description: parseString(description),
+        });
+    }
+    /** @inheritdoc */
+    toString() {
+        return `${this.getDateTypePrefix()} ${this.account} "${this.description}"${this.getMetaDataString()}`;
+    }
+}
+// Ensure class conforms to NodeConstructor pattern
+assertNodeConstructor(Note);

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

@@ -0,0 +1,27 @@
+import type { GenericParseResultWithDate } from '../../genericParse.mjs';
+import { DatedNode } from '../DatedNode.mjs';
+import { FormatOptions } from '../ParseResult.mjs';
+/**
+ * Represents an Open node that declares a new account.
+ * Open directives define the beginning of an account's lifespan.
+ */
+export declare class Open extends DatedNode {
+    /** @inheritdoc */
+    type: "open";
+    /** The account name being opened */
+    account: string;
+    /** Optional list of allowed currencies for this account */
+    constraintCurrencies?: string[];
+    /** Optional booking method specification */
+    bookingMethod?: string;
+    /**
+     * Creates an Open instance from a generic parse result.
+     * @param genericParseResult - The parsed open node data
+     * @returns A new Open instance
+     */
+    static fromGenericParseResult(genericParseResult: GenericParseResultWithDate): Open;
+    /** @inheritdoc */
+    toString(): string;
+    /** @inheritdoc */
+    toFormattedString(formatOptions?: FormatOptions): string;
+}