chain-simple 1.3.3 → 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/{index.d.ts → cjs/index.d.ts}

@@ -5,6 +5,7 @@ export type TChainable<T extends Record<string, TFn>> = {
 };
 type TConfig = {
     getEntity?: string;
+    extendOnly?: boolean;
     extendProxed?: (propName: any) => {
         [k: string]: any;
     } | ((item: any) => {
@@ -16,7 +17,7 @@ type TConfig = {
 };
 /**
  * @example
- * const {makePropertiesChainable} = require('chain-simple');
+ * const {chainProps} = require('chain-simple');
  * const obj = {
  *   async method1() {
  *    return Promise.resolve(1).then(value => {
@@ -37,7 +38,7 @@ type TConfig = {
  *     });
  *   },
  * };
- * const chainableObj = makePropertiesChainable(obj);
+ * const chainableObj = chainProps(obj);
  * obj.method1().method3().then((val) => console.log(val))
  *
  *
@@ -45,6 +46,6 @@ type TConfig = {
  * @param {{getEntity: string}} [config] config to describe how to get original not project object
  * @returns {object} object with chainable properties
  */
-declare function makePropertiesChainable(item: any, config?: TConfig): any;
+declare function chainProps(item: any, config?: TConfig): any;
 declare function makeConstructorInstancePropertiesChainable(constructorFunction: any, config?: TConfig): any;
-export { makePropertiesChainable, makeConstructorInstancePropertiesChainable };
+export { chainProps, makeConstructorInstancePropertiesChainable };

package/built/{index.js → cjs/index.js}

@@ -1,12 +1,31 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.makeConstructorInstancePropertiesChainable = exports.makePropertiesChainable = void 0;
+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);
+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))) {
+        try {
+            const extension = config.extendProxed(propName);
+            if ((0, sat_utils_1.isObject)(extension)) {
+                Object.assign(target, extension);
+            }
+            else if ((0, sat_utils_1.isFunction)(extension)) {
+                const result = extension(target);
+                Object.assign(target, result);
+            }
+        }
+        catch (error) {
+            console.error(error);
+        }
+        return target;
+    }
+}
 /**
  * @example
- * const {makePropertiesChainable} = require('chain-simple');
+ * const {chainProps} = require('chain-simple');
  * const obj = {
  *   async method1() {
  *    return Promise.resolve(1).then(value => {
@@ -27,7 +46,7 @@ logger_1.logger.setLogLevel(process.env.CHAIN_SIMPLE_LOG_LEVEL);
  *     });
  *   },
  * };
- * const chainableObj = makePropertiesChainable(obj);
+ * const chainableObj = chainProps(obj);
  * obj.method1().method3().then((val) => console.log(val))
  *
  *
@@ -35,7 +54,7 @@ logger_1.logger.setLogLevel(process.env.CHAIN_SIMPLE_LOG_LEVEL);
  * @param {{getEntity: string}} [config] config to describe how to get original not project object
  * @returns {object} object with chainable properties
  */
-function makePropertiesChainable(item, config) {
+function chainProps(item, config) {
     const promiseCallableProps = ['then', 'catch', 'finally'];
     const propsList = [];
     if ((0, sat_utils_1.isObject)(config) && config.getEntityPropList) {
@@ -47,23 +66,27 @@ function makePropertiesChainable(item, config) {
             : config.getEntityPropList));
     }
     if (!(0, sat_utils_1.canBeProxed)(item)) {
-        throw new TypeError('makePropertiesChainable(): first argument should be an entity that can be proxed');
+        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)) {
-        throw new TypeError('makePropertiesChainable(): second argument should be an object');
+        throw new TypeError('chainProps(): second argument should be an object');
     }
