@nejs/basic-extensions 1.0.0

package/dist/mjs/index.d.ts

@@ -0,0 +1,7 @@
+export function enableAll(owners: any): void;
+export function disableAll(owners: any): void;
+import { ObjectExtensions } from './objectextensions.js';
+import { FunctionExtensions } from './functionextensions.js';
+import { ReflectExtensions } from './reflectextensions.js';
+import { ArrayPrototypeExtensions } from './arrayextensions.js';
+export { ObjectExtensions, FunctionExtensions, ReflectExtensions, ArrayPrototypeExtensions };

package/dist/mjs/index.js

@@ -0,0 +1,22 @@
+import { FunctionExtensions } from './functionextensions.js';
+import { ObjectExtensions } from './objectextensions.js';
+import { ReflectExtensions } from './reflectextensions.js';
+import { ArrayPrototypeExtensions } from './arrayextensions.js';
+import { Patch } from '@nejs/extension';
+const Owners = [
+    Object,
+    Function,
+    Reflect,
+    Array.prototype,
+];
+export function enableAll(owners) {
+    (owners || Owners).forEach(owner => {
+        Patch.enableFor(owner);
+    });
+}
+export function disableAll(owners) {
+    (owners || Owners).forEach(owner => {
+        Patch.disableFor(owner);
+    });
+}
+export { ObjectExtensions, FunctionExtensions, ReflectExtensions, ArrayPrototypeExtensions, };

package/dist/mjs/objectextensions.d.ts

@@ -0,0 +1,10 @@
+/**
+ * `ObjectExtensions` is a patch for the JavaScript built-in `Object` class. It
+ * adds utility methods to the `Object` class without modifying the global namespace
+ * directly. This patch includes methods for key validation, object type checking,
+ * and retrieving the string tag of an object. These methods are useful for
+ * enhancing the capabilities of the standard `Object` class with additional
+ * utility functions.
+ */
+export const ObjectExtensions: Patch;
+import { Patch } from '@nejs/extension';

package/dist/mjs/objectextensions.js

@@ -0,0 +1,76 @@
+import { Patch } from '@nejs/extension';
+/**
+ * `ObjectExtensions` is a patch for the JavaScript built-in `Object` class. It
+ * adds utility methods to the `Object` class without modifying the global namespace
+ * directly. This patch includes methods for key validation, object type checking,
+ * and retrieving the string tag of an object. These methods are useful for
+ * enhancing the capabilities of the standard `Object` class with additional
+ * utility functions.
+ */
+export const ObjectExtensions = new Patch(Object, {
+    /**
+     * Checks if the given value is a valid key for an object. In JavaScript, a valid
+     * key can be either a string or a symbol. This method is useful for validating
+     * object keys before using them in operations like setting or getting object properties.
+     *
+     * @param {*} value - The value to be checked.
+     * @returns {boolean} - Returns `true` if the value is a valid object key (string or symbol),
+     *                      otherwise `false`.
+     */
+    isValidKey(value) {
+        return (typeof value === 'string' || typeof value === 'symbol');
+    },
+    /**
+     * Determines if the provided value is an object. This method checks whether the
+     * value is an instance of `Object` or if its type is 'object'. It's a utility
+     * method for type-checking, ensuring that a value is an object before performing
+     * operations that are specific to objects.
+     *
+     * @param {*} value - The value to be checked.
+     * @returns {boolean} - Returns `true` if the value is an object, otherwise `false`.
+     */
+    isObject(value) {
+        return value && (value instanceof Object || typeof value === 'object');
+    },
+    /**
+     * Retrieves the string tag of an object. The string tag is a representation of
+     * the object's type, as defined by its `Object.prototype.toString` method. This
+     * utility method is helpful for getting a more descriptive type of an object than
+     * what is returned by the `typeof` operator, especially for custom objects.
+     *
+     * @param {*} value - The object whose string tag is to be retrieved.
+     * @returns {string} - The string tag of the object, indicating its type.
+     */
+    getStringTag(value) {
+        return /(\w+)]/.exec(Object.prototype.toString.call(value))[1];
+    },
+    /**
+     * Determines the type of the given value based on its string tag. This method
+     * uses `Object.getStringTag` to obtain the string tag of the value, which
+     * represents its more specific type (e.g., Array, Map, Set) rather than just
+     * 'object'. The method then maps this string tag to the corresponding type
+     * present in the provided `owner` object, which defaults to `globalThis`.
+     * This utility method is especially useful for identifying the specific
+     * constructor or class of an object, beyond the basic types identified by
+     * the `typeof` operator.
+     *
+     * @param {any} value - The value whose type is to be determined.
+     * @param {object} [owner=globalThis] - The object in which to look up the
+     * constructor corresponding to the string tag. Defaults to `globalThis`, which
+     * covers global constructors like `Array`, `Object`, etc.
+     * @returns {Function|object|null|undefined} - Returns the constructor or type
+     * of the value based on its string tag. For 'Null' and 'Undefined', it returns
+     * `null` and `undefined`, respectively. For other types, it returns the
+     * corresponding constructor (e.g., `Array` for arrays) if available in the
+     * `owner` object.
+     */
+    getType(value, owner = globalThis) {
+        const stringTag = Object.getStringTag(value);
+        switch (stringTag) {
+            case 'Null': return null;
+            case 'Undefined': return undefined;
+            default:
+                return owner[stringTag];
+        }
+    },
+});

