@cabloy/utils 1.0.31 → 1.0.32

package/dist/cel.d.ts

@@ -1,6 +1,6 @@
-import type * as Celjs from 'cel-js' with { 'resolution-mode': 'import' };
+import type * as Celjs from '@cabloy/cel-js' with { 'resolution-mode': 'import' };
 import type { CstNode } from 'chevrotain';
 export declare const CeljsPrefix = "#!#";
-export declare function evaluateExpressions(expressions: any, context?: Record<string, unknown>, functions?: Record<string, CallableFunction>, dry?: boolean): unknown;
-export declare function evaluate(expression: CstNode | string, context?: Record<string, unknown>, functions?: Record<string, CallableFunction>): unknown;
+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;

package/dist/cel.js

@@ -1,5 +1,7 @@
-import * as celjs from 'cel-js';
+import * as celjs from '@cabloy/cel-js';
 import { isNil } from "./check.js";
+import { hashkey } from "./hash.js";
+import { getProperty } from "./utils.js";
 export const CeljsPrefix = '#!#';
 export function evaluateExpressions(expressions, context, functions, dry) {
     if (isNil(expressions))
@@ -32,6 +34,8 @@ function _returnExpressionWithDry(expression, dry) {
     return dry ? false : expression;
 }
 export function evaluate(expression, context, functions) {
+    // functions
+    functions = _prepareFunctions(functions);
     // CstNode
     if (typeof expression === 'object' && expression.children) {
         return celjs.evaluate(expression, context, functions);
@@ -49,3 +53,16 @@ export function evaluate(expression, context, functions) {
 export function parse(expression) {
     return celjs.parse(expression);
 }
+function _prepareFunctions(functions) {
+    return Object.assign({
+        concat: (...args) => {
+            return args.reduce((accumulator, current) => `${accumulator}${current}`, '');
+        },
+        get: (obj, name, sep) => {
+            return getProperty(obj, name, sep);
+        },
+        hashkey: (key) => {
+            return hashkey(key);
+        },
+    }, functions);
+}

package/dist/hash.d.ts

@@ -0,0 +1 @@
+export declare function hashkey(key: any): string;

package/dist/hash.js

@@ -0,0 +1,13 @@
+import objectHash from 'object-hash';
+export function hashkey(key) {
+    if (key === undefined || key === null || key === false) {
+        return '';
+    }
+    if (Array.isArray(key) || typeof key === 'object') {
+        return objectHash(key, { respectType: false });
+    }
+    if (typeof key !== 'string') {
+        return String(key);
+    }
+    return key;
+}

package/dist/index.d.ts

@@ -1,4 +1,5 @@
 export * from './cel.ts';
 export * from './check.ts';
+export * from './hash.ts';
 export * from './utils.ts';
 export * from './vona.ts';

package/dist/index.js

@@ -1,4 +1,5 @@
 export * from "./cel.js";
 export * from "./check.js";
+export * from "./hash.js";
 export * from "./utils.js";
 export * from "./vona.js";

package/dist/utils.js

@@ -53,16 +53,25 @@ export function getProperty(obj, name, sep) {
 export function getPropertyObject(obj, name, sep) {
     return _getProperty(obj, name, sep, true);
 }
+const __keysIgnore = ['constructor', 'prototype', '__proto__'];
 function _getProperty(_obj, name, sep, forceObject) {
     if (!_obj)
         return undefined;
     let obj = _obj;
     const names = name.split(sep || '.');
     // loop
-    for (const name of names) {
-        if (obj[name] === undefined || obj[name] === null) {
+    for (const _name of names) {
+        const [name, index] = _parsePropertyKey(_name);
+        if (__keysIgnore.includes(name))
+            throw new Error(`invalid prop: ${name}`);
+        if (obj[name] === undefined) { // not check obj[name] === null
             if (forceObject) {
-                obj[name] = {};
+                if (index === undefined) {
+                    obj[name] = {};
+                }
+                else {
+                    obj[name] = [];
+                }
             }
             else {
                 obj = obj[name];
@@ -70,9 +79,18 @@ function _getProperty(_obj, name, sep, forceObject) {
             }
         }
         obj = obj[name];
+        if (index !== undefined) {
+            obj = obj[index];
+        }
     }
     return obj;
 }
+function _parsePropertyKey(name) {
+    const matched = name.match((/([^[]+)\[(\d+)\]/));
+    if (!matched)
+        return [name, undefined];
+    return [matched[1], Number.parseInt(matched[2])];
+}
 export function createFunction(expression, scopeKeys) {
     let fn;
     try {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@cabloy/utils",
   "type": "module",
-  "version": "1.0.31",
+  "version": "1.0.32",
   "description": "cabloy utils",
   "publishConfig": {
     "access": "public"
@@ -25,10 +25,11 @@
     "dist"
   ],
   "dependencies": {
+    "@cabloy/cel-js": "^0.7.2",
     "@cabloy/module-info": "^1.3.23",
     "@cabloy/word-utils": "^2.0.1",
-    "cel-js": "^0.3.1",
-    "chevrotain": "^11.0.3"
+    "chevrotain": "^11.0.3",
+    "object-hash": "^3.0.0"
   },
   "gitHead": "0eab9dc4a5622caffe89e7b1b3f02c08ccbc4c4b",
   "scripts": {