@stackone/expressions 0.14.0 → 0.15.1

package/dist/index.d.mts

@@ -0,0 +1,11 @@
+//#region src/evaluate.d.ts
+declare const evaluateExpression: (expression?: string | null, context?: unknown, options?: {
+  incrementalJsonPath?: boolean;
+}) => unknown;
+declare const safeEvaluateExpression: (expression?: string | null, context?: unknown) => unknown;
+declare const safeEvaluateRecord: (record: Record<string, unknown>, context?: unknown) => Record<string, unknown>;
+//#endregion
+//#region src/validate.d.ts
+declare const isValidExpression: (expression?: string | null) => boolean;
+//#endregion
+export { evaluateExpression as evaluate, isValidExpression, safeEvaluateExpression as safeEvaluate, safeEvaluateRecord };

package/dist/index.d.ts

@@ -0,0 +1,11 @@
+//#region src/evaluate.d.ts
+declare const evaluateExpression: (expression?: string | null, context?: unknown, options?: {
+  incrementalJsonPath?: boolean;
+}) => unknown;
+declare const safeEvaluateExpression: (expression?: string | null, context?: unknown) => unknown;
+declare const safeEvaluateRecord: (record: Record<string, unknown>, context?: unknown) => Record<string, unknown>;
+//#endregion
+//#region src/validate.d.ts
+declare const isValidExpression: (expression?: string | null) => boolean;
+//#endregion
+export { evaluateExpression as evaluate, isValidExpression, safeEvaluateExpression as safeEvaluate, safeEvaluateRecord };

package/dist/index.js