package/dist/mjs/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "module"
+}

package/dist/mjs/reflectextensions.d.ts

@@ -0,0 +1,14 @@
+/**
+ * The `ReflectExtensions` class is a patch applied to the built-in JavaScript
+ * `Reflect` object. It extends `Reflect` with additional utility methods that
+ * enhance its capabilities. These methods provide more advanced ways of
+ * interacting with object properties, such as checking for the presence of
+ * multiple keys at once (`hasAll`) or verifying if at least one specified key
+ * exists in an object (`hasSome`). This class is part of the `@nejs/extension`
+ * library and is designed to offer these extended functionalities in a way
+ * that is consistent with the existing `Reflect` API, making it intuitive for
+ * developers who are already familiar with standard reflection methods in
+ * JavaScript.
+ */
+export const ReflectExtensions: Patch;
+import { Patch } from '@nejs/extension';

package/dist/mjs/reflectextensions.js

@@ -0,0 +1,84 @@
+import { Patch } from '@nejs/extension';
+/**
+ * The `ReflectExtensions` class is a patch applied to the built-in JavaScript
+ * `Reflect` object. It extends `Reflect` with additional utility methods that
+ * enhance its capabilities. These methods provide more advanced ways of
+ * interacting with object properties, such as checking for the presence of
+ * multiple keys at once (`hasAll`) or verifying if at least one specified key
+ * exists in an object (`hasSome`). This class is part of the `@nejs/extension`
+ * library and is designed to offer these extended functionalities in a way
+ * that is consistent with the existing `Reflect` API, making it intuitive for
+ * developers who are already familiar with standard reflection methods in
+ * JavaScript.
+ */
+export const ReflectExtensions = new Patch(Reflect, {
+    /**
+     * The function checks if an object has all the specified keys.
+     *
+     * @param object - The `object` parameter is the object that we want to
+     * check if it has all the specified keys.
+     * @param keys - The `keys` parameter is a rest parameter, which means
+     * it can accept any number of arguments. In this case, it is expected
+     * to receive multiple keys as arguments.
+     * @returns a boolean value.
+     */
+    hasAll(object, ...keys) {
+        return Object.isObject(object) && (keys.flat(Infinity)
+            .map(key => Reflect.has(object, key))
+            .every(has => has));
+    },
+    /**
+     * The function checks if an object has at least one of the specified keys.
+     *
+     * @param object - The `object` parameter is the object that we want to check
+     * for the presence of certain keys.
+     * @param keys - The `keys` parameter is a rest parameter, which means it can
+     * accept any number of arguments. These arguments are the keys that we want
+     * to check if they exist in the `object`.
+     * @returns The function `hasSome` returns a boolean value indicating whether
+     * at least one of the keys provided as arguments exists in the given object.
+     */
+    hasSome(object, ...keys) {
+        return Object.isObject(object) && (keys.flat(Infinity)
+            .map(key => Reflect.has(object, key))
+            .some(has => has));
+    },
+    /**
+     * Retrieves an array of [key, descriptor] pairs for each property of the
+     * provided object. This method is akin to `Object.entries` but includes
+     * property descriptors instead of the property values. It's useful for cases
+     * where you need detailed information about properties, including their
+     * configurability, enumerability, and accessors.
+     *
+     * @param {object} object - The object whose property entries are to be
+     * retrieved.
+     * @returns {Array} An array of [key, descriptor] pairs, where each pair
+     * consists of the property name (key) and its descriptor. Returns an empty
+     * array if the input is not a valid object.
+     */
+    entries(object) {
+        if (!object || typeof object !== 'object') {
+            return [];
+        }
+        return Reflect.ownKeys(object).map(key => [
+            key, Object.getOwnPropertyDescriptor(object, key)
+        ]);
+    },
+    /**
+     * Retrieves an array of values from the property descriptors of the given
+     * object. This method works similarly to `Object.values` but operates on
+     * property descriptors instead. It's useful when you need the values of
+     * properties including getters, setters, and other descriptor-specific
+     * attributes.
+     *
+     * @param {object} object - The object whose property values are to be
+     * retrieved.
+     * @returns {Array} An array of values extracted from the object's property
+     * descriptors. The values correspond to the `value` attribute in each
+     * property's descriptor. Returns an empty array if the input is not a valid
+     * object.
+     */
+    values(object) {
+        return Reflect.entries.map(([, value]) => value);
+    }
+});

