@luxuryescapes/lib-criterion-tree 0.1.0

package/dist/criterion-tree.d.ts

@@ -0,0 +1,29 @@
+export declare const MATCH_TYPES: readonly ['exact', 'not_exact', 'gt', 'gte', 'lt', 'lte', 'is_null', 'is_not_null', 'in', 'contains_substring', 'not_contains_substring', 'starts_with', 'ends_with'];
+export declare const VALUE_TYPES: readonly ['string', 'number', 'boolean', 'array', 'date'];
+export type Match = (typeof MATCH_TYPES)[number];
+export type ValueType = (typeof VALUE_TYPES)[number];
+export type AttributeLeaf = {
+    type: 'attribute';
+    name: string;
+    match: Match;
+    valueType?: ValueType;
+    value?: string | number | boolean | string[];
+};
+export type LogicalNode = {
+    type: 'and' | 'or';
+    children: CriterionNode[];
+};
+export type CriterionNode = AttributeLeaf | LogicalNode | null;
+export type ConditionJoin = 'AND' | 'OR';
+export type ChainedCondition = {
+    name: string;
+    match: Match;
+    valueType?: ValueType;
+    value?: string | number | boolean | string[];
+    joinWithNext?: ConditionJoin;
+};
+export declare const isValidCriterion: (value: unknown) => value is CriterionNode;
+export declare const evaluate: (node: CriterionNode, ctx: Record<string, unknown>) => boolean;
+export declare const optimize: (node: CriterionNode) => CriterionNode;
+export declare const toHumanReadableString: (node: CriterionNode) => string;
+export declare const fromChainedConditions: (rows: readonly ChainedCondition[]) => CriterionNode;

package/dist/criterion-tree.js

