@lowdefy/operators-js 0.0.0-experimental-20231123101256

package/dist/operators/shared/object.js

@@ -0,0 +1,129 @@
+/*
+  Copyright 2020-2023 Lowdefy, Inc
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+*/ import { type } from '@lowdefy/helpers';
+import { runClass, runInstance } from '@lowdefy/operators';
+const prep = (args)=>{
+    if (type.isNone(args[0])) {
+        args[0] = {};
+    }
+    return args;
+};
+const prepArray = (args)=>{
+    if (type.isNone(args[0])) {
+        args[0] = [];
+    }
+    return args;
+};
+const prepDescriptor = (args)=>{
+    const descriptor = args[2] || {};
+    if (type.isNone(descriptor.enumerable)) {
+        descriptor.enumerable = true;
+    }
+    if (type.isNone(descriptor.configurable)) {
+        descriptor.configurable = true;
+    }
+    args[2] = descriptor;
+    if (type.isNone(args[0])) {
+        args[0] = {};
+    }
+    return args;
+};
+const metaInstance = {
+    hasOwnProperty: {
+        namedArgs: [
+            'on',
+            'prop'
+        ],
+        validTypes: [
+            'array',
+            'object'
+        ],
+        prep
+    }
+};
+const metaClass = {
+    assign: {
+        spreadArgs: true,
+        validTypes: [
+            'array'
+        ],
+        prep
+    },
+    defineProperty: {
+        namedArgs: [
+            'on',
+            'key',
+            'descriptor'
+        ],
+        validTypes: [
+            'array',
+            'object'
+        ],
+        prep: prepDescriptor
+    },
+    entries: {
+        singleArg: true,
+        validTypes: [
+            'object',
+            'null'
+        ],
+        prep
+    },
+    fromEntries: {
+        singleArg: true,
+        validTypes: [
+            'array',
+            'null'
+        ],
+        prep: prepArray
+    },
+    keys: {
+        singleArg: true,
+        validTypes: [
+            'object',
+            'null'
+        ],
+        prep
+    },
+    values: {
+        singleArg: true,
+        validTypes: [
+            'object',
+            'null'
+        ],
+        prep
+    }
+};
+function _object({ params, location, methodName }) {
+    if (methodName === 'hasOwnProperty') {
+        return runInstance({
+            location,
+            meta: metaInstance,
+            methodName,
+            operator: '_object',
+            params,
+            instanceType: 'object'
+        });
+    }
+    return runClass({
+        functions: Object,
+        location,
+        meta: metaClass,
+        methodName,
+        operator: '_object',
+        params
+    });
+}
+export default _object;

package/dist/operators/shared/operator.js

@@ -0,0 +1,38 @@
+/*
+  Copyright 2020-2023 Lowdefy, Inc
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+*/ import { type } from '@lowdefy/helpers';
+function _operator(options) {
+    const { operators, params, location } = options;
+    if (!type.isString(params.name)) {
+        throw new Error(`Operator Error: _operator.name must be a valid operator name as string. Received: ${JSON.stringify(params)} at ${location}.`);
+    }
+    if (params.name === '_operator') {
+        throw new Error(`Operator Error: _operator.name cannot be set to _operator to infinite avoid loop reference. Received: ${JSON.stringify(params)} at ${location}.`);
+    }
+    if (params.name.includes('experimental')) {
+        throw new Error(`Operator Error: Experimental operators cannot be used with _operator. Received: ${JSON.stringify(params)} at ${location}.`);
+    }
+    const [operator, methodName] = params.name.split('.');
+    if (Object.prototype.hasOwnProperty.call(operators, operator)) {
+        return operators[operator]({
+            ...options,
+            location,
+            params: params?.params,
+            methodName
+        });
+    }
+    throw new Error(`Operator Error: _operator - Invalid operator name. Received: ${JSON.stringify(params)} at ${location}.`);
+}
+export default _operator;

package/dist/operators/shared/or.js

