danholibraryjs 1.3.0 → 1.7.0

package/src/Extensions/Map.ts

@@ -0,0 +1,73 @@
+export {}
+
+declare global {
+    interface Map<K, V> {
+        /**
+         * Converts into Array<[Key, Value]>
+         */
+        array(): Array<[K, V]>
+        /**
+         * Maps values into new types of generics
+         * @param callback Callbacking function to map values
+         */
+        map<EK, EV>(callback: (value: V, key: K, index: number, self: this) => [EK, EV]): Map<EK, EV>
+        /**
+         * Returns array of "accepted" values. Criteria defined in callback param
+         * @param callback Callbacking function to filter away unwanted values
+         */
+        filter(callback: (value: V, key: K, index: number, self: this) => boolean): Map<K, V>
+        /**
+         * Returns array of keys
+         */
+        keyArr(): Array<K>
+        /**
+         * Returns array of values
+         */
+        valueArr(): Array<V>
+        /**
+         * Returns first [key, value] match to callback param. Returns undefined if nothing found
+         * @param callback Callbacking function to find KeyValuePair
+         */
+        find(callback: (value: V, key: K, index: number, self: this) => boolean): [K, V] | undefined
+        /**
+         * Whether or not map includes a  value. Returns true if it does, false if not ¯\_(ツ)_/¯ 
+         * @param value Value that may be includded in map
+         * @param fromIndex Start looking for value from specific index+. Default: 0
+         */
+        includes(value: V, fromIndex?: number): boolean
+    }
+}
+
+Map.prototype.array = function<K, V>(this: Map<K, V>): Array<[K, V]> {
+    let result = new Array<[K, V]>();
+    for (const kvp of this) {
+        result.push(kvp);
+    }
+    return result;
+}
+Map.prototype.map = function<K, V, EK, EV>(this: Map<K, V>, callback: (value: V, key: K, index: number, map: Map<K, V>) => [EK, EV]): Map<EK, EV> {
+    return this.array()
+        .map(([k, v], i) => callback(v, k, i, this))
+        .reduce((map, [key, value]) => 
+            map.set(key, value), 
+        new Map<EK, EV>())
+}
+Map.prototype.filter = function<K, V>(this: Map<K, V>, callback: (value: V, key: K, index: number, map: Map<K, V>) => boolean): Map<K, V> {
+    return this.array()
+        .filter(([k, v], i) => callback(v, k, i, this))
+        .reduce((map, [key, value]) => 
+            map.set(key, value), 
+        new Map<K, V>())
+}
+Map.prototype.keyArr = function<K, V>(this: Map<K, V>): Array<K> {
+    return this.array().map(([k]) => k);
+}
+Map.prototype.valueArr = function<K, V>(this: Map<K, V>): Array<V> {
+    return this.array().map(([_, v]) => v);
+}
+Map.prototype.find = function<K, V>(this: Map<K, V>, callback: (value: V, key: K, index: number, map: Map<K, V>) => boolean) {
+    return this.array().find(([k, v], i) => callback(v, k, i, this));
+}
+Map.prototype.includes = function<K, V>(this: Map<K, V>, item: V, fromIndex?: number) {
+    return this.valueArr().includes(item, fromIndex);
+}

package/src/Extensions/Object.ts

@@ -0,0 +1,25 @@
+import { ValueOf } from "../Types";
+
+export {};
+
+declare global {
+    interface ObjectConstructor {
+        /**
+         * Destructures object into array of [property, value]
+         * @param from Object to destruct
+         */
+        array<From = {}>(from: From): Array<[keyof From, ValueOf<From>]>
+        /**
+         * Destructures object into array of property keys
+         * @param from Object to destruct
+         */
+        keysOf<From = {}>(from: From): Array<keyof From>
+    }
+}
+
+Object.keysOf = function<From = {}>(this: object, from: From): Array<keyof From> {
+    return Object.keys(from) as Array<keyof From>;
+}
+Object.array = function<From = {}>(this: object, from: From): Array<[keyof From, ValueOf<From>]> {
+    return Object.keysOf(from).map(prop => [prop, from[prop]]) as Array<[keyof From, ValueOf<From>]>;
+}

