mielk-fn 1.0.0

package/.babelrc

@@ -0,0 +1,3 @@
+{
+	"presets": ["@babel/preset-env"]
+}

package/help/arrays.json

@@ -0,0 +1,93 @@
+{
+    "arrays": {
+        "toIndexedArray": {
+            "summary": "Creates a new array where items are placed at their corresponding indices determined by a callback function.",
+            "signature": "const toIndexedArray = (items: any[], callback: CallbackFunction): any[]",
+            "parameters": [
+                {
+                    "name": "items",
+                    "type": "any[]",
+                    "description": "The input array of items to be indexed."
+                },
+                {
+                    "name": "callback",
+                    "type": "CallbackFunction",
+                    "description": "The function that determines the index at which each item should be placed in the resulting array."
+                }
+            ],
+            "returns": {
+                "type": "any[]",
+                "description": "A new array where items are placed at their corresponding indices, as determined by the callback function."
+            },
+            "examples": [
+                [
+                    "<span class=\"keyword\">const</span> items = [ { name: <span class=\"string\">'Adam'</span>, id: <span class=\"number\">1</span> }, { name: <span class=\"string\">'Bartek'</span>, id: <span class=\"number\">4</span> }, { name: <span class=\"string\">'Czesiek'</span>, id: <span class=\"number\">5</span> }];",
+                    "<span class=\"keyword\">const</span> callback = (item) => item.id;",
+                    "<span class=\"keyword\">const</span> result = <span class=\"function\">toIndexedArray</span>(items, callback);",
+                    "<span class=\"comment\">// result: [ { name: 'Adam', id: 1 }, , , { name: 'Bartek', id: 4 }, { name: 'Czesiek', id: 5 } ]</span>"
+                ],
+                [
+                    "<span class=\"keyword\">class</span> Person {",
+                    "  <span class=\"keyword\">constructor</span>(public name: <span class=\"keyword\">string</span>, public age: <span class=\"keyword\">number</span>) {}",
+                    "  <span class=\"function\">getAge</span>() { <span class=\"keyword\">return</span> <span class=\"keyword\">this</span>.age; }",
+                    "}",
+                    "<span class=\"keyword\">const</span> people = [<span class=\"keyword\">new</span> Person(<span class=\"string\">'John'</span>, <span class=\"number\">20</span>), <span class=\"keyword\">new</span> Person(<span class=\"string\">'Jane'</span>, <span class=\"number\">25</span>), <span class=\"keyword\">new</span> Person(<span class=\"string\">'Alice'</span>, <span class=\"number\">30</span>)];",
+                    "<span class=\"keyword\">const</span> callback = (person) => person.<span class=\"function\">getAge</span>();",
+                    "<span class=\"keyword\">const</span> result = <span class=\"function\">toIndexedArray</span>(people, callback);",
+                    "<span class=\"comment\">// result: [ , { name: 'John', age: 20 }, , , { name: 'Jane', age: 25 }, { name: 'Alice', age: 30 } ]</span>"
+                ]
+            ]
+        },
+        "toMap": {
+            "summary": "Converts an array of items into a Map object, using a key callback function to determine the keys and an optional value function to determine the values.",
+            "signature": "function toMap(items: any[], keyCallback: StringNumberFunction, valueFn: ValueFunction = (item) => item, ignoreDuplicates = true): Map<any, any>",
+            "parameters": [
+                {
+                    "name": "items",
+                    "type": "any[]",
+                    "description": "The array of items to convert to a Map."
+                },
+                {
+                    "name": "keyCallback",
+                    "type": "StringNumberFunction",
+                    "description": "A callback function that accepts an item and returns a string or number that will be used as the key in the Map."
+                },
+                {
+                    "name": "valueFn",
+                    "type": "ValueFunction",
+                    "description": "An optional callback function that accepts an item and returns the value to be associated with the key in the Map. Defaults to the item itself."
+                },
+                {
+                    "name": "ignoreDuplicates",
+                    "type": "boolean",
+                    "description": "An optional boolean value that determines whether to ignore items with duplicate keys. Defaults to `true`."
+                }
+            ],
+            "returns": {
+                "type": "Map<any, any>",
+                "description": "Returns a new Map object containing the key-value pairs."
+            },
+            "examples": [
+                [
+                    "<span class=\"keyword\">const</span> items = [<span class=\"json\">{</span> id: <span class=\"number\">1</span>, name: <span class=\"string\">'John'</span> }, <span class=\"json\">{</span> id: <span class=\"number\">2</span>, name: <span class=\"string\">'Jane'</span> }, <span class=\"json\">{</span> id: <span class=\"number\">3</span>, name: <span class=\"string\">'Bob'</span> }];",
+                    "<span class=\"keyword\">const</span> keyCallback = (item) => item.id;",
+                    "<span class=\"keyword\">const</span> map = <span class=\"function\">toMap</span>(items, keyCallback);",
+                    "console.log(map); <span class=\"comment\">// Output: Map(3) { 1 => { id: 1, name: 'John' }, 2 => { id: 2, name: 'Jane' }, 3 => { id: 3, name: 'Bob' } }</span>"
+                ],
+                [
+                    "<span class=\"keyword\">const</span> items = [<span class=\"json\">{</span> id: <span class=\"number\">1</span>, name: <span class=\"string\">'John'</span> }, <span class=\"json\">{</span> id: <span class=\"number\">2</span>, name: <span class=\"string\">'Jane'</span> }, <span class=\"json\">{</span> id: <span class=\"number\">3</span>, name: <span class=\"string\">'Bob'</span> }];",
+                    "<span class=\"keyword\">const</span> keyCallback = (item) => item.name;",
+                    "<span class=\"keyword\">const</span> valueFn = (item) => item.id;",
+                    "<span class=\"keyword\">const</span> map = <span class=\"function\">toMap</span>(items, keyCallback, valueFn);",
+                    "console.log(map); <span class=\"comment\">// Output: Map(3) { 'John' => 1, 'Jane' => 2, 'Bob' => 3 }</span>"
+                ],
+                [
+                    "<span class=\"keyword\">const</span> items = [<span class=\"json\">{</span> id: <span class=\"number\">1</span>, name: <span class=\"string\">'John'</span> }, <span class=\"json\">{</span> id: <span class=\"number\">2</span>, name: <span class=\"string\">'Jane'</span> }, <span class=\"json\">{</span> id: <span class=\"number\">2</span>, name: <span class=\"string\">'Bob'</span> }];",
+                    "<span class=\"keyword\">const</span> keyCallback = (item) => item.id;",
+                    "<span class=\"keyword\">const</span> map = <span class=\"function\">toMap</span>(items, keyCallback, undefined, false);",
+                    "console.log(map); <span class=\"comment\">// Output: Map(2) { 1 => { id: 1, name: 'John' }, 2 => { id: 2, name: 'Bob' } }</span>"
+                ]
+            ]
+        }
+    }
+}

