@posx/core 5.5.337 → 5.5.339

package/build/index.js

@@ -2850,16 +2850,282 @@ const stringHelpers = {
 */
 var string_helpers_default = stringHelpers;
 
+//#endregion
+//#region src/helpers/comparison.helpers.ts
+/**
+* Comparison Helpers for Handlebars
+* Browser-compatible comparison and logical utilities
+*/
+const isOptions = (val) => val && typeof val === "object" && typeof val.fn === "function";
+const getValue = (val, context, options) => {
+	if (isOptions(options)) {
+		if (val) return options.fn ? options.fn(context) : true;
+		return options.inverse ? options.inverse(context) : false;
+	}
+	return val;
+};
+/**
+* Block helper that renders if ALL given values are truthy
+* {{#and a b c}}...{{else}}...{{/and}}
+*/
+const and = function(...args) {
+	const options = args.pop();
+	return getValue(args.every((arg) => !!arg), this, options);
+};
+/**
+* Block helper that renders if ANY given value is truthy
+* {{#or a b c}}...{{else}}...{{/or}}
+*/
+const or = function(...args) {
+	const options = args.pop();
+	return getValue(args.some((arg) => !!arg), this, options);
+};
+/**
+* Returns true if value is falsey
+* {{#not val}}...{{/not}}
+*/
+const not = function(val, options) {
+	return getValue(!val, this, options);
+};
+/**
+* Block helper that renders if a === b (strict equality)
+* {{#eq a b}}...{{else}}...{{/eq}}
+*/
+const eq = function(a, b, options) {
+	if (arguments.length === 2) {
+		options = b;
+		b = options?.hash?.compare;
+	}
+	return getValue(a === b, this, options);
+};
+/**
+* Block helper that renders if a == b (loose equality)
+* {{#is a b}}...{{else}}...{{/is}}
+*/
+const is = function(a, b, options) {
+	if (arguments.length === 2) {
+		options = b;
+		b = options?.hash?.compare;
+	}
+	return getValue(a == b, this, options);
+};
+/**
+* Block helper that renders if a !== b
+* {{#neq a b}}...{{else}}...{{/neq}}
+*/
+const neq = function(a, b, options) {
+	if (arguments.length === 2) {
+		options = b;
+		b = options?.hash?.compare;
+	}
+	return getValue(a !== b, this, options);
+};
+/**
+* Block helper that renders if a != b (loose inequality)
+* {{#isnt a b}}...{{else}}...{{/isnt}}
+*/
+const isnt = function(a, b, options) {
+	if (arguments.length === 2) {
+		options = b;
+		b = options?.hash?.compare;
+	}
+	return getValue(a != b, this, options);
+};
+/**
+* Block helper that renders if a > b
+* {{#gt a b}}...{{else}}...{{/gt}}
+*/
+const gt = function(a, b, options) {
+	if (arguments.length === 2) {
+		options = b;
+		b = options?.hash?.compare;
+	}
+	return getValue(a > b, this, options);
+};
+/**
+* Block helper that renders if a >= b
+* {{#gte a b}}...{{else}}...{{/gte}}
+*/
+const gte = function(a, b, options) {
+	if (arguments.length === 2) {
+		options = b;
+		b = options?.hash?.compare;
+	}
+	return getValue(a >= b, this, options);
+};
+/**
+* Block helper that renders if a < b
+* {{#lt a b}}...{{else}}...{{/lt}}
+*/
+const lt = function(a, b, options) {
+	if (arguments.length === 2) {
+		options = b;
+		b = options?.hash?.compare;
+	}
+	return getValue(a < b, this, options);
+};
+/**
+* Block helper that renders if a <= b
+* {{#lte a b}}...{{else}}...{{/lte}}
+*/
+const lte = function(a, b, options) {
+	if (arguments.length === 2) {
+		options = b;
+		b = options?.hash?.compare;
+	}
+	return getValue(a <= b, this, options);
+};
+/**
+* Generic compare helper with operator
+* {{#compare a "===" b}}...{{/compare}}
+*/
+const compare = function(a, operator, b, options) {
+	if (arguments.length < 4) throw new Error("Helper {{compare}} expects 4 arguments");
+	let result;
+	switch (operator) {
+		case "==":
+			result = a == b;
+			break;
+		case "===":
+			result = a === b;
+			break;
+		case "!=":
+			result = a != b;
+			break;
+		case "!==":
+			result = a !== b;
+			break;
+		case "<":
+			result = a < b;
+			break;
+		case ">":
+			result = a > b;
+			break;
+		case "<=":
+			result = a <= b;
+			break;
+		case ">=":
+			result = a >= b;
+			break;
+		case "typeof":
+			result = typeof a === b;
+			break;
+		default: throw new Error(`Helper {{compare}}: invalid operator: \`${operator}\``);
+	}
+	return getValue(result, this, options);
+};
+/**
+* Block helper that renders if collection contains value
+* {{#contains array "value"}}...{{else}}...{{/contains}}
+*/
+const contains = function(collection, value, options) {
+	if (typeof options === "number") options = arguments[3];
+	if (collection == null) return getValue(false, this, options);
+	if (Array.isArray(collection)) return getValue(collection.includes(value), this, options);
+	if (typeof collection === "string") return getValue(collection.includes(value), this, options);
+	if (typeof collection === "object") return getValue(value in collection, this, options);
+	return getValue(false, this, options);
+};
+const includes = contains;
+/**
+* Block helper that renders if value is in the list
+* {{#in value "a" "b" "c"}}...{{else}}...{{/in}}
+*/
+const inArray = function(value, ...args) {
+	const options = args.pop();
+	return getValue(args.includes(value), this, options);
+};
+/**
+* Find first object in array by property, returns the object for chaining
+* {{findBy modifiers "category_uid" "imc_xxx"}} - returns first matching object
+* {{lookup (findBy modifiers "category_uid" "imc_xxx") "name"}} - get name of found object
+*/
+const findBy = function(collection, prop, value) {
+	if (!Array.isArray(collection)) return null;
+	return collection.find((item) => item && item[prop] === value) || null;
+};
+/**
+* Filter array by property value, returns array for indexing
+* {{filterBy modifiers "category_uid" "imc_xxx"}} - returns matching array
+* {{lookup (filterBy modifiers "category_uid" "imc_xxx") 0}} - get first match
+* {{lookup (lookup (filterBy modifiers "category_uid" "imc_xxx") 0) "name"}} - get name of first match
+*/
+const filterBy = function(collection, prop, value) {
+	if (!Array.isArray(collection)) return [];
+	return collection.filter((item) => item && item[prop] === value);
+};
+/**
+* Returns the first truthy value, or default
+* {{default value "fallback"}}
+*/
+const defaultValue = function(...args) {
+	for (let i = 0; i < args.length - 1; i++) if (args[i] != null) return args[i];
+	return "";
+};
+/**
+* Block helper that renders if neither a nor b is truthy
+* {{#neither a b}}...{{else}}...{{/neither}}
+*/
+const neither = function(a, b, options) {
+	return getValue(!a && !b, this, options);
+};
+/**
+* Block helper that renders if value is even
+* {{#ifEven value}}...{{else}}...{{/ifEven}}
+*/
+const ifEven = function(num, options) {
+	return getValue(num % 2 === 0, this, options);
+};
+/**
+* Block helper that renders if value is odd
+* {{#ifOdd value}}...{{else}}...{{/ifOdd}}
+*/
+const ifOdd = function(num, options) {
+	return getValue(num % 2 !== 0, this, options);
+};
+/**
+* Block helper that renders if b is divisible by a
+* {{#ifNth 3 value}}...{{else}}...{{/ifNth}}
+*/
+const ifNth = function(a, b, options) {
+	return getValue(typeof a === "number" && typeof b === "number" && b % a === 0, this, options);
+};
+const comparisonHelpers = {
+	and,
+	or,
+	not,
+	eq,
+	is,
+	neq,
+	isnt,
+	gt,
+	gte,
+	lt,
+	lte,
+	compare,
+	contains,
+	includes,
+	in: inArray,
+	findBy,
+	filterBy,
+	default: defaultValue,
+	neither,
+	ifEven,
+	ifOdd,
+	ifNth
+};
+var comparison_helpers_default = comparisonHelpers;
+
 //#endregion
 //#region src/helpers/helpers.register.ts
 /**
-* String Helpers Registration - Following handlebars-helpers API pattern
+* Helpers Registration - Following handlebars-helpers API pattern
 *
 * This module follows the same API as the original handlebars-helpers library:
 * helpers({ handlebars: Handlebars })
 */
 /**
-* Register string helpers with Handlebars
+* Register all helpers with Handlebars
 *
 * @param options - Options object with handlebars instance
 * @returns The registered helpers object
@@ -2867,19 +3133,25 @@ var string_helpers_default = stringHelpers;
 * @example
 * ```typescript
 * import Handlebars from 'handlebars';
-* import helpers from './string-helpers-register';
+* import helpers from './helpers.register';
 *
-* // Register all string helpers
+* // Register all helpers
 * helpers({ handlebars: Handlebars });
 *
 * const template = Handlebars.compile('{{camelcase "foo bar baz"}}');
 * console.log(template({})); // 'fooBarBaz'
+*
+* const template2 = Handlebars.compile('{{#eq a b}}equal{{else}}not equal{{/eq}}');
+* console.log(template2({ a: 1, b: 1 })); // 'equal'
 * ```
 */
 function helpers(options) {
 	const hbs = options?.handlebars || options?.hbs || __require("handlebars");
-	Object.keys(string_helpers_default).forEach((helperName) => {
-		hbs.registerHelper(helperName, string_helpers_default[helperName]);
+	Object.keys(string_helpers_default).forEach((name) => {
+		hbs.registerHelper(name, string_helpers_default[name]);
+	});
+	Object.keys(comparison_helpers_default).forEach((name) => {
+		hbs.registerHelper(name, comparison_helpers_default[name]);
 	});
 	return hbs.helpers;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@posx/core",
-  "version": "5.5.337",
+  "version": "5.5.339",
   "description": "POSX core libraries",
   "main": "./build/index.js",
   "author": "Steven Lee",

package/package.publish.json

@@ -1,6 +1,6 @@
 {
   "name": "@posx/core",
-  "version": "5.5.337",
+  "version": "5.5.339",
   "description": "POSX core libraries",
   "type": "module",
   "main": "./build/index.js",