@pippenly/ts-utils 1.0.0

package/.github/workflows/npm-publish-github-packages.yml

@@ -0,0 +1,36 @@
+# This workflow will run tests using node and then publish a package to GitHub Packages when a release is created
+# For more information see: https://docs.github.com/en/actions/publishing-packages/publishing-nodejs-packages
+
+name: Node.js Package
+
+on:
+  release:
+    types: [created]
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-node@v4
+        with:
+          node-version: 24
+      - run: npm ci
+      - run: npm test
+
+  publish-gpr:
+    needs: build
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read
+      packages: write
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-node@v4
+        with:
+          node-version: 24
+          registry-url: https://npm.pkg.github.com/
+      - run: npm ci
+      - run: npm publish
+        env:
+          NODE_AUTH_TOKEN: ${{secrets.GITHUB_TOKEN}}

package/README.md

@@ -0,0 +1,39 @@
+# TS-Utils
+
+Library where I implement ideas I have or consolidate utilities/helpers I use often
+
+# DOM
+
+## Resin
+A reactive state that can bind to an HTML element to automatically apply updates based on value changes. Has some utilities for controlling visibility, mapping inner values, and passes the default element event listener through so you can use those normally.
+
+```ts
+const number = resin(5); // Resin<T>;
+const numberElment = document.getElementById("number")!; // HTMLElement
+const otherNumberElement = document.getElementById("other-number")!; // HTMLElement
+const binding = bind(number, numberElment); // BoundResin<T>
+const complexBinding = bind(number, otherNumberElement, {
+    type: "innerText",
+    map: (n) => n * 2,
+    if: (n) => n > 5,
+    class: {
+        "red": (_, n) => n > 10,
+        "blue": (_, n) => n <= 10
+    },
+    attr: {
+        "data-value": (_, n) => String(n)
+    }
+});
+
+binding.value = 15; // Updates number.value, which triggers the effect to update numberElement's innerText
+complexBinding.value = 15;
+```
+
+# Result
+Small utility library so I can work with error as values and explict Error type declaration
+
+# Structures
+Queue only so far, it's what I found myself using the most often
+
+# Utils
+Quality of life things

package/jest.config.ts

@@ -0,0 +1,17 @@
+import type { Config } from 'jest';
+
+const config: Config = {
+    preset: 'ts-jest/presets/default-esm',
+    testEnvironment: 'node',
+    extensionsToTreatAsEsm: ['.ts'],
+    moduleNameMapper: {
+        // Rewrite .js extension imports to allow jest to resolve .ts source files
+        '^(\\.{1,2}/.*)\\.js$': '$1',
+    },
+    transform: {
+        '^.+\\.tsx?$': ['ts-jest', { useESM: true }],
+    },
+    testMatch: ['**/tests/**/*.test.ts'],
+};
+
+export default config;

package/package.json

@@ -0,0 +1,54 @@
+{
+  "name": "@pippenly/ts-utils",
+  "version": "1.0.0",
+  "description": "",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./result": {
+      "types": "./dist/result/index.d.ts",
+      "import": "./dist/result/index.js"
+    },
+    "./result/sync": {
+      "types": "./dist/result/sync/index.d.ts",
+      "import": "./dist/result/sync/index.js"
+    },
+    "./result/async": {
+      "types": "./dist/result/async/index.d.ts",
+      "import": "./dist/result/async/index.js"
+    },
+    "./utils": {
+      "types": "./dist/utils/index.d.ts",
+      "import": "./dist/utils/index.js"
+    },
+    "./dom": {
+      "types": "./dist/dom/index.d.ts",
+      "import": "./dist/dom/index.js"
+    }
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.build.json && tsc-alias",
+    "prebuild": "rm -rf dist",
+    "clean": "rm -rf dist",
+    "typecheck": "tsc --noEmit",
+    "test": "NODE_OPTIONS=--experimental-vm-modules jest --passWithNoTests",
+    "test:watch": "NODE_OPTIONS=--experimental-vm-modules jest --watch --passWithNoTests"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "ISC",
+  "devDependencies": {
+    "@types/jest": "^30.0.0",
+    "@types/node": "^25.5.2",
+    "jest": "^30.3.0",
+    "ts-jest": "^29.4.9",
+    "tsc-alias": "^1.8.16",
+    "typescript": "^6.0.2",
+    "uuid": "^13.0.0"
+  }
+}

package/src/dom/index.ts