package/help/index.html

@@ -0,0 +1,90 @@
+<!DOCTYPE html>
+<html lang="en">
+	<head>
+		<meta charset="UTF-8" />
+		<meta name="viewport" content="width=device-width, initial-scale=1.0" />
+		<title>isObject Function Documentation</title>
+		<style>
+			body {
+				font-family: Arial, sans-serif;
+			}
+			h1,
+			h2 {
+				color: #333;
+			}
+			h2 {
+				margin-top: 1.5em;
+				margin-bottom: 0.5em;
+			}
+			code {
+				background-color: #f0f0f0;
+				padding: 2px 4px;
+				font-family: 'Courier New', monospace;
+			}
+			pre {
+				background-color: #1e1e1e;
+				padding: 16px;
+				overflow-x: auto;
+				color: #d4d4d4;
+				font-family: 'Courier New', monospace;
+				border-radius: 4px;
+				font-size: 14px;
+			}
+			.keyword {
+				color: #c586c0;
+			}
+			.number {
+				color: #b5cea8;
+			}
+			.function {
+				color: #dcdcaa;
+			}
+			.comment {
+				color: #6a9955;
+			}
+			p {
+				margin-top: 0;
+			}
+		</style>
+	</head>
+	<body>
+		<div class="header">Documentation mielk-fn</div>
+		<div class="menu"></div>
+		<div class="content">
+			<h1 class="name"></h1>
+
+			<h2>Summary</h2>
+			<p class="summary"></p>
+
+			<h2>Signature</h2>
+			<pre class="signature">
+				function isObject(value: unknown): boolean
+			</pre
+			>
+
+			<h2>Parameters</h2>
+			<dl class="parameters">
+				<dt><code>value: unknown</code></dt>
+				<dd>The value to be checked for being an object.</dd>
+			</dl>
+
+			<h2>Returns</h2>
+			<p><code class="type"></code>: <span class="returns"></span>.</p>
+
+			<h2>Examples</h2>
+			<pre class="examples">
+				<span class="comment">// Example 1:</span>
+				<span class="keyword">const</span> obj = { key: <span class="string">'value'</span> };
+				console.log(<span class="function">isObject</span>(obj)); <span class="comment">// Output: true</span>
+	
+				<span class="comment">// Example 2:</span>
+				<span class="keyword">const</span> arr = [<span class="number">1</span>, <span class="number">2</span>, <span class="number">3</span>];
+				console.log(<span class="function">isObject</span>(arr)); <span class="comment">// Output: false</span>
+	
+				<span class="comment">// Example 3:</span>
+				console.log(<span class="function">isObject</span>(<span class="keyword">null</span>)); <span class="comment">// Output: false</span>
+			</pre>
+		</div>
+		<script src="help.js"></script>
+	</body>
+</html>

package/help/objects.json