package/src/Extensions/String.ts

@@ -0,0 +1,43 @@
+import IReplacement from "../Interfaces/IReplacement";
+export {}
+
+declare global {
+    interface String {
+        /**
+         * Uppercases first letter of string
+         */
+        toPascalCase(): string
+        /**
+         * Replaces "replacer" (default: ' ') with "replacement" (default: '_')
+         * @param replaceOptions This is practically your stereotypical String.replace, if you really want it to be
+         */
+        toSnakeCase(replaceOptions?: IReplacement): string
+        /**
+         * Replaces "replacer" (default: ' ') with "replacement" (default: '-')
+         * @param replaceOptions This is practically your stereotypical String.replace, if you really want it to be
+         */
+        toKebabCase(replaceOptions?: IReplacement): string,
+        /**
+         * String.substring but accepting negative numbers to cut from length
+         * @param start Start of string. 0 indexed, if negative number, subtracts number from length
+         * @param end End of string. 0 indexed, if negative number, substracts number from length
+         */
+        clip(start: number, end?: number): string
+    }
+}
+
+String.prototype.toPascalCase = function(this: string) {
+    return this.substring(0, 1).toUpperCase() + this.substring(1);
+}
+function spaceReplacer(self: string, replacer: string | RegExp, replacement: string) {
+    return self.replace(new RegExp(`${typeof replacer == 'string' ? replacer : replacer.source}+`), replacement);
+}
+String.prototype.toSnakeCase = function(this: string, replaceOptions: IReplacement) {
+    return spaceReplacer(this, replaceOptions.replacer || ' ', replaceOptions.replacement || '_')
+}
+String.prototype.toKebabCase = function(this: string, replaceOptions: IReplacement) {
+    return spaceReplacer(this, replaceOptions.replacer || ' ', replaceOptions.replacement || '-');
+}
+String.prototype.clip = function(this: string, start: number, end?: number) {
+    return this.substring(start < 0 ? this.length - start : start, end && end < 0 ? this.length + end : end);
+}

package/src/Extensions/index.ts

@@ -0,0 +1,83 @@
+import ElementOptions from "../Interfaces/ElementOptions";
+import { EventHandler, IElement } from "../Types";
+export * from './Array';
+export * from './Map';
+export * from './Object';
+export * from './String';
+
+declare global {
+    interface BooleanConstructor {
+        /**
+         * Parses string to boolean. Will only return true if value === "true" otherwise false
+         */
+        parseBoolean(value: string): boolean
+    }
+
+    interface Document {
+        /**
+         * Creates an element like Document#createElement, however with construction options to assign values in construction instead of after construction.
+         * @param tagName HTMLElement tag name
+         * @param options Construction options, instead of assigning values after construction
+         */
+        createProperElement<K extends keyof HTMLElementTagNameMap>(tagName: K, options?: ElementOptions, ...children: Array<IElement>): HTMLElementTagNameMap[K]
+        createFromHtml<K extends keyof HTMLElementTagNameMap>(html: string, parentTag?: K): HTMLElementTagNameMap[K]
+    }
+    interface HTMLCollection {
+        /**
+         * Converts HTMLCollection to Element[]
+         */
+        array(): Element[]
+    }
+}
+
+Boolean.parseBoolean = function(value: string) {
+    return value === "true";
+};
+
+try {
+    Document.prototype.createProperElement = function<K extends keyof HTMLElementTagNameMap>(this: Document, tagName: K, options?: ElementOptions, ...children: Array<IElement>): HTMLElementTagNameMap[K] {
+        let baseElement = document.createElement(tagName);
+        if (!options) return baseElement;
+
+        const { id, class: className, dataset, ...rest } = options;
+        if (id) baseElement.id = id;
+        if (className) {
+            const classNames = Array.isArray(className) ? className : [className];
+            classNames.forEach(className => baseElement.classList.add(className));
+        }
+        children ?? options.children;
+        if (children) {
+            const childrenElements = Array.isArray(children) ? children : [children];
+            childrenElements.forEach(child => baseElement.append(child));
+        }
+        if (dataset) Object.entries(dataset).forEach(([key, value]) => baseElement.dataset[key] = value);
+        
+        for (const optionKey in rest) {
+            const optionValue = rest[optionKey as keyof typeof rest] as EventHandler | object;
+            if (optionValue === undefined) continue;
+
+            if (typeof optionValue === 'function') {
+                baseElement.addEventListener(optionKey.substring(2), rest[optionKey as keyof typeof rest] as EventListener);
+            } else {
+                baseElement.setAttribute(optionKey, optionValue.toString());
+            }
+        }
+
+        return baseElement;
+    }
+    Document.prototype.createFromHtml = function<K extends keyof HTMLElementTagNameMap>(this: Document, html: string, parentTag?: K): HTMLElementTagNameMap[K] {
+        return new DOMParser().parseFromString(html, 'text/html').body.firstChild as HTMLElementTagNameMap[K];
+    }
+
+    HTMLCollection.prototype.array = function(this: HTMLCollection) {
+        let result = new Array<Element>();
+
+        for (let i = 0; i < this.length; i++) {
+            const item = this.item(i);
+            if (item !== null) result.push(item);
+        }
+        return result;
+    }
+} catch {
+    // Used in node.js
+}