@@ -0,0 +1,189 @@
+import { Err, Ok, type Result } from "@/result/index.js";
+
+type State<T> = { value: T };
+
+type Resin<T> = State<T> & { bound: false };
+
+type BoundState<E extends HTMLElement> = {
+    bound: true;
+    element: E;
+    dispose: () => Result<void, string>;
+} & Pick<HTMLElement, "addEventListener" | "removeEventListener">;
+
+type BoundResin<T> = State<T> & BoundState<HTMLElement>;
+
+type ElementBindOptions<T, E extends HTMLElement, R = T> = {
+    map?: (value: T) => R;
+    if?: (value: R) => boolean;
+    filter?: (value: R) => boolean;
+    class?: {
+        [className: string]: (element: E, value: R) => boolean;
+    },
+    attr?: {
+        [attrName: string]: (element: E, value: R) => string | null;
+    }
+}
+
+type TextElementTypes =
+    | HTMLParagraphElement
+    | HTMLSpanElement
+    | HTMLDivElement
+    | HTMLHeadingElement
+    | HTMLAnchorElement
+    | HTMLButtonElement
+    | HTMLLabelElement
+    | HTMLOptionElement
+    | HTMLTableCellElement;
+
+type TextBindOptions<T, E extends TextElementTypes> = ElementBindOptions<T, E> & {
+    type: 'innerText' | 'textContent' | 'innerHTML';
+    truncate?: number;
+    mask?: string;
+}
+
+type ValueBindOptions<T, E extends HTMLElement> = ElementBindOptions<T, E> & {
+    type: 'value';
+}
+
+type BindOptions<T, E extends HTMLElement> =
+    | TextBindOptions<T, E>
+    | ValueBindOptions<T, E>;
+
+export function resin<T>(initialValue: T): Resin<T> {
+    return { value: initialValue, bound: false };
+}
+
+export function bind<T, E extends TextElementTypes>(resin: Resin<T>, element: E, options?: TextBindOptions<T, E>): BoundResin<T>;
+export function bind<T, E extends HTMLElement>(resin: Resin<T>, element: E, options?: ValueBindOptions<T, E>): BoundResin<T>;
+export function bind<T, E extends HTMLElement>(resin: Resin<T>, element: E, options?: BindOptions<T, E>): BoundResin<T> {
+    const subscribers = new Set<Effect>();
+    let disposed = false;
+    let _value = resin.value;
+
+    const notify = () => {
+        if (disposed) {
+            return;
+        }
+
+        subscribers.forEach(fn => fn());
+    };
+
+    const getValue = (): T => {
+        const currentEffect = stack[stack.length - 1];
+        if (currentEffect) {
+            subscribers.add(currentEffect);
+        }
+        return _value;
+    };
+
+    const domEffect = () => {
+        const value = getValue();
+        const mappedValue = options?.map ? options.map(value) : value;
+
+        if (options?.filter && !options.filter(mappedValue)) {
+            return;
+        }
+
+        if (options?.if) {
+            if (!options.if(mappedValue as ReturnType<NonNullable<typeof options.map>>)) {
+                element.style.display = "none";
+                return;
+            } else {
+                element.style.display = element.style.display || "";
+            }
+        }
+
+        if (options?.class) {
+            for (const [className, fn] of Object.entries(options.class)) {
+                if (fn(element, mappedValue)) {
+                    element.classList.add(className);
+                } else {
+                    element.classList.remove(className);
+                }
+            }
+        }
+
+        if (options?.attr) {
+            for (const [attrName, fn] of Object.entries(options.attr)) {
+                const attrValue = fn(element, mappedValue);
+                if (attrValue === null) {
+                    element.removeAttribute(attrName);
+                } else {
+                    element.setAttribute(attrName, attrValue);
+                }
+            }
+        }
+
+        let valueStr = String(mappedValue);
+        if (options?.type === 'innerText' || options?.type === 'textContent') {
+            if (options?.truncate !== undefined) {
+                valueStr = valueStr.slice(0, options.truncate);
+            }
+            if (options?.mask !== undefined) {
+                valueStr = valueStr.replace(/./g, options.mask);
+            }
+        }
+
+        if (options?.type === "innerText") {
+            element.innerText = valueStr;
+        } else if (options?.type === "textContent") {
+            element.textContent = valueStr;
+        } else if (options?.type === "innerHTML") {
+            element.innerHTML = valueStr;
+        } else if (options?.type === "value") {
+            if (element instanceof HTMLInputElement || element instanceof HTMLTextAreaElement || element instanceof HTMLSelectElement) {
+                element.value = valueStr;
+            } else {
+                throw new Error("Value binding is only supported on input, textarea, and select elements");
+            }
+        }
+    };
+
+    watchEffect(domEffect);
+
+    return {
+        ...resin,
+        bound: true,
+        element,
+        addEventListener: element.addEventListener.bind(element),
+        removeEventListener: element.removeEventListener.bind(element),
+        get value(): T {
+            if (disposed) {
+                throw new Error("Cannot get value of a disposed resin");
+            }
+
+            return getValue();
+        },
+        set value(newValue: T) {
+            if (disposed) {
+                throw new Error("Cannot set value of a disposed resin");
+            }
+
+            if (_value === newValue) {
+                return;
+            }
+
+            _value = newValue;
+            notify();
+        },
+        dispose: () => {
+            if (disposed) {
+                return Err("Resin is already disposed");
+            }
+
+            subscribers.delete(domEffect);
+            disposed = true;
+            return Ok(undefined);
+        }
+    }
+}
+
+type Effect = () => void;
+
+const stack: Effect[] = [];
+
+export function watchEffect(fn: Effect): void {
+    stack.push(fn);
+    fn();
+    stack.pop();
+}

