ts-packages 1.0.0 → 3.0.0

package/packages/js-extensions/src/number/number-extensions.ts

@@ -0,0 +1,129 @@
+import { defineExtension } from 'src/utils'
+import { makeInternalCacheKey, withCache } from '../core/performance'
+
+let numberExtended = false
+
+export function extendNumber() {
+	if (numberExtended) return
+	numberExtended = true
+
+	defineExtension(Number.prototype, 'toPercent', function (this: number, decimals = 2): string {
+		return `${(this * 100).toFixed(decimals)}%`
+	})
+
+	defineExtension(Number.prototype, 'toCurrency', function (this: number, currency = 'USD', locale = 'en-US'): string {
+		return new Intl.NumberFormat(locale, { style: 'currency', currency }).format(this)
+	})
+
+	defineExtension(Number.prototype, 'clamp', function (this: number, min: number, max: number): number {
+		if (min > max) throw new RangeError(`clamp: min (${min}) cannot be greater than max (${max})`)
+		return Math.min(Math.max(this, min), max)
+	})
+
+	defineExtension(Number.prototype, 'isEven', function (this: number): boolean {
+		return this % 2 === 0
+	})
+
+	defineExtension(Number.prototype, 'isOdd', function (this: number): boolean {
+		return this % 2 !== 0
+	})
+
+	defineExtension(Number.prototype, 'isPrime', function (this: number): boolean {
+		const num = this
+		return withCache(makeInternalCacheKey('prime', num), () => {
+			if (num < 2) return false
+			for (let i = 2; i <= Math.sqrt(num); i++) if (num % i === 0) return false
+			return true
+		})
+	})
+
+	defineExtension(Number.prototype, 'factorial', function (this: number): number {
+		const num = Math.floor(this)
+		return withCache(makeInternalCacheKey('factorial', num), () => {
+			if (num < 0) return NaN
+			if (num <= 1) return 1
+			let result = 1
+			for (let i = 2; i <= num; i++) result *= i
+			return result
+		})
+	})
+
+	defineExtension(Number.prototype, 'toOrdinal', function (this: number): string {
+		const num = Math.floor(this)
+		const suffix = ['th', 'st', 'nd', 'rd']
+		const v = num % 100
+		return num + (suffix[(v - 20) % 10] || suffix[v] || suffix[0])
+	})
+
+	defineExtension(Number.prototype, 'toRoman', function (this: number): string {
+		const num = Math.floor(this)
+		if (num <= 0) throw new RangeError('toRoman: number must be positive')
+		if (num >= 4000) throw new RangeError('toRoman: number must be less than 4000')
+
+		return withCache(makeInternalCacheKey('roman', num), () => {
+			const values = [1000, 900, 500, 400, 100, 90, 50, 40, 10, 9, 5, 4, 1]
+			const symbols = ['M', 'CM', 'D', 'CD', 'C', 'XC', 'L', 'XL', 'X', 'IX', 'V', 'IV', 'I']
+			let n = num
+			let result = ''
+			for (let i = 0; i < values.length; i++) {
+				while (n >= values[i]) {
+					result += symbols[i]
+					n -= values[i]
+				}
+			}
+			return result
+		})
+	})
+
+	defineExtension(Number.prototype, 'inRange', function (this: number, min: number, max: number): boolean {
+		return this >= min && this <= max
+	})
+
+	defineExtension(Number.prototype, 'round', function (this: number, decimals = 0): number {
+		if (!Number.isInteger(decimals) || decimals < 0) throw new TypeError('round: decimals must be non-negative integer')
+		const factor = Math.pow(10, decimals)
+		return Math.round(this * factor) / factor
+	})
+
+	defineExtension(Number.prototype, 'ceil', function (this: number, decimals = 0): number {
+		if (!Number.isInteger(decimals) || decimals < 0) throw new TypeError('ceil: decimals must be non-negative integer')
+		const factor = Math.pow(10, decimals)
+		return Math.ceil(this * factor) / factor
+	})
+
+	defineExtension(Number.prototype, 'floor', function (this: number, decimals = 0): number {
+		if (!Number.isInteger(decimals) || decimals < 0) throw new TypeError('floor: decimals must be non-negative integer')
+		const factor = Math.pow(10, decimals)
+		return Math.floor(this * factor) / factor
+	})
+
+	defineExtension(Number.prototype, 'abs', function (this: number): number {
+		return Math.abs(this)
+	})
+
+	defineExtension(Number.prototype, 'sign', function (this: number): number {
+		return Math.sign(this)
+	})
+
+	defineExtension(Number.prototype, 'times', function (this: number, callback: (index: number) => void): void {
+		if (typeof callback !== 'function') throw new TypeError('times: callback must be a function')
+		for (let i = 0; i < Math.floor(this); i++) callback(i)
+	})
+
+	defineExtension(Number.prototype, 'toFixedNumber', function (this: number, decimals = 0): number {
+		if (!Number.isInteger(decimals) || decimals < 0) {
+			throw new TypeError(`toFixedNumber: decimals must be a non-negative integer, got ${decimals}`);
+		}
+		const factor = Math.pow(10, decimals);
+		return Math.round(this.valueOf() * factor) / factor;
+	});
+
+	defineExtension(Number.prototype, 'randomUpTo', function (this: number): number {
+		const max = this.valueOf();
+		if (!Number.isFinite(max)) {
+			throw new TypeError(`randomUpTo: number must be finite, got ${max}`);
+		}
+		return Math.random() * max;
+	});
+
+}