package/package.json

@@ -0,0 +1,48 @@
+{
+  "author": "Brielle Harrison <nyteshade at gmail.com>",
+  "description": "Basic but commonly used extensions",
+  "devDependencies": {
+    "@jest/expect": "^29.7.0",
+    "jest": "^29.7.0",
+    "jest-cli": "^29.7.0",
+    "jest-localstorage-mock": "^2.4.26",
+    "prompts": "^2.4.2",
+    "typescript": "^5.2.2"
+  },
+  "engines": {
+    "node": ">=16"
+  },
+  "exports": {
+    ".": {
+      "import": "./dist/mjs/index.js",
+      "require": "./dist/cjs/index.js"
+    }
+  },
+  "jest": {
+    "verbose": true,
+    "setupFiles": [
+      "jest-localstorage-mock"
+    ],
+    "transform": {
+      "^.+\\.[t|j]sx?$": "babel-jest"
+    }
+  },
+  "keywords": [
+    "javascript",
+    "browser",
+    "localStorage"
+  ],
+  "license": "MIT",
+  "main": "dist/cjs/index.js",
+  "module": "dist/mjs/index.js",
+  "name": "@nejs/basic-extensions",
+  "scripts": {
+    "build": "bin/build",
+    "test": "jest"
+  },
+  "type": "module",
+  "version": "1.0.0",
+  "dependencies": {
+    "@nejs/extension": "^1.0.0"
+  }
+}

package/src/arrayextensions.js

@@ -0,0 +1,38 @@
+import { Patch } from '@nejs/extension'
+
+/**
+ * The `ArrayPrototypeExtensions` patch extends the prototype of the built-in
+ * JavaScript `Array` with additional properties for convenience and improved
+ * readability. By applying this patch, all array instances gain new getter
+ * properties `first` and `last`, which provide quick access to the first and
+ * last elements of the array, respectively. This enhancement simplifies common
+ * operations on arrays and makes code more expressive and concise.
+ */
+export const ArrayPrototypeExtensions = new Patch(Array.prototype, {
+  /**
+   * A getter property that returns the first element of the array. If the
+   * array is empty, it returns `undefined`. This property is useful for
+   * scenarios where you need to quickly access the first item of an array
+   * without the need for additional checks or method calls.
+   *
+   * @returns {*} The first element of the array or `undefined` if the array
+   * is empty.
+   */
+  get first() {
+    return this[0];
+  },
+
+  /**
+   * A getter property that returns the last element of the array. It
+   * calculates the last index based on the array's length. If the array is
+   * empty, it returns `undefined`. This property is beneficial when you need
+   * to access the last item in an array, improving code readability and
+   * avoiding manual index calculation.
+   *
+   * @returns {*} The last element of the array or `undefined` if the
+   * array is empty.
+   */
+  get last() {
+    return this[this.length - 1];
+  }
+})

package/src/functionextensions.js