@@ -0,0 +1,221 @@
+{
+    "objects": {
+        "invert": {
+            "summary": "Swaps keys and values for a given JavaScript object.",
+            "signature": "function invert(obj: Record<string | number, string | number>): Record<string | number, string | number>",
+            "parameters": [
+                {
+                    "name": "obj",
+                    "type": "Record<string | number, string | number>",
+                    "description": "The object for which keys and values should be swapped."
+                }
+            ],
+            "returns": {
+                "type": "Record<string | number, string | number>",
+                "description": "Returns a new object with the keys and values of the input object swapped."
+            },
+            "restrictions": [
+                "The input object must have keys and values of type string or number."
+            ],
+            "examples": [
+                [
+                    "const input = { key1: <span class=\"string\">'value1'</span>, key2: <span class=\"string\">'value2'</span> };",
+                    "const result = <span class=\"function\">invert</span>(input);",
+                    "console.log(result); <span class=\"comment\">// Output: { value1: 'key1', value2: 'key2' }</span>"
+                ],
+                [
+                    "const input = { [<span class=\"number\">1</span>]: <span class=\"number\">2</span>, [<span class=\"number\">3</span>]: <span class=\"number\">4</span> };",
+                    "const result = <span class=\"function\">invert</span>(input);",
+                    "console.log(result); <span class=\"comment\">// Output: { 2: '1', 4: '3' }</span>"
+                ],
+                [
+                    "const input = { key1: <span class=\"number\">1</span>, [<span class=\"number\">2</span>]: <span class=\"string\">'value2'</span> };",
+                    "const result = <span class=\"function\">invert</span>(input);",
+                    "console.log(result); <span class=\"comment\">// Output: { 1: 'key1', value2: '2' }</span>"
+                ],
+                [
+                    "const input = {};",
+                    "const result = <span class=\"function\">invert</span>(input);",
+                    "console.log(result); <span class=\"comment\">// Output: {}</span>"
+                ]
+            ]
+        },
+        "isObject": {
+            "summary": "Determines if the given value is an object, excluding arrays and null values.",
+            "signature": "function isObject(value: unknown): boolean",
+            "parameters": [
+                {
+                    "name": "value",
+                    "type": "unknown",
+                    "description": "The value to be checked for being an object."
+                }
+            ],
+            "returns": {
+                "type": "boolean",
+                "description": "Returns <code>true</code> if the input value is an object (excluding arrays and null values), and <code>false</code> otherwise."
+            },
+            "examples": [
+                [
+                    "<span class=\"keyword\">const</span> obj = { key: <span class=\"string\">'value'</span> };",
+                    "console.log(<span class=\"function\">isObject</span>(obj)); <span class=\"comment\">// Output: true</span>"
+                ],
+                [
+                    "<span class=\"keyword\">const</span> arr = [<span class=\"number\">1</span>, <span class=\"number\">2</span>, <span class=\"number\">3</span>];",
+                    "console.log(<span class=\"function\">isObject</span>(arr)); <span class=\"comment\">// Output: false</span>"
+                ],
+                [
+                    "console.log(<span class=\"function\">isObject</span>(<span class=\"keyword\">null</span>)); <span class=\"comment\">// Output: false</span>"
+                ]
+            ]
+        },
+        "isPlainObject": {
+            "summary": "Checks if a value is a plain JavaScript object.",
+            "signature": "(value: unknown) => boolean",
+            "parameters": [
+                {
+                    "name": "value",
+                    "type": "unknown",
+                    "description": "The value to check."
+                }
+            ],
+            "returns": {
+                "type": "boolean",
+                "description": "Returns `true` if the value is a plain JavaScript object, `false` otherwise."
+            },
+            "examples": [
+                [
+                    "<span class=\"keyword\">const</span> obj = { id: 1, name: 'John' };",
+                    "<span class=\"function\">console.log</span>(<span class=\"function\">isPlainObject</span>(obj)); <span class=\"comment\">// Output: true</span>"
+                ],
+                [
+                    "<span class=\"keyword\">const</span> date = <span class=\"keyword\">new</span> <span class=\"class\">Date</span>();",
+                    "<span class=\"function\">console.log</span>(<span class=\"function\">isPlainObject</span>(date)); <span class=\"comment\">// Output: false</span>"
+                ],
+                [
+                    "<span class=\"keyword\">class</span> <span class=\"class\">Person</span> {",
+                    "  <span class=\"keyword\">constructor</span>(<span class=\"keyword\">public</span> name: <span class=\"keyword\">string</span>) {}",
+                    "}",
+                    "<span class=\"keyword\">const</span> person = <span class=\"keyword\">new</span> <span class=\"class\">Person</span>('Jane');",
+                    "<span class=\"function\">console.log</span>(<span class=\"function\">isPlainObject</span>(person)); <span class=\"comment\">// Output: false</span>"
+                ],
+                [
+                    "<span class=\"keyword\">const</span> user = { name: 'Alice', age: 25, isAdmin: <span class=\"literal\">false</span> };",
+                    "<span class=\"function\">console.log</span>(<span class=\"function\">isPlainObject</span>(user)); <span class=\"comment\">// Output: true</span>"
+                ],
+                [
+                    "<span class=\"keyword\">const</span> arr = [<span class=\"string\">'apple'</span>, <span class=\"string\">'banana'</span>, <span class=\"string\">'orange'</span>];",
+                    "<span class=\"function\">console.log</span>(<span class=\"function\">isPlainObject</span>(arr)); <span class=\"comment\">// Output: false</span>"
+                ]
+            ]
+        },
+        "merge": {
+            "summary": "Merges two or more objects and returns an object that has properties of all those input objects.",
+            "signature": "function merge(objects: AnyObject[], override: boolean = false): AnyObject",
+            "parameters": [
+                {
+                    "name": "objects",
+                    "type": "AnyObject[]",
+                    "description": "An array of JavaScript objects to be merged."
+                },
+                {
+                    "name": "override",
+                    "type": "boolean",
+                    "description": "An optional parameter that determines which value should be assigned to the returned object if there is a conflict (more than one input objects have the same property). If this value is set to true, the last found value of the given property will be assigned to the returned object, otherwise the first found value."
+                }
+            ],
+            "returns": {
+                "type": "AnyObject",
+                "description": "Returns an object that has properties of all the input objects, merged according to the 'override' parameter."
+            },
+            "examples": [
+                [
+                    "<span class=\"keyword\">const</span> obj = { a: 1, b: 2, c: 3 };",
+                    "<span class=\"keyword\">const</span> callback = (key) => key.toUpperCase();",
+                    "<span class=\"keyword\">const</span> result = <span class=\"function\">modifyKeys</span>(obj, callback);",
+                    "console.log(result); <span class=\"comment\">// Output: { A: 1, B: 2, C: 3 }</span>"
+                ],
+                [
+                    "<span class=\"keyword\">const</span> obj = { a: 1, b: 2, c: 3 };",
+                    "<span class=\"keyword\">const</span> callback = (key) => key + '_new';",
+                    "<span class=\"keyword\">const</span> result = <span class=\"function\">modifyKeys</span>(obj, callback);",
+                    "console.log(result); <span class=\"comment\">// Output: { a_new: 1, b_new: 2, c_new: 3 }</span>"
+                ],
+                [
+                    "<span class=\"keyword\">const</span> obj = { 1: 'a', 2: 'b', 3: 'c' };",
+                    "<span class=\"keyword\">const</span> callback = (key) => parseInt(key) + 1;",
+                    "<span class=\"keyword\">const</span> result = <span class=\"function\">modifyKeys</span>(obj, callback);",
+                    "console.log(result); <span class=\"comment\">// Output: { 2: 'a', 3: 'b', 4: 'c' }</span>"
+                ],
+                [
+                    "<span class=\"keyword\">const</span> obj = { a: 1, b: 2, c: 3 };",
+                    "<span class=\"keyword\">const</span> callback = (key) => key;",
+                    "<span class=\"keyword\">const</span> result = <span class=\"function\">modifyKeys</span>(obj, callback, false);",
+                    "console.log(result); <span class=\"comment\">// Output: { a: 1, b: 2, c: 3 }</span>"
+                ],
+                [
+                    "<span class=\"keyword\">const</span> obj = { a: 1, b: 2, c: 3, 1: 'd' };",
+                    "<span class=\"keyword\">const</span> callback = (key) => key;",
+                    "<span class=\"keyword\">const</span> result = <span class=\"function\">modifyKeys</span>(obj, callback, true);",
+                    "console.log(result); <span class=\"comment\">// Output: { a: 1, b: 2, c: 3 }</span>"
+                ]
+            ]
+        },
+        "modifyKeys": {
+            "name": "modifyKeys",
+            "description": "Modifies an object's keys based on a callback function.",
+            "params": [
+                {
+                    "name": "obj",
+                    "type": "Object",
+                    "description": "The object to modify the keys for."
+                },
+                {
+                    "name": "callback",
+                    "type": "Function",
+                    "description": "The callback function to determine the new keys for each object."
+                },
+                {
+                    "name": "ignoreDuplicates",
+                    "type": "boolean",
+                    "description": "An optional boolean value that determines whether to ignore objects with duplicate keys. Defaults to `true`."
+                }
+            ],
+            "returns": {
+                "type": "Object",
+                "description": "The modified object with new keys."
+            },
+            "examples": [
+                [
+                    "<span class=\"keyword\">const</span> obj = { a: 1, b: 2, c: 3 };",
+                    "<span class=\"keyword\">const</span> callback = (key) => key.toUpperCase();",
+                    "<span class=\"keyword\">const</span> result = <span class=\"function\">modifyKeys</span>(obj, callback);",
+                    "console.log(result); <span class=\"comment\">// Output: { A: 1, B: 2, C: 3 }</span>"
+                ],
+                [
+                    "<span class=\"keyword\">const</span> obj = { a: 1, b: 2, c: 3 };",
+                    "<span class=\"keyword\">const</span> callback = (key) => key + '_new';",
+                    "<span class=\"keyword\">const</span> result = <span class=\"function\">modifyKeys</span>(obj, callback);",
+                    "console.log(result); <span class=\"comment\">// Output: { a_new: 1, b_new: 2, c_new: 3 }</span>"
+                ],
+                [
+                    "<span class=\"keyword\">const</span> obj = { 1: 'a', 2: 'b', 3: 'c' };",
+                    "<span class=\"keyword\">const</span> callback = (key) => parseInt(key) + 1;",
+                    "<span class=\"keyword\">const</span> result = <span class=\"function\">modifyKeys</span>(obj, callback);",
+                    "console.log(result); <span class=\"comment\">// Output: { 2: 'a', 3: 'b', 4: 'c' }</span>"
+                ],
+                [
+                    "<span class=\"keyword\">const</span> obj = { a: 1, b: 2, c: 3 };",
+                    "<span class=\"keyword\">const</span> callback = (key) => key;",
+                    "<span class=\"keyword\">const</span> result = <span class=\"function\">modifyKeys</span>(obj, callback, false);",
+                    "console.log(result); <span class=\"comment\">// Output: { a: 1, b: 2, c: 3 }</span>"
+                ],
+                [
+                    "<span class=\"keyword\">const</span> obj = { a: 1, b: 2, c: 3, 1: 'd' };",
+                    "<span class=\"keyword\">const</span> callback = (key) => key;",
+                    "<span class=\"keyword\">const</span> result = <span class=\"function\">modifyKeys</span>(obj, callback, true);",
+                    "console.log(result); <span class=\"comment\">// Output: { a: 1, b: 2, c: 3 }</span>"
+                ]
+            ]
+        }
+    }
+}