@@ -1 +1,274 @@
-"use strict";var r=require("@stackone/utils"),e=require("jexl"),t=require("jsonpath-plus"),n=require("lodash.get");function a(r){var e=Object.create(null);return r&&Object.keys(r).forEach((function(t){if("default"!==t){var n=Object.getOwnPropertyDescriptor(r,t);Object.defineProperty(e,t,n.get?n:{enumerable:!0,get:function(){return r[t]}})}})),e.default=r,Object.freeze(e)}var i=a(e);const s=/\${([^}]+)}/g,o=(r,e)=>{try{return r.compile(e)}catch{return null}},c=(r,e)=>{try{if(!r.startsWith("$"))throw new Error(`JSONPath expression must start with '$': ${r}`);if(r.includes("$_")||r.match(/\$[^.\[]/g)||r.includes("[")&&!r.includes("]")||r.includes(" ")&&!r.includes("["))throw new Error(`Invalid JSONPath expression: ${r}`);const n=t.JSONPath({path:r,json:e});if(0===n.length)return;return 1===n.length?n[0]:n}catch{throw new Error(`Invalid JSONPath expression: ${r}`)}},l=(r,e,t)=>r.replace(e,String(t)),u=(e,t,a)=>{const i=e.match(s);if(!i)return;const c=i.length,u=new Array(c);for(let r=0;r<c;r++)u[r]={toReplace:i[r],path:i[r].slice(2,-1)};return u.reduce(((e,i)=>((e,t,a,i)=>{const s=e.path.trim();if(!s)return i;try{const c=o(t,s);if(c){const r=c.evalSync(a);if(void 0!==r)return l(i,e.toReplace,r)}const u=n(a,s);return r.notMissing(u)?l(i,e.toReplace,u):i}catch{return i}})(i,a,t,e)),String(e))},d=(e,t,n,a)=>{if(Array.isArray(t)){const r=parseInt(n,10);if(!isNaN(r)&&(r<0||r>=t.length))return{value:void 0,error:`Invalid array index '${n}' at '${a}'`,availableKeys:t.map(((r,e)=>e.toString()))}}return r.isObject(t)?{value:void 0,error:`Key '${n}' not found at '${a}'`,availableKeys:Object.keys(t)}:{value:void 0,error:`${e} at '${a}'`,availableKeys:[]}},y=(e,t)=>{const n=/(\.\.)|(\[\*\])|(\[\?\()|(\[\d+:\d+\])/;try{if(n.test(e)){const r=c(e,t);return void 0===r?{value:void 0,error:`Invalid or empty JSONPath: '${e}'`}:{value:r}}const a=e.match(/\$|(?:\['([^']+)'\])|(?:\["([^"]+)"\])|\[\d+\]|[^[\].]+/g)||[];return((e,t)=>{if("$"!==e[0])return{value:void 0,error:"JSON path must start with $"};let n=t,a="$";for(let t=1;t<e.length;t++){const i=e[t],s=i.startsWith("[")?`${a}${i}`:`${a}.${i}`;if(Array.isArray(n)){const r=parseInt(i,10);if(isNaN(r)||r<0||r>=n.length)return d("Invalid array index",n,i,a);n=n[r],a=s}else{if(!r.isObject(n))return{value:void 0,error:`Cannot access '${i}' at '${a}' - parent is not an object`,availableKeys:[]};if(!Object.prototype.hasOwnProperty.call(n,i))return d("Key not found",n,i,a);n=n[i],a=s}}return{value:n}})(a.map((r=>r.replace(/^\['([^']+)'\]$/,"$1").replace(/^\["([^"]+)"\]$/,"$1").replace(/^\[(\d+)\]$/,"$1"))),t)}catch(r){return{value:void 0,error:`Something went wrong with evaluation of JSON path: ${String(r)}`}}},h=(e,t,n)=>{const a=e?.trim();if(null==a||""===a)throw new Error("Empty expression");const s=r.isObject(t)?t:{},l=((e=()=>new i.Jexl)=>{const t=e();return t.addFunction("nextAnniversary",((e,t)=>r.calculateNextAnniversary({initialDate:e,format:t}))),t.addFunction("yearsElapsed",((e,t,n)=>r.calculateYearsElapsed({startDate:e,endDate:n,format:t}))),t.addFunction("hasPassed",((e,t,n)=>r.dateHasPassed({date:e,yearsToAdd:n,format:t}))),t.addFunction("now",(()=>(new Date).toISOString())),t.addFunction("includes",((e,t)=>!(r.isMissing(e)||!Array.isArray(e)||0===e.length||r.isMissing(t))&&(Array.isArray(t)?t.every((r=>e.includes(r))):e.includes(t)))),t.addFunction("includesSome",((e,t)=>!(r.isMissing(e)||!Array.isArray(e)||0===e.length||r.isMissing(t))&&(Array.isArray(t)?t.some((r=>e.includes(r))):e.includes(t)))),t.addFunction("present",(e=>r.notMissing(e))),t.addFunction("missing",(e=>r.isMissing(e))),t.addFunction("keys",(e=>r.isMissing(e)||"object"!=typeof e||Array.isArray(e)?[]:Object.keys(e))),t.addFunction("values",(e=>r.isMissing(e)||"object"!=typeof e||Array.isArray(e)?[]:Object.values(e))),t.addBinaryOp("??",0,((e,t)=>r.isMissing(e)?t:r.isMissing(t)?e:e??t)),t})(),d=(r=>{if(r.startsWith("{{")&&r.endsWith("}}"))return r.slice(2,-2)})(a),h=(r=>r.replace(/\$\./g,"").trim())(d??a),p=u(h,s,l);if(p)return p;if(!d&&a.startsWith("$"))return n?.incrementalJsonPath?((r,e)=>{const t=y(r,e);if(t.error)throw new Error(`${t.error}${t.availableKeys?.length?`. Available keys: ${t.availableKeys.join(", ")}`:""}`);return t.value})(a,s):((r,e)=>{try{return c(r,e)}catch{throw new Error(`Invalid JSON path: "${r}"`)}})(a,s);if(!p&&!d)return e;const v=o(l,h);if(!v||"."===h)throw new Error(`Invalid expression: "${a}"`);try{return v.evalSync(s)}catch{return}},p=(r,e)=>{try{return h(r,e)}catch{return null}},v=(r,e)=>{const t=r=>Array.isArray(r)?r.map(t):"object"==typeof r&&null!==r?v(r,e):"string"==typeof r?p(r,e):r;return Object.fromEntries(Object.entries(r).map((([r,e])=>[r,t(e)])))};exports.evaluate=h,exports.isValidExpression=r=>{try{return h(r),!0}catch{return!1}},exports.safeEvaluate=p,exports.safeEvaluateRecord=v;
+//#region rolldown:runtime
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+
+//#endregion
+const __stackone_utils = __toESM(require("@stackone/utils"));
+const jexl = __toESM(require("jexl"));
+const jsonpath_plus = __toESM(require("jsonpath-plus"));
+const lodash_get = __toESM(require("lodash.get"));
+
+//#region src/factory.ts
+const createExpressionHandler = (instanceBuilder = () => new jexl.Jexl()) => {
+	const expressionHandler = instanceBuilder();
+	expressionHandler.addFunction("nextAnniversary", (initialDate, format) => (0, __stackone_utils.calculateNextAnniversary)({
+		initialDate,
+		format
+	}));
+	expressionHandler.addFunction("yearsElapsed", (startDate, format, endDate) => (0, __stackone_utils.calculateYearsElapsed)({
+		startDate,
+		endDate,
+		format
+	}));
+	expressionHandler.addFunction("hasPassed", (date, format, yearsToAdd) => (0, __stackone_utils.dateHasPassed)({
+		date,
+		yearsToAdd,
+		format
+	}));
+	expressionHandler.addFunction("now", () => (/* @__PURE__ */ new Date()).toISOString());
+	expressionHandler.addFunction("includes", (array, value) => {
+		if ((0, __stackone_utils.isMissing)(array) || !Array.isArray(array) || array.length === 0 || (0, __stackone_utils.isMissing)(value)) return false;
+		if (Array.isArray(value)) return value.every((val) => array.includes(val));
+		return array.includes(value);
+	});
+	expressionHandler.addFunction("includesSome", (array, value) => {
+		if ((0, __stackone_utils.isMissing)(array) || !Array.isArray(array) || array.length === 0 || (0, __stackone_utils.isMissing)(value)) return false;
+		if (Array.isArray(value)) return value.some((val) => array.includes(val));
+		return array.includes(value);
+	});
+	expressionHandler.addFunction("present", (value) => (0, __stackone_utils.notMissing)(value));
+	expressionHandler.addFunction("missing", (value) => (0, __stackone_utils.isMissing)(value));
+	expressionHandler.addFunction("keys", (value) => {
+		if ((0, __stackone_utils.isMissing)(value)) return [];
+		else if (typeof value === "object" && !Array.isArray(value)) return Object.keys(value);
+		else return [];
+	});
+	expressionHandler.addFunction("values", (value) => {
+		if ((0, __stackone_utils.isMissing)(value)) return [];
+		else if (typeof value === "object" && !Array.isArray(value)) return Object.values(value);
+		else return [];
+	});
+	expressionHandler.addBinaryOp("??", 0, (left, right) => {
+		if ((0, __stackone_utils.isMissing)(left)) return right;
+		else if ((0, __stackone_utils.isMissing)(right)) return left;
+		else return left ?? right;
+	});
+	return expressionHandler;
+};
+
+//#endregion
+//#region src/constants.ts
+const INTERPOLATED_EXPRESSION_REGEX = /\${([^}]+)}/g;
+
+//#endregion
+//#region src/utils.ts
+const cleanExpression = (expression) => {
+	return expression.replace(/\$\./g, "").trim();
+};
+const compileExpression = (expressionHandler, expression) => {
+	try {
+		const compiledExpression = expressionHandler.compile(expression);
+		return compiledExpression;
+	} catch {
+		return null;
+	}
+};
+const extractExpressionBetweenDoubleCurlyBraces = (expression) => {
+	if (expression.startsWith("{{") && expression.endsWith("}}")) return expression.slice(2, -2);
+};
+const evaluateJsonPath = (expression, context) => {
+	try {
+		if (!expression.startsWith("$")) throw new Error(`JSONPath expression must start with '$': ${expression}`);
+		if (expression.includes("$_") || expression.match(/\$[^.[]/g) || expression.includes("[") && !expression.includes("]") || expression.includes(" ") && !expression.includes("[")) throw new Error(`Invalid JSONPath expression: ${expression}`);
+		const result = (0, jsonpath_plus.JSONPath)({
+			path: expression,
+			json: context
+		});
+		if (result.length === 0) return void 0;
+		if (result.length === 1) return result[0];
+		return result;
+	} catch {
+		throw new Error(`Invalid JSONPath expression: ${expression}`);
+	}
+};
+const replaceInterpolation = (expression, toReplace, value) => expression.replace(toReplace, String(value));
+const handleSingleInterpolation = (interpolation, expressionHandler, context, currentExpression) => {
+	const path = interpolation.path.trim();
+	if (!path) return currentExpression;
+	try {
+		const compiledExpression = compileExpression(expressionHandler, path);
+		if (compiledExpression) {
+			const value = compiledExpression.evalSync(context);
+			if (value !== void 0) return replaceInterpolation(currentExpression, interpolation.toReplace, value);
+		}
+		const pathValue = (0, lodash_get.default)(context, path);
+		return (0, __stackone_utils.notMissing)(pathValue) ? replaceInterpolation(currentExpression, interpolation.toReplace, pathValue) : currentExpression;
+	} catch {
+		return currentExpression;
+	}
+};
+const evaluateStringInterpolations = (expression, context, expressionHandler) => {
+	const matches = expression.match(INTERPOLATED_EXPRESSION_REGEX);
+	if (!matches) return void 0;
+	const len = matches.length;
+	const interpolations = new Array(len);
+	for (let i = 0; i < len; i++) interpolations[i] = {
+		toReplace: matches[i],
+		path: matches[i].slice(2, -1)
+	};
+	return interpolations.reduce((acc, interpolation) => handleSingleInterpolation(interpolation, expressionHandler, context, acc), String(expression));
+};
+const handleSegmentPathError = (err, parentVal, segment, parentPath) => {
+	if (Array.isArray(parentVal)) {
+		const parsedIndex = parseInt(segment, 10);
+		if (!isNaN(parsedIndex) && (parsedIndex < 0 || parsedIndex >= parentVal.length)) return {
+			value: void 0,
+			error: `Invalid array index '${segment}' at '${parentPath}'`,
+			availableKeys: parentVal.map((_, idx) => idx.toString())
+		};
+	}
+	if ((0, __stackone_utils.isObject)(parentVal)) return {
+		value: void 0,
+		error: `Key '${segment}' not found at '${parentPath}'`,
+		availableKeys: Object.keys(parentVal)
+	};
+	return {
+		value: void 0,
+		error: `${err} at '${parentPath}'`,
+		availableKeys: []
+	};
+};
+const handleJsonPathSegments = (segments, ctx) => {
+	if (segments[0] !== "$") return {
+		value: void 0,
+		error: "JSON path must start with $"
+	};
+	let currentValue = ctx;
+	let currentPath = "$";
+	for (let i = 1; i < segments.length; i++) {
+		const segment = segments[i];
+		const nextPath = segment.startsWith("[") ? `${currentPath}${segment}` : `${currentPath}.${segment}`;
+		if (Array.isArray(currentValue)) {
+			const idx = parseInt(segment, 10);
+			if (isNaN(idx) || idx < 0 || idx >= currentValue.length) return handleSegmentPathError("Invalid array index", currentValue, segment, currentPath);
+			currentValue = currentValue[idx];
+			currentPath = nextPath;
+		} else if ((0, __stackone_utils.isObject)(currentValue)) {
+			if (!Object.prototype.hasOwnProperty.call(currentValue, segment)) return handleSegmentPathError("Key not found", currentValue, segment, currentPath);
+			currentValue = currentValue[segment];
+			currentPath = nextPath;
+		} else return {
+			value: void 0,
+			error: `Cannot access '${segment}' at '${currentPath}' - parent is not an object`,
+			availableKeys: []
+		};
+	}
+	return { value: currentValue };
+};
+const evaluateJsonPathIncremental = (path, context) => {
+	const SPECIAL_JSONPATH_REGEX = /(\.\.)|(\[\*\])|(\[\?\()|(\[\d+:\d+\])/;
+	try {
+		if (SPECIAL_JSONPATH_REGEX.test(path)) {
+			const result = evaluateJsonPath(path, context);
+			if (result === void 0) return {
+				value: void 0,
+				error: `Invalid or empty JSONPath: '${path}'`
+			};
+			return { value: result };
+		}
+		const segments = path.match(/\$|(?:\['([^']+)'\])|(?:\["([^"]+)"\])|\[\d+\]|[^[\].]+/g) || [];
+		const cleanedSegments = segments.map((seg) => seg.replace(/^\['([^']+)'\]$/, "$1").replace(/^\["([^"]+)"\]$/, "$1").replace(/^\[(\d+)\]$/, "$1"));
+		return handleJsonPathSegments(cleanedSegments, context);
+	} catch (error) {
+		return {
+			value: void 0,
+			error: `Something went wrong with evaluation of JSON path: ${String(error)}`
+		};
+	}
+};
+
+//#endregion
+//#region src/evaluate.ts
+const handleIncrementalJsonPath = (expr, ctx) => {
+	const result = evaluateJsonPathIncremental(expr, ctx);
+	if (result.error) throw new Error(`${result.error}${result.availableKeys?.length ? `. Available keys: ${result.availableKeys.join(", ")}` : ""}`);
+	return result.value;
+};
+const handleNormalJsonPath = (expr, ctx) => {
+	try {
+		return evaluateJsonPath(expr, ctx);
+	} catch {
+		throw new Error(`Invalid JSON path: "${expr}"`);
+	}
+};
+const evaluateExpression = (expression, context, options) => {
+	const trimmedExpression = expression?.trim();
+	if (trimmedExpression === null || trimmedExpression === void 0 || trimmedExpression === "") throw new Error("Empty expression");
+	const expressionContext = (0, __stackone_utils.isObject)(context) ? context : {};
+	const expressionHandler = createExpressionHandler();
+	const expressionBetweenDoubleCurlyBraces = extractExpressionBetweenDoubleCurlyBraces(trimmedExpression);
+	const extractedExpression = expressionBetweenDoubleCurlyBraces ?? trimmedExpression;
+	const cleanedExpression = cleanExpression(extractedExpression);
+	const interpolatedExpression = evaluateStringInterpolations(cleanedExpression, expressionContext, expressionHandler);
+	if (interpolatedExpression) return interpolatedExpression;
+	if (!expressionBetweenDoubleCurlyBraces && trimmedExpression.startsWith("$")) return options?.incrementalJsonPath ? handleIncrementalJsonPath(trimmedExpression, expressionContext) : handleNormalJsonPath(trimmedExpression, expressionContext);
+	if (!interpolatedExpression && !expressionBetweenDoubleCurlyBraces) return expression;
+	const compiledExpression = compileExpression(expressionHandler, cleanedExpression);
+	if (!compiledExpression || cleanedExpression === ".") throw new Error(`Invalid expression: "${trimmedExpression}"`);
+	try {
+		return compiledExpression.evalSync(expressionContext);
+	} catch {
+		return void 0;
+	}
+};
+const safeEvaluateExpression = (expression, context) => {
+	try {
+		return evaluateExpression(expression, context);
+	} catch {
+		return null;
+	}
+};
+const safeEvaluateRecord = (record, context) => {
+	const evaluateValue = (value) => {
+		if (Array.isArray(value)) return value.map(evaluateValue);
+		else if (typeof value === "object" && value !== null) return safeEvaluateRecord(value, context);
+		else if (typeof value === "string") return safeEvaluateExpression(value, context);
+		return value;
+	};
+	return Object.fromEntries(Object.entries(record).map(([key, value]) => [key, evaluateValue(value)]));
+};
+
+//#endregion
+//#region src/validate.ts
+const isValidExpression = (expression) => {
+	try {
+		evaluateExpression(expression);
+		return true;
+	} catch {
+		return false;
+	}
+};
+
+//#endregion
+exports.evaluate = evaluateExpression;
+exports.isValidExpression = isValidExpression;
+exports.safeEvaluate = safeEvaluateExpression;
+exports.safeEvaluateRecord = safeEvaluateRecord;

package/dist/index.mjs

@@ -0,0 +1,248 @@
+import { calculateNextAnniversary, calculateYearsElapsed, dateHasPassed, isMissing, isObject, notMissing } from "@stackone/utils";
+import * as jexl from "jexl";
+import { JSONPath } from "jsonpath-plus";
+import get from "lodash.get";
+
+//#region src/factory.ts
+const createExpressionHandler = (instanceBuilder = () => new jexl.Jexl()) => {
+	const expressionHandler = instanceBuilder();
+	expressionHandler.addFunction("nextAnniversary", (initialDate, format) => calculateNextAnniversary({
+		initialDate,
+		format
+	}));
+	expressionHandler.addFunction("yearsElapsed", (startDate, format, endDate) => calculateYearsElapsed({
+		startDate,
+		endDate,
+		format
+	}));
+	expressionHandler.addFunction("hasPassed", (date, format, yearsToAdd) => dateHasPassed({
+		date,
+		yearsToAdd,
+		format
+	}));
+	expressionHandler.addFunction("now", () => (/* @__PURE__ */ new Date()).toISOString());
+	expressionHandler.addFunction("includes", (array, value) => {
+		if (isMissing(array) || !Array.isArray(array) || array.length === 0 || isMissing(value)) return false;
+		if (Array.isArray(value)) return value.every((val) => array.includes(val));
+		return array.includes(value);
+	});
+	expressionHandler.addFunction("includesSome", (array, value) => {
+		if (isMissing(array) || !Array.isArray(array) || array.length === 0 || isMissing(value)) return false;
+		if (Array.isArray(value)) return value.some((val) => array.includes(val));
+		return array.includes(value);
+	});
+	expressionHandler.addFunction("present", (value) => notMissing(value));
+	expressionHandler.addFunction("missing", (value) => isMissing(value));
+	expressionHandler.addFunction("keys", (value) => {
+		if (isMissing(value)) return [];
+		else if (typeof value === "object" && !Array.isArray(value)) return Object.keys(value);
+		else return [];
+	});
+	expressionHandler.addFunction("values", (value) => {
+		if (isMissing(value)) return [];
+		else if (typeof value === "object" && !Array.isArray(value)) return Object.values(value);
+		else return [];
+	});
+	expressionHandler.addBinaryOp("??", 0, (left, right) => {
+		if (isMissing(left)) return right;
+		else if (isMissing(right)) return left;
+		else return left ?? right;
+	});
+	return expressionHandler;
+};
+
+//#endregion
+//#region src/constants.ts
+const INTERPOLATED_EXPRESSION_REGEX = /\${([^}]+)}/g;
+
+//#endregion
+//#region src/utils.ts
+const cleanExpression = (expression) => {
+	return expression.replace(/\$\./g, "").trim();
+};
+const compileExpression = (expressionHandler, expression) => {
+	try {
+		const compiledExpression = expressionHandler.compile(expression);
+		return compiledExpression;
+	} catch {
+		return null;
+	}
+};
+const extractExpressionBetweenDoubleCurlyBraces = (expression) => {
+	if (expression.startsWith("{{") && expression.endsWith("}}")) return expression.slice(2, -2);
+};
+const evaluateJsonPath = (expression, context) => {
+	try {
+		if (!expression.startsWith("$")) throw new Error(`JSONPath expression must start with '$': ${expression}`);
+		if (expression.includes("$_") || expression.match(/\$[^.[]/g) || expression.includes("[") && !expression.includes("]") || expression.includes(" ") && !expression.includes("[")) throw new Error(`Invalid JSONPath expression: ${expression}`);
+		const result = JSONPath({
+			path: expression,
+			json: context
+		});
+		if (result.length === 0) return void 0;
+		if (result.length === 1) return result[0];
+		return result;
+	} catch {
+		throw new Error(`Invalid JSONPath expression: ${expression}`);
+	}
+};
+const replaceInterpolation = (expression, toReplace, value) => expression.replace(toReplace, String(value));
+const handleSingleInterpolation = (interpolation, expressionHandler, context, currentExpression) => {
+	const path = interpolation.path.trim();
+	if (!path) return currentExpression;
+	try {
+		const compiledExpression = compileExpression(expressionHandler, path);
+		if (compiledExpression) {
+			const value = compiledExpression.evalSync(context);
+			if (value !== void 0) return replaceInterpolation(currentExpression, interpolation.toReplace, value);
+		}
+		const pathValue = get(context, path);
+		return notMissing(pathValue) ? replaceInterpolation(currentExpression, interpolation.toReplace, pathValue) : currentExpression;
+	} catch {
+		return currentExpression;
+	}
+};
+const evaluateStringInterpolations = (expression, context, expressionHandler) => {
+	const matches = expression.match(INTERPOLATED_EXPRESSION_REGEX);
+	if (!matches) return void 0;
+	const len = matches.length;
+	const interpolations = new Array(len);
+	for (let i = 0; i < len; i++) interpolations[i] = {
+		toReplace: matches[i],
+		path: matches[i].slice(2, -1)
+	};
+	return interpolations.reduce((acc, interpolation) => handleSingleInterpolation(interpolation, expressionHandler, context, acc), String(expression));
+};
+const handleSegmentPathError = (err, parentVal, segment, parentPath) => {
+	if (Array.isArray(parentVal)) {
+		const parsedIndex = parseInt(segment, 10);
+		if (!isNaN(parsedIndex) && (parsedIndex < 0 || parsedIndex >= parentVal.length)) return {
+			value: void 0,
+			error: `Invalid array index '${segment}' at '${parentPath}'`,
+			availableKeys: parentVal.map((_, idx) => idx.toString())
+		};
+	}
+	if (isObject(parentVal)) return {
+		value: void 0,
+		error: `Key '${segment}' not found at '${parentPath}'`,
+		availableKeys: Object.keys(parentVal)
+	};
+	return {
+		value: void 0,
+		error: `${err} at '${parentPath}'`,
+		availableKeys: []
+	};
+};
+const handleJsonPathSegments = (segments, ctx) => {
+	if (segments[0] !== "$") return {
+		value: void 0,
+		error: "JSON path must start with $"
+	};
+	let currentValue = ctx;
+	let currentPath = "$";
+	for (let i = 1; i < segments.length; i++) {
+		const segment = segments[i];
+		const nextPath = segment.startsWith("[") ? `${currentPath}${segment}` : `${currentPath}.${segment}`;
+		if (Array.isArray(currentValue)) {
+			const idx = parseInt(segment, 10);
+			if (isNaN(idx) || idx < 0 || idx >= currentValue.length) return handleSegmentPathError("Invalid array index", currentValue, segment, currentPath);
+			currentValue = currentValue[idx];
+			currentPath = nextPath;
+		} else if (isObject(currentValue)) {
+			if (!Object.prototype.hasOwnProperty.call(currentValue, segment)) return handleSegmentPathError("Key not found", currentValue, segment, currentPath);
+			currentValue = currentValue[segment];
+			currentPath = nextPath;
+		} else return {
+			value: void 0,
+			error: `Cannot access '${segment}' at '${currentPath}' - parent is not an object`,
+			availableKeys: []
+		};
+	}
+	return { value: currentValue };
+};
+const evaluateJsonPathIncremental = (path, context) => {
+	const SPECIAL_JSONPATH_REGEX = /(\.\.)|(\[\*\])|(\[\?\()|(\[\d+:\d+\])/;
+	try {
+		if (SPECIAL_JSONPATH_REGEX.test(path)) {
+			const result = evaluateJsonPath(path, context);
+			if (result === void 0) return {
+				value: void 0,
+				error: `Invalid or empty JSONPath: '${path}'`
+			};
+			return { value: result };
+		}
+		const segments = path.match(/\$|(?:\['([^']+)'\])|(?:\["([^"]+)"\])|\[\d+\]|[^[\].]+/g) || [];
+		const cleanedSegments = segments.map((seg) => seg.replace(/^\['([^']+)'\]$/, "$1").replace(/^\["([^"]+)"\]$/, "$1").replace(/^\[(\d+)\]$/, "$1"));
+		return handleJsonPathSegments(cleanedSegments, context);
+	} catch (error) {
+		return {
+			value: void 0,
+			error: `Something went wrong with evaluation of JSON path: ${String(error)}`
+		};
+	}
+};
+
+//#endregion
+//#region src/evaluate.ts
+const handleIncrementalJsonPath = (expr, ctx) => {
+	const result = evaluateJsonPathIncremental(expr, ctx);
+	if (result.error) throw new Error(`${result.error}${result.availableKeys?.length ? `. Available keys: ${result.availableKeys.join(", ")}` : ""}`);
+	return result.value;
+};
+const handleNormalJsonPath = (expr, ctx) => {
+	try {
+		return evaluateJsonPath(expr, ctx);
+	} catch {
+		throw new Error(`Invalid JSON path: "${expr}"`);
+	}
+};
+const evaluateExpression = (expression, context, options) => {
+	const trimmedExpression = expression?.trim();
+	if (trimmedExpression === null || trimmedExpression === void 0 || trimmedExpression === "") throw new Error("Empty expression");
+	const expressionContext = isObject(context) ? context : {};
+	const expressionHandler = createExpressionHandler();
+	const expressionBetweenDoubleCurlyBraces = extractExpressionBetweenDoubleCurlyBraces(trimmedExpression);
+	const extractedExpression = expressionBetweenDoubleCurlyBraces ?? trimmedExpression;
+	const cleanedExpression = cleanExpression(extractedExpression);
+	const interpolatedExpression = evaluateStringInterpolations(cleanedExpression, expressionContext, expressionHandler);
+	if (interpolatedExpression) return interpolatedExpression;
+	if (!expressionBetweenDoubleCurlyBraces && trimmedExpression.startsWith("$")) return options?.incrementalJsonPath ? handleIncrementalJsonPath(trimmedExpression, expressionContext) : handleNormalJsonPath(trimmedExpression, expressionContext);
+	if (!interpolatedExpression && !expressionBetweenDoubleCurlyBraces) return expression;
+	const compiledExpression = compileExpression(expressionHandler, cleanedExpression);
+	if (!compiledExpression || cleanedExpression === ".") throw new Error(`Invalid expression: "${trimmedExpression}"`);
+	try {
+		return compiledExpression.evalSync(expressionContext);
+	} catch {
+		return void 0;
+	}
+};
+const safeEvaluateExpression = (expression, context) => {
+	try {
+		return evaluateExpression(expression, context);
+	} catch {
+		return null;
+	}
+};
+const safeEvaluateRecord = (record, context) => {
+	const evaluateValue = (value) => {
+		if (Array.isArray(value)) return value.map(evaluateValue);
+		else if (typeof value === "object" && value !== null) return safeEvaluateRecord(value, context);
+		else if (typeof value === "string") return safeEvaluateExpression(value, context);
+		return value;
+	};
+	return Object.fromEntries(Object.entries(record).map(([key, value]) => [key, evaluateValue(value)]));
+};
+
+//#endregion
+//#region src/validate.ts
+const isValidExpression = (expression) => {
+	try {
+		evaluateExpression(expression);
+		return true;
+	} catch {
+		return false;
+	}
+};
+
+//#endregion
+export { evaluateExpression as evaluate, isValidExpression, safeEvaluateExpression as safeEvaluate, safeEvaluateRecord };

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@stackone/expressions",
-    "version": "0.14.0",
+    "version": "0.15.1",
     "description": "",
     "main": "dist/index.js",
     "module": "dist/index.es.mjs",
@@ -10,12 +10,20 @@
         "package.json",
         "README.md"
     ],
+    "exports": {
+        ".": {
+            "types": "./dist/types/index.d.ts",
+            "import": "./dist/index.es.mjs",
+            "require": "./dist/index.js"
+        },
+        "./package.json": "./package.json"
+    },
     "scripts": {
         "clean": "rimraf dist",
         "prebuild": "npm run clean",
-        "build": "rollup -c --environment NODE_ENV:production",
+        "build": "tsdown --env.NODE_ENV=production",
         "prebuild:dev": "npm run clean",
-        "build:dev": "rollup -c --environment NODE_ENV:development",
+        "build:dev": "tsdown --env.NODE_ENV=development",
         "code:format": "biome format ./src ./*.mjs",
         "code:format:fix": "biome format --write ./src ./*.mjs",
         "code:lint": "biome lint --error-on-warnings ./src ./*.mjs",
@@ -40,5 +48,12 @@
     "devDependencies": {
         "@types/jexl": "^2.3.4",
         "@types/lodash.get": "^4.4.9"
+    },
+    "tsdown": {
+        "dts": true,
+        "format": [
+            "esm",
+            "cjs"
+        ]
     }
 }

package/dist/index.es.mjs

@@ -1 +0,0 @@
-import{calculateNextAnniversary as r,calculateYearsElapsed as t,dateHasPassed as e,isMissing as n,notMissing as a,isObject as i}from"@stackone/utils";import*as o from"jexl";import{JSONPath as s}from"jsonpath-plus";import l from"lodash.get";const c=/\${([^}]+)}/g,u=(r,t)=>{try{return r.compile(t)}catch{return null}},d=(r,t)=>{try{if(!r.startsWith("$"))throw new Error(`JSONPath expression must start with '$': ${r}`);if(r.includes("$_")||r.match(/\$[^.\[]/g)||r.includes("[")&&!r.includes("]")||r.includes(" ")&&!r.includes("["))throw new Error(`Invalid JSONPath expression: ${r}`);const e=s({path:r,json:t});if(0===e.length)return;return 1===e.length?e[0]:e}catch{throw new Error(`Invalid JSONPath expression: ${r}`)}},y=(r,t,e)=>r.replace(t,String(e)),h=(r,t,e)=>{const n=r.match(c);if(!n)return;const i=n.length,o=new Array(i);for(let r=0;r<i;r++)o[r]={toReplace:n[r],path:n[r].slice(2,-1)};return o.reduce(((r,n)=>((r,t,e,n)=>{const i=r.path.trim();if(!i)return n;try{const o=u(t,i);if(o){const t=o.evalSync(e);if(void 0!==t)return y(n,r.toReplace,t)}const s=l(e,i);return a(s)?y(n,r.toReplace,s):n}catch{return n}})(n,e,t,r)),String(r))},p=(r,t,e,n)=>{if(Array.isArray(t)){const r=parseInt(e,10);if(!isNaN(r)&&(r<0||r>=t.length))return{value:void 0,error:`Invalid array index '${e}' at '${n}'`,availableKeys:t.map(((r,t)=>t.toString()))}}return i(t)?{value:void 0,error:`Key '${e}' not found at '${n}'`,availableKeys:Object.keys(t)}:{value:void 0,error:`${r} at '${n}'`,availableKeys:[]}},v=(r,t)=>{const e=/(\.\.)|(\[\*\])|(\[\?\()|(\[\d+:\d+\])/;try{if(e.test(r)){const e=d(r,t);return void 0===e?{value:void 0,error:`Invalid or empty JSONPath: '${r}'`}:{value:e}}const n=r.match(/\$|(?:\['([^']+)'\])|(?:\["([^"]+)"\])|\[\d+\]|[^[\].]+/g)||[];return((r,t)=>{if("$"!==r[0])return{value:void 0,error:"JSON path must start with $"};let e=t,n="$";for(let t=1;t<r.length;t++){const a=r[t],o=a.startsWith("[")?`${n}${a}`:`${n}.${a}`;if(Array.isArray(e)){const r=parseInt(a,10);if(isNaN(r)||r<0||r>=e.length)return p("Invalid array index",e,a,n);e=e[r],n=o}else{if(!i(e))return{value:void 0,error:`Cannot access '${a}' at '${n}' - parent is not an object`,availableKeys:[]};if(!Object.prototype.hasOwnProperty.call(e,a))return p("Key not found",e,a,n);e=e[a],n=o}}return{value:e}})(n.map((r=>r.replace(/^\['([^']+)'\]$/,"$1").replace(/^\["([^"]+)"\]$/,"$1").replace(/^\[(\d+)\]$/,"$1"))),t)}catch(r){return{value:void 0,error:`Something went wrong with evaluation of JSON path: ${String(r)}`}}},f=(s,l,c)=>{const y=s?.trim();if(null==y||""===y)throw new Error("Empty expression");const p=i(l)?l:{},f=((i=()=>new o.Jexl)=>{const s=i();return s.addFunction("nextAnniversary",((t,e)=>r({initialDate:t,format:e}))),s.addFunction("yearsElapsed",((r,e,n)=>t({startDate:r,endDate:n,format:e}))),s.addFunction("hasPassed",((r,t,n)=>e({date:r,yearsToAdd:n,format:t}))),s.addFunction("now",(()=>(new Date).toISOString())),s.addFunction("includes",((r,t)=>!(n(r)||!Array.isArray(r)||0===r.length||n(t))&&(Array.isArray(t)?t.every((t=>r.includes(t))):r.includes(t)))),s.addFunction("includesSome",((r,t)=>!(n(r)||!Array.isArray(r)||0===r.length||n(t))&&(Array.isArray(t)?t.some((t=>r.includes(t))):r.includes(t)))),s.addFunction("present",(r=>a(r))),s.addFunction("missing",(r=>n(r))),s.addFunction("keys",(r=>n(r)||"object"!=typeof r||Array.isArray(r)?[]:Object.keys(r))),s.addFunction("values",(r=>n(r)||"object"!=typeof r||Array.isArray(r)?[]:Object.values(r))),s.addBinaryOp("??",0,((r,t)=>n(r)?t:n(t)?r:r??t)),s})(),$=(r=>{if(r.startsWith("{{")&&r.endsWith("}}"))return r.slice(2,-2)})(y),m=(r=>r.replace(/\$\./g,"").trim())($??y),w=h(m,p,f);if(w)return w;if(!$&&y.startsWith("$"))return c?.incrementalJsonPath?((r,t)=>{const e=v(r,t);if(e.error)throw new Error(`${e.error}${e.availableKeys?.length?`. Available keys: ${e.availableKeys.join(", ")}`:""}`);return e.value})(y,p):((r,t)=>{try{return d(r,t)}catch{throw new Error(`Invalid JSON path: "${r}"`)}})(y,p);if(!w&&!$)return s;const g=u(f,m);if(!g||"."===m)throw new Error(`Invalid expression: "${y}"`);try{return g.evalSync(p)}catch{return}},$=(r,t)=>{try{return f(r,t)}catch{return null}},m=(r,t)=>{const e=r=>Array.isArray(r)?r.map(e):"object"==typeof r&&null!==r?m(r,t):"string"==typeof r?$(r,t):r;return Object.fromEntries(Object.entries(r).map((([r,t])=>[r,e(t)])))},w=r=>{try{return f(r),!0}catch{return!1}};export{f as evaluate,w as isValidExpression,$ as safeEvaluate,m as safeEvaluateRecord};

package/dist/types/constants.d.ts

@@ -1 +0,0 @@
-export declare const INTERPOLATED_EXPRESSION_REGEX: RegExp;

package/dist/types/evaluate.d.ts

@@ -1,5 +0,0 @@
-export declare const evaluateExpression: (expression?: string | null, context?: unknown, options?: {
-    incrementalJsonPath?: boolean;
-}) => unknown;
-export declare const safeEvaluateExpression: (expression?: string | null, context?: unknown) => unknown;
-export declare const safeEvaluateRecord: (record: Record<string, unknown>, context?: unknown) => Record<string, unknown>;

package/dist/types/factory.d.ts

@@ -1,39 +0,0 @@
-export declare const createExpressionHandler: (instanceBuilder?: () => {
-    addBinaryOp(operator: string, precedence: number, fn: (left: any, right: any) => any): void;
-    addUnaryOp(operator: string, fn: (right: any) => any): void;
-    addTransform(name: string, fn: (value: any, ...args: any[]) => any): void;
-    addTransforms(map: {
-        [key: string]: (value: any, ...args: any[]) => any;
-    }): void;
-    getTransform(name: string): (value: any, ...args: any[]) => any;
-    addFunction(name: string, fn: (value: any, ...args: any[]) => any): void;
-    addFunctions(map: {
-        [key: string]: (value: any, ...args: any[]) => any;
-    }): void;
-    getFunction(name: string): (value: any, ...args: any[]) => any;
-    eval(expression: string, context?: import("jexl/Expression").Context): Promise<any>;
-    evalSync(expression: string, context?: import("jexl/Expression").Context): any;
-    compile(expression: string): import("jexl/Expression").default;
-    createExpression(expression: string): import("jexl/Expression").default;
-    removeOp(operator: string): void;
-    _grammar: import("jexl/Grammar").default;
-}) => {
-    addBinaryOp(operator: string, precedence: number, fn: (left: any, right: any) => any): void;
-    addUnaryOp(operator: string, fn: (right: any) => any): void;
-    addTransform(name: string, fn: (value: any, ...args: any[]) => any): void;
-    addTransforms(map: {
-        [key: string]: (value: any, ...args: any[]) => any;
-    }): void;
-    getTransform(name: string): (value: any, ...args: any[]) => any;
-    addFunction(name: string, fn: (value: any, ...args: any[]) => any): void;
-    addFunctions(map: {
-        [key: string]: (value: any, ...args: any[]) => any;
-    }): void;
-    getFunction(name: string): (value: any, ...args: any[]) => any;
-    eval(expression: string, context?: import("jexl/Expression").Context): Promise<any>;
-    evalSync(expression: string, context?: import("jexl/Expression").Context): any;
-    compile(expression: string): import("jexl/Expression").default;
-    createExpression(expression: string): import("jexl/Expression").default;
-    removeOp(operator: string): void;
-    _grammar: import("jexl/Grammar").default;
-};

package/dist/types/index.d.ts

@@ -1,3 +0,0 @@
-export { evaluateExpression as evaluate } from './evaluate';
-export { safeEvaluateExpression as safeEvaluate, safeEvaluateRecord } from './evaluate';
-export { isValidExpression } from './validate';

package/dist/types/types.d.ts

@@ -1,8 +0,0 @@
-export type ExpressionContext = {
-    [key: string]: unknown;
-};
-export type JSONPathEvalResult = {
-    value: unknown;
-    error?: string;
-    availableKeys?: string[];
-};

package/dist/types/utils.d.ts

@@ -1,16 +0,0 @@
-import Expression from 'jexl/Expression';
-import { ExpressionContext } from './types';
-export declare const cleanExpression: (expression: string) => string;
-export declare const compileExpression: (expressionHandler: {
-    compile: (expr: string) => Expression;
-}, expression: string) => Expression | null;
-export declare const extractExpressionBetweenDoubleCurlyBraces: (expression: string) => string | undefined;
-export declare const evaluateJsonPath: (expression: string, context: unknown) => unknown;
-export declare const evaluateStringInterpolations: (expression: string, context: ExpressionContext, expressionHandler: {
-    compile: (expr: string) => Expression;
-}) => string | undefined;
-export declare const evaluateJsonPathIncremental: (path: string, context: unknown) => {
-    value: unknown;
-    error?: string;
-    availableKeys?: string[];
-};

package/dist/types/validate.d.ts

@@ -1 +0,0 @@
-export declare const isValidExpression: (expression?: string | null) => boolean;