@@ -0,0 +1,88 @@
+import { Patch } from '@nejs/extension'
+
+/**
+ * The `FunctionExtensions` class is a patch applied to the built-in JavaScript `Function`
+ * constructor. It extends `Function` with additional utility methods for determining the
+ * specific type or nature of function-like objects. These methods allow developers to
+ * distinguish between classes, regular functions, async functions, and arrow functions
+ * in a more intuitive and straightforward manner. This class is part of the `@nejs/extension`
+ * library and enhances the capabilities of function handling and introspection in JavaScript.
+ */
+export const FunctionExtensions = new Patch(Function, {
+  /**
+   * Determines if a given value is a class. It checks if the value is an instance of
+   * `Function` and if its string representation includes the keyword 'class'. This method
+   * is useful for distinguishing classes from other function types in JavaScript.
+   *
+   * @param {*} value - The value to be checked.
+   * @returns {boolean} Returns `true` if the value is a class, otherwise `false`.
+   */
+  isClass(value) {
+    return value instanceof Function && String(value).includes('class');
+  },
+
+  /**
+   * Checks if a given value is a regular function. This method verifies if the value is
+   * an instance of `Function`, which includes regular functions, classes, and async
+   * functions but excludes arrow functions.
+   *
+   * @param {*} value - The value to be checked.
+   * @returns {boolean} Returns `true` if the value is a regular function, otherwise `false`.
+   */
+  isFunction(value) {
+    return value instanceof Function;
+  },
+
+  /**
+   * Determines if a given value is an asynchronous function. It checks if the value is an
+   * instance of `Function` and if its string representation includes the keyword 'Async'.
+   * This method is particularly useful for identifying async functions.
+   *
+   * @param {*} value - The value to be checked.
+   * @returns {boolean} Returns `true` if the value is an async function, otherwise `false`.
+   */
+  isAsync(value) {
+    const stringTag = /(\w+)]/g.exec(Object.prototype.toString.call(value))[1]
+    return (
+      value instanceof Function &&
+      stringTag.includes('Async')
+    )
+  },
+
+  /**
+   * Checks if a given value is an arrow function. It verifies if the value is an instance
+   * of `Function`, if its string representation includes the '=>' symbol, and if it lacks
+   * a prototype, which is a characteristic of arrow functions in JavaScript.
+   *
+   * @param {*} value - The value to be checked.
+   * @returns {boolean} Returns `true` if the value is an arrow function, otherwise `false`.
+   */
+  isBigArrow(value) {
+    return (
+      value instanceof Function &&
+      String(value).includes('=>') &&
+      !String(value).startsWith('bound') &&
+      !Reflect.has(value, 'prototype')
+    );
+  },
+
+  /**
+   * Determines if a given value is a bound function. Bound functions are created using
+   * the `Function.prototype.bind` method, which allows setting the `this` value at the
+   * time of binding. This method checks if the value is an instance of `Function`, if
+   * its string representation starts with 'bound', and if it lacks a `prototype`
+   * property. These characteristics are indicative of bound functions in JavaScript.
+   *
+   * @param {*} value - The value to be checked, typically a function.
+   * @returns {boolean} Returns `true` if the value is a bound function, otherwise
+   * `false`. Bound functions have a specific format in their string representation
+   * and do not have their own `prototype` property.
+   */
+  isBound(value) {
+    return (
+      value instanceof Function &&
+      String(value).startsWith('bound') &&
+      !Reflect.has(value, 'prototype')
+    )
+  },
+})

package/src/index.js

@@ -0,0 +1,32 @@
+import { FunctionExtensions } from './functionextensions.js'
+import { ObjectExtensions } from './objectextensions.js'
+import { ReflectExtensions } from './reflectextensions.js'
+import { ArrayPrototypeExtensions } from './arrayextensions.js'
+import { Patch } from '@nejs/extension'
+
+const Owners = [
+  Object,
+  Function,
+  Reflect,
+
+  Array.prototype,
+]
+
+export function enableAll(owners) {
+  (owners || Owners).forEach(owner => {
+    Patch.enableFor(owner)
+  })
+}
+
+export function disableAll(owners) {
+  (owners || Owners).forEach(owner => {
+    Patch.disableFor(owner)
+  })
+}
+
+export {
+  ObjectExtensions,
+  FunctionExtensions,
+  ReflectExtensions,
+  ArrayPrototypeExtensions,
+}

package/src/objectextensions.js