package/index.ts

@@ -0,0 +1,6 @@
+// import arrays from './lib/arrays.js';
+import objects from './src/objects';
+// import routing from './lib/routing.js';
+
+// export { arrays, objects, routing };
+export { objects };

package/lib/arrays.d.ts

@@ -0,0 +1,8 @@
+type NumberFunction = (item: any) => number;
+type StringNumberFunction = (item: any) => string | number;
+type AnyFunction = (item: any) => any;
+declare const _default: {
+    toMap: (items: any[], keyCallback: StringNumberFunction, valueFn?: AnyFunction, ignoreDuplicates?: boolean) => Map<any, any>;
+    toIndexedArray: (items: any[], callback: NumberFunction) => any[];
+};
+export default _default;

package/lib/arrays.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const toMap = (items, keyCallback, valueFn = (item) => item, ignoreDuplicates = true) => {
+    const map = new Map();
+    items.forEach((item) => {
+        const key = keyCallback(item);
+        const value = valueFn ? valueFn(item) : item;
+        if (ignoreDuplicates && map.has(key)) {
+        }
+        else {
+            map.set(key, value);
+        }
+    });
+    return map;
+};
+const toIndexedArray = (items, callback) => {
+    const arr = [];
+    items.forEach((item) => {
+        // Check if item is an object and has a function named callback
+        if (typeof item === 'object' && item !== null) {
+            const index = callback(item);
+            if (typeof index !== 'number') {
+                throw new TypeError('Callback should return a number.');
+            }
+            arr[index] = item;
+        }
+    });
+    return arr;
+};
+exports.default = { toMap, toIndexedArray };

package/lib/objects.d.ts

@@ -0,0 +1,12 @@
+type AnyObject = {
+    [key: string]: any;
+};
+type NumberStringFunction = (key: string, item: any) => number | string;
+declare const _default: {
+    isObject: (value: unknown) => boolean;
+    isPlainObject: (value: unknown) => boolean;
+    merge: (objects: AnyObject[], override?: boolean) => AnyObject;
+    invert: (obj: Record<string | number, string | number>) => Record<string | number, string | number>;
+    modifyKeys: (obj: AnyObject, callback: NumberStringFunction, ignoreDuplicates?: boolean) => AnyObject;
+};
+export default _default;

package/lib/objects.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const isObject = (value) => typeof value === 'object' && !Array.isArray(value) && value !== null;
+const isPlainObject = (value) => (value === null || value === void 0 ? void 0 : value.constructor.name) === 'Object';
+const merge = (objects, override = false) => {
+    const merged = {};
+    objects.forEach((obj) => {
+        if (isObject(obj)) {
+            const entries = Object.entries(obj);
+            entries.forEach(([key, value]) => {
+                if (!merged[key] || override)
+                    merged[key] = value;
+            });
+        }
+    });
+    return merged;
+};
+const invert = (obj) => {
+    if (!isObject(obj)) {
+        throw new Error('Invalid input: the input must be an object.');
+    }
+    const inverted = {};
+    for (const [key, value] of Object.entries(obj)) {
+        if (typeof value !== 'string' && typeof value !== 'number') {
+            throw new Error('Invalid value type: the value must be a string or a number.');
+        }
+        inverted[value] = key;
+    }
+    return inverted;
+};
+const modifyKeys = (obj, callback, ignoreDuplicates = true) => {
+    if (!isPlainObject(obj))
+        throw new TypeError(`Invalid type of ${obj === null || obj === void 0 ? void 0 : obj.constructor.name}. Expected JavaScript object`);
+    const entries = Object.entries(obj || {});
+    const result = {};
+    entries.forEach(([key, value]) => {
+        const newKey = callback(key, value);
+        if (!result.hasOwnProperty(newKey) || !ignoreDuplicates) {
+            result[newKey] = value;
+        }
+    });
+    return result;
+};
+exports.default = { isObject, isPlainObject, merge, invert, modifyKeys };

package/package.json

@@ -0,0 +1,67 @@
+{
+  "name": "mielk-fn",
+  "version": "1.0.0",
+  "description": "Set of helpful functions",
+  "main": "index.js",
+  "type": "module",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/mielk/mielk-fn.git"
+  },
+  "author": "Tomasz Mielniczek",
+  "license": "ISC",
+  "bugs": {
+    "url": "https://github.com/mielk/mielk-fn/issues"
+  },
+  "homepage": "https://github.com/mielk/mielk-fn#readme",
+  "devDependencies": {
+    "@babel/cli": "^7.21.5",
+    "@babel/core": "^7.21.8",
+    "@babel/node": "^7.20.7",
+    "@babel/preset-env": "^7.21.5",
+    "@types/jest": "^29.5.1",
+    "@types/node": "^20.1.2",
+    "babel-jest": "^29.5.0",
+    "jest": "^29.5.0",
+    "jest-html-reporters": "^3.1.4",
+    "ts-jest": "^29.1.0",
+    "typescript": "^5.0.4"
+  },
+  "jest": {
+    "transform": {
+      "^.+\\.(t|j)sx?$": "ts-jest"
+    },
+    "moduleFileExtensions": [
+      "ts",
+      "tsx",
+      "js",
+      "jsx",
+      "json",
+      "node"
+    ],
+    "globals": {
+      "ts-jest": {
+        "tsconfig": "tsconfig.json"
+      }
+    },
+    "reporters": [
+      "default",
+      [
+        "jest-html-reporters",
+        {
+          "publicPath": "./reports/html-report",
+          "filename": "report.html",
+          "pageTitle": "My Project - Test Report",
+          "expand": true,
+          "openReport": true,
+          "groupBy": [
+            "describe"
+          ]
+        }
+      ]
+    ]
+  }
+}

package/src/arrays.ts