package/src/index.ts

@@ -0,0 +1,2 @@
+export * from './result/index.js';
+export * from './utils/index.js';

package/src/result/async/index.ts

@@ -0,0 +1,77 @@
+import { Ok, Err, isOk, isErr } from '../sync/index.js';
+import type { Result } from '../sync/index.js';
+
+export type AsyncResult<T, E> = Promise<Result<T, E>>;
+
+export async function fromPromise<T, E>(
+    promise: Promise<T>,
+    onErr: (e: unknown) => E,
+): AsyncResult<T, E> {
+    try {
+        return Ok(await promise);
+    } catch (e) {
+        return Err(onErr(e));
+    }
+}
+
+export async function asyncAndThen<T, E, U>(
+    result: AsyncResult<T, E>,
+    fn: (value: T) => AsyncResult<U, E>,
+): AsyncResult<U, E> {
+    const r = await result;
+    return isOk(r) ? fn(r.value) : r;
+}
+
+export async function asyncAndThenErr<T, E, F>(
+    result: AsyncResult<T, E>,
+    fn: (error: E) => AsyncResult<T, F>,
+): AsyncResult<T, F> {
+    const r = await result;
+    return isErr(r) ? fn(r.error) : r;
+}
+
+export async function asyncMap<T, E, U>(
+    result: AsyncResult<T, E>,
+    fn: (value: T) => Promise<U>,
+): AsyncResult<U, E> {
+    const r = await result;
+    return isOk(r) ? Ok(await fn(r.value)) : r;
+}
+
+export async function asyncMapErr<T, E, F>(
+    result: AsyncResult<T, E>,
+    fn: (error: E) => Promise<F>,
+): AsyncResult<T, F> {
+    const r = await result;
+    return isErr(r) ? Err(await fn(r.error)) : r;
+}
+
+export async function asyncTap<T, E>(
+    result: AsyncResult<T, E>,
+    fn: (value: T) => Promise<void>,
+): AsyncResult<T, E> {
+    const r = await result;
+    if (isOk(r)) await fn(r.value);
+    return r;
+}
+
+export async function asyncTapErr<T, E>(
+    result: AsyncResult<T, E>,
+    fn: (error: E) => Promise<void>,
+): AsyncResult<T, E> {
+    const r = await result;
+    if (isErr(r)) await fn(r.error);
+    return r;
+}
+
+export async function asyncCombine<T, E>(results: AsyncResult<T, E>[]): AsyncResult<T[], E> {
+    const settled = await Promise.all(results);
+    const values: T[] = [];
+    for (const r of settled) {
+        if (isErr(r)) {
+            return r;
+        }
+        values.push(r.value);
+    }
+    return Ok(values);
+}

package/src/result/index.ts

@@ -0,0 +1,2 @@
+export * from './sync/index.js';
+export * from './async/index.js';

package/src/result/sync/index.ts