@@ -0,0 +1,22 @@
+/*
+  Copyright 2020-2023 Lowdefy, Inc
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+*/ import { type } from '@lowdefy/helpers';
+function _or({ location, params }) {
+    if (!type.isArray(params)) {
+        throw new Error(`Operator Error: _or takes an array type. Received: ${JSON.stringify(params)} at ${location}.`);
+    }
+    return !!params.reduce((acc, el)=>acc || el, false);
+}
+export default _or;

package/dist/operators/shared/product.js

@@ -0,0 +1,27 @@
+/*
+  Copyright 2020-2023 Lowdefy, Inc
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+*/ import { type } from '@lowdefy/helpers';
+function _product({ params, location }) {
+    if (!type.isArray(params)) {
+        throw new Error(`Operator Error: _product takes an array type as input. Received: ${JSON.stringify(params)} at ${location}.`);
+    }
+    return params.reduce((accumulator, value)=>{
+        if (type.isNumber(value)) {
+            return accumulator * value;
+        }
+        return accumulator;
+    }, 1);
+}
+export default _product;

package/dist/operators/shared/random.js

@@ -0,0 +1,97 @@
+/*
+  Copyright 2020-2023 Lowdefy, Inc
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+*/ import { type } from '@lowdefy/helpers';
+const typesEnum = [
+    'string',
+    'integer',
+    'float'
+];
+function generateRandomString(length, randomString = '') {
+    randomString += Math.random().toString(36).substr(2, length);
+    if (randomString.length > length) return randomString.slice(0, length);
+    return generateRandomString(length, randomString);
+}
+// Both minimum and maximum is inclusive.
+function getRandomInt(min, max) {
+    return Math.floor(Math.random() * (Math.ceil(max) - Math.floor(min)) + Math.floor(min));
+}
+function getRandomFloat(min, max) {
+    return Math.random() * (Math.ceil(max) - Math.floor(min)) + Math.floor(min);
+}
+function evaluateDefaultNumber({ key, defaultValue, params, location }) {
+    if (type.isUndefined(params[key])) {
+        params[key] = defaultValue;
+    }
+    if (!type.isNumber(params[key])) {
+        throw new Error(`Operator Error: _random.${key} takes an number type. Received: ${JSON.stringify(params)} at ${location}.`);
+    }
+}
+function _random({ location, params }) {
+    if (!type.isString(params) && !type.isObject(params)) {
+        throw new Error(`Operator Error: _random takes an string or object type. Received: ${JSON.stringify(params)} at ${location}.`);
+    }
+    if (!type.isObject(params)) {
+        params = {
+            type: params
+        };
+    }
+    if (!typesEnum.includes(params.type)) {
+        throw new Error(`Operator Error: _random type can be either 'string', 'integer' or 'float'. Received: ${JSON.stringify(params)} at ${location}.`);
+    }
+    if (params.type === 'float') {
+        evaluateDefaultNumber({
+            key: 'min',
+            defaultValue: 0,
+            params,
+            location
+        });
+        evaluateDefaultNumber({
+            key: 'max',
+            defaultValue: params.min + 1,
+            params,
+            location
+        });
+        if (params.max < params.min) {
+            throw new Error(`Operator Error: _random.min must be less than _random.max. Received: ${JSON.stringify(params)} at ${location}.`);
+        }
+        return getRandomFloat(params.min, params.max);
+    }
+    if (params.type === 'integer') {
+        evaluateDefaultNumber({
+            key: 'min',
+            defaultValue: 0,
+            params,
+            location
+        });
+        evaluateDefaultNumber({
+            key: 'max',
+            defaultValue: params.min + 100,
+            params,
+            location
+        });
+        if (params.max < params.min) {
+            throw new Error(`Operator Error: _random.min must be less than _random.max. Received: ${JSON.stringify(params)} at ${location}.`);
+        }
+        return getRandomInt(params.min, params.max);
+    }
+    evaluateDefaultNumber({
+        key: 'length',
+        defaultValue: 8,
+        params,
+        location
+    });
+    return generateRandomString(params.length);
+}
+export default _random;

package/dist/operators/shared/regex.js

