@statedelta-libs/expressions 0.0.1

package/dist/index.d.ts

@@ -0,0 +1,511 @@
+import { ConditionExpr, Condition, ConditionGroup } from '@statedelta-libs/conditions';
+export { Condition, ConditionExpr, ConditionGroup, Ref } from '@statedelta-libs/conditions';
+import { types } from 'omni-ast';
+
+/**
+ * @statedelta-libs/expressions - Types
+ *
+ * Core types for expression compilation.
+ */
+
+/**
+ * Reference to a path in data object
+ * @example { "$": "user.name" }
+ * @example { "$": "items[*].price" }
+ */
+interface RefExpr {
+    $: string;
+}
+/**
+ * Conditional expression
+ * @example { "$if": condition, "then": expr, "else": expr }
+ */
+interface ConditionalExpr {
+    $if: Expression;
+    then: Expression;
+    else?: Expression;
+}
+/**
+ * Function call expression
+ * Calls a function from the provided scope with compiled arguments
+ * @example { "$fn": "add", "args": [{ "$": "a" }, { "$": "b" }] }
+ */
+interface FnExpr {
+    $fn: string;
+    args?: Expression[];
+}
+/**
+ * Pipe expression (DSL syntax for composition with initial value)
+ * First element is the initial value, rest are transformers
+ * @example { "$pipe": [{ "$": "items" }, { "$fn": "filter", "args": [pred] }, { "$fn": "sum" }] }
+ */
+interface PipeExpr {
+    $pipe: Expression[];
+}
+/**
+ * Literal values (primitives, arrays, plain objects)
+ */
+type Literal = string | number | boolean | null | Literal[] | {
+    [key: string]: Literal;
+};
+/**
+ * Union of all expression types
+ */
+type Expression = Literal | RefExpr | ConditionalExpr | FnExpr | PipeExpr | ConditionExpr;
+/**
+ * Compiled expression function
+ */
+type CompiledFn<T = unknown, R = unknown> = (data: T) => R;
+/**
+ * Result of compiling an expression
+ */
+interface CompiledExpression<T = unknown, R = unknown> {
+    /** Compiled function */
+    fn: CompiledFn<T, R>;
+    /** Paths this expression depends on */
+    deps: string[];
+    /** Unique hash for caching */
+    hash: string;
+}
+/**
+ * Path getter function
+ */
+type PathGetter<T = unknown> = (data: T) => unknown;
+/**
+ * Validation result
+ */
+interface ValidationResult {
+    valid: boolean;
+    errors: string[];
+}
+/**
+ * Function scope - functions available to $fn expressions
+ * @example { add, subtract, multiply, filter, map, sum }
+ */
+type Scope = Record<string, (...args: unknown[]) => unknown>;
+/**
+ * Options for compilation
+ */
+interface CompileOptions {
+    /** Functions available to $fn expressions */
+    scope?: Scope;
+}
+/**
+ * Check if value is a reference expression
+ */
+declare const isRef: (v: unknown) => v is RefExpr;
+/**
+ * Check if value is a conditional expression
+ */
+declare const isConditional: (v: unknown) => v is ConditionalExpr;
+/**
+ * Check if value is a function call expression
+ */
+declare const isFn: (v: unknown) => v is FnExpr;
+/**
+ * Check if value is a pipe expression
+ */
+declare const isPipe: (v: unknown) => v is PipeExpr;
+/**
+ * Check if value is a condition (from @statedelta-libs/conditions)
+ *
+ * IMPORTANT: Must verify that `op` is a valid condition operator,
+ * not just any string. Effect objects also have `path` and `op`
+ * properties (e.g., { resource: "x", op: "set", path: "y", value: z })
+ * but "set" is NOT a condition operator.
+ */
+declare const isCondition: (v: unknown) => v is Condition;
+/**
+ * Check if value is a condition group (from @statedelta-libs/conditions)
+ */
+declare const isConditionGroup: (v: unknown) => v is ConditionGroup;
+/**
+ * Check if value is any condition expression
+ */
+declare const isConditionExpr: (v: unknown) => v is ConditionExpr;
+/**
+ * Check if value is a literal (not an expression object)
+ */
+declare const isLiteral: (v: unknown) => v is Literal;
+
+/**
+ * @statedelta-libs/expressions - Compiler
+ *
+ * Compiles JSON DSL expressions to optimized functions.
+ * Functions are provided via scope, not hardcoded.
+ */
+
+/**
+ * Compile expression to optimized function
+ *
+ * @param expr - Expression to compile
+ * @param options - Compile options (scope with functions)
+ * @returns Compiled expression with fn, deps, and hash
+ *
+ * @example
+ * ```ts
+ * import { add, filter, sum } from '@statedelta-libs/operators';
+ *
+ * const { fn } = compile(
+ *   { $fn: "add", args: [{ $: "a" }, { $: "b" }] },
+ *   { scope: { add, filter, sum } }
+ * );
+ *
+ * fn({ a: 1, b: 2 }); // 3
+ * ```
+ */
+declare function compile<T = unknown, R = unknown>(expr: Expression, options?: CompileOptions): CompiledExpression<T, R>;
+/**
+ * Compile and execute in one step
+ *
+ * @example
+ * ```ts
+ * evaluate(
+ *   { $fn: "add", args: [{ $: "a" }, { $: "b" }] },
+ *   { a: 1, b: 2 },
+ *   { scope: { add } }
+ * ); // 3
+ * ```
+ */
+declare function evaluate<T = unknown, R = unknown>(expr: Expression, data: T, options?: CompileOptions): R;
+
+/**
+ * @statedelta-libs/expressions - Path Compiler
+ *
+ * Compiles paths to optimized getters with wildcard support.
+ * Performance: ~50M ops/sec for simple paths, ~10M ops/sec for wildcards
+ */
+
+/**
+ * Check if path has wildcards
+ */
+declare function hasWildcard(path: string): boolean;
+/**
+ * Compile path to optimized getter
+ */
+declare function compilePath<T = unknown>(path: string): PathGetter<T>;
+/**
+ * Get value at path directly (without caching)
+ */
+declare function get<T = unknown>(data: T, path: string): unknown;
+/**
+ * Normalize path for dependency tracking (remove wildcards)
+ * @example "items[*].price" → "items"
+ * @example "users[*].posts[*].title" → "users"
+ */
+declare function normalizePath(path: string): string;
+/**
+ * Clear path cache
+ */
+declare function clearPathCache(): void;
+/**
+ * Get cache size
+ */
+declare function getPathCacheSize(): number;
+
+/**
+ * @statedelta-libs/expressions - Dependency Extraction
+ *
+ * Extracts paths that an expression depends on.
+ * Performance: ~200K ops/sec
+ */
+
+/**
+ * Extract all paths an expression depends on
+ * @example { "$": "user.age" } → ["user.age"]
+ * @example { "$if": "$isVip", "then": { "$": "price.vip" } } → ["$isVip", "price.vip"]
+ */
+declare function extractDeps(expr: Expression): string[];
+/**
+ * Check if expression has dependencies
+ */
+declare function hasDeps(expr: Expression): boolean;
+/**
+ * Check if expression is pure (no dependencies)
+ */
+declare function isPure(expr: Expression): boolean;
+
+/**
+ * @statedelta-libs/expressions - Cache
+ *
+ * LRU cache for compiled expressions.
+ * Performance: cache hit ~10M ops/sec
+ */
+
+/**
+ * LRU Cache for compiled expressions
+ */
+declare class ExpressionCache {
+    private cache;
+    private _maxSize;
+    constructor(maxSize?: number);
+    /**
+     * Get or compile expression
+     *
+     * Note: The cache key is based on the expression only, not the scope.
+     * If you use different scopes for the same expression, consider using
+     * separate cache instances or not caching at all.
+     */
+    get<T = unknown, R = unknown>(expr: Expression, options?: CompileOptions): CompiledExpression<T, R>;
+    /**
+     * Check if expression is cached
+     */
+    has(expr: Expression): boolean;
+    /**
+     * Delete specific expression from cache
+     */
+    delete(expr: Expression): boolean;
+    /**
+     * Clear the cache
+     */
+    clear(): void;
+    /**
+     * Current cache size
+     */
+    get size(): number;
+    /**
+     * Maximum cache size
+     */
+    get maxSize(): number;
+    /**
+     * Set maximum cache size
+     */
+    set maxSize(value: number);
+}
+declare const cache: ExpressionCache;
+/**
+ * Compile and cache expression (convenience function)
+ *
+ * Note: Uses global cache. For custom scope management,
+ * use a dedicated ExpressionCache instance.
+ */
+declare function cached<T = unknown, R = unknown>(expr: Expression, options?: CompileOptions): CompiledExpression<T, R>;
+
+/**
+ * @statedelta-libs/expressions - Validation
+ *
+ * Validates expression structure before compilation.
+ */
+
+/**
+ * Validation options
+ */
+interface ValidateOptions {
+    /** Scope to validate function names against (optional) */
+    scope?: Scope;
+}
+/**
+ * Validate expression structure
+ *
+ * @param expr - Expression to validate
+ * @param path - Current path in expression tree (for error messages)
+ * @param options - Validation options
+ */
+declare function validate(expr: Expression, path?: string, options?: ValidateOptions): ValidationResult;
+/**
+ * Validate and throw if invalid
+ */
+declare function assertValid(expr: Expression, options?: ValidateOptions): void;
+/**
+ * Check if expression is valid
+ */
+declare function isValid(expr: Expression, options?: ValidateOptions): boolean;
+
+/**
+ * @statedelta-libs/expressions - DSL to AST Transformer
+ *
+ * Transforms JSON DSL expressions to ESTree AST nodes using omni-ast builders.
+ * Supports two modes:
+ * - With prefixes (default): generates `data?.user?.name`, `scope.add()`
+ * - Without prefixes: generates `user?.name`, `add()` (for use with destructuring)
+ */
+
+type ASTNode = types.Expression;
+/** Options for DSL to AST transformation */
+interface TransformOptions {
+    /**
+     * Name of data parameter (default: "data")
+     * When noPrefixes=true, this is ignored for property access
+     */
+    dataParam?: string;
+    /**
+     * Name of scope parameter (default: "scope")
+     * When noPrefixes=true, this is ignored for function calls
+     */
+    scopeParam?: string;
+    /**
+     * When true, generates code without data/scope prefixes.
+     * Assumes variables are available via destructuring.
+     * - `user?.name` instead of `data?.user?.name`
+     * - `add(a, b)` instead of `scope.add(data?.a, data?.b)`
+     */
+    noPrefixes?: boolean;
+}
+/**
+ * Transform DSL expression to AST node
+ *
+ * @param expr - DSL expression
+ * @param options - Transform options
+ * @returns ESTree AST node
+ *
+ * @example
+ * ```ts
+ * // With prefixes (default)
+ * dslToAST({ $: "user.name" })
+ * // → data?.user?.name
+ *
+ * // Without prefixes (for destructuring)
+ * dslToAST({ $: "user.name" }, { noPrefixes: true })
+ * // → user?.name
+ * ```
+ */
+declare function dslToAST(expr: Expression, options?: TransformOptions): ASTNode;
+/**
+ * Wrap AST expression in an arrow function
+ */
+declare function wrapInFunction(bodyAst: ASTNode, params?: string[]): ASTNode;
+
+/**
+ * @statedelta-libs/expressions - Extract Scope Functions
+ *
+ * Extracts function names used from scope in a DSL expression.
+ * Used to generate optimized destructuring: const { add, filter } = scope;
+ */
+
+/**
+ * Extract all function names used from scope in an expression
+ *
+ * @param expr - DSL expression to analyze
+ * @returns Set of function names used
+ *
+ * @example
+ * ```ts
+ * extractScopeFns({ $fn: "add", args: [{ $: "a" }, { $: "b" }] })
+ * // Set { "add" }
+ *
+ * extractScopeFns({
+ *   $pipe: [
+ *     { $: "items" },
+ *     { $fn: "filter", args: [pred] },
+ *     { $fn: "sum" }
+ *   ]
+ * })
+ * // Set { "filter", "sum" }
+ * ```
+ */
+declare function extractScopeFns(expr: Expression): Set<string>;
+/**
+ * Extract root-level data dependencies from paths
+ *
+ * @param deps - Array of dependency paths
+ * @returns Set of root-level property names
+ *
+ * @example
+ * ```ts
+ * extractDataRoots(["user.name", "user.age", "items", "config.theme"])
+ * // Set { "user", "items", "config" }
+ * ```
+ */
+declare function extractDataRoots(deps: string[]): Set<string>;
+
+/**
+ * @statedelta-libs/expressions - AST Compiler
+ *
+ * Compiles DSL expressions to optimized functions using AST generation.
+ * Uses destructuring for better performance:
+ * - Variables from data are destructured into local scope
+ * - Functions from scope are destructured into local scope
+ * - Generated code is smaller and faster
+ */
+
+/** Options for AST compilation */
+interface CompileASTOptions {
+    /** Scope with functions available to the expression */
+    scope?: Scope;
+    /** Return generated code instead of function (for debugging) */
+    returnCode?: boolean;
+}
+/** Result when returnCode is true */
+interface CompileASTCodeResult {
+    code: string;
+    deps: string[];
+    hash: string;
+    dataRoots: string[];
+    scopeFns: string[];
+}
+/**
+ * Compile DSL expression to optimized function using AST generation
+ *
+ * This is the high-performance compiler that:
+ * 1. Extracts dependencies and scope functions
+ * 2. Generates AST without prefixes
+ * 3. Wraps in destructuring for optimal variable access
+ * 4. Creates function via `new Function()` or `eval()`
+ *
+ * @example
+ * ```ts
+ * import { compileAST } from '@statedelta-libs/expressions';
+ * import { add, filter, sum } from '@statedelta-libs/operators';
+ *
+ * const { fn } = compileAST(
+ *   { $fn: "add", args: [{ $: "a" }, { $: "b" }] },
+ *   { scope: { add, filter, sum } }
+ * );
+ *
+ * fn({ a: 1, b: 2 }); // 3
+ * ```
+ */
+declare function compileAST<T = unknown, R = unknown>(expr: Expression, options: CompileASTOptions & {
+    returnCode: true;
+}): CompileASTCodeResult;
+declare function compileAST<T = unknown, R = unknown>(expr: Expression, options?: CompileASTOptions): CompiledExpression<T, R>;
+/**
+ * Compile and execute in one step
+ *
+ * @example
+ * ```ts
+ * evaluateAST(
+ *   { $fn: "add", args: [{ $: "a" }, { $: "b" }] },
+ *   { a: 1, b: 2 },
+ *   { scope: { add } }
+ * ); // 3
+ * ```
+ */
+declare function evaluateAST<T = unknown, R = unknown>(expr: Expression, data: T, options?: CompileASTOptions): R;
+
+/**
+ * @statedelta-libs/expressions
+ *
+ * JSON DSL compiler for optimized functions.
+ * Functions are provided via scope, not hardcoded.
+ *
+ * @example
+ * ```ts
+ * import { compile, evaluate } from '@statedelta-libs/expressions';
+ * import { filter, map, sum } from '@statedelta-libs/operators';
+ *
+ * const scope = { filter, map, sum };
+ *
+ * // Using $pipe for composition with initial value
+ * const { fn } = compile({
+ *   $pipe: [
+ *     { $: "items" },
+ *     { $fn: "filter", args: [{ path: "active", op: "eq", value: true }] },
+ *     { $fn: "map", args: [{ $: "price" }] },
+ *     { $fn: "sum" }
+ *   ]
+ * }, { scope });
+ *
+ * fn({ items: [...] }); // sum of active item prices
+ *
+ * // Using $fn for simple function calls
+ * evaluate(
+ *   { $fn: "add", args: [{ $: "a" }, { $: "b" }] },
+ *   { a: 1, b: 2 },
+ *   { scope: { add: (a, b) => a + b } }
+ * ); // 3
+ * ```
+ */
+declare const VERSION = "0.0.1";
+
+export { type CompileASTCodeResult, type CompileASTOptions, type CompileOptions, type CompiledExpression, type CompiledFn, type ConditionalExpr, type Expression, ExpressionCache, type FnExpr, type Literal, type PathGetter, type PipeExpr, type RefExpr, type Scope, type TransformOptions, VERSION, type ValidateOptions, type ValidationResult, assertValid, cache, cached, clearPathCache, compile, compileAST, compilePath, dslToAST, evaluate, evaluateAST, extractDataRoots, extractDeps, extractScopeFns, get, getPathCacheSize, hasDeps, hasWildcard, isCondition, isConditionExpr, isConditionGroup, isConditional, isFn, isLiteral, isPipe, isPure, isRef, isValid, normalizePath, validate, wrapInFunction };