+    const _config = { ...config };
     let proxifiedResult = item;
     const proxed = new Proxy(item, {
         get(_t, p, r) {
-            var _a;
             if (propsList.length && propsList.includes(p)) {
-                const propValue = (_a = Reflect.getOwnPropertyDescriptor(item, p)) === null || _a === void 0 ? void 0 : _a.value;
+                const propValue = Reflect.getOwnPropertyDescriptor(item, p)?.value;
                 if ((0, sat_utils_1.isFunction)(propValue) || (0, sat_utils_1.isAsyncFunction)(propValue)) {
                     return item[p].bind(item);
                 }
                 return item[p];
             }
-            if ((0, sat_utils_1.isObject)(config) && config.getEntity === p) {
+            if (_config.extendOnly) {
+                extendProxed(item, p, r, config);
+                return item[p];
+            }
+            if (_config.getEntity === p) {
                 return item;
             }
             if (p === Symbol.toStringTag) {
@@ -79,24 +102,8 @@ function makePropertiesChainable(item, config) {
                     return proxifiedResult;
                 };
             }
-            if (!promiseCallableProps.includes(p) &&
-                (0, sat_utils_1.isUndefined)(Reflect.get(item, p, r)) &&
-                (0, sat_utils_1.isObject)(config) &&
-                (0, sat_utils_1.isFunction)(config.extendProxed)) {
-                try {
-                    const extension = config.extendProxed(p);
-                    if ((0, sat_utils_1.isObject)(extension)) {
-                        Object.assign(item, extension);
-                    }
-                    else if ((0, sat_utils_1.isFunction)(extension)) {
-                        // @ts-ignore
-                        const result = extension(item);
-                        Object.assign(item, result);
-                    }
-                }
-                catch (error) {
-                    console.error(error);
-                }
+            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]) {
@@ -153,17 +160,15 @@ function makePropertiesChainable(item, config) {
     });
     return proxed;
 }
-exports.makePropertiesChainable = makePropertiesChainable;
 function handlerConstructor(config) {
     return {
         construct(target, args) {
             const item = new target(...args);
-            return makePropertiesChainable(item, config);
+            return chainProps(item, config);
         },
     };
 }
 function makeConstructorInstancePropertiesChainable(constructorFunction, config) {
     return new Proxy(constructorFunction, handlerConstructor(config));
 }
-exports.makeConstructorInstancePropertiesChainable = makeConstructorInstancePropertiesChainable;
 //# sourceMappingURL=index.js.map

package/built/esm/index.d.ts

@@ -0,0 +1,51 @@
+type TFn = (...args: any) => any;
+type TReplaceReturnType<T extends TFn, TNewReturnType> = (...args: Parameters<T>) => TNewReturnType;
+export type TChainable<T extends Record<string, TFn>> = {
+    [K in keyof T]: TReplaceReturnType<T[K], ReturnType<T[K]> & TChainable<T>>;
+};
+type TConfig = {
+    getEntity?: string;
+    extendOnly?: boolean;
+    extendProxed?: (propName: any) => {
+        [k: string]: any;
+    } | ((item: any) => {
+        [k: string]: any;
+    });
+    getEntityPropList?: string[] | {
+        [k: string]: any;
+    };
+};
+/**
+ * @example
+ * const {chainProps} = require('chain-simple');
+ * const obj = {
+ *   async method1() {
+ *    return Promise.resolve(1).then(value => {
+ *      console.log('method1', value);
+ *      return value;
+ *    });
+ *   },
+ *   async method2() {
+ *     return Promise.resolve(2).then(value => {
+ *       console.log('method2', value);
+ *       return value;
+ *     });
+ *   },
+ *   async method3() {
+ *     return Promise.resolve(3).then(value => {
+ *       console.log('method3', value);
+ *       return value;
+ *     });
+ *   },
+ * };
+ * const chainableObj = chainProps(obj);
+ * obj.method1().method3().then((val) => console.log(val))
+ *
+ *
+ * @param {!object} item
+ * @param {{getEntity: string}} [config] config to describe how to get original not project object
+ * @returns {object} object with chainable properties
+ */
+declare function chainProps(item: any, config?: TConfig): any;
+declare function makeConstructorInstancePropertiesChainable(constructorFunction: any, config?: TConfig): any;
+export { chainProps, makeConstructorInstancePropertiesChainable };

package/built/esm/index.js

@@ -0,0 +1,171 @@
+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 (isObject(config) && isFunction(config.extendProxed) && isUndefined(Reflect.get(target, propName, receiver))) {
+        try {
+            const extension = config.extendProxed(propName);
+            if (isObject(extension)) {
+                Object.assign(target, extension);
+            }
+            else if (isFunction(extension)) {
+                const result = extension(target);
+                Object.assign(target, result);
+            }
+        }
+        catch (error) {
+            console.error(error);
+        }
+        return target;
+    }
+}
+/**
+ * @example
+ * const {chainProps} = require('chain-simple');
+ * const obj = {
+ *   async method1() {
+ *    return Promise.resolve(1).then(value => {
+ *      console.log('method1', value);
+ *      return value;
+ *    });
+ *   },
+ *   async method2() {
+ *     return Promise.resolve(2).then(value => {
+ *       console.log('method2', value);
+ *       return value;
+ *     });
+ *   },
+ *   async method3() {
+ *     return Promise.resolve(3).then(value => {
+ *       console.log('method3', value);
+ *       return value;
+ *     });
+ *   },
+ * };
+ * const chainableObj = chainProps(obj);
+ * obj.method1().method3().then((val) => console.log(val))
+ *
+ *
+ * @param {!object} item
+ * @param {{getEntity: string}} [config] config to describe how to get original not project object
+ * @returns {object} object with chainable properties
+ */
+function chainProps(item, config) {
+    const promiseCallableProps = ['then', 'catch', 'finally'];
+    const propsList = [];
+    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(...(isObject(config.getEntityPropList)
+            ? Object.keys(config.getEntityPropList)
+            : config.getEntityPropList));
+    }
+    if (!canBeProxed(item)) {
+        throw new TypeError('chainProps(): first argument should be an entity that can be proxed');
+    }
+    if (!isUndefined(config) && !isObject(config)) {
+        throw new TypeError('chainProps(): second argument should be an object');
+    }
+    const _config = { ...config };
+    let proxifiedResult = item;
+    const proxed = new Proxy(item, {
+        get(_t, p, r) {
+            if (propsList.length && propsList.includes(p)) {
+                const propValue = Reflect.getOwnPropertyDescriptor(item, p)?.value;
+                if (isFunction(propValue) || isAsyncFunction(propValue)) {
+                    return item[p].bind(item);
+                }
+                return item[p];
+            }
+            if (_config.extendOnly) {
+                extendProxed(item, p, r, config);
+                return item[p];
+            }
+            if (_config.getEntity === p) {
+                return item;
+            }
+            if (p === Symbol.toStringTag) {
+                return proxifiedResult[Symbol.toStringTag];
+            }
+            if (p === 'toString') {
+                return function (...args) {
+                    return proxifiedResult.toString(...args);
+                };
+            }
+            if (p === 'toJSON') {
+                return function () {
+                    return proxifiedResult;
+                };
+            }
+            if (!promiseCallableProps.includes(p)) {
+                extendProxed(item, p, r, config);
+            }
+            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.chainer(`[CHAIN_SIMPLE]: ${String(p)} is a callable.`);
+                return function (...arguments_) {
+                    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.chainer(`[CHAIN_SIMPLE]: previous call result is: `, r);
+                            return item[p].call(item, ...arguments_);
+                        });
+                    }
+                    else {
+                        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) && 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) {
+                    const promised = proxifiedResult;
+                    proxifiedResult = item;
+                    return promised[p].call(promised, onRes, onRej);
+                };
+            }
+            else if (proxifiedResult[p]) {
+                return proxifiedResult[p];
+            }
+            if (!(p in item) && p in proxifiedResult) {
+                return proxifiedResult[p];
+            }
+        },
+        /** @info base */
+        getPrototypeOf(_t) {
+            return Object.getPrototypeOf(proxifiedResult);
+        },
+        ownKeys(_t) {
+            return Object.getOwnPropertyNames(proxifiedResult);
+        },
+        getOwnPropertyDescriptor(_t, p) {
+            return Object.getOwnPropertyDescriptor(proxifiedResult, p);
+        },
+    });
+    return proxed;
+}
+function handlerConstructor(config) {
+    return {
+        construct(target, args) {
+            const item = new target(...args);
+            return chainProps(item, config);
+        },
+    };
+}
+function makeConstructorInstancePropertiesChainable(constructorFunction, config) {
+    return new Proxy(constructorFunction, handlerConstructor(config));
+}
+export { chainProps, makeConstructorInstancePropertiesChainable };
+//# sourceMappingURL=index.js.map