@@ -0,0 +1,42 @@
+/*
+  Copyright 2020-2023 Lowdefy, Inc
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+*/ import { get, type } from '@lowdefy/helpers';
+function _regex({ location, params, state }) {
+    const pattern = type.isObject(params) ? params.pattern : params;
+    if (!type.isString(pattern)) {
+        throw new Error(`Operator Error: _regex.pattern must be a string. Received: ${JSON.stringify(params)} at ${location}.`);
+    }
+    let on = !type.isUndefined(params.on) ? params.on : get(state, location);
+    if (!type.isUndefined(params.key)) {
+        if (!type.isString(params.key)) {
+            throw new Error(`Operator Error: _regex.key must be a string. Received: ${JSON.stringify(params)} at ${location}.`);
+        }
+        on = get(state, params.key);
+    }
+    if (type.isNone(on)) {
+        return false;
+    }
+    if (!type.isString(on)) {
+        throw new Error(`Operator Error: _regex.on must be a string. Received: ${JSON.stringify(params)} at ${location}.`);
+    }
+    try {
+        const re = new RegExp(pattern, params.flags || 'gm');
+        return re.test(on);
+    } catch (e) {
+        // log e to LowdefyError
+        throw new Error(`Operator Error: _regex failed to execute RegExp.test. Received: ${JSON.stringify(params)} at ${location}.`);
+    }
+}
+export default _regex;

package/dist/operators/shared/string.js

@@ -0,0 +1,292 @@
+/*
+  Copyright 2020-2023 Lowdefy, Inc
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+*/ import { type } from '@lowdefy/helpers';
+import { runInstance } from '@lowdefy/operators';
+const prepRegex = (regexIndex, flagsIndex)=>(args)=>{
+        if (args[regexIndex]) {
+            args[regexIndex] = new RegExp(args[regexIndex], args[flagsIndex]);
+        }
+        if (type.isNone(args[0])) {
+            args[0] = '';
+        }
+        return args;
+    };
+const prep = (args)=>{
+    if (type.isNone(args[0])) {
+        args[0] = '';
+    }
+    return args;
+};
+const meta = {
+    charAt: {
+        namedArgs: [
+            'on',
+            'index'
+        ],
+        prep,
+        validTypes: [
+            'array',
+            'object'
+        ]
+    },
+    // 'charCodeAt',
+    concat: {
+        prep,
+        validTypes: [
+            'array'
+        ]
+    },
+    endsWith: {
+        namedArgs: [
+            'on',
+            'searchString',
+            'length'
+        ],
+        prep,
+        validTypes: [
+            'array',
+            'object'
+        ]
+    },
+    includes: {
+        namedArgs: [
+            'on',
+            'searchString',
+            'position'
+        ],
+        prep,
+        validTypes: [
+            'array',
+            'object'
+        ]
+    },
+    indexOf: {
+        namedArgs: [
+            'on',
+            'searchValue',
+            'fromIndex'
+        ],
+        prep,
+        validTypes: [
+            'array',
+            'object'
+        ]
+    },
+    lastIndexOf: {
+        namedArgs: [
+            'on',
+            'searchValue',
+            'fromIndex'
+        ],
+        prep,
+        validTypes: [
+            'array',
+            'object'
+        ]
+    },
+    // 'localeCompare',
+    match: {
+        namedArgs: [
+            'on',
+            'regex',
+            'regexFlags'
+        ],
+        prep: prepRegex(1, 2),
+        validTypes: [
+            'array',
+            'object'
+        ]
+    },
+    // 'matchAll',
+    normalize: {
+        namedArgs: [
+            'on',
+            'form'
+        ],
+        prep,
+        validTypes: [
+            'array',
+            'object'
+        ]
+    },
+    padEnd: {
+        namedArgs: [
+            'on',
+            'targetLength',
+            'padString'
+        ],
+        prep,
+        validTypes: [
+            'array',
+            'object'
+        ]
+    },
+    padStart: {
+        namedArgs: [
+            'on',
+            'targetLength',
+            'padString'
+        ],
+        prep,
+        validTypes: [
+            'array',
+            'object'
+        ]
+    },
+    repeat: {
+        namedArgs: [
+            'on',
+            'count'
+        ],
+        prep,
+        validTypes: [
+            'array',
+            'object'
+        ]
+    },
+    replace: {
+        namedArgs: [
+            'on',
+            'regex',
+            'newSubstr',
+            'regexFlags'
+        ],
+        prep: prepRegex(1, 3),
+        validTypes: [
+            'array',
+            'object'
+        ]
+    },
+    search: {
+        namedArgs: [
+            'on',
+            'regex',
+            'regexFlags'
+        ],
+        prep: prepRegex(1, 2),
+        validTypes: [
+            'array',
+            'object'
+        ]
+    },
+    slice: {
+        namedArgs: [
+            'on',
+            'start',
+            'end'
+        ],
+        prep,
+        validTypes: [
+            'array',
+            'object'
+        ]
+    },
+    split: {
+        namedArgs: [
+            'on',
+            'separator'
+        ],
+        prep,
+        validTypes: [
+            'array',
+            'object'
+        ]
+    },
+    startsWith: {
+        namedArgs: [
+            'on',
+            'searchString',
+            'position'
+        ],
+        prep,
+        validTypes: [
+            'array',
+            'object'
+        ]
+    },
+    substring: {
+        namedArgs: [
+            'on',
+            'start',
+            'end'
+        ],
+        prep,
+        validTypes: [
+            'array',
+            'object'
+        ]
+    },
+    // toLocaleLowerCase: { namedArgs: ['on', 'locale'], validTypes: ['array', 'object'] },
+    // toLocaleUpperCase: { namedArgs: ['on', 'locale'], validTypes: ['array', 'object'] },
+    toLowerCase: {
+        validTypes: [
+            'string',
+            'null'
+        ],
+        singleArg: true,
+        prep
+    },
+    toUpperCase: {
+        validTypes: [
+            'string',
+            'null'
+        ],
+        singleArg: true,
+        prep
+    },
+    trim: {
+        validTypes: [
+            'string',
+            'null'
+        ],
+        singleArg: true,
+        prep
+    },
+    trimEnd: {
+        validTypes: [
+            'string',
+            'null'
+        ],
+        singleArg: true,
+        prep
+    },
+    trimStart: {
+        validTypes: [
+            'string',
+            'null'
+        ],
+        singleArg: true,
+        prep
+    },
+    length: {
+        validTypes: [
+            'string',
+            'null'
+        ],
+        property: true,
+        prep
+    }
+};
+function _string({ params, location, methodName }) {
+    return runInstance({
+        location,
+        meta,
+        methodName,
+        operator: '_string',
+        params,
+        instanceType: 'string'
+    });
+}
+export default _string;