package/packages/js-extensions/src/object/index.ts

@@ -0,0 +1 @@
+export { extendObject } from './object-extensions'

package/packages/js-extensions/src/object/object-extensions.ts

@@ -0,0 +1,143 @@
+import { defineExtension } from "src/utils"
+
+
+let objectExtended = false
+
+export function extendObject() {
+	if (objectExtended) return
+	objectExtended = true
+
+	defineExtension(Object.prototype, 'isEmpty', function (this: object): boolean {
+		return Object.keys(this).length === 0
+	})
+
+	defineExtension(Object.prototype, 'pick', function <T extends Record<string, any>, K extends keyof T>(this: T, keys: K[]): Pick<T, K> {
+		if (!Array.isArray(keys)) throw new TypeError('pick: keys must be an array')
+		if (!keys.length) throw new TypeError('pick: keys array cannot be empty')
+		const result = {} as Pick<T, K>
+		keys.forEach((key) => {
+			if (key in this) result[key] = this[key]
+		})
+		return result
+	})
+
+	defineExtension(Object.prototype, 'omit', function <T extends Record<string, any>, K extends keyof T>(this: T, keys: K[]): Omit<T, K> {
+		if (!Array.isArray(keys)) throw new TypeError('omit: keys must be an array')
+		if (!keys.length) throw new TypeError('omit: keys array cannot be empty')
+		const result = { ...this }
+		keys.forEach((key) => delete result[key])
+		return result
+	})
+
+	defineExtension(Object.prototype, 'deepClone', function <T>(this: T): T {
+		const visited = new WeakSet()
+		function deepCloneSafe(obj: any): any {
+			if (obj === null || typeof obj !== 'object') return obj
+			if (visited.has(obj)) throw new Error('Circular reference detected in deepClone')
+			visited.add(obj)
+			if (obj instanceof Date) return new Date(obj.getTime())
+			if (Array.isArray(obj)) return obj.map((item) => deepCloneSafe(item))
+			const cloned: Record<string, unknown> = {}
+			Object.keys(obj).forEach((key) => {
+				cloned[key] = deepCloneSafe(obj[key])
+			})
+			return cloned
+		}
+		return deepCloneSafe(this)
+	})
+
+	defineExtension(Object.prototype, 'merge', function <T extends object>(this: T, other: Partial<T>): T {
+		return { ...this, ...other }
+	})
+
+	defineExtension(Object.prototype, 'deepFreeze', function <T>(this: T): T {
+		Object.getOwnPropertyNames(this).forEach((name) => {
+			const value = (this as any)[name]
+			if (value && typeof value === 'object') value.deepFreeze?.()
+		})
+		return Object.freeze(this)
+	})
+
+	defineExtension(Object.prototype, 'hasPath', function (this: object, path: string): boolean {
+		if (!path.trim()) throw new TypeError('hasPath: path cannot be empty')
+		return path.split('.').every((key) => {
+			if (this == null || !(key in this)) return false
+			// @ts-ignore
+			this = this[key]
+			return true
+		})
+	})
+
+	defineExtension(Object.prototype, 'getPath', function (this: object, path: string, defaultValue?: any): any {
+		if (!path.trim()) throw new TypeError('getPath: path cannot be empty')
+		return path.split('.').reduce((acc: any, key) => (acc && key in acc ? acc[key] : defaultValue), this as any)
+	})
+
+	defineExtension(Object.prototype, 'setPath', function (this: object, path: string, value: any): any {
+		if (!path.trim()) throw new TypeError('setPath: path cannot be empty')
+		const keys = path.split('.')
+		let current: any = this
+		for (let i = 0; i < keys.length - 1; i++) {
+			if (!(keys[i] in current) || typeof current[keys[i]] !== 'object') current[keys[i]] = {}
+			current = current[keys[i]]
+		}
+		current[keys[keys.length - 1]] = value
+		return this
+	})
+
+	defineExtension(Object.prototype, 'mapValues', function <T extends Record<string, any>>(this: T, fn: (value: T[keyof T], key: keyof T) => any): Record<string, any> {
+		if (typeof fn !== 'function') {
+			throw new TypeError(`mapValues: fn must be a function, got ${typeof fn}`);
+		}
+		const result: Record<string, any> = {};
+		for (const key in this) {
+			if (Object.prototype.hasOwnProperty.call(this, key)) {
+				result[key] = fn((this as any)[key], key);
+			}
+		}
+		return result;
+	});
+
+	defineExtension(Object.prototype, 'mapKeys', function <T extends Record<string, any>>(this: T, fn: (key: keyof T) => string | number | symbol): Record<string, any> {
+		if (typeof fn !== 'function') {
+			throw new TypeError(`mapKeys: fn must be a function, got ${typeof fn}`);
+		}
+		const result: Record<string, any> = {};
+		for (const key in this) {
+			if (Object.prototype.hasOwnProperty.call(this, key)) {
+				const newKey = fn(key);
+				result[newKey as string] = (this as any)[key];
+			}
+		}
+		return result;
+	});
+
+	defineExtension(Object.prototype, 'filterKeys', function <T extends Record<string, any>>(this: T, keys: (keyof T)[]): Partial<T> {
+		if (!Array.isArray(keys)) {
+			throw new TypeError(`filterKeys: keys must be an array, got ${typeof keys}`);
+		}
+		const result: Partial<T> = {};
+		for (const key of keys) {
+			if (key in this) {
+				result[key] = (this as any)[key];
+			}
+		}
+		return result;
+	});
+
+	defineExtension(Object.prototype, 'filterValues', function <T extends Record<string, any>>(this: T, fn: (value: T[keyof T], key: keyof T) => boolean): Partial<T> {
+		if (typeof fn !== 'function') {
+			throw new TypeError(`filterValues: fn must be a function, got ${typeof fn}`);
+		}
+		const result: Partial<T> = {};
+		for (const key in this) {
+			if (Object.prototype.hasOwnProperty.call(this, key)) {
+				const val = (this as any)[key];
+				if (fn(val, key)) {
+					result[key] = val;
+				}
+			}
+		}
+		return result;
+	});
+}

