@ricsam/formula-engine 0.0.1

package/dist/types/parser/parser.d.ts

@@ -0,0 +1,159 @@
+import type { ASTNode } from "./ast";
+import { type Token } from "./lexer";
+/**
+ * Parser error class
+ */
+export declare class ParseError extends Error {
+    position?: {
+        start: number;
+        end: number;
+    } | undefined;
+    constructor(message: string, position?: {
+        start: number;
+        end: number;
+    } | undefined);
+}
+/**
+ * Formula parser class
+ */
+export declare class Parser {
+    private tokens;
+    private input;
+    constructor(tokens: Token[], input?: string);
+    /**
+     * Look ahead to determine if this is a workbook reference [Workbook]Sheet
+     */
+    private lookAheadForWorkbookReference;
+    /**
+     * Parse workbook reference like [Workbook]Sheet or [Workbook]Sheet!A1
+     */
+    private parseWorkbookReference;
+    /**
+     * Parse bare column reference like [Column] or [Column1:Column2]
+     */
+    private parseBareColumnReference;
+    /**
+     * Parse a column name that might consist of multiple identifiers separated by spaces, contain dashes, or have parentheses
+     */
+    private parseColumnName;
+    /**
+     * Parse a formula string
+     */
+    static parse(formula: string): ASTNode;
+    /**
+     * Parse the entire formula
+     */
+    parseFormula(): ASTNode;
+    /**
+     * Parse an expression (entry point for recursive descent)
+     */
+    private parseExpression;
+    /**
+     * Parse binary expressions using precedence climbing
+     */
+    private parseBinaryExpression;
+    /**
+     * Parse unary expressions
+     */
+    private parseUnaryExpression;
+    /**
+     * Parse postfix expressions (currently just %)
+     */
+    private parsePostfixExpression;
+    /**
+     * Parse primary expressions
+     */
+    private parsePrimaryExpression;
+    /**
+     * Parse an absolute reference starting with $
+     */
+    private parseAbsoluteReference;
+    /**
+     * Parse a number literal or row range
+     */
+    private parseNumber;
+    /**
+     * Parse a string literal
+     */
+    private parseString;
+    /**
+     * Parse a boolean literal
+     */
+    private parseBoolean;
+    /**
+     * Parse an error literal
+     */
+    private parseError;
+    /**
+     * Parse a function call
+     */
+    private parseFunctionCall;
+    /**
+     * Parse an identifier (cell reference, range, or named expression)
+     */
+    private parseIdentifier;
+    /**
+     * Check if a string is a valid column identifier (A-Z, AA-ZZ, etc.)
+     */
+    private isColumnIdentifier;
+    /**
+     * Parse the end part of a range (handling $ signs, infinite ranges, and open-ended ranges)
+     */
+    private parseRangeEnd;
+    /**
+     * Parse a parenthesized expression
+     */
+    private parseParenthesizedExpression;
+    /**
+     * Parse an array literal
+     */
+    private parseArrayLiteral;
+    /**
+     * Parse a cell reference string
+     */
+    private parseCellReferenceString;
+    /**
+     * Parse table reference (e.g., Table1[Column1])
+     */
+    private parseTableReference;
+    /**
+     * Parse table reference with sheet name (e.g., Sheet1!Table1[Column1])
+     */
+    private parseTableReferenceWithSheet;
+    /**
+     * Parse cell or range after sheet range in 3D reference
+     */
+    private parseCellOrRangeAfterSheets;
+    /**
+     * Parse current row reference (e.g., [@Column], [@[Column Name]], or just @Column)
+     */
+    private parseCurrentRowReference;
+    /**
+     * Parse table selector (e.g., #Headers, #Data)
+     */
+    private parseTableSelector;
+    /**
+     * Parse a range reference with workbook name
+     */
+    private parseRangeWithWorkbook;
+    /**
+     * Parse table reference with workbook and sheet name
+     */
+    private parseTableReferenceWithWorkbookAndSheet;
+    /**
+     * Parse a range reference (including infinite ranges)
+     */
+    private parseRange;
+    /**
+     * Parse a cell or range reference with a known workbook and sheet name
+     */
+    private parseCellOrRangeWithWorkbookAndSheet;
+    /**
+     * Parse a cell or range reference with a known sheet name
+     */
+    private parseCellOrRangeWithSheet;
+}
+/**
+ * Parse a formula string into an AST
+ */
+export declare function parseFormula(formula: string): ASTNode;

package/dist/types/react/hooks.d.ts

@@ -0,0 +1,5 @@
+/**
+ * React hooks for FormulaEngine integration
+ */
+import type { FormulaEngine } from "../core/engine";
+export declare function useEngine(engine: FormulaEngine): ReturnType<typeof FormulaEngine.prototype.getState>;

package/package.json

@@ -0,0 +1,41 @@
+{
+  "name": "@ricsam/formula-engine",
+  "version": "0.0.1",
+  "module": "./dist/mjs/lib.mjs",
+  "scripts": {
+    "test": "bun test",
+    "agent:test": "CLAUDECODE=1 bun test",
+    "test:e2e": "npx playwright test",
+    "test:e2e:ui": "npx playwright test --ui",
+    "test:e2e:debug": "npx playwright test --debug",
+    "test:e2e:headed": "npx playwright test --headed",
+    "test:e2e:debug-visible": "npx playwright test --headed --debug",
+    "test:e2e:with-logs": "./scripts/run-test.sh",
+    "typecheck": "tsc --noEmit",
+    "demo:dev": "bun demo/index.tsx",
+    "demo:start": "NODE_ENV=production bun demo/index.tsx",
+    "demo:build": "tsr generate && bun run build.ts",
+    "demo:generate-routes": "tsr generate",
+    "demo:watch-routes": "tsr watch",
+    "knip": "knip",
+    "build": "bun build-lib.ts"
+  },
+  "peerDependencies": {
+    "typescript": "^5"
+  },
+  "main": "./dist/cjs/lib.cjs",
+  "types": "./dist/types/lib.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/types/lib.d.ts",
+      "require": "./dist/cjs/lib.cjs",
+      "import": "./dist/mjs/lib.mjs"
+    }
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    "dist"
+  ]
+}