@@ -0,0 +1,140 @@
+export type Ok<T> = {
+    ok: true;
+    value: T;
+};
+
+export type Err<E> = {
+    ok: false;
+    error: E;
+    code?: number;
+};
+
+export type Result<T, E = never> = Ok<T> | Err<E>;
+
+export function Ok<T>(value: T): Ok<T> {
+    return { ok: true, value };
+}
+
+export function Err<E>(error: E, code?: number): Err<E> {
+    return { ok: false, error, code };
+}
+
+export function tryCatch<T, E>(fn: () => T, onErr: (e: unknown) => E): Result<T, E> {
+    try {
+        return Ok(fn());
+    } catch (e) {
+        return Err(onErr(e));
+    }
+}
+
+export function fromNullable<T, E>(value: T | null | undefined, error: E): Result<NonNullable<T>, E> {
+    return value != null ? Ok(value as NonNullable<T>) : Err(error);
+}
+
+export function isOk<T, E>(result: Result<T, E>): result is Ok<T> {
+    return result.ok === true;
+}
+
+export function isErr<T, E>(result: Result<T, E>): result is Err<E> {
+    return result.ok === false;
+}
+
+export function unwrap<T, E>(result: Result<T, E>): T {
+    if (isOk(result)) return result.value;
+    throw new Error(`Tried to unwrap an Err: ${result.error}`);
+}
+
+export function unwrapErr<T, E>(result: Result<T, E>): E {
+    if (isErr(result)) return result.error;
+    throw new Error(`Tried to unwrapErr an Ok: ${result.value}`);
+}
+
+export function toNullable<T, E>(result: Result<T, E>): T | null {
+    return isOk(result) ? result.value : null;
+}
+
+export function toUndefined<T, E>(result: Result<T, E>): T | undefined {
+    return isOk(result) ? result.value : undefined;
+}
+
+export function orElse<T, E>(result: Result<T, E>, defaultValue: T): T {
+    return isOk(result) ? result.value : defaultValue;
+}
+
+export function orElseGet<T, E>(result: Result<T, E>, defaultValueFn: () => T): T {
+    return isOk(result) ? result.value : defaultValueFn();
+}
+
+export function orElseErr<T, E>(result: Result<T, E>, defaultError: E): E {
+    return isErr(result) ? result.error : defaultError;
+}
+
+export function orElseErrGet<T, E>(result: Result<T, E>, defaultErrorFn: () => E): E {
+    return isErr(result) ? result.error : defaultErrorFn();
+}
+
+export function andThen<T, E, U>(result: Result<T, E>, fn: (value: T) => Result<U, E>): Result<U, E> {
+    return isOk(result) ? fn(result.value) : result;
+}
+
+export function andThenErr<T, E, F>(result: Result<T, E>, fn: (error: E) => Result<T, F>): Result<T, F> {
+    return isErr(result) ? fn(result.error) : result;
+}
+
+export function map<T, E, U>(result: Result<T, E>, fn: (value: T) => U): Result<U, E> {
+    return isOk(result) ? Ok(fn(result.value)) : result;
+}
+
+export function mapErr<T, E, F>(result: Result<T, E>, fn: (error: E) => F): Result<T, F> {
+    return isErr(result) ? Err(fn(result.error)) : result;
+}
+
+export function mapOr<T, E, U>(result: Result<T, E>, defaultValue: U, fn: (value: T) => U): U {
+    return isOk(result) ? fn(result.value) : defaultValue;
+}
+
+export function mapOrElse<T, E, U>(result: Result<T, E>, defaultValueFn: () => U, fn: (value: T) => U): U {
+    return isOk(result) ? fn(result.value) : defaultValueFn();
+}
+
+export function filter<T, E>(result: Result<T, E>, predicate: (value: T) => boolean, onFail: E): Result<T, E> {
+    if (isOk(result)) {
+        return predicate(result.value) ? result : Err(onFail);
+    }
+    return result;
+}
+
+export function tap<T, E>(result: Result<T, E>, fn: (value: T) => void): Result<T, E> {
+    if (isOk(result)) fn(result.value);
+    return result;
+}
+
+export function tapErr<T, E>(result: Result<T, E>, fn: (error: E) => void): Result<T, E> {
+    if (isErr(result)) fn(result.error);
+    return result;
+}
+
+export function combine<T, E>(results: Result<T, E>[]): Result<T[], E> {
+    const values: T[] = [];
+    for (const result of results) {
+        if (isErr(result)) return result;
+        values.push(result.value);
+    }
+    return Ok(values);
+}
+
+export function fold<T, E, U>(result: Result<T, E>, onOk: (value: T) => U, onErr: (error: E) => U): U {
+    return isOk(result) ? onOk(result.value) : onErr(result.error);
+}
+
+export function swap<T, E>(result: Result<T, E>): Result<E, T> {
+    return isOk(result) ? Err(result.value) : Ok(result.error);
+}
+
+export function flatten<T, E>(result: Result<Result<T, E>, E>): Result<T, E> {
+    return isOk(result) ? result.value : result;
+}
+
+export function flattenErr<T, E>(result: Result<T, Result<T, E>>): Result<T, E> {
+    return isErr(result) ? result.error : result;
+}