package/packages/js-extensions/src/string/index.ts

@@ -0,0 +1 @@
+export { extendString } from './string-extensions'

package/packages/js-extensions/src/string/string-extensions.ts

@@ -0,0 +1,142 @@
+import { defineExtension } from "src/utils"
+
+
+let stringExtended = false
+
+export function extendString() {
+	if (stringExtended) return
+	stringExtended = true
+
+	defineExtension(String.prototype, 'toCapitalize', function (this: string): string {
+		return this.charAt(0).toUpperCase() + this.slice(1).toLowerCase()
+	})
+
+	defineExtension(String.prototype, 'toCamelCase', function (this: string): string {
+		return this.replace(/[-_\s]+(.)?/g, (_, char) => (char ? char.toUpperCase() : ''))
+	})
+
+	defineExtension(String.prototype, 'toKebabCase', function (this: string): string {
+		return this.replace(/([a-z])([A-Z])/g, '$1-$2')
+			.replace(/[\s_]+/g, '-')
+			.toLowerCase()
+	})
+
+	defineExtension(String.prototype, 'toSnakeCase', function (this: string): string {
+		return this.replace(/([a-z])([A-Z])/g, '$1_$2')
+			.replace(/[\s-]+/g, '_')
+			.toLowerCase()
+	})
+
+	defineExtension(String.prototype, 'truncate', function (this: string, length: number, suffix = '...'): string {
+		if (!Number.isInteger(length) || length < 0) {
+			throw new TypeError(`truncate: length must be a non-negative integer, got ${length}`)
+		}
+		return this.length > length ? this.substring(0, length) + suffix : this.toString()
+	})
+
+	defineExtension(String.prototype, 'isEmail', function (this: string): boolean {
+		const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/
+		return emailRegex.test(this.toString())
+	})
+
+	defineExtension(String.prototype, 'isUrl', function (this: string): boolean {
+		try {
+			new URL(this.toString())
+			return true
+		} catch {
+			return false
+		}
+	})
+
+	defineExtension(String.prototype, 'removeWhitespace', function (this: string): string {
+		return this.replace(/\s+/g, '')
+	})
+
+	defineExtension(String.prototype, 'reverse', function (this: string): string {
+		return this.split('').reverse().join('')
+	})
+
+	defineExtension(String.prototype, 'isPalindrome', function (this: string): boolean {
+		const cleaned = this.toLowerCase().replace(/[^a-z0-9]/g, '')
+		return cleaned === cleaned.split('').reverse().join('')
+	})
+
+	defineExtension(String.prototype, 'toTitleCase', function (this: string): string {
+		return this.replace(/\w\S*/g, (txt) => txt.charAt(0).toUpperCase() + txt.substr(1).toLowerCase())
+	})
+
+	defineExtension(String.prototype, 'stripHtml', function (this: string): string {
+		return this.replace(/<[^>]*>/g, '')
+	})
+
+	defineExtension(String.prototype, 'padStart', function (this: string, targetLength: number, padString = ' '): string {
+		if (!Number.isInteger(targetLength) || targetLength < 0) {
+			throw new TypeError(`padStart: targetLength must be a non-negative integer, got ${targetLength}`)
+		}
+		if (typeof padString !== 'string') {
+			throw new TypeError(`padStart: padString must be a string, got ${typeof padString}`)
+		}
+		if (padString.length === 0) {
+			throw new TypeError('padStart: padString cannot be empty')
+		}
+		return this.toString().padStart(targetLength, padString)
+	})
+
+	defineExtension(String.prototype, 'padEnd', function (this: string, targetLength: number, padString = ' '): string {
+		if (!Number.isInteger(targetLength) || targetLength < 0) {
+			throw new TypeError(`padEnd: targetLength must be a non-negative integer, got ${targetLength}`)
+		}
+		if (typeof padString !== 'string') {
+			throw new TypeError(`padEnd: padString must be a string, got ${typeof padString}`)
+		}
+		if (padString.length === 0) {
+			throw new TypeError('padEnd: padString cannot be empty')
+		}
+		return this.toString().padEnd(targetLength, padString)
+	})
+
+	defineExtension(String.prototype, 'count', function (this: string, substring: string): number {
+		if (typeof substring !== 'string') {
+			throw new TypeError(`count: substring must be a string, got ${typeof substring}`)
+		}
+		if (substring === '') {
+			throw new TypeError('count: substring cannot be empty')
+		}
+		const escaped = substring.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
+		return (this.match(new RegExp(escaped, 'g')) || []).length
+	})
+
+	defineExtension(String.prototype, 'words', function (this: string): string[] {
+		return this.trim().split(/\s+/).filter((word) => word.length > 0)
+	})
+
+	defineExtension(String.prototype, 'lines', function (this: string): string[] {
+		return this.split(/\r?\n/)
+	})
+
+	defineExtension(String.prototype, 'capitalizeWords', function (this: string): string {
+		return this.toString().replace(/\b\w/g, (char) => char.toUpperCase());
+	});
+
+	defineExtension(String.prototype, 'reverseWords', function (this: string): string {
+		return this.toString().split(/\s+/).reverse().join(' ');
+	});
+
+	defineExtension(String.prototype, 'truncateWords', function (this: string, count: number, suffix = '...'): string {
+		if (!Number.isInteger(count) || count < 0) {
+			throw new TypeError(`truncateWords: count must be a non-negative integer, got ${count}`);
+		}
+		const words = this.toString().split(/\s+/);
+		if (words.length <= count) return this.toString();
+		return words.slice(0, count).join(' ') + suffix;
+	});
+
+	defineExtension(String.prototype, 'slugify', function (this: string): string {
+		return this.toString()
+			.toLowerCase()
+			.replace(/[^\w\s-]/g, '')
+			.trim()
+			.replace(/[\s_-]+/g, '-');
+	});
+
+}