@@ -0,0 +1,81 @@
+import { Patch } from '@nejs/extension';
+
+/**
+ * `ObjectExtensions` is a patch for the JavaScript built-in `Object` class. It
+ * adds utility methods to the `Object` class without modifying the global namespace
+ * directly. This patch includes methods for key validation, object type checking,
+ * and retrieving the string tag of an object. These methods are useful for
+ * enhancing the capabilities of the standard `Object` class with additional
+ * utility functions.
+ */
+export const ObjectExtensions = new Patch(Object, {
+  /**
+   * Checks if the given value is a valid key for an object. In JavaScript, a valid
+   * key can be either a string or a symbol. This method is useful for validating
+   * object keys before using them in operations like setting or getting object properties.
+   *
+   * @param {*} value - The value to be checked.
+   * @returns {boolean} - Returns `true` if the value is a valid object key (string or symbol),
+   *                      otherwise `false`.
+   */
+  isValidKey(value) {
+    return (typeof value === 'string' || typeof value === 'symbol');
+  },
+
+  /**
+   * Determines if the provided value is an object. This method checks whether the
+   * value is an instance of `Object` or if its type is 'object'. It's a utility
+   * method for type-checking, ensuring that a value is an object before performing
+   * operations that are specific to objects.
+   *
+   * @param {*} value - The value to be checked.
+   * @returns {boolean} - Returns `true` if the value is an object, otherwise `false`.
+   */
+  isObject(value) {
+    return value && (value instanceof Object || typeof value === 'object');
+  },
+
+  /**
+   * Retrieves the string tag of an object. The string tag is a representation of
+   * the object's type, as defined by its `Object.prototype.toString` method. This
+   * utility method is helpful for getting a more descriptive type of an object than
+   * what is returned by the `typeof` operator, especially for custom objects.
+   *
+   * @param {*} value - The object whose string tag is to be retrieved.
+   * @returns {string} - The string tag of the object, indicating its type.
+   */
+  getStringTag(value) {
+    return /(\w+)]/.exec(Object.prototype.toString.call(value))[1];
+  },
+
+  /**
+   * Determines the type of the given value based on its string tag. This method
+   * uses `Object.getStringTag` to obtain the string tag of the value, which
+   * represents its more specific type (e.g., Array, Map, Set) rather than just
+   * 'object'. The method then maps this string tag to the corresponding type
+   * present in the provided `owner` object, which defaults to `globalThis`.
+   * This utility method is especially useful for identifying the specific
+   * constructor or class of an object, beyond the basic types identified by
+   * the `typeof` operator.
+   *
+   * @param {any} value - The value whose type is to be determined.
+   * @param {object} [owner=globalThis] - The object in which to look up the
+   * constructor corresponding to the string tag. Defaults to `globalThis`, which
+   * covers global constructors like `Array`, `Object`, etc.
+   * @returns {Function|object|null|undefined} - Returns the constructor or type
+   * of the value based on its string tag. For 'Null' and 'Undefined', it returns
+   * `null` and `undefined`, respectively. For other types, it returns the
+   * corresponding constructor (e.g., `Array` for arrays) if available in the
+   * `owner` object.
+   */
+  getType(value, owner = globalThis) {
+    const stringTag = Object.getStringTag(value)
+
+    switch (stringTag) {
+      case 'Null': return null
+      case 'Undefined': return undefined
+      default:
+        return owner[stringTag]
+    }
+  },
+});

package/src/reflectextensions.js