package/dist/index.js

@@ -0,0 +1 @@
+import {isRef,compile,validate}from'@statedelta-libs/conditions';import {builders,generate}from'omni-ast';var m=n=>n!==null&&typeof n=="object"&&"$"in n&&typeof n.$=="string"&&Object.keys(n).length===1,h=n=>n!==null&&typeof n=="object"&&"$if"in n&&"then"in n,E=n=>n!==null&&typeof n=="object"&&"$fn"in n&&typeof n.$fn=="string",C=n=>n!==null&&typeof n=="object"&&"$pipe"in n&&Array.isArray(n.$pipe),M=new Set(["eq","neq","gt","gte","lt","lte","in","notIn","contains","notContains","exists","notExists","matches","notMatches","startsWith","endsWith"]),g=n=>n!==null&&typeof n=="object"&&"path"in n&&"op"in n&&M.has(n.op)&&!("$"in n)&&!("$if"in n)&&!("$fn"in n),y=n=>n!==null&&typeof n=="object"&&"logic"in n&&"conditions"in n,H=n=>g(n)||y(n),W=n=>{if(n===null)return  true;let e=typeof n;if(e==="string"||e==="number"||e==="boolean"||Array.isArray(n))return  true;if(e==="object"&&n!==null){let t=n,o="path"in t&&"op"in t&&M.has(t.op);return !("$"in t)&&!("$if"in t)&&!("$fn"in t)&&!("$pipe"in t)&&!o&&!("logic"in t)}return  false};var R=new Map;function I(n){let e=[],t=n.length,o=0,i="";for(;o<t;){let s=n[o];if(s===".")i&&(e.push({type:"key",value:i}),i=""),o++;else if(s==="["){i&&(e.push({type:"key",value:i}),i=""),o++;let r=o;for(;o<t&&n[o]!=="]";)o++;let c=n.slice(r,o);if(o++,c==="*")e.push({type:"wildcard",value:"*"});else {let f=parseInt(c,10);e.push({type:"index",value:isNaN(f)?c:f});}}else i+=s,o++;}return i&&e.push({type:"key",value:i}),e}function V(n){return n.includes("[*]")}function x(n){let e=R.get(n);return e||(e=V(n)?U(n):Q(n),R.set(n,e),e)}function Q(n){if(!n.includes(".")&&!n.includes("["))return i=>i?.[n];let e=I(n),t=e.length;if(t===2){let[i,s]=e,r=i.value,c=s.value;return f=>f?.[r]?.[c]}if(t===3){let[i,s,r]=e,c=i.value,f=s.value,a=r.value;return u=>u?.[c]?.[f]?.[a]}let o=e.map(i=>i.value);return i=>{let s=i;for(let r=0;r<t&&s!=null;r++)s=s[o[r]];return s}}function U(n){let e=I(n),t=[];for(let o=0;o<e.length;o++)e[o].type==="wildcard"&&t.push(o);return t.length===1?X(e,t[0]):Z(e,t)}function X(n,e){let t=n.slice(0,e).map(r=>r.value),o=n.slice(e+1).map(r=>r.value),i=t.length,s=o.length;if(s===0){if(i===1){let r=t[0];return c=>c?.[r]}return r=>{let c=r;for(let f=0;f<i&&c!=null;f++)c=c[t[f]];return c}}if(s===1){let r=o[0];if(i===1){let c=t[0];return f=>{let a=f?.[c];if(Array.isArray(a))return a.map(u=>u?.[r])}}return c=>{let f=c;for(let a=0;a<i&&f!=null;a++)f=f[t[a]];if(Array.isArray(f))return f.map(a=>a?.[r])}}return r=>{let c=r;for(let f=0;f<i&&c!=null;f++)c=c[t[f]];if(Array.isArray(c))return c.map(f=>{let a=f;for(let u=0;u<s&&a!=null;u++)a=a[o[u]];return a})}}function Z(n,e){let t=[],o=0;for(let s=0;s<e.length;s++){let r=e[s],c=s===e.length-1,f=n.slice(o,r).map(a=>a.value);f.length>0&&t.push({type:"access",keys:f}),t.push({type:c?"map":"flatMap",keys:[]}),o=r+1;}let i=n.slice(o).map(s=>s.value);return s=>{let r=s;for(let c of t){if(r==null)return;if(c.type==="access")for(let f of c.keys){if(r==null)return;r=r[f];}else if(c.type==="flatMap"){if(!Array.isArray(r))return;r=r.flatMap(f=>{let a=f;return Array.isArray(a)?a:[a]});}else if(c.type==="map"){if(!Array.isArray(r))return;i.length>0&&(r=r.map(f=>{let a=f;for(let u of i){if(a==null)return;a=a[u];}return a}));}}return r}}function nn(n,e){return x(e)(n)}function k(n){let e=n.indexOf("[*]");return e===-1?n:n.slice(0,e)}function en(){R.clear();}function tn(){return R.size}function T(n){let e=new Set;return A(n,e),Array.from(e)}function A(n,e){if(n===null||typeof n!="object")return;if(Array.isArray(n)){for(let i=0;i<n.length;i++)A(n[i],e);return}if(m(n)){e.add(k(n.$));return}if(h(n)){if(typeof n.$if=="string"){let i=n.$if.startsWith("!")?n.$if.slice(1):n.$if;e.add(k(i));}else A(n.$if,e);A(n.then,e),n.else!==void 0&&A(n.else,e);return}if(C(n)){for(let i=0;i<n.$pipe.length;i++)A(n.$pipe[i],e);return}if(E(n)){if(n.args)for(let i=0;i<n.args.length;i++)A(n.args[i],e);return}if(g(n)){e.add(k(n.path)),n.value!==void 0&&isRef(n.value)&&e.add(k(n.value.$));return}if(y(n)){for(let i=0;i<n.conditions.length;i++)A(n.conditions[i],e);return}let t=n,o=Object.keys(t);for(let i=0;i<o.length;i++)A(t[o[i]],e);}function rn(n){return T(n).length>0}function sn(n){return T(n).length===0}function ln(n){return JSON.stringify(n)}function O(n,e={}){let t=e.scope??{},o=b(n,t),i=T(n),s=ln(n);return {fn:o,deps:i,hash:s}}function b(n,e){if(n===null)return ()=>null;if(typeof n!="object")return ()=>n;if(Array.isArray(n)){let t=n.map(o=>b(o,e));return o=>t.map(i=>i(o))}if(m(n))return cn(n);if(h(n))return fn(n,e);if(C(n))return an(n,e);if(E(n))return un(n,e);if(g(n))return compile(n);if(y(n))return compile(n);if(W(n)){let t=n,o=Object.keys(t),i=o.map(s=>b(t[s],e));return s=>{let r={};for(let c=0;c<o.length;c++)r[o[c]]=i[c](s);return r}}return ()=>n}function cn(n){return x(n.$)}function fn(n,e){let t;if(typeof n.$if=="string"){let s=n.$if.startsWith("!")?n.$if.slice(1):n.$if,r=x(s);t=n.$if.startsWith("!")?f=>!r(f):f=>!!r(f);}else {let s=b(n.$if,e);t=r=>!!s(r);}let o=b(n.then,e),i=n.else!==void 0?b(n.else,e):()=>{};return s=>t(s)?o(s):i(s)}function an(n,e){let t=n.$pipe;if(t.length===0)return ()=>{};if(t.length===1)return b(t[0],e);let o=b(t[0],e),i=t.slice(1).map(r=>b(r,e)),s=i.length;if(s===1){let[r]=i;return c=>{let f=o(c),a=r(c);return typeof a=="function"?a(f):a}}if(s===2){let[r,c]=i;return f=>{let a=o(f),u=r(f);return a=typeof u=="function"?u(a):u,u=c(f),typeof u=="function"?u(a):u}}if(s===3){let[r,c,f]=i;return a=>{let u=o(a),p=r(a);return u=typeof p=="function"?p(u):p,p=c(a),u=typeof p=="function"?p(u):p,p=f(a),typeof p=="function"?p(u):p}}return r=>{let c=o(r);for(let f=0;f<s;f++){let a=i[f](r);c=typeof a=="function"?a(c):a;}return c}}function un(n,e){let t=n.$fn,o=n.args;if(o===void 0)return ()=>{let r=e[t];if(!r)throw new Error(`Function not found in scope: ${t}`);return r};let i=o.map(r=>b(r,e)),s=i.length;if(s===0)return r=>{let c=e[t];if(!c)throw new Error(`Function not found in scope: ${t}`);return c()};if(s===1){let[r]=i;return c=>{let f=e[t];if(!f)throw new Error(`Function not found in scope: ${t}`);return f(r(c))}}if(s===2){let[r,c]=i;return f=>{let a=e[t];if(!a)throw new Error(`Function not found in scope: ${t}`);return a(r(f),c(f))}}if(s===3){let[r,c,f]=i;return a=>{let u=e[t];if(!u)throw new Error(`Function not found in scope: ${t}`);return u(r(a),c(a),f(a))}}return r=>{let c=e[t];if(!c)throw new Error(`Function not found in scope: ${t}`);return c(...i.map(f=>f(r)))}}function pn(n,e,t={}){return O(n,t).fn(e)}var v=class{constructor(e=1e3){this.cache=new Map,this._maxSize=e;}get(e,t={}){let o=JSON.stringify(e),i=this.cache.get(o);if(i)return this.cache.delete(o),this.cache.set(o,i),i;let s=O(e,t);if(this.cache.size>=this._maxSize){let r=this.cache.keys().next().value;r&&this.cache.delete(r);}return this.cache.set(o,s),s}has(e){return this.cache.has(JSON.stringify(e))}delete(e){return this.cache.delete(JSON.stringify(e))}clear(){this.cache.clear();}get size(){return this.cache.size}get maxSize(){return this._maxSize}set maxSize(e){for(this._maxSize=e;this.cache.size>this._maxSize;){let t=this.cache.keys().next().value;t&&this.cache.delete(t);}}},_=new v;function dn(n,e={}){return _.get(n,e)}function z(n,e="root",t={}){let o=[];return $(n,e,o,t),{valid:o.length===0,errors:o}}function $(n,e,t,o){if(n===null||typeof n!="object")return;if(Array.isArray(n)){for(let r=0;r<n.length;r++)$(n[r],`${e}[${r}]`,t,o);return}if(m(n)){(!n.$||typeof n.$!="string")&&t.push(`${e}: invalid reference, $ must be non-empty string`);return}if(h(n)){typeof n.$if=="string"?(n.$if.startsWith("!")?n.$if.slice(1):n.$if)||t.push(`${e}.$if: empty path in string shorthand`):$(n.$if,`${e}.$if`,t,o),$(n.then,`${e}.then`,t,o),n.else!==void 0&&$(n.else,`${e}.else`,t,o);return}if(C(n)){if(!Array.isArray(n.$pipe)){t.push(`${e}.$pipe: must be an array`);return}if(n.$pipe.length===0){t.push(`${e}.$pipe: must have at least one element`);return}for(let r=0;r<n.$pipe.length;r++)$(n.$pipe[r],`${e}.$pipe[${r}]`,t,o);return}if(E(n)){if(!n.$fn||typeof n.$fn!="string"){t.push(`${e}: invalid function, $fn must be non-empty string`);return}if(o.scope&&!(n.$fn in o.scope)&&t.push(`${e}: function "${n.$fn}" not found in scope`),n.args!==void 0)if(!Array.isArray(n.args))t.push(`${e}.args: must be an array`);else for(let r=0;r<n.args.length;r++)$(n.args[r],`${e}.args[${r}]`,t,o);return}if(g(n)){let r=validate(n,e);r.valid||t.push(...r.errors);return}if(y(n)){let r=validate(n,e);r.valid||t.push(...r.errors);return}let i=n,s=Object.keys(i);for(let r=0;r<s.length;r++){let c=s[r];$(i[c],`${e}.${c}`,t,o);}}function mn(n,e={}){let t=z(n,"root",e);if(!t.valid)throw new Error(`Invalid expression: ${t.errors.join("; ")}`)}function gn(n,e={}){return z(n,"root",e).valid}var P="data",J="scope",yn={eq:"===",neq:"!==",gt:">",gte:">=",lt:"<",lte:"<="};function N(n,e={}){let{dataParam:t=P,scopeParam:o=J,noPrefixes:i=false}=e;return d(n,t,o,i)}function d(n,e,t,o){if(n===null)return builders.literal(null);if(typeof n=="string")return builders.literal(n);if(typeof n=="number")return builders.literal(n);if(typeof n=="boolean")return builders.literal(n);if(Array.isArray(n))return builders.arrayExpression(n.map(i=>d(i,e,t,o)));if(m(n))return hn(n.$,e,o);if(h(n))return Cn(n,e,t,o);if(C(n))return Sn(n.$pipe,e,t,o);if(E(n))return bn(n,e,t,o);if(g(n))return An(n,e,t,o);if(y(n))return $n(n,e,t,o);if(typeof n=="object"){let s=Object.entries(n).map(([r,c])=>builders.property(builders.identifier(r),d(c,e,t,o)));return builders.objectExpression(s)}return builders.literal(null)}function hn(n,e,t){return n.includes("[*]")?En(n,e,t):w(n,e,t)}function w(n,e,t){let o=F(n);if(o.length===0)return t?builders.identifier("undefined"):builders.identifier(e);let i;if(t){let s=o[0];i=builders.identifier(s.value);for(let r=1;r<o.length;r++){let c=o[r];c.type==="key"?i=builders.memberExpression(i,builders.identifier(c.value),false,true):i=builders.memberExpression(i,builders.literal(c.value),true,true);}}else {i=builders.identifier(e);for(let s of o)s.type==="key"?i=builders.memberExpression(i,builders.identifier(s.value),false,true):i=builders.memberExpression(i,builders.literal(s.value),true,true);}return i}function En(n,e,t){let o=n.indexOf("[*]"),i=n.slice(0,o),s=n.slice(o+3),r;if(i?r=w(i,e,t):r=t?builders.identifier("undefined"):builders.identifier(e),!s||s==="")return r;if(s.includes("[*]"))return B(r,s);let c="_i",f=s.startsWith(".")?s.slice(1):s,a=builders.identifier(c);if(f){let u=F(f);for(let p of u)p.type==="key"?a=builders.memberExpression(a,builders.identifier(p.value),false,true):a=builders.memberExpression(a,builders.literal(p.value),true,true);}return builders.callExpression(builders.memberExpression(r,builders.identifier("map"),false,true),[builders.arrowFunctionExpression([builders.identifier(c)],a)])}function B(n,e){let t=e.indexOf("[*]"),o=e.slice(0,t),i=e.slice(t+3),s="_i",r=o.startsWith(".")?o.slice(1):o,c=builders.identifier(s);if(r){let a=F(r);for(let u of a)u.type==="key"&&(c=builders.memberExpression(c,builders.identifier(u.value),false,true));}if(i.includes("[*]")){let a=B(c,i);return builders.callExpression(builders.memberExpression(n,builders.identifier("flatMap"),false,true),[builders.arrowFunctionExpression([builders.identifier(s)],a)])}let f=i.startsWith(".")?i.slice(1):i;if(f){let a=F(f);for(let u of a)u.type==="key"&&(c=builders.memberExpression(c,builders.identifier(u.value),false,true));}return builders.callExpression(builders.memberExpression(n,builders.identifier("flatMap"),false,true),[builders.arrowFunctionExpression([builders.identifier(s)],c)])}function Cn(n,e,t,o){let i;if(typeof n.$if=="string"){let c=n.$if.startsWith("!"),f=c?n.$if.slice(1):n.$if,a=w(f,e,o);i=c?builders.unaryExpression("!",a):a;}else i=d(n.$if,e,t,o);let s=d(n.then,e,t,o),r=n.else!==void 0?d(n.else,e,t,o):builders.identifier("undefined");return builders.conditionalExpression(i,s,r)}function bn(n,e,t,o){let i=o?builders.identifier(n.$fn):builders.memberExpression(builders.identifier(t),builders.identifier(n.$fn),false,false);if(n.args===void 0)return i;let s=n.args.map(r=>d(r,e,t,o));return builders.callExpression(i,s)}function Sn(n,e,t,o){if(n.length===0)return builders.identifier("undefined");if(n.length===1)return d(n[0],e,t,o);let i=d(n[0],e,t,o);for(let s=1;s<n.length;s++){let r=d(n[s],e,t,o);i=builders.callExpression(r,[i]);}return i}function An(n,e,t,o){let i=w(n.path,e,o),s=n.value!==void 0?m(n.value)?w(n.value.$,e,o):d(n.value,e,t,o):builders.literal(null),r=yn[n.op];if(r)return builders.binaryExpression(r,i,s);switch(n.op){case "in":return builders.callExpression(builders.memberExpression(s,builders.identifier("includes")),[i]);case "notIn":return builders.unaryExpression("!",builders.callExpression(builders.memberExpression(s,builders.identifier("includes")),[i]));case "contains":return builders.callExpression(builders.memberExpression(i,builders.identifier("includes"),false,true),[s]);case "notContains":return builders.unaryExpression("!",builders.callExpression(builders.memberExpression(i,builders.identifier("includes"),false,true),[s]));case "exists":return builders.binaryExpression("!=",i,builders.literal(null));case "notExists":return builders.binaryExpression("==",i,builders.literal(null));case "matches":return builders.callExpression(builders.memberExpression(builders.newExpression(builders.identifier("RegExp"),[s]),builders.identifier("test")),[i]);case "notMatches":return builders.unaryExpression("!",builders.callExpression(builders.memberExpression(builders.newExpression(builders.identifier("RegExp"),[s]),builders.identifier("test")),[i]));case "startsWith":return builders.callExpression(builders.memberExpression(i,builders.identifier("startsWith"),false,true),[s]);case "endsWith":return builders.callExpression(builders.memberExpression(i,builders.identifier("endsWith"),false,true),[s]);default:return builders.binaryExpression("===",i,s)}}function $n(n,e,t,o){let{logic:i,conditions:s}=n,r=i==="AND"?"&&":"||";if(s.length===0)return builders.literal(i==="AND");if(s.length===1)return d(s[0],e,t,o);let c=d(s[0],e,t,o);for(let f=1;f<s.length;f++){let a=d(s[f],e,t,o);c=builders.logicalExpression(r,c,a);}return c}function F(n){let e=[],t=n.length,o=0,i="";for(;o<t;){let s=n[o];if(s===".")i&&(e.push({type:"key",value:i}),i=""),o++;else if(s==="["){i&&(e.push({type:"key",value:i}),i=""),o++;let r=o;for(;o<t&&n[o]!=="]";)o++;let c=n.slice(r,o);if(o++,c!=="*"){let f=parseInt(c,10);e.push({type:"index",value:isNaN(f)?c:f});}}else i+=s,o++;}return i&&e.push({type:"key",value:i}),e}function K(n,e=[P]){return builders.arrowFunctionExpression(e.map(t=>builders.identifier(t)),n)}function j(n){let e=new Set;return S(n,e),e}function S(n,e){if(n===null||typeof n!="object")return;if(Array.isArray(n)){for(let o of n)S(o,e);return}if(m(n))return;if(h(n)){S(n.$if,e),S(n.then,e),n.else!==void 0&&S(n.else,e);return}if(C(n)){for(let o of n.$pipe)S(o,e);return}if(E(n)){if(e.add(n.$fn),n.args)for(let o of n.args)S(o,e);return}if(g(n)){n.value!==void 0&&typeof n.value=="object"&&S(n.value,e);return}if(y(n)){for(let o of n.conditions)S(o,e);return}let t=n;for(let o of Object.keys(t))S(t[o],e);}function G(n){let e=new Set;for(let t of n){let o=t.indexOf("."),i=t.indexOf("["),s=t.length;o!==-1&&(s=Math.min(s,o)),i!==-1&&(s=Math.min(s,i));let r=t.slice(0,s);r&&e.add(r);}return e}function kn(n){return JSON.stringify(n)}function xn(n,e,t){let o=N(n,{noPrefixes:true}),i=generate(o),s=e.size>0?`const{${[...e].join(",")}}=data??{};`:"",r=t.size>0?`const{${[...t].join(",")}}=scope;`:"";return r?`(function(scope){${r}return function(data){${s}return ${i}}})`:`(function(){return function(data){${s}return ${i}}})`}function D(n,e={}){let{scope:t={},returnCode:o=false}=e,i=T(n),s=G(i),r=j(n),c=kn(n),f=xn(n,s,r);if(o)return {code:f,deps:i,hash:c,dataRoots:[...s],scopeFns:[...r]};let a;try{a=new Function(`return ${f}`)()(t);}catch(u){throw new Error(`AST compilation failed. If this is due to CSP, use the standard compile() function instead. Error: ${u instanceof Error?u.message:String(u)}`)}return {fn:a,deps:i,hash:c}}function Y(n,e,t={}){let{fn:o}=D(n,t);return o(e)}var ie="0.0.1";export{v as ExpressionCache,ie as VERSION,mn as assertValid,_ as cache,dn as cached,en as clearPathCache,O as compile,D as compileAST,x as compilePath,N as dslToAST,pn as evaluate,Y as evaluateAST,G as extractDataRoots,T as extractDeps,j as extractScopeFns,nn as get,tn as getPathCacheSize,rn as hasDeps,V as hasWildcard,g as isCondition,H as isConditionExpr,y as isConditionGroup,h as isConditional,E as isFn,W as isLiteral,C as isPipe,sn as isPure,m as isRef,gn as isValid,k as normalizePath,z as validate,K as wrapInFunction};

package/package.json

@@ -0,0 +1,58 @@
+{
+  "name": "@statedelta-libs/expressions",
+  "version": "0.0.1",
+  "description": "JSON DSL compiler for optimized functions - StateDelta expression engine",
+  "type": "module",
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs"
+    }
+  },
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsup --watch",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "test:coverage": "vitest run --coverage",
+    "typecheck": "tsc --noEmit",
+    "clean": "rm -rf dist",
+    "format": "prettier --write \"src/**/*.ts\"",
+    "format:check": "prettier --check \"src/**/*.ts\""
+  },
+  "dependencies": {
+    "@statedelta-libs/conditions": "workspace:*",
+    "omni-ast": "^2.0.0"
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "sideEffects": false,
+  "engines": {
+    "node": ">=18"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/andersondrosa/statedelta.git",
+    "directory": "engine/expressions"
+  },
+  "keywords": [
+    "statedelta",
+    "expressions",
+    "dsl",
+    "compiler",
+    "json",
+    "functional",
+    "typescript"
+  ],
+  "author": "Anderson D. Rosa <andersondrosa@outlook.com>",
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  }
+}