package/built/esm/logger.d.ts

@@ -0,0 +1,4 @@
+declare const logger: import("sat-utils").Tlogger & {
+    chainer: (...args: any[]) => void;
+};
+export { logger };

package/built/esm/logger.js

@@ -0,0 +1,4 @@
+import { createLogger } from 'sat-utils';
+const logger = createLogger().addCustomLevel('chainer', 'CHAIN_LOG', 'CHAIN_LOG', 'info', 'BgBlue', 'BgWhite');
+export { logger };
+//# sourceMappingURL=logger.js.map

package/lib/index.ts

@@ -14,13 +14,32 @@ export type TChainable<T extends Record<string, TFn>> = {
 
 type TConfig = {
   getEntity?: string;
+  extendOnly?: boolean;
   extendProxed?: (propName) => { [k: string]: any } | ((item: any) => { [k: string]: any });
   getEntityPropList?: string[] | { [k: string]: any };
 };
 
+function extendProxed(target, propName: string | symbol, receiver: any, config: TConfig) {
+  if (isObject(config) && isFunction(config.extendProxed) && isUndefined(Reflect.get(target, propName, receiver))) {
+    try {
+      const extension = config.extendProxed(propName);
+      if (isObject(extension)) {
+        Object.assign(target, extension);
+      } else if (isFunction(extension)) {
+        const result = (extension as TConfig['extendProxed'])(target);
+        Object.assign(target, result);
+      }
+    } catch (error) {
+      console.error(error);
+    }
+
+    return target;
+  }
+}
+
 /**
  * @example
- * const {makePropertiesChainable} = require('chain-simple');
+ * const {chainProps} = require('chain-simple');
  * const obj = {
  *   async method1() {
  *    return Promise.resolve(1).then(value => {
@@ -41,7 +60,7 @@ type TConfig = {
  *     });
  *   },
  * };
- * const chainableObj = makePropertiesChainable(obj);
+ * const chainableObj = chainProps(obj);
  * obj.method1().method3().then((val) => console.log(val))
  *
  *
@@ -49,7 +68,7 @@ type TConfig = {
  * @param {{getEntity: string}} [config] config to describe how to get original not project object
  * @returns {object} object with chainable properties
  */
-function makePropertiesChainable(item, config?: TConfig) {
+function chainProps(item, config?: TConfig) {
   const promiseCallableProps: any[] = ['then', 'catch', 'finally'];
   const propsList = [];
 
@@ -66,12 +85,13 @@ function makePropertiesChainable(item, config?: TConfig) {
   }
 
   if (!canBeProxed(item)) {
-    throw new TypeError('makePropertiesChainable(): first argument should be an entity that can be proxed');
+    throw new TypeError('chainProps(): first argument should be an entity that can be proxed');
   }
 
   if (!isUndefined(config) && !isObject(config)) {
-    throw new TypeError('makePropertiesChainable(): second argument should be an object');
+    throw new TypeError('chainProps(): second argument should be an object');
   }
+  const _config = { ...config };
 
   let proxifiedResult = item;
   const proxed = new Proxy(item, {
@@ -84,7 +104,13 @@ function makePropertiesChainable(item, config?: TConfig) {
         return item[p];
       }
 
-      if (isObject(config) && config.getEntity === p) {
+      if (_config.extendOnly) {
+        extendProxed(item, p, r, config);
+
+        return item[p];
+      }
+
+      if (_config.getEntity === p) {
         return item;
       }
 
@@ -104,24 +130,8 @@ function makePropertiesChainable(item, config?: TConfig) {
         };
       }
 
-      if (
-        !promiseCallableProps.includes(p) &&
-        isUndefined(Reflect.get(item, p, r)) &&
-        isObject(config) &&
-        isFunction(config.extendProxed)
-      ) {
-        try {
-          const extension = config.extendProxed(p);
-          if (isObject(extension)) {
-            Object.assign(item, extension);
-          } else if (isFunction(extension)) {
-            // @ts-ignore
-            const result = extension(item);
-            Object.assign(item, result);
-          }
-        } catch (error) {
-          console.error(error);
-        }
+      if (!promiseCallableProps.includes(p)) {
+        extendProxed(item, p, r, config);
       }
 
       const isCallable = isFunction(Reflect.get(item, p, r)) || isAsyncFunction(Reflect.get(item, p, r));
@@ -191,7 +201,7 @@ function handlerConstructor(config) {
   return {
     construct(target, args) {
       const item = new target(...args);
-      return makePropertiesChainable(item, config);
+      return chainProps(item, config);
     },
   };
 }
@@ -200,4 +210,4 @@ function makeConstructorInstancePropertiesChainable(constructorFunction, config?
   return new Proxy(constructorFunction, handlerConstructor(config));
 }
 
-export { makePropertiesChainable, makeConstructorInstancePropertiesChainable };
+export { chainProps, makeConstructorInstancePropertiesChainable };

package/package.json

@@ -1,8 +1,14 @@
 {
   "name": "chain-simple",
-  "version": "1.3.3",
+  "version": "2.2.0",
   "description": "Main purpose of this package is - provide simple way to build chain between any item methods",
-  "main": "built/index.js",
+  "main": "./built/cjs/index.js",
+  "exports": {
+    ".": {
+      "require": "./built/cjs/index.js",
+      "import": "./built/esm/index.js"
+    }
+  },
   "directories": {
     "example": "examples",
     "lib": "lib"
@@ -11,8 +17,10 @@
     "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 ./",
-    "tsc": "rm -rf ./built && tsc",
+    "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",
     "prepublish": "npm run tsc"
   },
   "keywords": [
@@ -37,24 +45,19 @@
   },
   "homepage": "https://github.com/Simple-Automation-Testing/chain-simple#readme",
   "devDependencies": {
-    "@types/mocha": "^8.2.0",
-    "@types/node": "^14.14.17",
-    "@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",
-    "ts-node": "^10.9.1",
-    "typescript": "^4.9.3"
+    "@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.9.3"
   },
   "engines": {
-    "node": ">=12.18.3"
+    "node": ">=20.9.0"
   },
   "dependencies": {
-    "sat-utils": "1.9.0"
+    "sat-utils": "3.2.0"
   }
 }
+

package/readme.md

@@ -5,7 +5,7 @@
 The purpose of this library is - build simple and flexible chainable call of the object` methods
 
 ```ts
-import { makePropertiesChainable } from 'chain-simple';
+import { chainProps } from 'chain-simple';
 import type { TChainable } from 'chain-simple';
 
 const obj = {
@@ -29,7 +29,7 @@ const obj = {
   },
 };
 
-const chainableObj: TChainable<typeof obj> = makePropertiesChainable(obj);
+const chainableObj: TChainable<typeof obj> = chainProps(obj);
 
 chainableObj
   .method1()
@@ -38,7 +38,7 @@ chainableObj
 ```
 
 ```js
-const { makePropertiesChainable } = require('chain-simple');
+const { chainProps } = require('chain-simple');
 
 const obj = {
   async method1() {
@@ -61,10 +61,10 @@ const obj = {
   },
 };
 
-const chainableObj: TChainable<typeof obj> = makePropertiesChainable(obj);
+const chainableObj: TChainable<typeof obj> = chainProps(obj);
 
 chainableObj
   .method1()
   .method3()
   .then(val => console.log(val)); // method1 1 \n method3 3 \n 3
-```
+```

package/tsconfig.esm.json

@@ -0,0 +1,19 @@
+{
+  "compilerOptions": {
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "target": "ESNext",
+    "sourceMap": true,
+    "outDir": "built/esm",
+    "declaration": true,
+    "experimentalDecorators": true,
+    "allowJs": true
+  },
+  "exclude": [
+    "node_modules",
+    "built",
+    "specs",
+    "example",
+    "playground.*"
+  ]
+}

package/tsconfig.json

@@ -1,19 +1,18 @@
 {
   "compilerOptions": {
     "module": "commonjs",
-    "target": "es2018",
+    "target": "es2020",
     "sourceMap": true,
-    "outDir": "built",
+    "outDir": "built/cjs",
     "declaration": true,
-    "experimentalDecorators": true
+    "experimentalDecorators": true,
+    "allowJs": true
   },
-  "include": [
-    "lib"
-  ],
   "exclude": [
     "node_modules",
     "built",
     "specs",
-    "example"
+    "example",
+    "playground.*"
   ]
 }

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',
-  },
-};