package/packages/js-extensions/src/types/extension-types.ts

@@ -0,0 +1,12 @@
+// Types for extension options and configurations
+import { PerformanceConfig } from '../core/performance'
+
+export interface ExtensionOptions {
+	string?: boolean
+	array?: boolean
+	object?: boolean
+	number?: boolean
+	performance?: PerformanceConfig
+}
+
+export { PerformanceConfig }

package/packages/js-extensions/src/types/global-augmentations.ts

@@ -0,0 +1,81 @@
+// TypeScript declarations for all extensions
+declare global {
+	interface String {
+		toCapitalize(): string
+		toCamelCase(): string
+		toKebabCase(): string
+		toSnakeCase(): string
+		truncate(length: number, suffix?: string): string
+		isEmail(): boolean
+		isUrl(): boolean
+		removeWhitespace(): string
+		reverse(): string
+		isPalindrome(): boolean
+		toTitleCase(): string
+		stripHtml(): string
+		padStart(targetLength: number, padString?: string): string
+		padEnd(targetLength: number, padString?: string): string
+		count(substring: string): number
+		words(): string[]
+		lines(): string[]
+	}
+
+	interface Array<T> {
+		unique(): T[]
+		shuffle(): T[]
+		chunk(size: number): T[][]
+		groupBy<K extends string | number>(keyFn: (item: T) => K): Record<K, T[]>
+		sum(): number
+		average(): number
+		compact(): T[]
+		compactTruthy(): T[]
+		pluck<K extends keyof T>(key: K): T[K][]
+		findLast(predicate: (item: T) => boolean): T | undefined
+		partition(predicate: (item: T) => boolean): [T[], T[]]
+		flatten(depth?: number): any[]
+		deepFlatten(): any[]
+		difference(other: T[]): T[]
+		intersection(other: T[]): T[]
+		union(other: T[]): T[]
+		sample(): T | undefined
+		take(count: number): T[]
+		drop(count: number): T[]
+	}
+
+	interface Object {
+		isEmpty(): boolean
+		pick<T extends Record<string, any>, K extends keyof T>(
+			keys: K[],
+		): Pick<T, K>
+		omit<T extends Record<string, any>, K extends keyof T>(
+			keys: K[],
+		): Omit<T, K>
+		deepClone<T>(): T
+		merge(other: Record<string, any>): Record<string, any>
+		deepFreeze<T>(): T
+		hasPath(path: string): boolean
+		getPath(path: string, defaultValue?: any): any
+		setPath(path: string, value: any): any
+	}
+
+	interface Number {
+		toPercent(decimals?: number): string
+		toCurrency(currency?: string, locale?: string): string
+		clamp(min: number, max: number): number
+		isEven(): boolean
+		isOdd(): boolean
+		isPrime(): boolean
+		factorial(): number
+		toOrdinal(): string
+		toRoman(): string
+		inRange(min: number, max: number): boolean
+		round(decimals?: number): number
+		ceil(decimals?: number): number
+		floor(decimals?: number): number
+		abs(): number
+		sign(): number
+		times(callback: (index: number) => void): void
+	}
+}
+
+export { }

