@cabloy/utils 1.0.31 → 1.0.33

package/dist/cel.d.ts

@@ -1,6 +1,5 @@
-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,6 +1,8 @@
-import * as celjs from 'cel-js';
+import * as celjs from '@cabloy/cel-js';
 import { isNil } from "./check.js";
-export const CeljsPrefix = '#!#';
+import { hashkey } from "./hash.js";
+import { StringPrefixCel, StringPrefixRaw } from "./types.js";
+import { getProperty } from "./utils.js";
 export function evaluateExpressions(expressions, context, functions, dry) {
     if (isNil(expressions))
         return _returnExpressionWithDry(expressions, dry);
@@ -24,22 +26,24 @@ function _evaluateExpressionInner(expression, context, functions, dry) {
         return evaluateExpressions(expression, context, functions, dry);
     if (typeof expression !== 'string')
         return _returnExpressionWithDry(expression, dry);
-    if (!expression.startsWith(CeljsPrefix))
+    if (!expression.startsWith(StringPrefixCel))
         return _returnExpressionWithDry(expression, dry);
-    return dry ? true : evaluate(expression.substring(CeljsPrefix.length), context, functions);
+    return dry ? true : evaluate(expression.substring(StringPrefixCel.length), context, functions);
 }
 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);
     }
     // string
     if (typeof expression === 'string') {
-        if (expression.startsWith(CeljsPrefix)) {
-            return expression.substring(CeljsPrefix.length);
+        if (expression.startsWith(StringPrefixRaw)) {
+            return expression.substring(StringPrefixRaw.length);
         }
         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,7 @@
 export * from './cel.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';

package/dist/index.js

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

package/dist/match.d.ts

@@ -0,0 +1,4 @@
+export type TypeMatchSelectorFunction = (this: any, ...args: any[]) => boolean;
+export type TypeMatchSelectorRule<T> = T | RegExp | TypeMatchSelectorFunction;
+export type TypeMatchSelectorRules<T> = (TypeMatchSelectorRule<T>)[] | TypeMatchSelectorRule<T>;
+export declare function matchSelector<T>(match: TypeMatchSelectorRules<T>, selector: string | boolean, matchThis?: any, ...matchArgs: any[]): any;

package/dist/match.js

@@ -0,0 +1,16 @@
+import { evaluateExpressions } from "./cel.js";
+import { StringPrefixCel, StringPrefixRegexp } from "./types.js";
+import { evaluateSimple } from "./utils.js";
+export function matchSelector(match, selector, matchThis, ...matchArgs) {
+    if (!Array.isArray(match)) {
+        // prepare
+        if (typeof match === 'string' && match.startsWith(StringPrefixRegexp)) {
+            match = evaluateSimple(match.substring(StringPrefixRegexp.length));
+        }
+        return ((typeof match === 'string' && match.startsWith(StringPrefixCel) && !!evaluateExpressions(match, { selector, context: matchArgs[0], args: matchArgs })) ||
+            (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));
+}

package/dist/types.d.ts

@@ -0,0 +1,3 @@
+export declare const StringPrefixRegexp = "regexp://";
+export declare const StringPrefixCel = "cel://";
+export declare const StringPrefixRaw = "raw://";

package/dist/types.js

@@ -0,0 +1,3 @@
+export const StringPrefixRegexp = 'regexp://';
+export const StringPrefixCel = 'cel://';
+export const StringPrefixRaw = 'raw://';

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.33",
   "description": "cabloy utils",
   "publishConfig": {
     "access": "public"
@@ -25,10 +25,11 @@
     "dist"
   ],
   "dependencies": {
-    "@cabloy/module-info": "^1.3.23",
+    "@cabloy/cel-js": "^0.7.2",
+    "@cabloy/module-info": "^1.3.24",
     "@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": {