beancount 0.0.1

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

@@ -0,0 +1,23 @@
+import { assertEntryConstructor } from '../Entry.mjs';
+import { DateEntry } from '../DateEntry.mjs';
+import { parseString, Value } from '../Value.mjs';
+import { stringAwareParseLine } from '../../utils/stringAwareParseLine.mjs';
+export class Event extends DateEntry {
+    constructor() {
+        super(...arguments);
+        this.type = 'event';
+    }
+    static fromGenericParseResult(genericParseResult) {
+        const [name, value] = stringAwareParseLine(genericParseResult.header);
+        return new Event({
+            ...genericParseResult.props,
+            name: parseString(name),
+            value: Value.fromString(value),
+        });
+    }
+    toString() {
+        return `${this.getDateTypePrefix()} "${this.name}" ${this.value.toString()}${this.getMetaDataString()}`;
+    }
+}
+// Ensure class conforms to EntryConstructor pattern
+assertEntryConstructor(Event);

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

@@ -0,0 +1,8 @@
+import type { GenericParseResult } from '../../genericParse.mjs';
+import { Entry } from '../Entry.mjs';
+export declare class Include extends Entry {
+    type: "include";
+    filename: string;
+    static fromGenericParseResult(genericParseResult: GenericParseResult): Include;
+    toString(): string;
+}

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

@@ -0,0 +1,20 @@
+import { parseString } from '../Value.mjs';
+import { stringAwareParseLine } from '../../utils/stringAwareParseLine.mjs';
+import { assertEntryConstructor, Entry } from '../Entry.mjs';
+export class Include extends Entry {
+    constructor() {
+        super(...arguments);
+        this.type = 'include';
+    }
+    static fromGenericParseResult(genericParseResult) {
+        const [filename] = stringAwareParseLine(genericParseResult.header);
+        return new Include({
+            filename: parseString(filename),
+        });
+    }
+    toString() {
+        return `${this.type} "${this.filename}"`;
+    }
+}
+// Ensure class conforms to EntryConstructor pattern
+assertEntryConstructor(Include);

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

@@ -0,0 +1,9 @@
+import type { GenericParseResultWithDate } from '../../genericParse.mjs';
+import { DateEntry } from '../DateEntry.mjs';
+export declare class Note extends DateEntry {
+    type: "note";
+    account: string;
+    description: string;
+    static fromGenericParseResult(genericParseResult: GenericParseResultWithDate): Note;
+    toString(): string;
+}

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

@@ -0,0 +1,23 @@
+import { assertEntryConstructor } from '../Entry.mjs';
+import { DateEntry } from '../DateEntry.mjs';
+import { parseString } from '../Value.mjs';
+import { stringAwareParseLine } from '../../utils/stringAwareParseLine.mjs';
+export class Note extends DateEntry {
+    constructor() {
+        super(...arguments);
+        this.type = 'note';
+    }
+    static fromGenericParseResult(genericParseResult) {
+        const [account, description] = stringAwareParseLine(genericParseResult.header);
+        return new Note({
+            ...genericParseResult.props,
+            account,
+            description: parseString(description),
+        });
+    }
+    toString() {
+        return `${this.getDateTypePrefix()} ${this.account} "${this.description}"${this.getMetaDataString()}`;
+    }
+}
+// Ensure class conforms to EntryConstructor pattern
+assertEntryConstructor(Note);

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

@@ -0,0 +1,12 @@
+import type { GenericParseResultWithDate } from '../../genericParse.mjs';
+import { FormatOptions } from '../Entry.mjs';
+import { DateEntry } from '../DateEntry.mjs';
+export declare class Open extends DateEntry {
+    type: "open";
+    account: string;
+    constraintCurrencies?: string[];
+    bookingMethod?: string;
+    static fromGenericParseResult(genericParseResult: GenericParseResultWithDate): Open;
+    toString(): string;
+    toFormattedString(formatOptions: FormatOptions): string;
+}

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