@@ -0,0 +1,394 @@
+export const MATCH_TYPES = [
+    'exact',
+    'not_exact',
+    'gt',
+    'gte',
+    'lt',
+    'lte',
+    'is_null',
+    'is_not_null',
+    'in',
+    'contains_substring',
+    'not_contains_substring',
+    'starts_with',
+    'ends_with',
+];
+export const VALUE_TYPES = ['string', 'number', 'boolean', 'array', 'date'];
+const MATCH_TYPE_SET = new Set(MATCH_TYPES);
+const VALUE_TYPE_SET = new Set(VALUE_TYPES);
+const MATCH_PHRASE = {
+    exact: 'is',
+    not_exact: 'is not',
+    gt: 'is greater than',
+    gte: 'is greater than or equal to',
+    lt: 'is less than',
+    lte: 'is less than or equal to',
+    is_null: 'is empty',
+    is_not_null: 'is not empty',
+    in: 'is one of',
+    contains_substring: 'contains',
+    not_contains_substring: 'does not contain',
+    starts_with: 'starts with',
+    ends_with: 'ends with',
+};
+const isMatch = (value) => typeof value === 'string' && MATCH_TYPE_SET.has(value);
+const isValueType = (value) => typeof value === 'string' && VALUE_TYPE_SET.has(value);
+const isLogicalNode = (node) => node !== null && (node.type === 'and' || node.type === 'or');
+const isNullish = (value) => value === null || value === undefined;
+const parseNumber = (value) => {
+    if (typeof value === 'number' && Number.isFinite(value)) {
+        return value;
+    }
+    if (typeof value === 'string' && value.trim() !== '') {
+        const parsed = Number(value);
+        if (Number.isFinite(parsed)) {
+            return parsed;
+        }
+    }
+    return undefined;
+};
+const parseDateMs = (value) => {
+    if (value instanceof Date) {
+        const ms = value.getTime();
+        return Number.isNaN(ms) ? undefined : ms;
+    }
+    if (typeof value === 'number' && Number.isFinite(value)) {
+        return value;
+    }
+    if (typeof value === 'string' && value !== '') {
+        const ms = Date.parse(value);
+        return Number.isNaN(ms) ? undefined : ms;
+    }
+    return undefined;
+};
+const parseBoolean = (value) => {
+    if (typeof value === 'boolean') {
+        return value;
+    }
+    if (value === 'true') {
+        return true;
+    }
+    if (value === 'false') {
+        return false;
+    }
+    return undefined;
+};
+const asString = (value) => typeof value === 'string' ? value : undefined;
+const isNonEmptyString = (value) => typeof value === 'string' && value.length > 0;
+const isStringArray = (value) => Array.isArray(value) && value.length > 0 && value.every(item => isNonEmptyString(item));
+const readOwn = (ctx, name) => Object.hasOwn(ctx, name) ? ctx[name] : undefined;
+const valuesEqual = (actual, expected, valueType) => {
+    if (valueType === 'number') {
+        const actualNumber = parseNumber(actual);
+        const expectedNumber = parseNumber(expected);
+        return (actualNumber !== undefined && expectedNumber !== undefined && actualNumber === expectedNumber);
+    }
+    if (valueType === 'boolean') {
+        const actualBoolean = parseBoolean(actual);
+        const expectedBoolean = parseBoolean(expected);
+        return (actualBoolean !== undefined &&
+            expectedBoolean !== undefined &&
+            actualBoolean === expectedBoolean);
+    }
+    if (valueType === 'date') {
+        const actualMs = parseDateMs(actual);
+        const expectedMs = parseDateMs(expected);
+        return actualMs !== undefined && expectedMs !== undefined && actualMs === expectedMs;
+    }
+    if (valueType === 'string') {
+        return isNonEmptyString(expected) && actual === expected;
+    }
+    return false;
+};
+const compareOrdered = (actual, expected, valueType, op) => {
+    if (valueType === 'date') {
+        return compareNumbers(parseDateMs(actual), parseDateMs(expected), op);
+    }
+    if (valueType === 'number') {
+        return compareNumbers(parseNumber(actual), parseNumber(expected), op);
+    }
+    return false;
+};
+const compareNumbers = (actual, expected, op) => {
+    if (actual === undefined || expected === undefined) {
+        return false;
+    }
+    if (op === 'gt') {
+        return actual > expected;
+    }
+    if (op === 'gte') {
+        return actual >= expected;
+    }
+    if (op === 'lt') {
+        return actual < expected;
+    }
+    return actual <= expected;
+};
+const matchSubstring = (actual, expected, valueType, op) => {
+    if (valueType !== 'string') {
+        return false;
+    }
+    const actualString = asString(actual);
+    const expectedString = asString(expected);
+    if (actualString === undefined || !isNonEmptyString(expectedString)) {
+        return false;
+    }
+    const haystack = actualString.toLowerCase();
+    const needle = expectedString.toLowerCase();
+    if (op === 'contains_substring') {
+        return haystack.includes(needle);
+    }
+    if (op === 'not_contains_substring') {
+        return !haystack.includes(needle);
+    }
+    if (op === 'starts_with') {
+        return haystack.startsWith(needle);
+    }
+    return haystack.endsWith(needle);
+};
+const evaluateAttribute = (node, ctx) => {
+    const actual = readOwn(ctx, node.name);
+    switch (node.match) {
+        case 'is_null':
+            return isNullish(actual);
+        case 'is_not_null':
+            return !isNullish(actual);
+        case 'not_exact':
+            return (node.valueType !== undefined &&
+                !isNullish(actual) &&
+                !valuesEqual(actual, node.value, node.valueType));
+        case 'exact':
+            return node.valueType !== undefined && valuesEqual(actual, node.value, node.valueType);
+        case 'gt':
+        case 'gte':
+        case 'lt':
+        case 'lte':
+            return compareOrdered(actual, node.value, node.valueType, node.match);
+        case 'in':
+            return (node.valueType === 'array' &&
+                isStringArray(node.value) &&
+                typeof actual === 'string' &&
+                node.value.includes(actual));
+        case 'contains_substring':
+        case 'not_contains_substring':
+        case 'starts_with':
+        case 'ends_with':
+            return matchSubstring(actual, node.value, node.valueType, node.match);
+        default:
+            return false;
+    }
+};
+const isFiniteNumber = (value) => typeof value === 'number' && Number.isFinite(value);
+const isDateValue = (value) => {
+    if (isFiniteNumber(value)) {
+        return true;
+    }
+    return typeof value === 'string' && value !== '' && !Number.isNaN(Date.parse(value));
+};
+const isValidOrderedValue = (value, valueType) => {
+    if (valueType === 'date') {
+        return isDateValue(value);
+    }
+    if (valueType === 'number') {
+        return isFiniteNumber(value);
+    }
+    return false;
+};
+const isValidEqualityValue = (value, valueType) => {
+    if (valueType === 'date') {
+        return isDateValue(value);
+    }
+    if (valueType === 'number') {
+        return isFiniteNumber(value);
+    }
+    if (valueType === 'boolean') {
+        return typeof value === 'boolean';
+    }
+    if (valueType === 'string') {
+        return isNonEmptyString(value);
+    }
+    return false;
+};
+const isValidAttribute = (node) => {
+    if (typeof node.name !== 'string' || node.name.length === 0) {
+        return false;
+    }
+    if (!isMatch(node.match)) {
+        return false;
+    }
+    if (node.match === 'is_null' || node.match === 'is_not_null') {
+        return node.value === undefined && node.valueType === undefined;
+    }
+    if (!isValueType(node.valueType)) {
+        return false;
+    }
+    if (node.match === 'in') {
+        return node.valueType === 'array' && isStringArray(node.value);
+    }
+    if (node.match === 'starts_with' ||
+        node.match === 'ends_with' ||
+        node.match === 'contains_substring' ||
+        node.match === 'not_contains_substring') {
+        return node.valueType === 'string' && isNonEmptyString(node.value);
+    }
+    if (node.match === 'gt' || node.match === 'gte' || node.match === 'lt' || node.match === 'lte') {
+        return isValidOrderedValue(node.value, node.valueType);
+    }
+    return isValidEqualityValue(node.value, node.valueType);
+};
+const isValidNode = (value, isChild) => {
+    if (value === null) {
+        return !isChild;
+    }
+    if (value === undefined || typeof value !== 'object') {
+        return false;
+    }
+    const node = value;
+    if (node.type === 'and' || node.type === 'or') {
+        return (Array.isArray(node.children) &&
+            node.children.length > 0 &&
+            node.children.every(child => isValidNode(child, true)));
+    }
+    if (node.type === 'attribute') {
+        return isValidAttribute(node);
+    }
+    return false;
+};
+const formatValue = (value) => {
+    if (value === undefined) {
+        return '';
+    }
+    if (Array.isArray(value)) {
+        return value.join(', ');
+    }
+    return String(value);
+};
+const formatNode = (node, indent) => {
+    const pad = '  '.repeat(indent);
+    if (node === null) {
+        return `${pad}(empty)`;
+    }
+    if (isLogicalNode(node)) {
+        const prefix = node.type === 'and' ? 'All of:' : 'Any of:';
+        const children = node.children.map(child => formatNode(child, indent + 1)).join('\n');
+        return `${pad}${prefix}\n${children}`;
+    }
+    const phrase = MATCH_PHRASE[node.match];
+    if (node.match === 'is_null' || node.match === 'is_not_null') {
+        return `${pad}attribute '${node.name}' ${phrase}`;
+    }
+    return `${pad}attribute '${node.name}' ${phrase} ${formatValue(node.value)}`;
+};
+const chainedToLeaf = (row) => {
+    const leaf = {
+        type: 'attribute',
+        name: row.name,
+        match: row.match,
+    };
+    if (row.match === 'is_null' || row.match === 'is_not_null') {
+        return leaf;
+    }
+    if (row.valueType !== undefined) {
+        leaf.valueType = row.valueType;
+    }
+    if (row.value !== undefined) {
+        leaf.value = row.value;
+    }
+    return leaf;
+};
+export const isValidCriterion = (value) => isValidNode(value, false);
+export const evaluate = (node, ctx) => {
+    if (node === null) {
+        return false;
+    }
+    if (node.type === 'and') {
+        if (node.children.length === 0) {
+            return false;
+        }
+        for (const child of node.children) {
+            if (!evaluate(child, ctx)) {
+                return false;
+            }
+        }
+        return true;
+    }
+    if (node.type === 'or') {
+        for (const child of node.children) {
+            if (evaluate(child, ctx)) {
+                return true;
+            }
+        }
+        return false;
+    }
+    if (node.type === 'attribute') {
+        return evaluateAttribute(node, ctx);
+    }
+    return false;
+};
+export const optimize = (node) => {
+    if (node === null) {
+        return null;
+    }
+    if (node.type === 'attribute') {
+        return node;
+    }
+    const children = [];
+    for (const child of node.children) {
+        const optimized = optimize(child);
+        if (optimized !== null) {
+            children.push(optimized);
+        }
+    }
+    if (children.length === 0) {
+        return null;
+    }
+    const firstChild = children[0];
+    if (children.length === 1 && firstChild !== undefined) {
+        return firstChild;
+    }
+    const flattened = [];
+    for (const child of children) {
+        if (isLogicalNode(child) && child.type === node.type) {
+            for (const nested of child.children) {
+                if (nested !== null) {
+                    flattened.push(nested);
+                }
+            }
+        }
+        else {
+            flattened.push(child);
+        }
+    }
+    const onlyChild = flattened[0];
+    if (flattened.length === 1 && onlyChild !== undefined) {
+        return onlyChild;
+    }
+    return { type: node.type, children: flattened };
+};
+export const toHumanReadableString = (node) => formatNode(node, 0);
+export const fromChainedConditions = (rows) => {
+    const first = rows[0];
+    if (first === undefined) {
+        return null;
+    }
+    let result = chainedToLeaf(first);
+    for (let index = 1; index < rows.length; index += 1) {
+        const previous = rows[index - 1];
+        const row = rows[index];
+        if (previous === undefined || row === undefined) {
+            continue;
+        }
+        const join = previous.joinWithNext === 'AND' ? 'and' : 'or';
+        const next = chainedToLeaf(row);
+        if (result.type === 'and' && join === 'and') {
+            result = { type: 'and', children: [...result.children, next] };
+        }
+        else if (result.type === 'or' && join === 'or') {
+            result = { type: 'or', children: [...result.children, next] };
+        }
+        else {
+            result = { type: join, children: [result, next] };
+        }
+    }
+    return result;
+};

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+export { MATCH_TYPES, VALUE_TYPES, evaluate, fromChainedConditions, isValidCriterion, optimize, toHumanReadableString, } from './criterion-tree.js';
+export type { AttributeLeaf, ChainedCondition, ConditionJoin, CriterionNode, LogicalNode, Match, ValueType, } from './criterion-tree.js';

