@cabloy/utils 1.0.49 → 2.0.1

package/dist/celjs/base.d.ts

@@ -0,0 +1,2 @@
+import { Environment } from '@marcbachmann/cel-js';
+export declare const celEnvBase: Environment;

package/dist/celjs/evaluate.d.ts

@@ -0,0 +1,4 @@
+import type { Environment, ParseResult } from '@marcbachmann/cel-js';
+export declare function evaluateExpressions<T = any>(expressions: any, context?: object, celEnv?: Environment, dry?: boolean): T;
+export declare function evaluate<T = any>(expression: string, context?: object, celEnv?: Environment): T;
+export declare function parse(expression: string, celEnv?: Environment): ParseResult;

package/dist/celjs/index.d.ts

@@ -0,0 +1,4 @@
+export * from './base.ts';
+export * from './evaluate.ts';
+export * from './types.ts';
+export * from './utils.ts';

package/dist/celjs/utils.d.ts

@@ -0,0 +1,5 @@
+export declare function regexp(str: string): string;
+export declare function cel(str: string): string;
+export declare function raw(str: string): string;
+export declare function createFunction(expression: string, scopeKeys?: string[]): Function;
+export declare function evaluateSimple(expression: string, scope?: object): any;

package/dist/index.d.ts

@@ -1,8 +1,7 @@
-export * from './cel.ts';
+export * from './celjs/index.ts';
 export * from './check.ts';
 export * from './hash.ts';
 export * from './match.ts';
-export * from './types.ts';
 export * from './utils.ts';
 export * from './vona.ts';
 export * from './zod.ts';

package/dist/index.js

@@ -1,4 +1,4 @@
-import * as celjs from '@cabloy/cel-js';
+import { Environment } from '@marcbachmann/cel-js';
 import objectHash from 'object-hash';
 import { toLowerCaseFirstChar, stringToCapitalize } from '@cabloy/word-utils';
 
@@ -63,25 +63,6 @@ function safeBoolean(value) {
   return Boolean(value);
 }
 