package/packages/js-extensions/src/types/index.ts

@@ -0,0 +1,3 @@
+// Re-export all types
+export * from './extension-types'
+export * from './global-augmentations'

package/packages/js-extensions/src/utils/config.ts

@@ -0,0 +1,33 @@
+// Configuration validation utilities (import PerformanceConfig from core/performance)
+import type { PerformanceConfig } from '../core/performance'
+
+export function validateConfig(
+	config: Partial<PerformanceConfig>,
+	defaultConfig: PerformanceConfig,
+): PerformanceConfig {
+	return { ...defaultConfig, ...config }
+}
+
+export function validatePerformanceSettings(
+	settings: Partial<PerformanceConfig>,
+): PerformanceConfig {
+	const validated: PerformanceConfig = {
+		enableCaching: settings.enableCaching ?? false,
+		maxCacheSize: Math.max(1, settings.maxCacheSize ?? 100),
+		enableValidation: settings.enableValidation ?? true,
+	}
+	return validated
+}
+
+export function mergeConfigs<T extends Record<string, any>>(
+	base: T,
+	override: Partial<T>,
+): T {
+	const result = { ...base }
+	for (const key in override) {
+		if (override[key] !== undefined) {
+			result[key] = override[key]
+		}
+	}
+	return result
+}