package/dist/index.js

@@ -0,0 +1 @@
+export { MATCH_TYPES, VALUE_TYPES, evaluate, fromChainedConditions, isValidCriterion, optimize, toHumanReadableString, } from './criterion-tree.js';

package/package.json

@@ -0,0 +1,42 @@
+{
+  "name": "@luxuryescapes/lib-criterion-tree",
+  "version": "0.1.0",
+  "description": "Criterion tree types and evaluation",
+  "repository": "git@github.com:lux-group/svc-lab-v2.git",
+  "author": "@lux-group/team-cx-platform",
+  "license": "MIT",
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "publishConfig": {
+    "main": "./dist/index.js",
+    "types": "./dist/index.d.ts",
+    "exports": {
+      ".": {
+        "types": "./dist/index.d.ts",
+        "import": "./dist/index.js"
+      }
+    }
+  },
+  "scripts": {
+    "build": "rimraf dist && tsc --project ./tsconfig.build.json",
+    "prepack": "yarn build",
+    "check:types": "tsc --noEmit --project ./tsconfig.json",
+    "test": "yarn run -T vitest run",
+    "test:watch": "yarn run -T vitest watch"
+  },
+  "devDependencies": {
+    "@types/node": "^26.6.2",
+    "rimraf": "6.1.3",
+    "typescript": "^7.0.2"
+  },
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts"
+}