package/dist/operators/shared/subtract.js

@@ -0,0 +1,28 @@
+/*
+  Copyright 2020-2023 Lowdefy, Inc
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+*/ import { type } from '@lowdefy/helpers';
+function _subtract({ params, location }) {
+    if (!type.isArray(params)) {
+        throw new Error(`Operator Error: _subtract takes an array type as input. Received: ${JSON.stringify(params)} at ${location}.`);
+    }
+    if (params.length !== 2) {
+        throw new Error(`Operator Error: _subtract takes an array of length 2 as input. Received: ${JSON.stringify(params)} at ${location}.`);
+    }
+    if (!type.isNumber(params[0]) || !type.isNumber(params[1])) {
+        throw new Error(`Operator Error: _subtract takes an array of 2 numbers. Received: ${JSON.stringify(params)} at ${location}.`);
+    }
+    return params[0] - params[1];
+}
+export default _subtract;

package/dist/operators/shared/sum.js

@@ -0,0 +1,27 @@
+/*
+  Copyright 2020-2023 Lowdefy, Inc
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+*/ import { type } from '@lowdefy/helpers';
+function _sum({ params, location }) {
+    if (!type.isArray(params)) {
+        throw new Error(`Operator Error: _sum takes an array type as input. Received: ${JSON.stringify(params)} at ${location}.`);
+    }
+    return params.reduce((accumulator, value)=>{
+        if (type.isNumber(value)) {
+            return accumulator + value;
+        }
+        return accumulator;
+    }, 0);
+}
+export default _sum;