beancount 0.1.0 → 0.2.0

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

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

@@ -0,0 +1,66 @@
+import { assertNodeConstructor } from '../Node.mjs';
+import { DatedNode } from '../DatedNode.mjs';
+import { simpleParseLine } from '../../utils/simpleParseLine.mjs';
+import { parseString } from '../Value.mjs';
+import { defaultFormatOptions } from '../ParseResult.mjs';
+/**
+ * Represents an Open node that declares a new account.
+ * Open directives define the beginning of an account's lifespan.
+ */
+export class Open extends DatedNode {
+    constructor() {
+        super(...arguments);
+        /** @inheritdoc */
+        this.type = 'open';
+    }
+    /**
+     * Creates an Open instance from a generic parse result.
+     * @param genericParseResult - The parsed open node data
+     * @returns A new Open instance
+     */
+    static fromGenericParseResult(genericParseResult) {
+        const [account, ...other] = simpleParseLine(genericParseResult.header);
+        let constraintCurrencies, bookingMethod;
+        if (other.length === 2) {
+            constraintCurrencies = other[0];
+            bookingMethod = parseString(other[1]);
+        }
+        else if (other.length === 1) {
+            if (other[0].startsWith('"') && other[0].endsWith('"')) {
+                bookingMethod = parseString(other[0]);
+            }
+            else {
+                constraintCurrencies = other[0];
+            }
+        }
+        return new Open({
+            ...genericParseResult.props,
+            account,
+            constraintCurrencies: constraintCurrencies?.split(','),
+            bookingMethod,
+        });
+    }
+    /** @inheritdoc */
+    toString() {
+        return this.toFormattedString({ currencyColumn: 0 });
+    }
+    /** @inheritdoc */
+    toFormattedString(formatOptions = defaultFormatOptions) {
+        const parts = [`${this.getDateTypePrefix()} ${this.account}`];
+        if (this.constraintCurrencies !== undefined) {
+            const paddingLength = formatOptions.currencyColumn -
+                parts.join(' ').length -
+                this.constraintCurrencies.join(',').length;
+            if (paddingLength > 0) {
+                parts.push(' '.repeat(paddingLength));
+            }
+            parts.push(this.constraintCurrencies.join(','));
+        }
+        if (this.bookingMethod !== undefined) {
+            parts.push(`"${this.bookingMethod}"`);
+        }
+        return parts.join(' ') + this.getMetaDataString();
+    }
+}
+// Ensure class conforms to NodeConstructor pattern
+assertNodeConstructor(Open);

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

@@ -0,0 +1,23 @@
+import type { GenericParseResult } from '../../genericParse.mjs';
+import { Value } from '../Value.mjs';
+import { Node } from '../Node.mjs';
+/**
+ * Represents an Option node that sets a Beancount configuration option.
+ * Option directives configure various aspects of Beancount's behavior.
+ */
+export declare class Option extends Node {
+    /** @inheritdoc */
+    type: "option";
+    /** The option name */
+    name: string;
+    /** The option value */
+    value: Value;
+    /**
+     * Creates an Option instance from a generic parse result.
+     * @param genericParseResult - The parsed option node data
+     * @returns A new Option instance
+     */
+    static fromGenericParseResult(genericParseResult: GenericParseResult): Option;
+    /** @inheritdoc */
+    toString(): string;
+}

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

@@ -0,0 +1,32 @@
+import { parseString, Value } from '../Value.mjs';
+import { stringAwareParseLine } from '../../utils/stringAwareParseLine.mjs';
+import { assertNodeConstructor, Node } from '../Node.mjs';
+/**
+ * Represents an Option node that sets a Beancount configuration option.
+ * Option directives configure various aspects of Beancount's behavior.
+ */
+export class Option extends Node {
+    constructor() {
+        super(...arguments);
+        /** @inheritdoc */
+        this.type = 'option';
+    }
+    /**
+     * Creates an Option instance from a generic parse result.
+     * @param genericParseResult - The parsed option node data
+     * @returns A new Option instance
+     */
+    static fromGenericParseResult(genericParseResult) {
+        const [name, value] = stringAwareParseLine(genericParseResult.header);
+        return new Option({
+            name: parseString(name),
+            value: Value.fromString(value),
+        });
+    }
+    /** @inheritdoc */
+    toString() {
+        return `${this.type} "${this.name}" ${this.value.toString()}`;
+    }
+}
+// Ensure class conforms to NodeConstructor pattern
+assertNodeConstructor(Option);

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

@@ -0,0 +1,22 @@
+import type { GenericParseResultWithDate } from '../../genericParse.mjs';
+import { DatedNode } from '../DatedNode.mjs';
+/**
+ * Represents a Pad node that automatically balances accounts.
+ * Pad directives insert transactions to bring an account to a specific balance.
+ */
+export declare class Pad extends DatedNode {
+    /** @inheritdoc */
+    type: "pad";
+    /** The account to be padded/balanced */
+    account: string;
+    /** The source account to use for padding */
+    accountPad: string;
+    /**
+     * Creates a Pad instance from a generic parse result.
+     * @param genericParseResult - The parsed pad node data
+     * @returns A new Pad instance
+     */
+    static fromGenericParseResult(genericParseResult: GenericParseResultWithDate): Pad;
+    /** @inheritdoc */
+    toString(): string;
+}

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

