chain-simple 2.0.0 → 2.2.0

package/.oxlintrc.json

@@ -0,0 +1,47 @@
+{
+  "$schema": "./node_modules/oxlint/configuration_schema.json",
+  "plugins": ["unicorn", "typescript", "promise", "jest"],
+  "env": {
+    "browser": true
+  },
+  "globals": {
+    "browser": "readonly"
+  },
+  "categories": {
+    "correctness": "error"
+  },
+  "ignorePatterns": ["built", "node_modules"],
+  "rules": {
+    "no-console": "error",
+    "no-unused-vars": "off",
+    "no-unassigned-vars": "off",
+    "jest/no-focused-tests": "error",
+    "jest/expect-expect": "off",
+    "jest/no-disabled-tests": "off",
+    "jest/valid-title": "off",
+    "jest/no-identical-title": "off",
+    "jest/no-conditional-expect": "off",
+    "unicorn/no-null": "off",
+    "unicorn/explicit-length-check": "off",
+    "unicorn/prevent-abbreviations": "off",
+    "unicorn/prefer-node-protocol": "off",
+    "unicorn/import-style": "off",
+    "unicorn/prefer-module": "off",
+    "unicorn/prefer-spread": "off",
+    "unicorn/consistent-destructuring": "off",
+    "unicorn/no-this-assignment": "off",
+    "unicorn/no-array-for-each": "off",
+    "unicorn/no-array-reduce": "off",
+    "unicorn/filename-case": "off",
+    "unicorn/no-abusive-eslint-disable": "off"
+  },
+  "overrides": [
+    {
+      "files": ["*.spec.ts", "*.test.ts"],
+      "rules": {
+        "no-console": "off",
+        "no-unused-expressions": "off"
+      }
+    }
+  ]
+}

package/built/esm/index.js