package/src/structures/index.ts

@@ -0,0 +1,6 @@
+export type LinkedList<T> = {
+    value: T;
+    next: LinkedList<T> | null;
+}
+
+export * from './queue/index.js';

package/src/structures/queue/bounded/index.ts

@@ -0,0 +1,121 @@
+import { Err, Ok, type Result } from "@/result/index.js";
+import type { Queue } from "../queue.js";
+
+function makeRingBuffer<T>(capacity: number) {
+    const buffer = new Array<T | undefined>(capacity);
+    let head = 0;
+    let tail = 0;
+    let length = 0;
+
+    function rawPush(item: T): void {
+        buffer[tail] = item;
+        tail = (tail + 1) % capacity;
+        length++;
+    }
+
+    function rawPop(): T {
+        const value = buffer[head] as T;
+        buffer[head] = undefined;
+        head = (head + 1) % capacity;
+        length--;
+        return value;
+    }
+
+    return {
+        getLength: () => length,
+        rawPush,
+        rawPop,
+        pop(): Result<T, string> {
+            if (length === 0) return Err("Queue is empty");
+            return Ok(rawPop());
+        },
+        peek(): Result<T, string> {
+            return length > 0 ? Ok(buffer[head] as T) : Err("Queue is empty");
+        },
+        size(): number {
+            return length;
+        },
+        isEmpty(): boolean {
+            return length === 0;
+        },
+        iterator(): Iterator<T> {
+            let i = 0;
+            let pos = head;
+            const snap = length;
+            return {
+                next(): IteratorResult<T> {
+                    if (i < snap) {
+                        const value = buffer[pos] as T;
+                        pos = (pos + 1) % capacity;
+                        i++;
+                        return { value, done: false };
+                    }
+                    return { value: undefined as unknown as T, done: true };
+                }
+            };
+        }
+    };
+}
+
+export function boundedQueue<T>(capacity: number): Result<Queue<T>, string> {
+    if (capacity <= 0) {
+        return Err("Capacity must be greater than 0");
+    }
+    const rb = makeRingBuffer<T>(capacity);
+    return Ok({
+        push(item: T): Result<void, string> {
+            if (rb.getLength() >= capacity) {
+                return Err("Queue is full");
+            }
+            rb.rawPush(item);
+            return Ok(undefined);
+        },
+        pop: () => rb.pop(),
+        peek: () => rb.peek(),
+        size: () => rb.size(),
+        isEmpty: () => rb.isEmpty(),
+        iterator: () => rb.iterator()
+    });
+}
+
+export function slidingQueue<T>(capacity: number): Result<Queue<T>, string> {
+    if (capacity <= 0) {
+        return Err("Capacity must be greater than 0");
+    }
+    const rb = makeRingBuffer<T>(capacity);
+    return Ok({
+        push(item: T): Result<void, string> {
+            if (rb.getLength() >= capacity) {
+                rb.rawPop();
+            }
+            rb.rawPush(item);
+            return Ok(undefined);
+        },
+        pop: () => rb.pop(),
+        peek: () => rb.peek(),
+        size: () => rb.size(),
+        isEmpty: () => rb.isEmpty(),
+        iterator: () => rb.iterator()
+    });
+}
+
+export function droppingQueue<T>(capacity: number): Result<Queue<T>, string> {
+    if (capacity <= 0) {
+        return Err("Capacity must be greater than 0");
+    }
+    const rb = makeRingBuffer<T>(capacity);
+    return Ok({
+        push(item: T): Result<void, string> {
+            if (rb.getLength() >= capacity) {
+                return Err("Queue is full");
+            }
+            rb.rawPush(item);
+            return Ok(undefined);
+        },
+        pop: () => rb.pop(),
+        peek: () => rb.peek(),
+        size: () => rb.size(),
+        isEmpty: () => rb.isEmpty(),
+        iterator: () => rb.iterator()
+    });
+}

package/src/structures/queue/index.ts

@@ -0,0 +1,2 @@
+export * from './bounded/index.js';
+export * from './unbounded/index.js';

package/src/structures/queue/queue.ts