-function hashkey(key) {
-  if (key === undefined || key === null) {
-    return '';
-  }
-  if (Array.isArray(key) || typeof key === 'object') {
-    return objectHash(key, {
-      respectType: false
-    });
-  }
-  if (typeof key !== 'string') {
-    return String(key);
-  }
-  return key;
-}
-
-const StringPrefixRegexp = 'regexp://';
-const StringPrefixCel = 'cel://';
-const StringPrefixRaw = 'raw://';
-
 function deprecated(oldUsage, newUsage) {
   const message = '`'.concat(oldUsage, '` is deprecated and will be removed in a later version. Use `').concat(newUsage, '` instead');
   console.warn(message);
@@ -175,22 +156,6 @@ function _parsePropertyKey(name) {
   if (!matched) return [name, undefined];
   return [matched[1], Number.parseInt(matched[2])];
 }
-function createFunction(expression, scopeKeys) {
-  let fn;
-  try {
-    const js = `return (${expression})`;
-    fn = scopeKeys && scopeKeys.length > 0 ? new Function(scopeKeys.join(','), js) : new Function(js);
-  } catch (_err) {
-    fn = scopeKeys && scopeKeys.length > 0 ? new Function(scopeKeys.join(','), expression) : new Function(expression);
-  }
-  return fn;
-}
-function evaluateSimple(expression, scope) {
-  const scopeKeys = scope ? Object.keys(scope) : undefined;
-  const scopeValues = scope ? Object.values(scope) : undefined;
-  const fn = createFunction(expression, scopeKeys);
-  return scopeValues ? fn(...scopeValues) : fn();
-}
 function getRandomInt(size, start = 0) {
   return Math.floor(Math.random() * size) + start;
 }
@@ -207,7 +172,8 @@ function combineQueries(pagePath, queries) {
   if (queries) {
     for (const key in queries) {
       const value = queries[key];
-      if (value && typeof value === 'object') {
+      if (isNil(value)) continue;
+      if (typeof value === 'object') {
         query2.push([key, value]);
       } else {
         parts.push(`${encodeURIComponent(key)}=${encodeURIComponent(value)}`);
@@ -255,72 +221,117 @@ function stringLazy(fn) {
   };
 }
 
+const celEnvBase = new Environment({
+  unlistedVariablesAreDyn: true,
+  enableOptionalTypes: true,
+  homogeneousAggregateLiterals: false
+});
+const params = [];
+for (let i = 0; i < 10; i++) {
+  params.push('dyn');
+  celEnvBase.registerFunction(`concat(${params.join(',')}):list`, _concat);
+}
+celEnvBase.registerFunction('join(list):string', list => {
+  return _join(list);
+});
+celEnvBase.registerFunction('join(list,string):string', (list, sep) => {
+  return _join(list, sep);
+});
+celEnvBase.registerFunction('get(map,string):dyn', (obj, name) => {
+  return getProperty(obj, name);
+});
+celEnvBase.registerFunction('get(map,string,string):dyn', (obj, name, sep) => {
+  return getProperty(obj, name, sep);
+});
+celEnvBase.registerOperator('string + int', (str, n) => str + String(n));
+celEnvBase.registerOperator('int + string', (n, str) => String(n) + str);
+function _concat(...args) {
+  return [].concat(...args);
+}
+function _join(list, sep) {
+  if (!list) return '';
+  return list.join(sep);
+}
+
+const StringPrefixRegexp = 'regexp://';
+const StringPrefixCel = 'cel://';
+const StringPrefixRaw = 'raw://';
+
+function regexp(str) {
+  return `${StringPrefixRegexp}${str}`;
+}
 function cel(str) {
   return `${StringPrefixCel}${str}`;
 }
 function raw(str) {
   return `${StringPrefixRaw}${str}`;
 }
-function evaluateExpressions(expressions, context, functions, dry) {
+function createFunction(expression, scopeKeys) {
+  let fn;
+  try {
+    const js = `return (${expression})`;
+    fn = scopeKeys && scopeKeys.length > 0 ? new Function(scopeKeys.join(','), js) : new Function(js);
+  } catch (_err) {
+    fn = scopeKeys && scopeKeys.length > 0 ? new Function(scopeKeys.join(','), expression) : new Function(expression);
+  }
+  return fn;
+}
+function evaluateSimple(expression, scope) {
+  const scopeKeys = scope ? Object.keys(scope) : undefined;
+  const scopeValues = scope ? Object.values(scope) : undefined;
+  const fn = createFunction(expression, scopeKeys);
+  return scopeValues ? fn(...scopeValues) : fn();
+}
+
+function evaluateExpressions(expressions, context, celEnv, dry) {
   if (isNil(expressions)) return _returnExpressionWithDry(expressions, dry);
   if (Array.isArray(expressions)) {
-    return expressions.map(item => _evaluateExpressionInner(item, context, functions, dry));
+    return expressions.map(item => _evaluateExpressionInner(item, context, celEnv, dry));
   } else if (typeof expressions === 'object') {
     const res = {};
     for (const key in expressions) {
-      res[key] = _evaluateExpressionInner(expressions[key], context, functions, dry);
+      res[key] = _evaluateExpressionInner(expressions[key], context, celEnv, dry);
     }
     return res;
   }
   // others
-  return _evaluateExpressionInner(expressions, context, functions, dry);
+  return _evaluateExpressionInner(expressions, context, celEnv, dry);
 }
-function _evaluateExpressionInner(expression, context, functions, dry) {
+function _evaluateExpressionInner(expression, context, celEnv, dry) {
   if (isNil(expression)) return _returnExpressionWithDry(expression, dry);
-  if (typeof expression === 'object') return evaluateExpressions(expression, context, functions, dry);
+  if (typeof expression === 'object') return evaluateExpressions(expression, context, celEnv, dry);
   if (typeof expression !== 'string') return _returnExpressionWithDry(expression, dry);
   if (!expression.startsWith(StringPrefixCel)) return _returnExpressionWithDry(expression, dry);
-  return dry ? true : evaluate(expression.substring(StringPrefixCel.length), context, functions);
+  return dry ? true : evaluate(expression.substring(StringPrefixCel.length), context, celEnv);
 }
 function _returnExpressionWithDry(expression, dry) {
   return dry ? false : expression;
 }
-function evaluate(expression, context, functions) {
-  // functions
-  functions = _prepareFunctions(functions);
-  // CstNode
-  if (typeof expression === 'object' && expression.children) {
-    return celjs.evaluate(expression, context, functions);
+function evaluate(expression, context, celEnv) {
+  if (expression.startsWith(StringPrefixRaw)) {
+    return expression.substring(StringPrefixRaw.length);
+  } else if (expression.startsWith(StringPrefixRegexp)) {
+    return evaluateSimple(expression.substring(StringPrefixRegexp.length));
   }
-  // string
-  if (typeof expression === 'string') {
-    if (expression.startsWith(StringPrefixRaw)) {
-      return expression.substring(StringPrefixRaw.length);
-    }
-    return celjs.evaluate(expression, context, functions);
+  return (celEnv ?? celEnvBase).evaluate(expression, context);
+}
+function parse(expression, celEnv) {
+  return (celEnv ?? celEnvBase).parse(expression);
+}
+
+function hashkey(key) {
+  if (key === undefined || key === null) {
+    return '';
   }
-  // others
-  return expression;
-}
-function parse(expression) {
-  return celjs.parse(expression);
-}
-function _prepareFunctions(functions) {
-  return Object.assign({
-    concat: (...args) => {
-      return [].concat(...args);
-    },
-    join: (arr, sep) => {
-      if (!arr) return '';
-      return arr.join(sep);
-    },
-    get: (obj, name, sep) => {
-      return getProperty(obj, name, sep);
-    },
-    hashkey: key => {
-      return hashkey(key);
-    }
-  }, functions);
+  if (Array.isArray(key) || typeof key === 'object') {
+    return objectHash(key, {
+      respectType: false
+    });
+  }
+  if (typeof key !== 'string') {
+    return String(key);
+  }
+  return key;
 }
 
 function matchSelector(match, selector, matchThis, ...matchArgs) {
@@ -331,8 +342,9 @@ function matchSelector(match, selector, matchThis, ...matchArgs) {
     }
     return typeof match === 'string' && match.startsWith(StringPrefixCel) && !!evaluateExpressions(match, {
       selector,
-      context: matchArgs[0],
-      args: matchArgs
+      context: matchArgs[0] && typeof matchArgs[0] === 'object' ? {
+        ...matchArgs[0]
+      } : matchArgs[0]
     }) || typeof match === 'string' && !match.startsWith(StringPrefixCel) && typeof selector === 'string' && match === selector || match instanceof RegExp && typeof selector === 'string' && match.test(selector) || typeof match === 'function' && match.call(matchThis, selector, ...matchArgs);
   }
   return match.some(item => matchSelector(item, selector));
@@ -413,4 +425,4 @@ function zodCustomError(path, message) {
   return error;
 }
 
-export { StringPrefixCel, StringPrefixRaw, StringPrefixRegexp, addLeadingSlash, catchError, catchErrorSync, cel, checkMeta, combineApiPath, combineApiPathControllerAndAction, combineApiPathControllerAndActionRaw, combineParamsAndQuery, combineQueries, combineResourceName, combineResourceNameParts, createFunction, defaultPathSerializer, deprecated, ensureArray, evaluate, evaluateExpressions, evaluateSimple, getProperty, getPropertyObject, getRandomInt, hashkey, isClass, isClassStrict, isConstructor, isEmpty, isEmptyObject, isFunction, isNil, isNilOrEmptyString, isNumber, isObject, isPlainObject, isPromise, isString, isSymbol, isUndefined, matchSelector, normalizePath, parse, raw, replaceTemplate, safeBoolean, setProperty, sleep, stringLazy, stripEndSlash, zodCustomError };
+export { StringPrefixCel, StringPrefixRaw, StringPrefixRegexp, addLeadingSlash, catchError, catchErrorSync, cel, celEnvBase, checkMeta, combineApiPath, combineApiPathControllerAndAction, combineApiPathControllerAndActionRaw, combineParamsAndQuery, combineQueries, combineResourceName, combineResourceNameParts, createFunction, defaultPathSerializer, deprecated, ensureArray, evaluate, evaluateExpressions, evaluateSimple, getProperty, getPropertyObject, getRandomInt, hashkey, isClass, isClassStrict, isConstructor, isEmpty, isEmptyObject, isFunction, isNil, isNilOrEmptyString, isNumber, isObject, isPlainObject, isPromise, isString, isSymbol, isUndefined, matchSelector, normalizePath, parse, raw, regexp, replaceTemplate, safeBoolean, setProperty, sleep, stringLazy, stripEndSlash, zodCustomError };

package/dist/utils.d.ts

@@ -6,8 +6,6 @@ export declare function replaceTemplate(content: string, scope: object): string;
 export declare function setProperty<T>(obj: object, name: string, value: T): void;
 export declare function getProperty<T>(obj: object | undefined, name: string, sep?: string): T | undefined;
 export declare function getPropertyObject<T>(obj: object | undefined, name: string, sep?: string): T | undefined;
-export declare function createFunction(expression: string, scopeKeys?: string[]): Function;
-export declare function evaluateSimple(expression: string, scope?: object): any;
 export declare function getRandomInt(size: number, start?: number): number;
 export declare function combineParamsAndQuery(path: string, options?: {
     params?: object;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@cabloy/utils",
   "type": "module",
-  "version": "1.0.49",
+  "version": "2.0.1",
   "description": "cabloy utils",
   "publishConfig": {
     "access": "public"
@@ -25,10 +25,9 @@
     "dist"
   ],
   "dependencies": {
-    "@cabloy/cel-js": "^0.7.4",
     "@cabloy/module-info": "^1.3.32",
     "@cabloy/word-utils": "^2.0.1",
-    "chevrotain": "^11.0.3",
+    "@marcbachmann/cel-js": "^6.4.0",
     "object-hash": "^3.0.0"
   },
   "gitHead": "0eab9dc4a5622caffe89e7b1b3f02c08ccbc4c4b",

package/dist/cel.d.ts

@@ -1,7 +0,0 @@
-import type * as Celjs from '@cabloy/cel-js' with { 'resolution-mode': 'import' };
-import type { CstNode } from 'chevrotain';
-export declare function cel(str: string): string;
-export declare function raw(str: string): string;
-export declare function evaluateExpressions<T = any>(expressions: any, context?: object, functions?: Record<string, CallableFunction>, dry?: boolean): T;
-export declare function evaluate<T = any>(expression: CstNode | string, context?: object, functions?: Record<string, CallableFunction>): T;
-export declare function parse(expression: string): Celjs.ParseResult;