@@ -0,0 +1,53 @@
+import { assertEntryConstructor } from '../Entry.mjs';
+import { DateEntry } from '../DateEntry.mjs';
+import { simpleParseLine } from '../../utils/simpleParseLine.mjs';
+import { parseString } from '../Value.mjs';
+export class Open extends DateEntry {
+    constructor() {
+        super(...arguments);
+        this.type = 'open';
+    }
+    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,
+        });
+    }
+    toString() {
+        return this.toFormattedString({ currencyColumn: 0 });
+    }
+    toFormattedString(formatOptions) {
+        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 EntryConstructor pattern
+assertEntryConstructor(Open);

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

@@ -0,0 +1,10 @@
+import type { GenericParseResult } from '../../genericParse.mjs';
+import { Value } from '../Value.mjs';
+import { Entry } from '../Entry.mjs';
+export declare class Option extends Entry {
+    type: "option";
+    name: string;
+    value: Value;
+    static fromGenericParseResult(genericParseResult: GenericParseResult): Option;
+    toString(): string;
+}

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

@@ -0,0 +1,21 @@
+import { parseString, Value } from '../Value.mjs';
+import { stringAwareParseLine } from '../../utils/stringAwareParseLine.mjs';
+import { assertEntryConstructor, Entry } from '../Entry.mjs';
+export class Option extends Entry {
+    constructor() {
+        super(...arguments);
+        this.type = 'option';
+    }
+    static fromGenericParseResult(genericParseResult) {
+        const [name, value] = stringAwareParseLine(genericParseResult.header);
+        return new Option({
+            name: parseString(name),
+            value: Value.fromString(value),
+        });
+    }
+    toString() {
+        return `${this.type} "${this.name}" ${this.value.toString()}`;
+    }
+}
+// Ensure class conforms to EntryConstructor pattern
+assertEntryConstructor(Option);

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

@@ -0,0 +1,9 @@
+import type { GenericParseResultWithDate } from '../../genericParse.mjs';
+import { DateEntry } from '../DateEntry.mjs';
+export declare class Pad extends DateEntry {
+    type: "pad";
+    account: string;
+    accountPad: string;
+    static fromGenericParseResult(genericParseResult: GenericParseResultWithDate): Pad;
+    toString(): string;
+}

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

@@ -0,0 +1,22 @@
+import { assertEntryConstructor } from '../Entry.mjs';
+import { DateEntry } from '../DateEntry.mjs';
+import { simpleParseLine } from '../../utils/simpleParseLine.mjs';
+export class Pad extends DateEntry {
+    constructor() {
+        super(...arguments);
+        this.type = 'pad';
+    }
+    static fromGenericParseResult(genericParseResult) {
+        const [account, accountPad] = simpleParseLine(genericParseResult.header);
+        return new Pad({
+            ...genericParseResult.props,
+            account,
+            accountPad,
+        });
+    }
+    toString() {
+        return `${this.getDateTypePrefix()} ${this.account} ${this.accountPad}${this.getMetaDataString()}`;
+    }
+}
+// Ensure class conforms to EntryConstructor pattern
+assertEntryConstructor(Pad);

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

@@ -0,0 +1,9 @@
+import type { GenericParseResult } from '../../genericParse.mjs';
+import { Entry } from '../Entry.mjs';
+export declare class Plugin extends Entry {
+    type: "plugin";
+    moduleName: string;
+    config?: string;
+    static fromGenericParseResult(genericParseResult: GenericParseResult): Plugin;
+    toString(): string;
+}

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

@@ -0,0 +1,25 @@
+import { parseString } from '../Value.mjs';
+import { stringAwareParseLine } from '../../utils/stringAwareParseLine.mjs';
+import { assertEntryConstructor, Entry } from '../Entry.mjs';
+export class Plugin extends Entry {
+    constructor() {
+        super(...arguments);
+        this.type = 'plugin';
+    }
+    static fromGenericParseResult(genericParseResult) {
+        const [moduleName, config] = stringAwareParseLine(genericParseResult.header);
+        return new Plugin({
+            moduleName: parseString(moduleName),
+            config: config ? parseString(config) : undefined,
+        });
+    }
+    toString() {
+        const parts = [`${this.type} "${this.moduleName}"`];
+        if (this.config !== undefined) {
+            parts.push(`"${this.config}"`);
+        }
+        return parts.join(' ');
+    }
+}
+// Ensure class conforms to EntryConstructor pattern
+assertEntryConstructor(Plugin);

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

@@ -0,0 +1,9 @@
+import type { GenericParseResult } from '../../genericParse.mjs';
+import { Entry } from '../Entry.mjs';
+import { Tag } from './Transaction/Tag.mjs';
+export declare class Poptag extends Entry {
+    type: "poptag";
+    tag: Tag;
+    static fromGenericParseResult(genericParseResult: GenericParseResult): Poptag;
+    toString(): string;
+}

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

@@ -0,0 +1,23 @@
+import { simpleParseLine } from '../../utils/simpleParseLine.mjs';
+import { assertEntryConstructor, Entry } from '../Entry.mjs';
+import { Tag } from './Transaction/Tag.mjs';
+export class Poptag extends Entry {
+    constructor() {
+        super(...arguments);
+        this.type = 'poptag';
+    }
+    static fromGenericParseResult(genericParseResult) {
+        const [tagContent] = simpleParseLine(genericParseResult.header);
+        return new Poptag({
+            tag: new Tag({
+                content: tagContent.trim().replace(/^#/, ''),
+                fromStack: true,
+            }),
+        });
+    }
+    toString() {
+        return `poptag #${this.tag.content}`;
+    }
+}
+// Ensure class conforms to EntryConstructor pattern
+assertEntryConstructor(Poptag);

package/build/src/classes/entryTypes/Price.d.mts

@@ -0,0 +1,11 @@
+import type { GenericParseResultWithDate } from '../../genericParse.mjs';
+import { DateEntry } from '../DateEntry.mjs';
+export declare class Price extends DateEntry {
+    type: "price";
+    commodity: string;
+    currency: string;
+    amount: string;
+    get price(): string | undefined;
+    static fromGenericParseResult(genericParseResult: GenericParseResultWithDate): Price;
+    toString(): string;
+}

package/build/src/classes/entryTypes/Price.mjs

@@ -0,0 +1,27 @@
+import { assertEntryConstructor } from '../Entry.mjs';
+import { DateEntry } from '../DateEntry.mjs';
+import { simpleParseLine } from '../../utils/simpleParseLine.mjs';
+import { formatPrice } from '../../utils/formatPrice.mjs';
+export class Price extends DateEntry {
+    constructor() {
+        super(...arguments);
+        this.type = 'price';
+    }
+    get price() {
+        return formatPrice(this.amount, this.currency);
+    }
+    static fromGenericParseResult(genericParseResult) {
+        const [commodity, amount, currency] = simpleParseLine(genericParseResult.header);
+        return new Price({
+            ...genericParseResult.props,
+            commodity,
+            currency,
+            amount,
+        });
+    }
+    toString() {
+        return `${this.getDateTypePrefix()} ${this.commodity} ${this.amount} ${this.currency}${this.getMetaDataString()}`;
+    }
+}
+// Ensure class conforms to EntryConstructor pattern
+assertEntryConstructor(Price);

package/build/src/classes/entryTypes/Pushtag.d.mts

@@ -0,0 +1,9 @@
+import type { GenericParseResult } from '../../genericParse.mjs';
+import { Entry } from '../Entry.mjs';
+import { Tag } from './Transaction/Tag.mjs';
+export declare class Pushtag extends Entry {
+    type: "pushtag";
+    tag: Tag;
+    static fromGenericParseResult(genericParseResult: GenericParseResult): Pushtag;
+    toString(): string;
+}

package/build/src/classes/entryTypes/Pushtag.mjs

@@ -0,0 +1,23 @@
+import { simpleParseLine } from '../../utils/simpleParseLine.mjs';
+import { assertEntryConstructor, Entry } from '../Entry.mjs';
+import { Tag } from './Transaction/Tag.mjs';
+export class Pushtag extends Entry {
+    constructor() {
+        super(...arguments);
+        this.type = 'pushtag';
+    }
+    static fromGenericParseResult(genericParseResult) {
+        const [tagContent] = simpleParseLine(genericParseResult.header);
+        return new Pushtag({
+            tag: new Tag({
+                content: tagContent.trim().replace(/^#/, ''),
+                fromStack: true,
+            }),
+        });
+    }
+    toString() {
+        return `${this.type} #${this.tag.content}`;
+    }
+}
+// Ensure class conforms to EntryConstructor pattern
+assertEntryConstructor(Pushtag);

package/build/src/classes/entryTypes/Query.d.mts

@@ -0,0 +1,9 @@
+import type { GenericParseResultWithDate } from '../../genericParse.mjs';
+import { DateEntry } from '../DateEntry.mjs';
+export declare class Query extends DateEntry {
+    type: "query";
+    name: string;
+    sqlContents: string;
+    static fromGenericParseResult(genericParseResult: GenericParseResultWithDate): Query;
+    toString(): string;
+}

package/build/src/classes/entryTypes/Query.mjs

@@ -0,0 +1,23 @@
+import { assertEntryConstructor } from '../Entry.mjs';
+import { DateEntry } from '../DateEntry.mjs';
+import { stringAwareParseLine } from '../../utils/stringAwareParseLine.mjs';
+import { parseString } from '../Value.mjs';
+export class Query extends DateEntry {
+    constructor() {
+        super(...arguments);
+        this.type = 'query';
+    }
+    static fromGenericParseResult(genericParseResult) {
+        const [name, sqlContents] = stringAwareParseLine(genericParseResult.header);
+        return new Query({
+            ...genericParseResult.props,
+            name: parseString(name),
+            sqlContents: parseString(sqlContents).trim(),
+        });
+    }
+    toString() {
+        return `${this.getDateTypePrefix()} "${this.name}" "${this.sqlContents}"${this.getMetaDataString()}`;
+    }
+}
+// Ensure class conforms to EntryConstructor pattern
+assertEntryConstructor(Query);

package/build/src/classes/entryTypes/Transaction/Posting.d.mts

@@ -0,0 +1,16 @@
+import { FormatOptions } from '../../Entry.mjs';
+export declare class Posting {
+    flag?: string;
+    account: string;
+    amount?: string;
+    currency?: string;
+    cost?: string;
+    priceCurrency?: string;
+    priceAmount?: string;
+    comment?: string;
+    constructor(obj: Record<string, unknown>);
+    static fromGenericParseResult(unparsedline: string): Posting;
+    get price(): string | undefined;
+    toString(): string;
+    toFormattedString(formatOptions: FormatOptions): string;
+}

package/build/src/classes/entryTypes/Transaction/Posting.mjs

@@ -0,0 +1,53 @@
+import { formatPrice } from '../../../utils/formatPrice.mjs';
+export class Posting {
+    constructor(obj) {
+        Object.assign(this, obj);
+    }
+    static fromGenericParseResult(unparsedline) {
+        // [Flag] Account Amount [{Cost}] [@ Price]
+        const matches = /^(?:([^ ]) )?([^ ]*)(?: +([^A-Z]*) +(\w+)(?: +{(.*)})?(?: +@ +(?:(\d+\.?\d*) (\w+)))?)?( *;.*)?$/.exec(unparsedline);
+        if (!matches) {
+            throw new Error('Could not parse posting');
+        }
+        const [, flag, account, amount, currency, cost, priceAmount, priceCurrency, comment,] = matches;
+        return new Posting({
+            flag: flag,
+            account: account?.trim(),
+            amount: amount?.trim(),
+            currency: currency?.trim(),
+            cost: cost?.trim(),
+            priceAmount: priceAmount?.trim(),
+            priceCurrency: priceCurrency?.trim(),
+            comment: comment?.replace(/^ *;/, '').trim(),
+        });
+    }
+    get price() {
+        return formatPrice(this.amount, this.currency, this.cost, this.priceAmount, this.priceCurrency);
+    }
+    toString() {
+        return this.toFormattedString({ currencyColumn: 0 });
+    }
+    toFormattedString(formatOptions) {
+        const parts = [];
+        if (this.flag !== undefined) {
+            parts.push(this.flag);
+        }
+        parts.push(this.account);
+        if (this.price !== undefined) {
+            const paddingLength = formatOptions.currencyColumn -
+                parts.join(' ').length -
+                this.amount.length -
+                2 - // indent
+                2 - // spacing
+                2; // not sure what this is for
+            if (paddingLength > 0) {
+                parts.push(' '.repeat(paddingLength));
+            }
+            parts.push(this.price);
+        }
+        if (this.comment !== undefined) {
+            parts.push(';', this.comment);
+        }
+        return parts.join(' ');
+    }
+}

package/build/src/classes/entryTypes/Transaction/Tag.d.mts

@@ -0,0 +1,9 @@
+export declare class Tag {
+    content: string;
+    fromStack: boolean;
+    constructor(obj: {
+        content: string;
+        fromStack: boolean;
+    });
+    toString(): string;
+}

package/build/src/classes/entryTypes/Transaction/Tag.mjs

@@ -0,0 +1,11 @@
+export class Tag {
+    constructor(obj) {
+        Object.assign(this, obj);
+    }
+    toString() {
+        if (this.fromStack) {
+            return '';
+        }
+        return `#${this.content}`;
+    }
+}

package/build/src/classes/entryTypes/Transaction/index.d.mts

@@ -0,0 +1,17 @@
+import type { GenericParseResultTransaction } from '../../../genericParse.mjs';
+import { FormatOptions } from '../../Entry.mjs';
+import { DateEntry } from '../../DateEntry.mjs';
+import { Posting } from './Posting.mjs';
+import { Tag } from './Tag.mjs';
+export declare class Transaction extends DateEntry {
+    type: "transaction";
+    payee: string;
+    narration?: string;
+    flag?: string;
+    postings: Posting[];
+    links: string[];
+    tags: Tag[];
+    static fromGenericParseResult(genericParseResult: GenericParseResultTransaction): Transaction;
+    toString(): string;
+    toFormattedString(formatOptions: FormatOptions): string;
+}

package/build/src/classes/entryTypes/Transaction/index.mjs

@@ -0,0 +1,102 @@
+import { assertEntryConstructor } from '../../Entry.mjs';
+import { DateEntry } from '../../DateEntry.mjs';
+import { stringAwareParseLine } from '../../../utils/stringAwareParseLine.mjs';
+import { parseString } from '../../Value.mjs';
+import { parseMetadata } from '../../../utils/parseMetadata.mjs';
+import { Posting } from './Posting.mjs';
+import { Tag } from './Tag.mjs';
+const AccountTypes = ['Assets', 'Liabilities', 'Equity', 'Income', 'Expenses'];
+const getStringLinksAndTags = (input) => {
+    let links = [];
+    let tags = [];
+    // default if no narration
+    let strRemaining = '';
+    let linksAndTags = input;
+    // check for narration
+    const match = /^(".*")(.*)/.exec(input);
+    if (match) {
+        // strRemaining = narration
+        strRemaining = match[1];
+        linksAndTags = match[2];
+    }
+    const linksMatch = linksAndTags.matchAll(/\^([\w-]*)/g);
+    if (linksMatch) {
+        links = linksMatch.map((m) => m[1]).toArray();
+    }
+    const tagsMatch = linksAndTags.matchAll(/#([\w-]*)/g);
+    if (tagsMatch) {
+        tags = tagsMatch
+            .map((m) => new Tag({ content: m[1], fromStack: false }))
+            .toArray();
+    }
+    return { links, tags, string: strRemaining };
+};
+export class Transaction extends DateEntry {
+    constructor() {
+        super(...arguments);
+        this.type = 'transaction';
+    }
+    static fromGenericParseResult(genericParseResult) {
+        // eslint-disable-next-line prefer-const
+        let [payee, ...rest] = stringAwareParseLine(genericParseResult.header);
+        let links = [];
+        let tags = [];
+        let narration;
+        if (rest.length === 0) {
+            // no narration
+            const payeeParsed = getStringLinksAndTags(payee);
+            payee = payeeParsed.string;
+            links = payeeParsed.links;
+            tags = payeeParsed.tags;
+        }
+        else {
+            const payeeParsed = getStringLinksAndTags(rest.join(' '));
+            narration = payeeParsed.string;
+            links = payeeParsed.links;
+            tags = payeeParsed.tags;
+        }
+        const unparsedPostings = [];
+        const unparsedMetadata = [];
+        genericParseResult.body.forEach((line) => {
+            //                           V remove flag,       V get account type
+            const accountType = line.replace(/^[^ ] /, '').split(':')[0];
+            if (AccountTypes.includes(accountType)) {
+                unparsedPostings.push(line);
+            }
+            else {
+                unparsedMetadata.push(line);
+            }
+        });
+        const postings = unparsedPostings.map((p) => Posting.fromGenericParseResult(p));
+        const metadata = parseMetadata(unparsedMetadata);
+        return new Transaction({
+            ...genericParseResult.props,
+            payee: parseString(payee),
+            narration: narration ? parseString(narration) : undefined,
+            postings,
+            metadata,
+            links,
+            tags,
+        });
+    }
+    toString() {
+        return this.toFormattedString({ currencyColumn: 0 });
+    }
+    toFormattedString(formatOptions) {
+        const firstLine = [
+            this.date.toJSON(),
+            this.flag ?? 'txn',
+            `"${this.payee}"`,
+        ];
+        if (this.narration !== undefined) {
+            firstLine.push(`"${this.narration}"`);
+        }
+        firstLine.push(...this.links.map((l) => `^${l}`));
+        firstLine.push(...this.tags.map((t) => t.toString()));
+        const lines = [firstLine.join(' ') + this.getMetaDataString()];
+        lines.push(...this.postings.map((p) => `  ${p.toFormattedString(formatOptions)}`));
+        return lines.join('\n');
+    }
+}
+// Ensure class conforms to EntryConstructor pattern
+assertEntryConstructor(Transaction);

package/build/src/classes/entryTypes/Transaction.d.mts

@@ -0,0 +1,12 @@
+import type { GenericParseResultTransaction } from '../../genericParse.mjs';
+import { DateEntry } from '../DateEntry.mjs';
+import { Posting } from '../Posting.mjs';
+export declare class Transaction extends DateEntry {
+    type: "transaction";
+    payee: string;
+    narration?: string;
+    flag?: string;
+    postings: Posting[];
+    static fromGenericParseResult(genericParseResult: GenericParseResultTransaction): Transaction;
+    toString(): string;
+}