@@ -0,0 +1,38 @@
+type NumberFunction = (item: any) => number;
+type StringNumberFunction = (item: any) => string | number;
+type AnyFunction = (item: any) => any;
+
+const toMap = (
+	items: any[],
+	keyCallback: StringNumberFunction,
+	valueFn: AnyFunction = (item) => item,
+	ignoreDuplicates = true
+) => {
+	const map = new Map();
+	items.forEach((item) => {
+		const key = keyCallback(item);
+		const value = valueFn ? valueFn(item) : item;
+		if (ignoreDuplicates && map.has(key)) {
+		} else {
+			map.set(key, value);
+		}
+	});
+	return map;
+};
+
+const toIndexedArray = (items: any[], callback: NumberFunction): any[] => {
+	const arr: any[] = [];
+	items.forEach((item) => {
+		// Check if item is an object and has a function named callback
+		if (typeof item === 'object' && item !== null) {
+			const index = callback(item);
+			if (typeof index !== 'number') {
+				throw new TypeError('Callback should return a number.');
+			}
+			arr[index] = item;
+		}
+	});
+	return arr;
+};
+
+export default { toMap, toIndexedArray };

package/src/objects.ts

@@ -0,0 +1,57 @@
+import { isDate } from 'util/types';
+
+type AnyObject = { [key: string]: any };
+type NumberStringFunction = (key: string, item: any) => number | string;
+
+const isObject = (value: unknown) => typeof value === 'object' && !Array.isArray(value) && value !== null;
+
+const isPlainObject = (value: unknown) => value?.constructor.name === 'Object';
+
+const merge = (objects: AnyObject[], override: boolean = false): AnyObject => {
+	const merged: AnyObject = {};
+	objects.forEach((obj) => {
+		if (isObject(obj)) {
+			const entries = Object.entries(obj);
+			entries.forEach(([key, value]) => {
+				if (!merged[key] || override) merged[key] = value;
+			});
+		}
+	});
+	return merged;
+};
+
+const invert = (
+	obj: Record<string | number, string | number>
+): Record<string | number, string | number> => {
+	if (!isObject(obj)) {
+		throw new Error('Invalid input: the input must be an object.');
+	}
+
+	const inverted: Record<string | number, string | number> = {};
+
+	for (const [key, value] of Object.entries(obj)) {
+		if (typeof value !== 'string' && typeof value !== 'number') {
+			throw new Error('Invalid value type: the value must be a string or a number.');
+		}
+
+		inverted[value] = key;
+	}
+
+	return inverted;
+};
+
+const modifyKeys = (obj: AnyObject, callback: NumberStringFunction, ignoreDuplicates = true) => {
+	if (!isPlainObject(obj))
+		throw new TypeError(`Invalid type of ${obj?.constructor.name}. Expected JavaScript object`);
+	const entries = Object.entries(obj || {});
+	const result: AnyObject = {};
+	entries.forEach(([key, value]) => {
+		const newKey: string | number = callback(key, value);
+		if (!result.hasOwnProperty(newKey) || !ignoreDuplicates) {
+			result[newKey] = value;
+		}
+	});
+	return result;
+};
+
+export default { isObject, isPlainObject, merge, invert, modifyKeys };

package/tests/arrays.test.ts

@@ -0,0 +1,118 @@
+import arrays from '../src/arrays';
+
+/**
+ * Unit tests for toMap function
+ */
+describe('toMap', () => {
+	const { toMap } = arrays;
+	const objects = [
+		{ name: 'Adam', id: 1 },
+		{ name: 'Bartek', id: 4 },
+		{ name: 'Czesiek', id: 5 },
+	];
+	const primitives = ['Adam', 'Bartek', 'Czesiek'];
+
+	it('should create a map from an array of objects', () => {
+		const map = toMap(objects, (obj) => obj.id);
+		expect(map.size).toBe(3);
+		expect(map.get(1)).toEqual(objects[0]);
+		expect(map.get(4)).toEqual(objects[1]);
+		expect(map.get(5)).toEqual(objects[2]);
+	});
+
+	it('should create a map from an array of primitives', () => {
+		const map = toMap(primitives, (str) => str.charAt(0));
+		expect(map.size).toBe(3);
+		expect(map.get('A')).toEqual(primitives[0]);
+		expect(map.get('B')).toEqual(primitives[1]);
+		expect(map.get('C')).toEqual(primitives[2]);
+	});
+
+	it('should allow custom value callback', () => {
+		const map = toMap(
+			objects,
+			(obj) => obj.id,
+			(obj) => obj.name
+		);
+		expect(map.size).toBe(3);
+		expect(map.get(1)).toBe('Adam');
+		expect(map.get(4)).toBe('Bartek');
+		expect(map.get(5)).toBe('Czesiek');
+	});
+
+	it('should ignore duplicate keys by default', () => {
+		const objectsWithDuplicate = [
+			{ name: 'Adam', id: 1 },
+			{ name: 'Bartek', id: 4 },
+			{ name: 'Czesiek', id: 4 },
+		];
+		const map = toMap(objectsWithDuplicate, (obj) => obj.id);
+		expect(map.size).toBe(2);
+		expect(map.get(1)).toEqual(objectsWithDuplicate[0]);
+		expect(map.get(4)).toEqual(objectsWithDuplicate[1]);
+	});
+});
+
+describe('toIndexedArray', () => {
+	const { toIndexedArray } = arrays;
+	it('should return an indexed array with basic objects', () => {
+		const items = [
+			{ name: 'Adam', id: 1 },
+			{ name: 'Bartek', id: 4 },
+			{ name: 'Czesiek', id: 5 },
+		];
+
+		const callback = (item: any) => item.id;
+		const result = toIndexedArray(items, callback);
+
+		expect(result[1]).toEqual({ name: 'Adam', id: 1 });
+		expect(result[4]).toEqual({ name: 'Bartek', id: 4 });
+		expect(result[5]).toEqual({ name: 'Czesiek', id: 5 });
+	});
+
+	it('should handle custom class instances', () => {
+		class Person {
+			fullName: string;
+			id: number;
+
+			constructor(fullName: string, id: number) {
+				this.fullName = fullName;
+				this.id = id;
+			}
+		}
+
+		const items = [new Person('Adam', 1), new Person('Bartek', 4), new Person('Czesiek', 5)];
+
+		const callback = (item: unknown) => {
+			if (typeof item === 'object' && item !== null && 'id' in item) {
+				return (item as Person).id;
+			}
+			return -1;
+		};
+		const result = toIndexedArray(items, callback);
+
+		expect(result[1]).toEqual(new Person('Adam', 1));
+		expect(result[4]).toEqual(new Person('Bartek', 4));
+		expect(result[5]).toEqual(new Person('Czesiek', 5));
+	});
+
+	it('should throw an error when the callback returns a non-number value', () => {
+		const items = [
+			{ name: 'Adam', id: '1' },
+			{ name: 'Bartek', id: '4' },
+			{ name: 'Czesiek', id: '5' },
+		];
+
+		const callback = (item: any) => item.id;
+		expect(() => toIndexedArray(items, callback)).toThrow(
+			new TypeError('Callback should return a number.')
+		);
+	});
+
+	it('should handle an empty array', () => {
+		const items: any[] = [];
+		const callback = (item: any) => item.id;
+		const result = toIndexedArray(items, callback);
+		expect(result).toEqual([]);
+	});
+});