@@ -1,18 +1,14 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.chainProps = chainProps;
-exports.makeConstructorInstancePropertiesChainable = makeConstructorInstancePropertiesChainable;
-const sat_utils_1 = require("sat-utils");
-const logger_1 = require("./logger");
-logger_1.logger.setLogLevel(process.env.CHAIN_SIMPLE_LOG_LEVEL);
+import { isArray, isObject, isPromise, isFunction, isAsyncFunction, canBeProxed, isUndefined } from 'sat-utils';
+import { logger } from './logger';
+logger.setLogLevel(process.env.CHAIN_SIMPLE_LOG_LEVEL);
 function extendProxed(target, propName, receiver, config) {
-    if ((0, sat_utils_1.isObject)(config) && (0, sat_utils_1.isFunction)(config.extendProxed) && (0, sat_utils_1.isUndefined)(Reflect.get(target, propName, receiver))) {
+    if (isObject(config) && isFunction(config.extendProxed) && isUndefined(Reflect.get(target, propName, receiver))) {
         try {
             const extension = config.extendProxed(propName);
-            if ((0, sat_utils_1.isObject)(extension)) {
+            if (isObject(extension)) {
                 Object.assign(target, extension);
             }
-            else if ((0, sat_utils_1.isFunction)(extension)) {
+            else if (isFunction(extension)) {
                 const result = extension(target);
                 Object.assign(target, result);
             }
@@ -57,18 +53,18 @@ function extendProxed(target, propName, receiver, config) {
 function chainProps(item, config) {
     const promiseCallableProps = ['then', 'catch', 'finally'];
     const propsList = [];
-    if ((0, sat_utils_1.isObject)(config) && config.getEntityPropList) {
-        if (!(0, sat_utils_1.isObject)(config.getEntityPropList) && !(0, sat_utils_1.isArray)(config.getEntityPropList)) {
+    if (isObject(config) && config.getEntityPropList) {
+        if (!isObject(config.getEntityPropList) && !isArray(config.getEntityPropList)) {
             throw new TypeError('config "getEntityPropList" should be an array or an object');
         }
-        propsList.push(...((0, sat_utils_1.isObject)(config.getEntityPropList)
+        propsList.push(...(isObject(config.getEntityPropList)
             ? Object.keys(config.getEntityPropList)
             : config.getEntityPropList));
     }
-    if (!(0, sat_utils_1.canBeProxed)(item)) {
+    if (!canBeProxed(item)) {
         throw new TypeError('chainProps(): first argument should be an entity that can be proxed');
     }
-    if (!(0, sat_utils_1.isUndefined)(config) && !(0, sat_utils_1.isObject)(config)) {
+    if (!isUndefined(config) && !isObject(config)) {
         throw new TypeError('chainProps(): second argument should be an object');
     }
     const _config = { ...config };
@@ -77,7 +73,7 @@ function chainProps(item, config) {
         get(_t, p, r) {
             if (propsList.length && propsList.includes(p)) {
                 const propValue = Reflect.getOwnPropertyDescriptor(item, p)?.value;
-                if ((0, sat_utils_1.isFunction)(propValue) || (0, sat_utils_1.isAsyncFunction)(propValue)) {
+                if (isFunction(propValue) || isAsyncFunction(propValue)) {
                     return item[p].bind(item);
                 }
                 return item[p];
@@ -105,33 +101,33 @@ function chainProps(item, config) {
             if (!promiseCallableProps.includes(p)) {
                 extendProxed(item, p, r, config);
             }
-            const isCallable = (0, sat_utils_1.isFunction)(Reflect.get(item, p, r)) || (0, sat_utils_1.isAsyncFunction)(Reflect.get(item, p, r));
-            if (!isCallable && !(0, sat_utils_1.isPromise)(proxifiedResult) && item[p] && !proxifiedResult[p]) {
-                logger_1.logger.chainer(`[CHAIN_SIMPLE]: ${String(p)} is not a callable.`);
+            const isCallable = isFunction(Reflect.get(item, p, r)) || isAsyncFunction(Reflect.get(item, p, r));
+            if (!isCallable && !isPromise(proxifiedResult) && item[p] && !proxifiedResult[p]) {
+                logger.chainer(`[CHAIN_SIMPLE]: ${String(p)} is not a callable.`);
                 return item[p];
             }
             else if (isCallable) {
-                logger_1.logger.chainer(`[CHAIN_SIMPLE]: ${String(p)} is a callable.`);
+                logger.chainer(`[CHAIN_SIMPLE]: ${String(p)} is a callable.`);
                 return function (...arguments_) {
-                    logger_1.logger.chainer(`[CHAIN_SIMPLE]: ${String(p)} is called with args: `, ...arguments);
-                    if ((0, sat_utils_1.isPromise)(proxifiedResult)) {
-                        logger_1.logger.chainer(`[CHAIN_SIMPLE]: previous call result is a promise`);
+                    logger.chainer(`[CHAIN_SIMPLE]: ${String(p)} is called with args: `, ...arguments);
+                    if (isPromise(proxifiedResult)) {
+                        logger.chainer(`[CHAIN_SIMPLE]: previous call result is a promise`);
                         proxifiedResult = proxifiedResult.then(function (r) {
-                            logger_1.logger.chainer(`[CHAIN_SIMPLE]: previous call result is: `, r);
+                            logger.chainer(`[CHAIN_SIMPLE]: previous call result is: `, r);
                             return item[p].call(item, ...arguments_);
                         });
                     }
                     else {
-                        logger_1.logger.chainer(`[CHAIN_SIMPLE]: previous call result is not a promise`);
-                        logger_1.logger.chainer(`[CHAIN_SIMPLE]: previous call result is: `, proxifiedResult);
+                        logger.chainer(`[CHAIN_SIMPLE]: previous call result is not a promise`);
+                        logger.chainer(`[CHAIN_SIMPLE]: previous call result is: `, proxifiedResult);
                         proxifiedResult = item[p].call(item, ...arguments_);
                     }
                     return proxed;
                 };
             }
-            else if (promiseCallableProps.includes(p) && (0, sat_utils_1.isPromise)(proxifiedResult)) {
-                logger_1.logger.chainer(`[CHAIN_SIMPLE]: previous call result is a promise and next call is a promise method call`);
-                if (!(0, sat_utils_1.isPromise)(proxifiedResult)) {
+            else if (promiseCallableProps.includes(p) && isPromise(proxifiedResult)) {
+                logger.chainer(`[CHAIN_SIMPLE]: previous call result is a promise and next call is a promise method call`);
+                if (!isPromise(proxifiedResult)) {
                     return proxifiedResult;
                 }
                 return function (onRes, onRej) {
@@ -171,4 +167,5 @@ function handlerConstructor(config) {
 function makeConstructorInstancePropertiesChainable(constructorFunction, config) {
     return new Proxy(constructorFunction, handlerConstructor(config));
 }
+export { chainProps, makeConstructorInstancePropertiesChainable };
 //# sourceMappingURL=index.js.map

package/built/esm/logger.js

@@ -1,7 +1,4 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.logger = void 0;
-const sat_utils_1 = require("sat-utils");
-const logger = (0, sat_utils_1.createLogger)().addCustomLevel('chainer', 'CHAIN_LOG', 'CHAIN_LOG', 'info', 'BgBlue', 'BgWhite');
-exports.logger = logger;
+import { createLogger } from 'sat-utils';
+const logger = createLogger().addCustomLevel('chainer', 'CHAIN_LOG', 'CHAIN_LOG', 'info', 'BgBlue', 'BgWhite');
+export { logger };
 //# sourceMappingURL=logger.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "chain-simple",
-  "version": "2.0.0",
+  "version": "2.2.0",
   "description": "Main purpose of this package is - provide simple way to build chain between any item methods",
   "main": "./built/cjs/index.js",
   "exports": {
@@ -17,7 +17,7 @@
     "test": "LOG_LEVEL=VERBOSE mocha ./specs/**/*.spec.ts --require ts-node/register --timeout 30000",
     "test:verbose": "LOG_LEVEL=VERBOSE mocha ./specs/**/*.spec.ts --require ts-node/register --timeout 30000",
     "test:watch": "mocha ./specs/**/*.spec.ts --require ts-node/register --timeout 30000 --watch",
-    "lint": "eslint --ext .ts ./",
+    "lint": "oxlint --fix",
     "tsc:cjs": "tsc -p tsconfig.json",
     "tsc:esm": "tsc -p tsconfig.esm.json",
     "tsc": "rm -rf ./built && npm run tsc:cjs && npm run tsc:esm",
@@ -45,24 +45,19 @@
   },
   "homepage": "https://github.com/Simple-Automation-Testing/chain-simple#readme",
   "devDependencies": {
-    "@types/mocha": "^8.2.0",
-    "@typescript-eslint/eslint-plugin": "^4.11.1",
-    "@typescript-eslint/parser": "^4.11.1",
-    "assertior": "0.0.23",
-    "eslint": "^7.16.0",
-    "eslint-plugin-chai-expect": "^2.2.0",
-    "eslint-plugin-chai-friendly": "^0.6.0",
-    "eslint-plugin-mocha": "^8.0.0",
-    "mocha": "^8.2.1",
-    "prettier": "^2.6.2",
+    "@types/mocha": "^10.0.10",
+    "assertior": "^0.0.28",
+    "mocha": "^11.7.5",
+    "oxlint": "^1.43.0",
+    "prettier": "^3.8.1",
     "ts-node": "^10.9.2",
-    "typescript": "^5.8.3"
+    "typescript": "^5.9.3"
   },
   "engines": {
     "node": ">=20.9.0"
   },
   "dependencies": {
-    "sat-utils": "1.9.0"
+    "sat-utils": "3.2.0"
   }
 }
 

package/tsconfig.esm.json

@@ -1,6 +1,7 @@
 {
   "compilerOptions": {
-    "module": "NodeNext",
+    "module": "ESNext",
+    "moduleResolution": "bundler",
     "target": "ESNext",
     "sourceMap": true,
     "outDir": "built/esm",

package/.eslintignore

@@ -1 +0,0 @@
-built

package/.eslintrc.js

@@ -1,38 +0,0 @@
-module.exports = {
-  plugins: ['sonarjs', 'promise', 'unicorn', 'prettier', 'no-only-tests'],
-  parser: '@typescript-eslint/parser',
-  rules: {
-    'jsdoc/valid-types': 'off',
-    'jsdoc/check-property-names': 'off',
-    'no-await-in-loop': 'off',
-    'unicorn/no-null': 'off',
-    'jsdoc/no-undefined-types': 'off',
-    'unicorn/explicit-length-check': 'off',
-    'no-restricted-syntax': 'off',
-    'func-names': 'off',
-    'no-plusplus': 'off',
-    'unicorn/prevent-abbreviations': 'off',
-    'unicorn/no-reduce': 'off',
-    'no-unused-expressions': 'off',
-    'unicorn/prefer-node-protocol': 'off',
-    'unicorn/import-style': 'off',
-    'no-useless-constructor': 'off',
-    'unicorn/prefer-module': 'off',
-    'unicorn/prefer-spread': 'off',
-    'unicorn/consistent-destructuring': 'off',
-    'import/no-unresolved': 'off',
-    'unicorn/no-this-assignment': 'off',
-    'unicorn/no-array-for-each': 'off',
-    'default-case': 'off',
-    'sonarjs/no-duplicate-string': 'off',
-    'unicorn/no-array-reduce': 'off',
-    'unicorn/filename-case': 'off',
-    'unicorn/no-abusive-eslint-disable': 'off',
-    'no-only-tests/no-only-tests': 'error',
-    'no-console': 'error',
-  },
-  extends: ['plugin:sonarjs/recommended', 'plugin:unicorn/recommended', 'prettier', 'plugin:prettier/recommended'],
-  globals: {
-    browser: 'readonly',
-  },
-};