@rustledger/wasm 1.0.0-rc.5

package/README.md

@@ -0,0 +1,173 @@
+# rustledger
+
+A pure Rust implementation of [Beancount](https://beancount.github.io/), the double-entry bookkeeping language.
+
+[![Crates.io](https://img.shields.io/crates/v/rustledger.svg)](https://crates.io/crates/rustledger)
+[![Documentation](https://docs.rs/rustledger/badge.svg)](https://docs.rs/rustledger)
+[![License](https://img.shields.io/crates/l/rustledger.svg)](LICENSE)
+
+## Features
+
+- **Pure Rust** - No Python dependencies, compiles to native and WebAssembly
+- **Full Beancount Syntax** - Parses all directive types with error recovery
+- **Drop-in Replacement** - Compatible CLI commands for Python beancount users
+- **7 Booking Methods** - STRICT, FIFO, LIFO, HIFO, AVERAGE, and more
+- **14 Built-in Plugins** - implicit_prices, auto_accounts, pedantic, etc.
+- **BQL Query Engine** - SQL-like queries on your ledger
+- **Fast** - 10x faster than Python beancount
+
+## Installation
+
+### CLI Tools
+
+```bash
+# Install with bean-* compatibility aliases (default)
+cargo install rustledger
+
+# Install only rledger-* commands (no bean-* aliases)
+cargo install rustledger --no-default-features
+```
+
+### As a Library
+
+```bash
+cargo add rustledger-core rustledger-parser rustledger-loader
+```
+
+## CLI Usage
+
+```bash
+# Validate a ledger file
+rledger-check ledger.beancount
+
+# Format a ledger file
+rledger-format ledger.beancount
+rledger-format --in-place ledger.beancount
+
+# Run a BQL query (one-shot or interactive)
+rledger-query ledger.beancount "SELECT account, SUM(position) GROUP BY account"
+rledger-query ledger.beancount   # Interactive shell with readline/history
+
+# Generate reports
+rledger-report ledger.beancount balances
+rledger-report ledger.beancount accounts
+rledger-report ledger.beancount stats
+
+# Debugging tools
+rledger-doctor ledger.beancount context 42        # Show context around line 42
+rledger-doctor ledger.beancount linked ^link-name # Find linked transactions
+rledger-doctor ledger.beancount missing           # Find missing Open directives
+rledger-doctor ledger.beancount stats             # Ledger statistics
+
+# Use plugins
+rledger-check --native-plugin auto_accounts ledger.beancount
+rledger-check --native-plugin pedantic ledger.beancount
+```
+
+### Python Beancount Compatibility
+
+For users migrating from Python beancount, the `bean-*` commands are also available:
+
+```bash
+bean-check ledger.beancount
+bean-format ledger.beancount
+bean-query ledger.beancount "SELECT ..."
+bean-report ledger.beancount balances
+bean-doctor ledger.beancount context 42
+```
+
+## Library Usage
+
+```rust
+use rustledger_loader::load;
+
+fn main() -> anyhow::Result<()> {
+    let result = load("ledger.beancount")?;
+
+    println!("Loaded {} directives", result.directives.len());
+
+    for error in &result.errors {
+        eprintln!("{}", error);
+    }
+
+    Ok(())
+}
+```
+
+## Crates
+
+| Crate | Description |
+|-------|-------------|
+| [`rustledger-core`](crates/rustledger-core) | Core types: Amount, Position, Inventory, Directives |
+| [`rustledger-parser`](crates/rustledger-parser) | Lexer and parser with error recovery |
+| [`rustledger-loader`](crates/rustledger-loader) | File loading, includes, options |
+| [`rustledger-booking`](crates/rustledger-booking) | Interpolation and booking engine |
+| [`rustledger-validate`](crates/rustledger-validate) | 30 validation error codes |
+| [`rustledger-query`](crates/rustledger-query) | BQL query engine |
+| [`rustledger-plugin`](crates/rustledger-plugin) | Native and WASM plugin system |
+| [`rustledger`](crates/rustledger) | Command-line tools |
+| [`rustledger-wasm`](crates/rustledger-wasm) | WebAssembly library target |
+
+## Supported Features
+
+### Parser
+
+- All 12 directive types (transaction, balance, open, close, etc.)
+- Cost specifications: `{100 USD}`, `{{100 USD}}`, `{100 # 5 USD}`, `{*}`
+- Price annotations: `@ 100 USD`, `@@ 1000 USD`
+- Arithmetic expressions: `(40.00/3 + 5) USD`
+- Multi-line strings: `"""..."""`
+- All transaction flags: `* ! P S T C U R M`
+- Metadata with 6 value types
+- Error recovery (continues parsing after errors)
+
+### Booking Methods
+
+- `STRICT` - Lots must match exactly (with total match exception)
+- `STRICT_WITH_SIZE` - Exact-size matches accept oldest lot
+- `FIFO` - First in, first out
+- `LIFO` - Last in, first out
+- `HIFO` - Highest cost first
+- `AVERAGE` - Average cost basis
+- `NONE` - No cost tracking
+
+### Built-in Plugins
+
+| Plugin | Description |
+|--------|-------------|
+| `implicit_prices` | Generate price entries from costs |
+| `check_commodity` | Validate commodity declarations |
+| `auto_accounts` | Auto-generate Open directives |
+| `leafonly` | Error on non-leaf postings |
+| `noduplicates` | Hash-based duplicate detection |
+| `onecommodity` | Single commodity per account |
+| `unique_prices` | One price per day per pair |
+| `check_closing` | Zero balance assertion on closing |
+| `close_tree` | Close descendant accounts |
+| `coherent_cost` | Enforce cost OR price consistency |
+| `sellgains` | Cross-check gains against sales |
+| `pedantic` | Enable all strict validations |
+| `unrealized` | Calculate unrealized gains |
+
+### Options (28 supported)
+
+- Account prefixes (`name_assets`, `name_liabilities`, etc.)
+- Equity accounts (`account_previous_balances`, etc.)
+- Tolerance settings (`inferred_tolerance_default` with wildcards)
+- Booking method, documents directories, and more
+
+## Compatibility
+
+rustledger is compatible with Python beancount. It can parse and validate any valid beancount file. The `bean-*` command aliases are included by default for easy migration.
+
+## Performance
+
+Benchmarks show rustledger is approximately 10x faster than Python beancount for parsing and validation.
+
+## License
+
+This project is licensed under the GNU General Public License v3.0 - see the [LICENSE](LICENSE) file for details.
+
+## Contributing
+
+Contributions are welcome! Please feel free to submit a Pull Request.

package/package.json

@@ -0,0 +1,32 @@
+{
+  "name": "@rustledger/wasm",
+  "type": "module",
+  "collaborators": [
+    "Rustledger Contributors"
+  ],
+  "description": "Beancount WebAssembly bindings for JavaScript/TypeScript",
+  "version": "1.0.0-rc.5",
+  "license": "GPL-3.0",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/rustledger/rustledger"
+  },
+  "files": [
+    "rustledger_wasm_bg.wasm",
+    "rustledger_wasm.js",
+    "rustledger_wasm.d.ts"
+  ],
+  "main": "rustledger_wasm.js",
+  "homepage": "https://rustledger.github.io",
+  "types": "rustledger_wasm.d.ts",
+  "sideEffects": [
+    "./snippets/*"
+  ],
+  "keywords": [
+    "beancount",
+    "accounting",
+    "finance",
+    "double-entry",
+    "ledger"
+  ]
+}

package/rustledger_wasm.d.ts

@@ -0,0 +1,413 @@
+/* tslint:disable */
+/* eslint-disable */
+
+/** Error severity level. */
+export type Severity = 'error' | 'warning';
+
+/** Error with source location information. */
+export interface BeancountError {
+    message: string;
+    line?: number;
+    column?: number;
+    severity: Severity;
+}
+
+/** Amount with number and currency. */
+export interface Amount {
+    number: string;
+    currency: string;
+}
+
+/** Posting cost specification. */
+export interface PostingCost {
+    number_per?: string;
+    currency?: string;
+    date?: string;
+    label?: string;
+}
+
+/** A posting within a transaction. */
+export interface Posting {
+    account: string;
+    units?: Amount;
+    cost?: PostingCost;
+    price?: Amount;
+}
+
+/** Base directive with date. */
+interface BaseDirective {
+    date: string;
+}
+
+/** Transaction directive. */
+export interface TransactionDirective extends BaseDirective {
+    type: 'transaction';
+    flag: string;
+    payee?: string;
+    narration?: string;
+    tags: string[];
+    links: string[];
+    postings: Posting[];
+}
+
+/** Balance assertion directive. */
+export interface BalanceDirective extends BaseDirective {
+    type: 'balance';
+    account: string;
+    amount: Amount;
+}
+
+/** Open account directive. */
+export interface OpenDirective extends BaseDirective {
+    type: 'open';
+    account: string;
+    currencies: string[];
+    booking?: string;
+}
+
+/** Close account directive. */
+export interface CloseDirective extends BaseDirective {
+    type: 'close';
+    account: string;
+}
+
+/** All directive types. */
+export type Directive =
+    | TransactionDirective
+    | BalanceDirective
+    | OpenDirective
+    | CloseDirective
+    | { type: 'commodity'; date: string; currency: string }
+    | { type: 'pad'; date: string; account: string; source_account: string }
+    | { type: 'event'; date: string; event_type: string; value: string }
+    | { type: 'note'; date: string; account: string; comment: string }
+    | { type: 'document'; date: string; account: string; path: string }
+    | { type: 'price'; date: string; currency: string; amount: Amount }
+    | { type: 'query'; date: string; name: string; query_string: string }
+    | { type: 'custom'; date: string; custom_type: string };
+
+/** Ledger options. */
+export interface LedgerOptions {
+    operating_currencies: string[];
+    title?: string;
+}
+
+/** Parsed ledger. */
+export interface Ledger {
+    directives: Directive[];
+    options: LedgerOptions;
+}
+
+/** Result of parsing a Beancount file. */
+export interface ParseResult {
+    ledger?: Ledger;
+    errors: BeancountError[];
+}
+
+/** Result of validation. */
+export interface ValidationResult {
+    valid: boolean;
+    errors: BeancountError[];
+}
+
+/** Cell value in query results. */
+export type CellValue =
+    | null
+    | string
+    | number
+    | boolean
+    | Amount
+    | { units: Amount; cost?: { number: string; currency: string; date?: string; label?: string } }
+    | { positions: Array<{ units: Amount }> }
+    | string[];
+
+/** Result of a BQL query. */
+export interface QueryResult {
+    columns: string[];
+    rows: CellValue[][];
+    errors: BeancountError[];
+}
+
+/** Result of formatting. */
+export interface FormatResult {
+    formatted?: string;
+    errors: BeancountError[];
+}
+
+/** Result of pad expansion. */
+export interface PadResult {
+    directives: Directive[];
+    padding_transactions: Directive[];
+    errors: BeancountError[];
+}
+
+/** Result of running a plugin. */
+export interface PluginResult {
+    directives: Directive[];
+    errors: BeancountError[];
+}
+
+/** Plugin information. */
+export interface PluginInfo {
+    name: string;
+    description: string;
+}
+
+/** BQL completion suggestion. */
+export interface Completion {
+    text: string;
+    category: string;
+    description?: string;
+}
+
+/** Result of BQL completion request. */
+export interface CompletionResult {
+    completions: Completion[];
+    context: string;
+}
+
+/**
+ * A parsed and validated ledger that caches the parse result.
+ * Use this class when you need to perform multiple operations on the same
+ * source without re-parsing each time.
+ */
+export class ParsedLedger {
+    constructor(source: string);
+    free(): void;
+
+    /** Check if the ledger is valid (no parse or validation errors). */
+    isValid(): boolean;
+
+    /** Get all errors (parse + validation). */
+    getErrors(): BeancountError[];
+
+    /** Get parse errors only. */
+    getParseErrors(): BeancountError[];
+
+    /** Get validation errors only. */
+    getValidationErrors(): BeancountError[];
+
+    /** Get the parsed directives. */
+    getDirectives(): Directive[];
+
+    /** Get the ledger options. */
+    getOptions(): LedgerOptions;
+
+    /** Get the number of directives. */
+    directiveCount(): number;
+
+    /** Run a BQL query on this ledger. */
+    query(queryStr: string): QueryResult;
+
+    /** Get account balances (shorthand for query("BALANCES")). */
+    balances(): QueryResult;
+
+    /** Format the ledger source. */
+    format(): FormatResult;
+
+    /** Expand pad directives. */
+    expandPads(): PadResult;
+
+    /** Run a native plugin on this ledger. */
+    runPlugin(pluginName: string): PluginResult;
+}
+
+
+
+export class ParsedLedger {
+  free(): void;
+  [Symbol.dispose](): void;
+  /**
+   * Get all errors (parse + validation).
+   */
+  getErrors(): any;
+  /**
+   * Run a native plugin on this ledger.
+   */
+  runPlugin(plugin_name: string): any;
+  /**
+   * Expand pad directives.
+   */
+  expandPads(): any;
+  /**
+   * Get the ledger options.
+   */
+  getOptions(): any;
+  /**
+   * Get the parsed directives.
+   */
+  getDirectives(): any;
+  /**
+   * Get the number of directives.
+   */
+  directiveCount(): number;
+  /**
+   * Get parse errors only.
+   */
+  getParseErrors(): any;
+  /**
+   * Get validation errors only.
+   */
+  getValidationErrors(): any;
+  /**
+   * Create a new `ParsedLedger` from source text.
+   *
+   * Parses, interpolates, and validates the source. Call `isValid()` to check for errors.
+   */
+  constructor(source: string);
+  /**
+   * Run a BQL query on this ledger.
+   */
+  query(query_str: string): any;
+  /**
+   * Format the ledger source.
+   */
+  format(): any;
+  /**
+   * Get account balances (shorthand for query("BALANCES")).
+   */
+  balances(): any;
+  /**
+   * Check if the ledger is valid (no parse or validation errors).
+   */
+  isValid(): boolean;
+}
+
+/**
+ * Calculate account balances.
+ *
+ * Shorthand for `query(source, "BALANCES")`.
+ */
+export function balances(source: string): any;
+
+/**
+ * Get BQL query completions at cursor position.
+ *
+ * Returns context-aware completions for the BQL query language.
+ */
+export function bqlCompletions(partial_query: string, cursor_pos: number): any;
+
+/**
+ * Process pad directives and expand them.
+ *
+ * Returns directives with pad-generated transactions included.
+ */
+export function expandPads(source: string): any;
+
+/**
+ * Format a Beancount source string.
+ *
+ * Parses and reformats with consistent alignment.
+ * Returns a `FormatResult` with the formatted source or errors.
+ */
+export function format(source: string): any;
+
+/**
+ * Initialize the WASM module.
+ *
+ * This sets up panic hooks for better error messages in the browser console.
+ * Call this once before using any other functions.
+ */
+export function init(): void;
+
+/**
+ * List available native plugins.
+ *
+ * Returns an array of `PluginInfo` objects with name and description.
+ */
+export function listPlugins(): any;
+
+/**
+ * Parse a Beancount source string.
+ *
+ * Returns a `ParseResult` with the parsed ledger and any errors.
+ */
+export function parse(source: string): any;
+
+/**
+ * Run a BQL query on a Beancount source string.
+ *
+ * Parses the source, interpolates, then executes the query.
+ * Returns a `QueryResult` with columns, rows, and any errors.
+ */
+export function query(source: string, query_str: string): any;
+
+/**
+ * Run a native plugin on the source.
+ *
+ * Available plugins can be listed with `listPlugins()`.
+ */
+export function runPlugin(source: string, plugin_name: string): any;
+
+/**
+ * Validate a Beancount source string.
+ *
+ * Parses, interpolates, and validates in one step.
+ * Returns a `ValidationResult` indicating whether the ledger is valid.
+ */
+export function validateSource(source: string): any;
+
+/**
+ * Get version information.
+ *
+ * Returns the version string of the rustledger-wasm package.
+ */
+export function version(): string;
+
+export type InitInput = RequestInfo | URL | Response | BufferSource | WebAssembly.Module;
+
+export interface InitOutput {
+  readonly memory: WebAssembly.Memory;
+  readonly __wbg_parsedledger_free: (a: number, b: number) => void;
+  readonly balances: (a: number, b: number, c: number) => void;
+  readonly bqlCompletions: (a: number, b: number, c: number, d: number) => void;
+  readonly expandPads: (a: number, b: number, c: number) => void;
+  readonly format: (a: number, b: number, c: number) => void;
+  readonly listPlugins: (a: number) => void;
+  readonly parse: (a: number, b: number, c: number) => void;
+  readonly parsedledger_balances: (a: number, b: number) => void;
+  readonly parsedledger_directiveCount: (a: number) => number;
+  readonly parsedledger_expandPads: (a: number, b: number) => void;
+  readonly parsedledger_format: (a: number, b: number) => void;
+  readonly parsedledger_getDirectives: (a: number, b: number) => void;
+  readonly parsedledger_getErrors: (a: number, b: number) => void;
+  readonly parsedledger_getOptions: (a: number, b: number) => void;
+  readonly parsedledger_getParseErrors: (a: number, b: number) => void;
+  readonly parsedledger_getValidationErrors: (a: number, b: number) => void;
+  readonly parsedledger_isValid: (a: number) => number;
+  readonly parsedledger_new: (a: number, b: number) => number;
+  readonly parsedledger_query: (a: number, b: number, c: number, d: number) => void;
+  readonly parsedledger_runPlugin: (a: number, b: number, c: number, d: number) => void;
+  readonly query: (a: number, b: number, c: number, d: number, e: number) => void;
+  readonly runPlugin: (a: number, b: number, c: number, d: number, e: number) => void;
+  readonly validateSource: (a: number, b: number, c: number) => void;
+  readonly version: (a: number) => void;
+  readonly init: () => void;
+  readonly __wbindgen_export: (a: number, b: number) => number;
+  readonly __wbindgen_export2: (a: number, b: number, c: number, d: number) => number;
+  readonly __wbindgen_export3: (a: number, b: number, c: number) => void;
+  readonly __wbindgen_add_to_stack_pointer: (a: number) => number;
+  readonly __wbindgen_start: () => void;
+}
+
+export type SyncInitInput = BufferSource | WebAssembly.Module;
+
+/**
+* Instantiates the given `module`, which can either be bytes or
+* a precompiled `WebAssembly.Module`.
+*
+* @param {{ module: SyncInitInput }} module - Passing `SyncInitInput` directly is deprecated.
+*
+* @returns {InitOutput}
+*/
+export function initSync(module: { module: SyncInitInput } | SyncInitInput): InitOutput;
+
+/**
+* If `module_or_path` is {RequestInfo} or {URL}, makes a request and
+* for everything else, calls `WebAssembly.instantiate` directly.
+*
+* @param {{ module_or_path: InitInput | Promise<InitInput> }} module_or_path - Passing `InitInput` directly is deprecated.
+*
+* @returns {Promise<InitOutput>}
+*/
+export default function __wbg_init (module_or_path?: { module_or_path: InitInput | Promise<InitInput> } | InitInput | Promise<InitInput>): Promise<InitOutput>;