package/tests/objects.test.ts

@@ -0,0 +1,259 @@
+import objects from '../src/objects';
+
+describe('isObject', () => {
+	const isObject = objects.isObject;
+	test('returns true for non-empty object', () => {
+		const obj = { value: 123 };
+		expect(isObject(obj)).toEqual(true);
+	});
+
+	test('returns true for empty object', () => {
+		expect(isObject({})).toEqual(true);
+	});
+	test('should return true for an object', () => {
+		const obj = { key: 'value' };
+		expect(isObject(obj)).toBe(true);
+	});
+
+	test('should return false for an array', () => {
+		const arr = [1, 2, 3];
+		expect(isObject(arr)).toBe(false);
+	});
+
+	test('should return false for null', () => {
+		expect(isObject(null)).toBe(false);
+	});
+
+	test('should return false for undefined', () => {
+		expect(isObject(undefined)).toBe(false);
+	});
+
+	test('should return false for a string', () => {
+		expect(isObject('string')).toBe(false);
+	});
+
+	test('should return false for a number', () => {
+		expect(isObject(42)).toBe(false);
+	});
+
+	test('should return false for a boolean', () => {
+		expect(isObject(true)).toBe(false);
+		expect(isObject(false)).toBe(false);
+	});
+
+	test('should return false for a function', () => {
+		const func = () => {};
+		expect(isObject(func)).toBe(false);
+	});
+});
+
+describe('isPlainObject', () => {
+	const { isPlainObject } = objects;
+	it('should return true for plain JavaScript objects', () => {
+		expect(isPlainObject({})).toBe(true);
+		expect(isPlainObject({ key: 'value' })).toBe(true);
+	});
+
+	it('should return false for non-plain JavaScript objects', () => {
+		expect(isPlainObject([])).toBe(false);
+		expect(isPlainObject(new Date())).toBe(false);
+		expect(isPlainObject(null)).toBe(false);
+		expect(isPlainObject(undefined)).toBe(false);
+		expect(isPlainObject(123)).toBe(false);
+		expect(isPlainObject('string')).toBe(false);
+		expect(isPlainObject(true)).toBe(false);
+		expect(isPlainObject(() => {})).toBe(false);
+		class CustomClass {}
+		expect(isPlainObject(new CustomClass())).toBe(false);
+	});
+});
+
+describe('merge', () => {
+	const merge = objects.merge;
+	test('Empty array', () => {
+		const result = merge([]);
+		expect(result).toEqual({});
+	});
+
+	it('Array with non-objects', () => {
+		const input = ['string1', 42, true] as unknown as Array<object>;
+		const result = merge(input);
+		expect(result).toEqual({});
+	});
+
+	it('Array with objects and non-objects', () => {
+		const obj1 = { key1: 'value1' };
+		const obj2 = { key2: 'value2' };
+		const input = [obj1, 'string1', 42, obj2, true] as unknown as Array<object>;
+		const result = merge(input);
+		expect(result).toEqual({ key1: 'value1', key2: 'value2' });
+	});
+
+	test('Array with empty objects', () => {
+		const result = merge([{}, {}, {}]);
+		expect(result).toEqual({});
+	});
+
+	test('Array with objects without duplicated properties', () => {
+		const result = merge([{ a: 1 }, { b: 2 }, { c: 3 }]);
+		expect(result).toEqual({ a: 1, b: 2, c: 3 });
+	});
+
+	test('Array with objects with duplicated properties and override=false', () => {
+		const result = merge([{ a: 1 }, { a: 2 }, { a: 3 }], false);
+		expect(result).toEqual({ a: 1 });
+	});
+
+	test('Array with objects with duplicated properties and override=true', () => {
+		const result = merge([{ a: 1 }, { a: 2 }, { a: 3 }], true);
+		expect(result).toEqual({ a: 3 });
+	});
+});
+
+describe('invert', () => {
+	const invert = objects.invert;
+	it('Basic case', () => {
+		const input = { key1: 'value1', key2: 'value2' };
+		const result = invert(input);
+		expect(result).toEqual({ value1: 'key1', value2: 'key2' });
+	});
+
+	it('Number keys and values', () => {
+		const input = { 1: 2, 3: 4 };
+		const result = invert(input);
+		expect(result).toEqual({ 2: '1', 4: '3' });
+	});
+
+	it('Mixed keys and values', () => {
+		const input = { key1: 1, 2: 'value2' };
+		const result = invert(input);
+		expect(result).toEqual({ 1: 'key1', value2: '2' });
+	});
+
+	it('Empty object', () => {
+		const input = {};
+		const result = invert(input);
+		expect(result).toEqual({});
+	});
+
+	it('Non-object input', () => {
+		const input = 'string' as unknown as Record<string | number, string | number>;
+		expect(() => invert(input)).toThrowError('Invalid input: the input must be an object.');
+	});
+
+	it('Invalid value type', () => {
+		const input = { key1: true } as unknown as Record<string | number, string | number>;
+		expect(() => invert(input)).toThrowError(
+			'Invalid value type: the value must be a string or a number.'
+		);
+	});
+});
+
+describe('modifyKeys function', () => {
+	const { modifyKeys } = objects;
+	type NumberStringFunction = (key: number | string) => number | string;
+	describe('modifyKeys', () => {
+		it('should modify the keys of the object', () => {
+			const input = { id: 1, name: 'John' };
+			const callback: NumberStringFunction = (key) => ('' + key).toUpperCase();
+			const result = modifyKeys(input, callback);
+			expect(result).toEqual({ ID: 1, NAME: 'John' });
+		});
+
+		it('should handle an empty object', () => {
+			const input = {};
+			const callback: NumberStringFunction = (key) => ('' + key).toUpperCase();
+			const result = modifyKeys(input, callback);
+			expect(result).toEqual({});
+		});
+
+		it('should handle an object with non-string keys', () => {
+			const input = { 1: 'one', 2: 'two', 3: 'three' };
+			const callback: NumberStringFunction = (key) => key + '_new';
+			const result = modifyKeys(input, callback);
+			expect(result).toEqual({ '1_new': 'one', '2_new': 'two', '3_new': 'three' });
+		});
+
+		it('should modify the keys based on the callback function', () => {
+			const input = { id: 1, name: 'John', age: 30 };
+			const callback: NumberStringFunction = (key) => key + '_new';
+			const result = modifyKeys(input, callback);
+			expect(result).toEqual({ id_new: 1, name_new: 'John', age_new: 30 });
+		});
+
+		it('should not modify the original object', () => {
+			const input = { id: 1, name: 'John' };
+			const callback: NumberStringFunction = (key) => ('' + key).toUpperCase();
+			const result = modifyKeys(input, callback);
+			expect(result).toEqual({ ID: 1, NAME: 'John' });
+			expect(input).toEqual({ id: 1, name: 'John' });
+		});
+		it('should modify the keys of an object', () => {
+			const obj = { a: 1, b: 2, c: 3 };
+			const callback: NumberStringFunction = (key) => ('' + key).toUpperCase();
+			const result = modifyKeys(obj, callback);
+			expect(result).toEqual({ A: 1, B: 2, C: 3 });
+		});
+
+		it('should handle an empty object', () => {
+			const obj = {};
+			const callback: NumberStringFunction = (key) => ('' + key).toUpperCase();
+			const result = modifyKeys(obj, callback);
+			expect(result).toEqual({});
+		});
+
+		it('should throw an error if the second argument is not a function', () => {
+			const obj = { a: 1, b: 2, c: 3 };
+			const callback = 'not a function';
+			expect(() => modifyKeys(obj, callback as unknown as NumberStringFunction)).toThrow(TypeError);
+		});
+
+		it('should handle an object with duplicate modified keys', () => {
+			const obj = { a: 1, b: 2, c: 3 };
+			const callback: NumberStringFunction = (key) => 'new_key';
+			const result = modifyKeys(obj, callback, true);
+			expect(result).toEqual({ new_key: 1 });
+		});
+
+		it('should handle an object with duplicate modified keys if ignoreDuplicates is false', () => {
+			const obj = { a: 1, b: 2, c: 3 };
+			const callback: NumberStringFunction = (key) => 'new_key';
+			const result = modifyKeys(obj, callback, false);
+			expect(result).toEqual({ new_key: 3 });
+		});
+
+		it('should throw an error in strict mode if given a non-object value', () => {
+			'use strict';
+			const callback: NumberStringFunction = (key: number | string) => 'new_key';
+			const fn = () => {};
+			expect(() => modifyKeys(undefined as any, callback)).toThrow(
+				new TypeError('Invalid type of undefined. Expected JavaScript object')
+			);
+			expect(() => modifyKeys(123 as any, callback)).toThrow(
+				new TypeError('Invalid type of Number. Expected JavaScript object')
+			);
+			expect(() => modifyKeys('string' as any, callback)).toThrow(
+				new TypeError('Invalid type of String. Expected JavaScript object')
+			);
+			expect(() => modifyKeys(Symbol() as any, callback)).toThrow(
+				new TypeError('Invalid type of Symbol. Expected JavaScript object')
+			);
+			expect(() => modifyKeys(true as any, callback)).toThrow(
+				new TypeError('Invalid type of Boolean. Expected JavaScript object')
+			);
+			expect(() => modifyKeys(fn as any, callback)).toThrow(
+				new TypeError('Invalid type of Function. Expected JavaScript object')
+			);
+			expect(() => modifyKeys([] as any, callback)).toThrow(
+				new TypeError('Invalid type of Array. Expected JavaScript object')
+			);
+			expect(() => modifyKeys(new Date() as any, callback)).toThrow(
+				new TypeError(`Invalid type of Date. Expected JavaScript object`)
+			);
+			class MyClass {}
+			expect(() => modifyKeys(new MyClass() as any, callback)).toThrow(
+				new TypeError(`Invalid type of MyClass. Expected JavaScript object`)
+			);
+		});
+	});
+});