@@ -0,0 +1,52 @@
+import { Err, Ok, type Result } from "@/result/index.js";
+
+export interface Queue<T> {
+    push(item: T): Result<void, string>;
+    pop(): Result<T, string>;
+    peek(): Result<T, string>;
+    size(): number;
+    isEmpty(): boolean;
+    iterator(): Iterator<T>;
+}
+
+export function queue<T>(): Queue<T> {
+    const map = new Map<number, T>();
+    let head = 0;
+    let tail = 0;
+
+    return {
+        push(item: T): Result<void, string> {
+            map.set(tail++, item);
+            return Ok(undefined);
+        },
+        pop(): Result<T, string> {
+            if (map.size === 0) {
+                return Err("Queue is empty");
+            }
+            const value = map.get(head)!;
+            map.delete(head++);
+            return Ok(value);
+        },
+        peek(): Result<T, string> {
+            return map.size > 0 ? Ok(map.get(head)!) : Err("Queue is empty");
+        },
+        size(): number {
+            return map.size;
+        },
+        isEmpty(): boolean {
+            return map.size === 0;
+        },
+        iterator(): Iterator<T> {
+            let current = head;
+            const end = tail;
+            return {
+                next(): IteratorResult<T> {
+                    if (current < end && map.has(current)) {
+                        return { value: map.get(current++)!, done: false };
+                    }
+                    return { value: undefined as unknown as T, done: true };
+                }
+            };
+        }
+    };
+}

package/src/structures/queue/unbounded/index.ts

@@ -0,0 +1,5 @@
+import { queue, type Queue } from "../queue.js";
+
+export function unboundedQueue<T>(): Queue<T> {
+    return queue<T>();
+}

package/src/utils/index.ts

@@ -0,0 +1,23 @@
+import { v4 as uuidv4 } from "uuid";
+
+export const generateUUID = (): string => {
+    return uuidv4();
+};
+
+export const ENVIRONMENT = (() => {
+    if (typeof process !== "undefined" && process.versions != null && process.versions.node != null) {
+        return "node";
+    } else {
+        return "browser";
+    }
+})();
+
+export const eventToPromise = (eventTarget: EventTarget, eventName: string): Promise<Event> => {
+    return new Promise<Event>((resolve) => {
+        const handler = (event: Event) => {
+            eventTarget.removeEventListener(eventName, handler);
+            resolve(event);
+        };
+        eventTarget.addEventListener(eventName, handler);
+    });
+};

package/tsconfig.build.json

@@ -0,0 +1,9 @@
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    "rootDir": "./src",
+    "outDir": "./dist"
+  },
+  "include": ["src"],
+  "exclude": ["node_modules", "dist"]
+}

package/tsconfig.json

@@ -0,0 +1,56 @@
+{
+  // Visit https://aka.ms/tsconfig to read more about this file
+  "compilerOptions": {
+    // File Layout
+    // "rootDir": "./src",
+    // "outDir": "./dist",
+
+    // Environment Settings
+    // See also https://aka.ms/tsconfig/module
+    "module": "nodenext",
+    "target": "esnext",
+    // For nodejs:
+    "lib": ["esnext", "DOM"],
+    "types": ["node"],
+    // and npm install -D @types/node
+
+    // Other Outputs
+    "sourceMap": true,
+    "declaration": true,
+    "declarationMap": true,
+
+    // Stricter Typechecking Options
+    "noUncheckedIndexedAccess": true,
+    // "exactOptionalPropertyTypes": true,
+
+    // Style Options
+    // "noImplicitReturns": true,
+    // "noImplicitOverride": true,
+    // "noUnusedLocals": true,
+    // "noUnusedParameters": true,
+    // "noFallthroughCasesInSwitch": true,
+    // "noPropertyAccessFromIndexSignature": true,
+
+    // Recommended Options
+    "strict": true,
+    "jsx": "react-jsx",
+    "verbatimModuleSyntax": true,
+    "isolatedModules": true,
+    "noUncheckedSideEffectImports": true,
+    "moduleDetection": "force",
+    "skipLibCheck": true,
+    "outDir": "./dist",
+    "paths": {
+      "@/*": ["./src/*"],
+      "@result/sync": ["./src/result/sync/index.ts"],
+      "@result/async": ["./src/result/async/index.ts"],
+      "@result": ["./src/result/index.ts"],
+      "@utils/*": ["./src/utils/*"],
+      "@structures/*": ["./src/structures/*"],
+      "@structures/queue": ["./src/structures/queue/index.ts"],
+      "@internal/*": ["./src/internal/index.ts"],
+      "@dom": ["./src/dom/index.ts"]
+    }
+  },
+  "exclude": ["dist", "node_modules"]
+}