@@ -0,0 +1,89 @@
+import { Patch } from '@nejs/extension'
+
+/**
+ * The `ReflectExtensions` class is a patch applied to the built-in JavaScript
+ * `Reflect` object. It extends `Reflect` with additional utility methods that
+ * enhance its capabilities. These methods provide more advanced ways of
+ * interacting with object properties, such as checking for the presence of
+ * multiple keys at once (`hasAll`) or verifying if at least one specified key
+ * exists in an object (`hasSome`). This class is part of the `@nejs/extension`
+ * library and is designed to offer these extended functionalities in a way
+ * that is consistent with the existing `Reflect` API, making it intuitive for
+ * developers who are already familiar with standard reflection methods in
+ * JavaScript.
+ */
+export const ReflectExtensions = new Patch(Reflect, {
+  /**
+   * The function checks if an object has all the specified keys.
+   *
+   * @param object - The `object` parameter is the object that we want to
+   * check if it has all the specified keys.
+   * @param keys - The `keys` parameter is a rest parameter, which means
+   * it can accept any number of arguments. In this case, it is expected
+   * to receive multiple keys as arguments.
+   * @returns a boolean value.
+   */
+  hasAll(object, ...keys) {
+    return Object.isObject(object) && (keys.flat(Infinity)
+      .map(key => Reflect.has(object, key))
+      .every(has => has)
+    )
+  },
+
+  /**
+   * The function checks if an object has at least one of the specified keys.
+   *
+   * @param object - The `object` parameter is the object that we want to check
+   * for the presence of certain keys.
+   * @param keys - The `keys` parameter is a rest parameter, which means it can
+   * accept any number of arguments. These arguments are the keys that we want
+   * to check if they exist in the `object`.
+   * @returns The function `hasSome` returns a boolean value indicating whether
+   * at least one of the keys provided as arguments exists in the given object.
+   */
+  hasSome(object, ...keys) {
+    return Object.isObject(object) && (keys.flat(Infinity)
+      .map(key => Reflect.has(object, key))
+      .some(has => has)
+    )
+  },
+
+  /**
+   * Retrieves an array of [key, descriptor] pairs for each property of the
+   * provided object. This method is akin to `Object.entries` but includes
+   * property descriptors instead of the property values. It's useful for cases
+   * where you need detailed information about properties, including their
+   * configurability, enumerability, and accessors.
+   *
+   * @param {object} object - The object whose property entries are to be
+   * retrieved.
+   * @returns {Array} An array of [key, descriptor] pairs, where each pair
+   * consists of the property name (key) and its descriptor. Returns an empty
+   * array if the input is not a valid object.
+   */
+  entries(object) {
+    if (!object || typeof object !== 'object') { return [] }
+
+    return Reflect.ownKeys(object).map(key => [
+      key, Object.getOwnPropertyDescriptor(object, key)
+    ])
+  },
+
+  /**
+   * Retrieves an array of values from the property descriptors of the given
+   * object. This method works similarly to `Object.values` but operates on
+   * property descriptors instead. It's useful when you need the values of
+   * properties including getters, setters, and other descriptor-specific
+   * attributes.
+   *
+   * @param {object} object - The object whose property values are to be
+   * retrieved.
+   * @returns {Array} An array of values extracted from the object's property
+   * descriptors. The values correspond to the `value` attribute in each
+   * property's descriptor. Returns an empty array if the input is not a valid
+   * object.
+   */
+  values(object) {
+    return Reflect.entries.map(([,value]) => value)
+  }
+})

package/tests/index.test.js

@@ -0,0 +1,36 @@
+const { enableAll, disableAll } = require('../dist/cjs/index.js')
+
+describe('Enabled extensions', () => {
+  beforeEach(() => {
+    enableAll()
+  });
+
+  afterEach(() => {
+    disableAll()
+  });
+
+  test('first returns the first element of the array', () => {
+    expect([1, 2, 3].first).toBe(1);
+  });
+
+  test('last returns the last element of the array', () => {
+    expect([1, 2, 3].last).toBe(3);
+  });
+
+  test('isObject checks if a value is an object', () => {
+    expect(Object.isObject({})).toBe(true);
+    expect(Object.isObject(123)).toBe(false);
+  });
+
+  test('isAsync identifies async functions', () => {
+    async function asyncFunc() {}
+    expect(Function.isAsync(asyncFunc)).toBe(true);
+    expect(Function.isAsync(() => {})).toBe(false);
+  });
+
+  test('hasAll checks if an object has all specified keys', () => {
+    const obj = { a: 1, b: 2 };
+    expect(Reflect.hasAll(obj, 'a', 'b')).toBe(true);
+    expect(Reflect.hasAll(obj, 'a', 'c')).toBe(false);
+  });
+});

package/tsconfig.base.json

@@ -0,0 +1,25 @@
+{
+  "compilerOptions": {
+    "allowJs": true,
+    "allowSyntheticDefaultImports": true,
+    "baseUrl": "src",
+    "declaration": true,
+    "esModuleInterop": true,
+    "inlineSourceMap": false,
+    "lib": ["esnext"],
+    "listEmittedFiles": false,
+    "listFiles": false,
+    "moduleResolution": "node",
+    "noFallthroughCasesInSwitch": false,
+    "pretty": true,
+    "resolveJsonModule": true,
+    "rootDir": "src",
+    "skipLibCheck": true,
+    "strict": true,
+    "traceResolution": false,
+    "types": ["node", "jest"]
+  },
+  "compileOnSave": false,
+  "exclude": ["node_modules", "dist"],
+  "include": ["src"]
+}