@@ -0,0 +1,33 @@
+import { assertNodeConstructor } from '../Node.mjs';
+import { DatedNode } from '../DatedNode.mjs';
+import { simpleParseLine } from '../../utils/simpleParseLine.mjs';
+/**
+ * Represents a Pad node that automatically balances accounts.
+ * Pad directives insert transactions to bring an account to a specific balance.
+ */
+export class Pad extends DatedNode {
+    constructor() {
+        super(...arguments);
+        /** @inheritdoc */
+        this.type = 'pad';
+    }
+    /**
+     * Creates a Pad instance from a generic parse result.
+     * @param genericParseResult - The parsed pad node data
+     * @returns A new Pad instance
+     */
+    static fromGenericParseResult(genericParseResult) {
+        const [account, accountPad] = simpleParseLine(genericParseResult.header);
+        return new Pad({
+            ...genericParseResult.props,
+            account,
+            accountPad,
+        });
+    }
+    /** @inheritdoc */
+    toString() {
+        return `${this.getDateTypePrefix()} ${this.account} ${this.accountPad}${this.getMetaDataString()}`;
+    }
+}
+// Ensure class conforms to NodeConstructor pattern
+assertNodeConstructor(Pad);

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

@@ -0,0 +1,22 @@
+import type { GenericParseResult } from '../../genericParse.mjs';
+import { Node } from '../Node.mjs';
+/**
+ * Represents a Plugin node that loads a Beancount plugin.
+ * Plugin directives enable plugins to process the ledger.
+ */
+export declare class Plugin extends Node {
+    /** @inheritdoc */
+    type: "plugin";
+    /** The Python module name of the plugin */
+    moduleName: string;
+    /** Optional configuration string for the plugin */
+    config?: string;
+    /**
+     * Creates a Plugin instance from a generic parse result.
+     * @param genericParseResult - The parsed plugin node data
+     * @returns A new Plugin instance
+     */
+    static fromGenericParseResult(genericParseResult: GenericParseResult): Plugin;
+    /** @inheritdoc */
+    toString(): string;
+}

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

@@ -0,0 +1,36 @@
+import { parseString } from '../Value.mjs';
+import { stringAwareParseLine } from '../../utils/stringAwareParseLine.mjs';
+import { assertNodeConstructor, Node } from '../Node.mjs';
+/**
+ * Represents a Plugin node that loads a Beancount plugin.
+ * Plugin directives enable plugins to process the ledger.
+ */
+export class Plugin extends Node {
+    constructor() {
+        super(...arguments);
+        /** @inheritdoc */
+        this.type = 'plugin';
+    }
+    /**
+     * Creates a Plugin instance from a generic parse result.
+     * @param genericParseResult - The parsed plugin node data
+     * @returns A new Plugin instance
+     */
+    static fromGenericParseResult(genericParseResult) {
+        const [moduleName, config] = stringAwareParseLine(genericParseResult.header);
+        return new Plugin({
+            moduleName: parseString(moduleName),
+            config: config ? parseString(config) : undefined,
+        });
+    }
+    /** @inheritdoc */
+    toString() {
+        const parts = [`${this.type} "${this.moduleName}"`];
+        if (this.config !== undefined) {
+            parts.push(`"${this.config}"`);
+        }
+        return parts.join(' ');
+    }
+}
+// Ensure class conforms to NodeConstructor pattern
+assertNodeConstructor(Plugin);

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

@@ -0,0 +1,21 @@
+import type { GenericParseResult } from '../../genericParse.mjs';
+import { Node } from '../Node.mjs';
+import { Tag } from './Transaction/Tag.mjs';
+/**
+ * Represents a Poptag node that removes a tag from the tag stack.
+ * Transactions after this will no longer inherit the popped tag.
+ */
+export declare class Poptag extends Node {
+    /** @inheritdoc */
+    type: "poptag";
+    /** The tag being popped from the stack */
+    tag: Tag;
+    /**
+     * Creates a Poptag instance from a generic parse result.
+     * @param genericParseResult - The parsed poptag node data
+     * @returns A new Poptag instance
+     */
+    static fromGenericParseResult(genericParseResult: GenericParseResult): Poptag;
+    /** @inheritdoc */
+    toString(): string;
+}

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

@@ -0,0 +1,34 @@
+import { simpleParseLine } from '../../utils/simpleParseLine.mjs';
+import { assertNodeConstructor, Node } from '../Node.mjs';
+import { Tag } from './Transaction/Tag.mjs';
+/**
+ * Represents a Poptag node that removes a tag from the tag stack.
+ * Transactions after this will no longer inherit the popped tag.
+ */
+export class Poptag extends Node {
+    constructor() {
+        super(...arguments);
+        /** @inheritdoc */
+        this.type = 'poptag';
+    }
+    /**
+     * Creates a Poptag instance from a generic parse result.
+     * @param genericParseResult - The parsed poptag node data
+     * @returns A new Poptag instance
+     */
+    static fromGenericParseResult(genericParseResult) {
+        const [tagContent] = simpleParseLine(genericParseResult.header);
+        return new Poptag({
+            tag: new Tag({
+                content: tagContent.trim().replace(/^#/, ''),
+                fromStack: true,
+            }),
+        });
+    }
+    /** @inheritdoc */
+    toString() {
+        return `poptag #${this.tag.content}`;
+    }
+}
+// Ensure class conforms to NodeConstructor pattern
+assertNodeConstructor(Poptag);