package/tsconfig.json

@@ -0,0 +1,110 @@
+{
+	"compilerOptions": {
+		/* Visit https://aka.ms/tsconfig to read more about this file */
+
+		/* Projects */
+		// "incremental": true,                              /* Save .tsbuildinfo files to allow for incremental compilation of projects. */
+		// "composite": true,                                /* Enable constraints that allow a TypeScript project to be used with project references. */
+		// "tsBuildInfoFile": "./.tsbuildinfo",              /* Specify the path to .tsbuildinfo incremental compilation file. */
+		// "disableSourceOfProjectReferenceRedirect": true,  /* Disable preferring source files instead of declaration files when referencing composite projects. */
+		// "disableSolutionSearching": true,                 /* Opt a project out of multi-project reference checking when editing. */
+		// "disableReferencedProjectLoad": true,             /* Reduce the number of projects loaded automatically by TypeScript. */
+
+		/* Language and Environment */
+		"target": "ES6" /* Set the JavaScript language version for emitted JavaScript and include compatible library declarations. */,
+		// "lib": [],                                        /* Specify a set of bundled library declaration files that describe the target runtime environment. */
+		// "jsx": "preserve",                                /* Specify what JSX code is generated. */
+		// "experimentalDecorators": true,                   /* Enable experimental support for legacy experimental decorators. */
+		// "emitDecoratorMetadata": true,                    /* Emit design-type metadata for decorated declarations in source files. */
+		// "jsxFactory": "",                                 /* Specify the JSX factory function used when targeting React JSX emit, e.g. 'React.createElement' or 'h'. */
+		// "jsxFragmentFactory": "",                         /* Specify the JSX Fragment reference used for fragments when targeting React JSX emit e.g. 'React.Fragment' or 'Fragment'. */
+		// "jsxImportSource": "",                            /* Specify module specifier used to import the JSX factory functions when using 'jsx: react-jsx*'. */
+		// "reactNamespace": "",                             /* Specify the object invoked for 'createElement'. This only applies when targeting 'react' JSX emit. */
+		// "noLib": true,                                    /* Disable including any library files, including the default lib.d.ts. */
+		// "useDefineForClassFields": true,                  /* Emit ECMAScript-standard-compliant class fields. */
+		// "moduleDetection": "auto",                        /* Control what method is used to detect module-format JS files. */
+
+		/* Modules */
+		"module": "commonjs" /* Specify what module code is generated. */,
+		// "rootDir": "./",                                  /* Specify the root folder within your source files. */
+		// "moduleResolution": "node10",                     /* Specify how TypeScript looks up a file from a given module specifier. */
+		// "baseUrl": "./",                                  /* Specify the base directory to resolve non-relative module names. */
+		// "paths": {},                                      /* Specify a set of entries that re-map imports to additional lookup locations. */
+		// "rootDirs": [],                                   /* Allow multiple folders to be treated as one when resolving modules. */
+		// "typeRoots": [],                                  /* Specify multiple folders that act like './node_modules/@types'. */
+		// "types": [],                                      /* Specify type package names to be included without being referenced in a source file. */
+		// "allowUmdGlobalAccess": true,                     /* Allow accessing UMD globals from modules. */
+		// "moduleSuffixes": [],                             /* List of file name suffixes to search when resolving a module. */
+		// "allowImportingTsExtensions": true,               /* Allow imports to include TypeScript file extensions. Requires '--moduleResolution bundler' and either '--noEmit' or '--emitDeclarationOnly' to be set. */
+		// "resolvePackageJsonExports": true,                /* Use the package.json 'exports' field when resolving package imports. */
+		// "resolvePackageJsonImports": true,                /* Use the package.json 'imports' field when resolving imports. */
+		// "customConditions": [],                           /* Conditions to set in addition to the resolver-specific defaults when resolving imports. */
+		// "resolveJsonModule": true,                        /* Enable importing .json files. */
+		// "allowArbitraryExtensions": true,                 /* Enable importing files with any extension, provided a declaration file is present. */
+		// "noResolve": true,                                /* Disallow 'import's, 'require's or '<reference>'s from expanding the number of files TypeScript should add to a project. */
+
+		/* JavaScript Support */
+		// "allowJs": true,                                  /* Allow JavaScript files to be a part of your program. Use the 'checkJS' option to get errors from these files. */
+		// "checkJs": true,                                  /* Enable error reporting in type-checked JavaScript files. */
+		// "maxNodeModuleJsDepth": 1,                        /* Specify the maximum folder depth used for checking JavaScript files from 'node_modules'. Only applicable with 'allowJs'. */
+
+		/* Emit */
+		"declaration": true /* Generate .d.ts files from TypeScript and JavaScript files in your project. */,
+		// "declarationMap": true,                           /* Create sourcemaps for d.ts files. */
+		// "emitDeclarationOnly": true,                      /* Only output d.ts files and not JavaScript files. */
+		// "sourceMap": true,                                /* Create source map files for emitted JavaScript files. */
+		// "inlineSourceMap": true,                          /* Include sourcemap files inside the emitted JavaScript. */
+		// "outFile": "./",                                  /* Specify a file that bundles all outputs into one JavaScript file. If 'declaration' is true, also designates a file that bundles all .d.ts output. */
+		"outDir": "lib" /* Specify an output folder for all emitted files. */,
+		// "removeComments": true,                           /* Disable emitting comments. */
+		// "noEmit": true,                                   /* Disable emitting files from a compilation. */
+		// "importHelpers": true,                            /* Allow importing helper functions from tslib once per project, instead of including them per-file. */
+		// "importsNotUsedAsValues": "remove",               /* Specify emit/checking behavior for imports that are only used for types. */
+		// "downlevelIteration": true,                       /* Emit more compliant, but verbose and less performant JavaScript for iteration. */
+		// "sourceRoot": "",                                 /* Specify the root path for debuggers to find the reference source code. */
+		// "mapRoot": "",                                    /* Specify the location where debugger should locate map files instead of generated locations. */
+		// "inlineSources": true,                            /* Include source code in the sourcemaps inside the emitted JavaScript. */
+		// "emitBOM": true,                                  /* Emit a UTF-8 Byte Order Mark (BOM) in the beginning of output files. */
+		// "newLine": "crlf",                                /* Set the newline character for emitting files. */
+		// "stripInternal": true,                            /* Disable emitting declarations that have '@internal' in their JSDoc comments. */
+		// "noEmitHelpers": true,                            /* Disable generating custom helper functions like '__extends' in compiled output. */
+		// "noEmitOnError": true,                            /* Disable emitting files if any type checking errors are reported. */
+		// "preserveConstEnums": true,                       /* Disable erasing 'const enum' declarations in generated code. */
+		// "declarationDir": "./",                           /* Specify the output directory for generated declaration files. */
+		// "preserveValueImports": true,                     /* Preserve unused imported values in the JavaScript output that would otherwise be removed. */
+
+		/* Interop Constraints */
+		// "isolatedModules": true,                          /* Ensure that each file can be safely transpiled without relying on other imports. */
+		// "verbatimModuleSyntax": true,                     /* Do not transform or elide any imports or exports not marked as type-only, ensuring they are written in the output file's format based on the 'module' setting. */
+		// "allowSyntheticDefaultImports": true,             /* Allow 'import x from y' when a module doesn't have a default export. */
+		"esModuleInterop": true /* Emit additional JavaScript to ease support for importing CommonJS modules. This enables 'allowSyntheticDefaultImports' for type compatibility. */,
+		// "preserveSymlinks": true,                         /* Disable resolving symlinks to their realpath. This correlates to the same flag in node. */
+		"forceConsistentCasingInFileNames": true /* Ensure that casing is correct in imports. */,
+
+		/* Type Checking */
+		"strict": true /* Enable all strict type-checking options. */,
+		// "noImplicitAny": true,                            /* Enable error reporting for expressions and declarations with an implied 'any' type. */
+		// "strictNullChecks": true,                         /* When type checking, take into account 'null' and 'undefined'. */
+		// "strictFunctionTypes": true,                      /* When assigning functions, check to ensure parameters and the return values are subtype-compatible. */
+		// "strictBindCallApply": true,                      /* Check that the arguments for 'bind', 'call', and 'apply' methods match the original function. */
+		// "strictPropertyInitialization": true,             /* Check for class properties that are declared but not set in the constructor. */
+		// "noImplicitThis": true,                           /* Enable error reporting when 'this' is given the type 'any'. */
+		// "useUnknownInCatchVariables": true,               /* Default catch clause variables as 'unknown' instead of 'any'. */
+		// "alwaysStrict": true,                             /* Ensure 'use strict' is always emitted. */
+		// "noUnusedLocals": true,                           /* Enable error reporting when local variables aren't read. */
+		// "noUnusedParameters": true,                       /* Raise an error when a function parameter isn't read. */
+		// "exactOptionalPropertyTypes": true,               /* Interpret optional property types as written, rather than adding 'undefined'. */
+		// "noImplicitReturns": true,                        /* Enable error reporting for codepaths that do not explicitly return in a function. */
+		// "noFallthroughCasesInSwitch": true,               /* Enable error reporting for fallthrough cases in switch statements. */
+		// "noUncheckedIndexedAccess": true,                 /* Add 'undefined' to a type when accessed using an index. */
+		// "noImplicitOverride": true,                       /* Ensure overriding members in derived classes are marked with an override modifier. */
+		// "noPropertyAccessFromIndexSignature": true,       /* Enforces using indexed accessors for keys declared using an indexed type. */
+		// "allowUnusedLabels": true,                        /* Disable error reporting for unused labels. */
+		// "allowUnreachableCode": true,                     /* Disable error reporting for unreachable code. */
+
+		/* Completeness */
+		// "skipDefaultLibCheck": true,                      /* Skip type checking .d.ts files that are included with TypeScript. */
+		"skipLibCheck": true /* Skip type checking all .d.ts files. */
+	},
+	"include": ["src/**/*"]
+}