package/src/Functions/GetCSSProperty.ts

@@ -0,0 +1,27 @@
+type CSSReturnTypes = {
+    string: string,
+    number: number
+}
+
+/**
+ * Gets the value of "property" in type "type" from query "query"
+ * Basically, you can get your --color-primary from :root
+ * 
+ * @param property Name of the property to get
+ * @param type Type of the property to parse
+ * @param query Query to get the element that has the property
+ * @returns Property value converted to type
+*/
+export function GetCSSProperty<Type extends keyof CSSReturnTypes>(property: string, type: Type, query = ":root"): CSSReturnTypes[Type] {
+    const rootEl = document.querySelector(query);
+    if (!rootEl) throw new Error(`${query} does not exist!`);
+
+    const rootStyles = getComputedStyle(rootEl);
+    const cssProp = rootStyles.getPropertyValue(property);
+    if (type === 'string') return cssProp as CSSReturnTypes[Type];
+
+    const numberValue = parseInt(cssProp);
+    if (isNaN(numberValue)) throw new Error(`${property} is not a number!: ${cssProp}`);
+    return numberValue as CSSReturnTypes[Type];
+}
+

package/src/Functions/HTMLEvent.ts

@@ -0,0 +1,13 @@
+/**
+ * Create HTMLEvent object from function
+ * @param name Name of the event
+ * @param handler Handler for the event
+ * @returns Parameters as object
+ */
+export function HTMLEvent<
+    Event extends keyof HTMLElementEventMap,
+    ReturnType extends any
+>(name: Event, handler: (event: HTMLElementEventMap[Event]) => ReturnType) {
+    return { name, handler };
+}
+export default HTMLEvent;

package/src/Functions/SetNavigationSelected.ts