package/packages/js-extensions/src/utils/defineExtension.ts

@@ -0,0 +1,14 @@
+export function defineExtension<T extends object>(
+    prototype: T,
+    name: string,
+    fn: Function,
+) {
+    if (!Object.prototype.hasOwnProperty.call(prototype, name)) {
+        Object.defineProperty(prototype, name, {
+            value: fn,
+            writable: false,
+            configurable: false,
+            enumerable: false,
+        })
+    }
+}

package/packages/js-extensions/src/utils/helpers.ts

@@ -0,0 +1,35 @@
+// Shared helper functions for extensions
+
+export function isValidArrayIndex(index: number): boolean {
+	return Number.isInteger(index) && index >= 0
+}
+
+export function ensurePositiveInteger(value: number, name: string): void {
+	if (!Number.isInteger(value) || value < 0) {
+		throw new TypeError(`${name} must be a positive integer`)
+	}
+}
+
+export function safeClone<T>(obj: T): T {
+	if (obj === null || typeof obj !== 'object') return obj
+
+	if (obj instanceof Date) return new Date(obj.getTime()) as unknown as T
+	if (Array.isArray(obj))
+		return obj.map((item) => safeClone(item)) as unknown as T
+
+	const cloned = {} as Record<string, unknown>
+	for (const key in obj) {
+		if (obj.hasOwnProperty(key)) {
+			cloned[key] = safeClone((obj as Record<string, unknown>)[key])
+		}
+	}
+	return cloned as T
+}
+
+export function getPathSegments(path: string): string[] {
+	return path.split('.').filter((segment) => segment.length > 0)
+}
+
+export function hasOwnProperty(obj: any, key: string): boolean {
+	return Object.prototype.hasOwnProperty.call(obj, key)
+}

package/packages/js-extensions/src/utils/index.ts

@@ -0,0 +1,4 @@
+// Re-export all utilities
+export * from './config'
+export * from './helpers'
+export * from './defineExtension'

package/packages/js-extensions/tsconfig.base.json

@@ -0,0 +1,18 @@
+{
+  "compilerOptions": {
+    "target": "ES2020",
+    "moduleResolution": "node",
+    "strict": true,
+    "esModuleInterop": true,
+    "allowSyntheticDefaultImports": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "declaration": true,
+    "baseUrl": ".",
+    "paths": {
+      "*": ["*", "*.ts", "*.js"]
+    },
+    "lib": ["ES2020", "DOM"]
+  },
+  "include": ["src/**/*"]
+}

package/packages/js-extensions/tsconfig.cjs.json

@@ -0,0 +1,9 @@
+{
+  "extends": "./tsconfig.base.json",
+  "compilerOptions": {
+    "module": "CommonJS",
+    "moduleResolution": "Node",
+    "rootDir": "./src",
+    "outDir": "./dist/cjs"
+  }
+}

package/packages/js-extensions/tsconfig.esm.json

@@ -0,0 +1,9 @@
+{
+  "extends": "./tsconfig.base.json",
+  "compilerOptions": {
+    "module": "ESNext",
+    "moduleResolution": "Bundler",
+    "rootDir": "./src",
+    "outDir": "./dist/esm"
+  }
+}

package/packages/js-extensions/tsconfig.json

@@ -0,0 +1,22 @@
+{
+  "compilerOptions": {
+    "target": "ES2020",
+    "module": "CommonJS",
+    "moduleResolution": "node",
+    "rootDir": "./src",
+    "outDir": "./dist",
+    "strict": true,
+    "esModuleInterop": true,
+    "allowSyntheticDefaultImports": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "declaration": true,
+    "baseUrl": ".",
+    "paths": {
+      "*": ["*", "*.ts", "*.js"]
+    },
+    "lib": ["ES2020", "DOM"]
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist"]
+}