@@ -7,6 +7,7 @@
  */
  export function SetNavigationSelected(query: string, ...currentPageClasses: string[]) {
     const header = document.querySelector(query);
+    if (!header) throw { message: `Couldn't find header from query, ${query}` }
     const children = header.children.array().filter(c => c.tagName === 'a') as HTMLAnchorElement[];
     const currentPage = document.location.href;
 

package/src/Functions/index.ts

@@ -1,2 +1,4 @@
 export * from './CopyToClipboard';
-export * from './SetNavigationSelected';
+export * from './GetCSSProperty';
+export * from './SetNavigationSelected';
+export * from './HTMLEvent';

package/src/Interfaces/ElementOptions.ts

@@ -1,19 +1,21 @@
-import { EventHandler } from "..";
-import IElement from "../Types/IElement";
+import { Arrayable, IElement } from "../Types"
+
+type Events = Record<
+    `on${Capitalize<keyof HTMLElementEventMap>}`,
+    (event: Event) => void
+>
 
 /**
  * Construction options when creating an HTML element using:
- * @see Document.createProperElement */
-export interface ElementOptions {
-    /**css classes to give the element*/
-    classes?: string[],
-    /**attributes to give the element*/
-    attributes?: [string, string][],
-    /**Children of the element*/
-    children?: IElement[],
-    /**Events for the element to listen to
-     * @borrows EventHandler
-    */
-    events?: Array<{ name: string, handlers: EventHandler[] }>
-}
-export default ElementOptions
+ * @see Document.createProperElement 
+ * @borwwos IElement
+ * @borrows Arrayable
+ */
+export type ElementOptions = Partial<
+    Events & Record<string, any> & {
+    id: string,
+    class: Arrayable<string>;
+    children: Arrayable<IElement>;
+    dataset: Record<string, string>
+}>
+export default ElementOptions;

package/src/Interfaces/IReplacement.ts

@@ -1,4 +1,4 @@
-import StringRegex from "../Types/StringRegex";
+import { StringRegex } from "../Types";
 
 /**
  * Replacement tool for 
@@ -6,7 +6,8 @@ import StringRegex from "../Types/StringRegex";
  * @see String.toKebabCase
  * @borrows StringRegex
 */
-export default interface IReplacement {
+export interface IReplacement {
     replacer?: StringRegex,
     replacement?: string
-}
+}
+export default IReplacement;

package/src/Types/BetterTypes.ts

@@ -0,0 +1,10 @@
+/**
+ * Construct a type with the properties of Type except for those in type Properties.
+ */
+export type BetterOmit<Type, Properties extends keyof Type> = Omit<Type, Properties>;
+/**
+ * Extract from From those types that are assignable to Properties
+ */
+export type BetterExtract<From, Properties extends From> = Extract<From, Properties>;
+
+export type PartialExcept<From, Properties extends keyof From> = Partial<From> & Required<Pick<From, Properties>>

package/src/Types/Date.ts

@@ -0,0 +1,7 @@
+export type LongMonth = 'Janurary' | 'February' | 'March' | 'April' | 'May' | 'June' | 'July' | 'August' | 'September' | 'October' | 'November' | 'December';
+export type ShortMonth = 'Jan' | 'Feb' | 'Mar' | 'Apr' | 'May' | 'Jun' | 'Jul' | 'Aug' | 'Sep' | 'Oct' | 'Nov' | 'Dec';
+export type Month = LongMonth | ShortMonth;
+
+export type ShortDay = 'Mon' | 'Tue' | 'Wed' | 'Thu' | 'Fri' | 'Sat' | 'Sun';
+export type LongDay = `${'Mon' | 'Tues' | 'Wednes' | 'Thurs' | 'Fri' | 'Satur' | 'Sun'}day`;
+export type Day = ShortDay | LongDay;

package/src/Types/Events.ts

@@ -0,0 +1,15 @@
+/**
+ * Default eventhandler mapper. Object with properties that are arrays
+ */
+ export type BaseEvent<Keys extends string, Types extends Array<any>> = Record<Keys, Types>;
+
+ /**
+  * Eventhandler type for:
+  * @see EventCollection
+  * @borrows BaseEvent
+  */
+ export type EventHandler<
+     Events extends BaseEvent<string, Array<any>> = BaseEvent<string, Array<any>>,
+     Event extends keyof Events = keyof Events,
+     ReturnType = any
+ > = (...args: Events[Event]) => ReturnType;

package/src/Types/PropertiesWith.ts

@@ -0,0 +1,14 @@
+/**
+ * Filters all properties from From that has the return type of Type
+ */
+export type PropertiesWith<Type, From> = {
+    [Key in keyof From as From[Key] extends Type ? Key : never]: From[Key]
+}
+export default PropertiesWith;
+
+/**
+ * Fitlers all properties from From that don't have the return type of Type
+ */
+export type PropertiesWithout<Type, From> = {
+    [Key in keyof From as From[Key] extends Type ? never : Key]: From[Key]
+}

package/src/Types/TransformTypes.ts

@@ -0,0 +1,18 @@
+/**
+ * Converts Start types to Switch types in From type
+ */
+export type TransformType<From, Start, Switch> = {
+    [Key in keyof From]: From[Key] extends Start ? Switch : From[Key]
+}
+
+/**
+ * Returns object with properties matching BaseType with types of NewType
+ */
+export type TransformTypes<From, BaseType, NewType> = Record<keyof { 
+    [Key in keyof From as From[Key] extends BaseType ? Key : never]: Key 
+}, NewType>
+
+//Returns From with properties switched from BaseType to NewType
+// export type TransformTypes<From, BaseType, NewType> = TransformType<From, BaseType[keyof BaseType], NewType>;
+
+export default TransformTypes;

package/src/Types/index.ts

@@ -1,3 +1,36 @@
-export * from './EventHandler';
-export * from './IElement';
-export * from './StringRegex';
+export * from './BetterTypes';
+export * from './Date';
+export * from './Events';
+export * from './TransformTypes';
+export * from './PropertiesWith';
+
+/**
+ * Item is single or multiple
+ */
+export type Arrayable<T> = T | Array<T>;
+
+/**
+ * Used for HTMLElement.append in ElementOptions, Document.createProperElement.
+ * IElement accepts HTML Elements or HTMl-like strings.
+ * 
+ * @see HTMLElement.append
+ * @see Document.createProperElement
+ */
+export type IElement = HTMLElement | string;
+
+/**
+ * Return types of T
+ */
+export type ValueOf<T> = T[keyof T];
+
+/**
+ * Type's properties are ReturnType
+ */
+export type AllPropsAre<ReturnType> = {
+    [key: string]: ReturnType
+}
+
+/**
+ * string or RegExp.. pretty self-explanatory
+ */
+export type StringRegex = string | RegExp;

package/src/index.ts

@@ -1,13 +1,5 @@
-import { EventHandler, IElement } from './Types';
-export { EventHandler, IElement };
-
-import { ElementOptions } from './Interfaces';
-export { ElementOptions };
-
-import { EventCollection, EventEmitter } from './Classes';
-export { EventCollection, EventEmitter };
-
-import { CopyToClipboard, SetNavigationSelected } from './Functions';
-export { CopyToClipboard, SetNavigationSelected };
-
-export * as Extensions from './Extensions';
+export * from './Classes';
+export * from './Extensions';
+export * from './Functions';
+export * from './Interfaces';
+export * from './Types';

package/tsconfig.json

@@ -1,10 +1,102 @@
 {
   "compilerOptions": {
-    "module": "commonjs",
-    "target": "esnext",
-    "declaration": true,
-    "outDir": "./dist",
-    "resolveJsonModule": true,
-    "watch": true
-  }
+    /* Visit https://aka.ms/tsconfig.json to read more about this file */
+
+    /* Projects */
+    // "incremental": true,                              /* Enable incremental compilation */
+    // "composite": true,                                /* Enable constraints that allow a TypeScript project to be used with project references. */
+    // "tsBuildInfoFile": "./",                          /* Specify the folder for .tsbuildinfo incremental compilation files. */
+    // "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": "esnext",                                  /* Set the JavaScript language version for emitted JavaScript and include compatible library declarations. */
+    "lib": ["ESNext", "DOM"],                                   /* 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 TC39 stage 2 draft 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. */
+
+    /* Modules */
+    "module": "commonjs",                                /* Specify what module code is generated. */
+    "rootDir": "./src",                                  /* Specify the root folder within your source files. */
+    // "moduleResolution": "node",                       /* 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. */
+    "resolveJsonModule": true,                        /* Enable importing .json files */
+    // "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. */
+    // "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": "./dist",                                   /* 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. */
+    // "inlineSourceMap": true,                          /* Include sourcemap files inside the emitted JavaScript. */
+    // "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. */
+    // "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,               /* Type catch clause variables as 'unknown' instead of 'any'. */
+    // "alwaysStrict": true,                             /* Ensure 'use strict' is always emitted. */
+    // "noUnusedLocals": true,                           /* Enable error reporting when a 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,                 /* Include 'undefined' in index signature results */
+    // "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. */
+    "watch": true,
+  },
 }