quantam-async 0.1.0

package/dist/types.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Type definitions for Quantam
+ */
+export type AsyncFn<T = any, R = any> = (input: T, context?: ExecutionContext) => Promise<R>;
+export interface ExecutionContext {
+    signal?: AbortSignal;
+    retryCount?: number;
+    stepIndex?: number;
+}
+export interface FlowOptions {
+    signal?: AbortSignal;
+}
+export interface RunManyOptions extends FlowOptions {
+    concurrency?: number;
+}
+export interface Flow<T = any> {
+    step<R>(fn: AsyncFn<T, R>): Flow<R>;
+    parallel<R>(fns: AsyncFn<T, any>[]): Flow<R[]>;
+    retry(count: number, delayMs?: number): Flow<T>;
+    timeout(ms: number): Flow<T>;
+    stepTimeout(ms: number): Flow<T>;
+    withSignal(signal: AbortSignal): Flow<T>;
+    run(input: T, options?: FlowOptions): Promise<T>;
+    runMany(inputs: T[], options?: RunManyOptions): Promise<T[]>;
+}
+export interface QuantamConfig {
+    retries?: number;
+    retryDelay?: number;
+    timeout?: number;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,MAAM,MAAM,OAAO,CAAC,CAAC,GAAG,GAAG,EAAE,CAAC,GAAG,GAAG,IAAI,CAAC,KAAK,EAAE,CAAC,EAAE,OAAO,CAAC,EAAE,gBAAgB,KAAK,OAAO,CAAC,CAAC,CAAC,CAAC;AAE7F,MAAM,WAAW,gBAAgB;IAC/B,MAAM,CAAC,EAAE,WAAW,CAAC;IACrB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAED,MAAM,WAAW,WAAW;IAC1B,MAAM,CAAC,EAAE,WAAW,CAAC;CACtB;AAED,MAAM,WAAW,cAAe,SAAQ,WAAW;IACjD,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB;AAED,MAAM,WAAW,IAAI,CAAC,CAAC,GAAG,GAAG;IAC3B,IAAI,CAAC,CAAC,EAAE,EAAE,EAAE,OAAO,CAAC,CAAC,EAAE,CAAC,CAAC,GAAG,IAAI,CAAC,CAAC,CAAC,CAAC;IACpC,QAAQ,CAAC,CAAC,EAAE,GAAG,EAAE,OAAO,CAAC,CAAC,EAAE,GAAG,CAAC,EAAE,GAAG,IAAI,CAAC,CAAC,EAAE,CAAC,CAAC;IAC/C,KAAK,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC,CAAC,CAAC,CAAC;IAChD,OAAO,CAAC,EAAE,EAAE,MAAM,GAAG,IAAI,CAAC,CAAC,CAAC,CAAC;IAC7B,WAAW,CAAC,EAAE,EAAE,MAAM,GAAG,IAAI,CAAC,CAAC,CAAC,CAAC;IACjC,UAAU,CAAC,MAAM,EAAE,WAAW,GAAG,IAAI,CAAC,CAAC,CAAC,CAAC;IACzC,GAAG,CAAC,KAAK,EAAE,CAAC,EAAE,OAAO,CAAC,EAAE,WAAW,GAAG,OAAO,CAAC,CAAC,CAAC,CAAC;IAChD,OAAO,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,OAAO,CAAC,EAAE,cAAc,GAAG,OAAO,CAAC,CAAC,EAAE,CAAC,CAAC;CAC/D;AAED,MAAM,WAAW,aAAa;IAC5B,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB"}

package/dist/types.js

@@ -0,0 +1,6 @@
+"use strict";
+/**
+ * Type definitions for Quantam
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=types.js.map

package/dist/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":";AAAA;;GAEG"}

package/examples/basic.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=basic.d.ts.map

package/examples/basic.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"basic.d.ts","sourceRoot":"","sources":["basic.ts"],"names":[],"mappings":""}

package/examples/basic.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const src_1 = require("../src");
+async function main() {
+    async function fetchUser(id) {
+        return { id, name: 'Alice' };
+    }
+    async function fetchOrders(user) {
+        return { user, orders: [1, 2, 3] };
+    }
+    async function enrichData(data) {
+        return { ...data, enriched: true };
+    }
+    const flow = (0, src_1.quantam)()
+        .step(fetchUser)
+        .step(fetchOrders)
+        .step(enrichData);
+    const result = await flow.run('user-123');
+    console.log(result);
+}
+main().catch((err) => {
+    console.error(err);
+    process.exitCode = 1;
+});
+//# sourceMappingURL=basic.js.map

package/examples/basic.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"basic.js","sourceRoot":"","sources":["basic.ts"],"names":[],"mappings":";;AAAA,gCAAiC;AAgBjC,KAAK,UAAU,IAAI;IACjB,KAAK,UAAU,SAAS,CAAC,EAAU;QACjC,OAAO,EAAE,EAAE,EAAE,IAAI,EAAE,OAAO,EAAE,CAAC;IAC/B,CAAC;IAED,KAAK,UAAU,WAAW,CAAC,IAAU;QACnC,OAAO,EAAE,IAAI,EAAE,MAAM,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,EAAE,CAAC;IACrC,CAAC;IAED,KAAK,UAAU,UAAU,CAAC,IAAoB;QAC5C,OAAO,EAAE,GAAG,IAAI,EAAE,QAAQ,EAAE,IAAI,EAAE,CAAC;IACrC,CAAC;IAED,MAAM,IAAI,GAAG,IAAA,aAAO,GAAU;SAC3B,IAAI,CAAC,SAAS,CAAC;SACf,IAAI,CAAC,WAAW,CAAC;SACjB,IAAI,CAAC,UAAU,CAAC,CAAC;IAEpB,MAAM,MAAM,GAAG,MAAM,IAAI,CAAC,GAAG,CAAC,UAAU,CAAC,CAAC;IAC1C,OAAO,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC;AACtB,CAAC;AAED,IAAI,EAAE,CAAC,KAAK,CAAC,CAAC,GAAG,EAAE,EAAE;IACnB,OAAO,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;IACnB,OAAO,CAAC,QAAQ,GAAG,CAAC,CAAC;AACvB,CAAC,CAAC,CAAC"}

package/examples/batch.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=batch.d.ts.map

package/examples/batch.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"batch.d.ts","sourceRoot":"","sources":["batch.ts"],"names":[],"mappings":""}

package/examples/batch.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const src_1 = require("../src");
+async function main() {
+    const flow = (0, src_1.quantam)().step(async (n) => n + 1);
+    const inputs = Array.from({ length: 1000 }, (_, i) => i);
+    const results = await flow.runMany(inputs, { concurrency: 64 });
+    console.log({
+        length: results.length,
+        first: results[0],
+        last: results[results.length - 1],
+    });
+}
+main().catch((err) => {
+    console.error(err);
+    process.exitCode = 1;
+});
+//# sourceMappingURL=batch.js.map

package/examples/batch.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"batch.js","sourceRoot":"","sources":["batch.ts"],"names":[],"mappings":";;AAAA,gCAAiC;AAEjC,KAAK,UAAU,IAAI;IACjB,MAAM,IAAI,GAAG,IAAA,aAAO,GAAU,CAAC,IAAI,CAAC,KAAK,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC;IAExD,MAAM,MAAM,GAAa,KAAK,CAAC,IAAI,CAAC,EAAE,MAAM,EAAE,IAAI,EAAE,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,CAAC;IACnE,MAAM,OAAO,GAAG,MAAM,IAAI,CAAC,OAAO,CAAC,MAAM,EAAE,EAAE,WAAW,EAAE,EAAE,EAAE,CAAC,CAAC;IAEhE,OAAO,CAAC,GAAG,CAAC;QACV,MAAM,EAAE,OAAO,CAAC,MAAM;QACtB,KAAK,EAAE,OAAO,CAAC,CAAC,CAAC;QACjB,IAAI,EAAE,OAAO,CAAC,OAAO,CAAC,MAAM,GAAG,CAAC,CAAC;KAClC,CAAC,CAAC;AACL,CAAC;AAED,IAAI,EAAE,CAAC,KAAK,CAAC,CAAC,GAAG,EAAE,EAAE;IACnB,OAAO,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;IACnB,OAAO,CAAC,QAAQ,GAAG,CAAC,CAAC;AACvB,CAAC,CAAC,CAAC"}

package/package.json

@@ -0,0 +1,29 @@
+{
+  "name": "quantam-async",
+  "version": "0.1.0",
+  "description": "A lightweight async workflow engine for composing, running, and controlling complex task pipelines with retries, parallelism, timeouts, and cancellation.",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsc --watch",
+    "test": "node --test dist/tests/*.test.js",
+    "clean": "rm -rf dist"
+  },
+  "keywords": [
+    "async",
+    "pipeline",
+    "workflow",
+    "retry",
+    "timeout",
+    "cancellation",
+    "parallel",
+    "orchestration"
+  ],
+  "author": "",
+  "license": "MIT",
+  "devDependencies": {
+    "@types/node": "^20.0.0",
+    "typescript": "^5.0.0"
+  }
+}

package/src/bench.ts

@@ -0,0 +1,28 @@
+import { quantam } from './index';
+
+async function main() {
+  const size = 100000;
+  const inputs = Array.from({ length: size }, (_, i) => i);
+  const flow = quantam<number>().step(async (n) => n + 1);
+  const start = Date.now();
+  const results = await flow.runMany(inputs, { concurrency: 512 });
+  const durationMs = Date.now() - start;
+  const opsPerSec = durationMs > 0 ? size / (durationMs / 1000) : 0;
+
+  console.log(
+    JSON.stringify({
+      size,
+      concurrency: 512,
+      durationMs,
+      opsPerSec,
+      first: results[0],
+      last: results[results.length - 1],
+    }),
+  );
+}
+
+main().catch((err) => {
+  console.error(err);
+  process.exitCode = 1;
+});
+

package/src/core.ts

@@ -0,0 +1,244 @@
+/**
+ * Quantam Core Implementation
+ * Fluent API for composing async pipelines
+ */
+
+import { AsyncFn, Flow, FlowOptions, ExecutionContext } from './types';
+
+interface Step {
+  type: 'single' | 'parallel';
+  fn?: AsyncFn;
+  fns?: AsyncFn[];
+  retries?: number;
+  retryDelay?: number;
+  timeout?: number;
+}
+
+export class Quantam<T = any> implements Flow<T> {
+  private steps: Step[] = [];
+  private timeoutMs?: number;
+  private abortSignal?: AbortSignal;
+
+  step<R>(fn: AsyncFn<T, R>): Quantam<R> {
+    const newFlow = new Quantam<R>();
+    newFlow.steps = [...this.steps];
+    newFlow.timeoutMs = this.timeoutMs;
+    newFlow.abortSignal = this.abortSignal;
+    newFlow.steps.push({ type: 'single', fn });
+    return newFlow;
+  }
+
+  parallel<R>(fns: AsyncFn<T, any>[]): Quantam<R[]> {
+    const newFlow = new Quantam<R[]>();
+    newFlow.steps = [...this.steps];
+    newFlow.timeoutMs = this.timeoutMs;
+    newFlow.abortSignal = this.abortSignal;
+    newFlow.steps.push({ type: 'parallel', fns });
+    return newFlow;
+  }
+
+  retry(count: number, delayMs: number = 100): Quantam<T> {
+    const newFlow = new Quantam<T>();
+    newFlow.steps = [...this.steps];
+    newFlow.timeoutMs = this.timeoutMs;
+    newFlow.abortSignal = this.abortSignal;
+
+    if (newFlow.steps.length > 0) {
+      const lastStep = newFlow.steps[newFlow.steps.length - 1];
+      lastStep.retries = count;
+      lastStep.retryDelay = delayMs;
+    }
+
+    return newFlow;
+  }
+
+  stepTimeout(ms: number): Quantam<T> {
+    const newFlow = new Quantam<T>();
+    newFlow.steps = [...this.steps];
+    newFlow.timeoutMs = this.timeoutMs;
+    newFlow.abortSignal = this.abortSignal;
+
+    if (newFlow.steps.length > 0) {
+      const lastStep = newFlow.steps[newFlow.steps.length - 1];
+      lastStep.timeout = ms;
+    }
+
+    return newFlow;
+  }
+
+  withSignal(signal: AbortSignal): Quantam<T> {
+    const newFlow = new Quantam<T>();
+    newFlow.steps = [...this.steps];
+    newFlow.timeoutMs = this.timeoutMs;
+    newFlow.abortSignal = signal;
+    return newFlow;
+  }
+
+  timeout(ms: number): Quantam<T> {
+    const newFlow = new Quantam<T>();
+    newFlow.steps = [...this.steps];
+    newFlow.timeoutMs = ms;
+    newFlow.abortSignal = this.abortSignal;
+    return newFlow;
+  }
+
+  async runMany(inputs: T[], options?: FlowOptions & { concurrency?: number }): Promise<T[]> {
+    const configuredConcurrency = options?.concurrency;
+    const concurrency = configuredConcurrency != null ? configuredConcurrency : inputs.length;
+    if (inputs.length === 0) {
+      return [];
+    }
+
+    if (concurrency <= 0 || concurrency >= inputs.length) {
+      return Promise.all(inputs.map((input) => this.run(input, options)));
+    }
+
+    const results: T[] = new Array(inputs.length);
+    let index = 0;
+    const worker = async () => {
+      while (true) {
+        const currentIndex = index++;
+        if (currentIndex >= inputs.length) {
+          break;
+        }
+        results[currentIndex] = await this.run(inputs[currentIndex], options);
+      }
+    };
+
+    const workers: Promise<void>[] = [];
+    const workerCount = Math.min(concurrency, inputs.length);
+    for (let i = 0; i < workerCount; i++) {
+      workers.push(worker());
+    }
+
+    await Promise.all(workers);
+    return results;
+  }
+
+  async run(input: T, options?: FlowOptions): Promise<T> {
+    const signal = options?.signal || this.abortSignal;
+    let result: any = input;
+    const context: ExecutionContext = {
+      signal,
+      stepIndex: 0,
+      retryCount: 0,
+    };
+
+    for (let i = 0; i < this.steps.length; i++) {
+      this.checkAborted(signal);
+
+      const step = this.steps[i];
+      context.stepIndex = i;
+      context.retryCount = 0;
+
+      if (step.type === 'single' && step.fn) {
+        result = await this.executeSingleStep(
+          step.fn,
+          result,
+          context,
+          step.retries || 0,
+          step.retryDelay || 100,
+          step.timeout,
+        );
+      } else if (step.type === 'parallel' && step.fns) {
+        result = await this.executeParallelSteps(
+          step.fns,
+          result,
+          context,
+          step.retries || 0,
+          step.retryDelay || 100,
+          step.timeout,
+        );
+      }
+    }
+
+    return result;
+  }
+
+  private async executeSingleStep(
+    fn: AsyncFn,
+    input: any,
+    context: ExecutionContext,
+    retries: number,
+    retryDelay: number,
+    stepTimeout?: number,
+  ): Promise<any> {
+    let lastError: Error | null = null;
+
+    for (let attempt = 0; attempt <= retries; attempt++) {
+      try {
+        this.checkAborted(context.signal);
+        context.retryCount = attempt;
+
+        const promise = fn(input, context);
+        const effectiveTimeout = stepTimeout ?? this.timeoutMs;
+        const result = effectiveTimeout
+          ? await Promise.race([
+              promise,
+              this.createTimeout(effectiveTimeout),
+            ])
+          : await promise;
+
+        return result;
+      } catch (error) {
+        lastError = error as Error;
+
+        if (attempt < retries) {
+          const delay = retryDelay * (1 << attempt);
+          await this.sleep(delay, context.signal);
+        }
+      }
+    }
+
+    throw lastError || new Error('Step execution failed');
+  }
+
+  private async executeParallelSteps(
+    fns: AsyncFn[],
+    input: any,
+    context: ExecutionContext,
+    retries: number,
+    retryDelay: number,
+    stepTimeout?: number,
+  ): Promise<any[]> {
+    const promises = fns.map((fn) =>
+      this.executeSingleStep(fn, input, context, retries, retryDelay, stepTimeout),
+    );
+
+    return Promise.all(promises);
+  }
+
+  private checkAborted(signal?: AbortSignal): void {
+    if (signal?.aborted) {
+      throw new Error('Pipeline aborted');
+    }
+  }
+
+  private createTimeout(ms: number): Promise<never> {
+    return new Promise((_, reject) =>
+      setTimeout(() => reject(new Error(`Timeout after ${ms}ms`)), ms),
+    );
+  }
+
+  private sleep(ms: number, signal?: AbortSignal): Promise<void> {
+    return new Promise((resolve, reject) => {
+      const timeoutId = setTimeout(resolve, ms);
+
+      if (signal) {
+        const onAbort = () => {
+          clearTimeout(timeoutId);
+          reject(new Error('Sleep aborted'));
+        };
+        if (signal.aborted) {
+          onAbort();
+          return;
+        }
+        signal.addEventListener('abort', onAbort, { once: true });
+      }
+    });
+  }
+}
+
+export function quantam<T = any>(): Quantam<T> {
+  return new Quantam<T>();
+}

package/src/examples/basic.ts

@@ -0,0 +1,42 @@
+import { quantam } from '../index';
+
+interface User {
+  id: string;
+  name: string;
+}
+
+interface UserWithOrders {
+  user: User;
+  orders: number[];
+}
+
+interface EnrichedUser extends UserWithOrders {
+  enriched: boolean;
+}
+
+async function main(): Promise<void> {
+  async function fetchUser(id: string): Promise<User> {
+    return { id, name: 'Alice' };
+  }
+
+  async function fetchOrders(user: User): Promise<UserWithOrders> {
+    return { user, orders: [1, 2, 3] };
+  }
+
+  async function enrichData(data: UserWithOrders): Promise<EnrichedUser> {
+    return { ...data, enriched: true };
+  }
+
+  const flow = quantam()
+    .step(fetchUser)
+    .step(fetchOrders)
+    .step(enrichData);
+
+  const result = await flow.run('user-123' as any);
+  console.log(result);
+}
+
+main().catch((err) => {
+  console.error(err);
+  process.exitCode = 1;
+});

package/src/examples/batch.ts

@@ -0,0 +1,20 @@
+import { quantam } from '../index';
+
+async function main(): Promise<void> {
+  const flow = quantam<number>().step(async (n) => n + 1);
+
+  const inputs: number[] = Array.from({ length: 1000 }, (_, i) => i);
+  const results = await flow.runMany(inputs, { concurrency: 64 });
+
+  console.log({
+    length: results.length,
+    first: results[0],
+    last: results[results.length - 1],
+  });
+}
+
+main().catch((err) => {
+  console.error(err);
+  process.exitCode = 1;
+});
+

package/src/index.ts

@@ -0,0 +1,7 @@
+/**
+ * Quantam - A lightweight async workflow engine
+ * Core entry point
+ */
+
+export { Quantam, quantam } from './core';
+export type { Flow, FlowOptions, ExecutionContext } from './types';

package/src/tests/quantam.test.ts

@@ -0,0 +1,74 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { quantam } from '../index';
+
+test('runs basic sequential pipeline', async () => {
+  const flow = quantam<number>()
+    .step(async (n) => n + 1)
+    .step(async (n) => n * 2);
+
+  const result = await flow.run(1);
+  assert.equal(result, 4);
+});
+
+test('retries and exposes retryCount', async () => {
+  let attempts = 0;
+
+  const flow = quantam<number>()
+    .step(async (n, ctx) => {
+      attempts++;
+      if ((ctx?.retryCount ?? 0) < 2) {
+        throw new Error('transient');
+      }
+      return n + (ctx?.retryCount ?? 0);
+    })
+    .retry(3, 1);
+
+  const result = await flow.run(1);
+  assert.equal(result, 3);
+  assert.equal(attempts, 3);
+});
+
+test('stepTimeout rejects slow step', async () => {
+  const flow = quantam<number>()
+    .step(async (n) => {
+      await new Promise((resolve) => setTimeout(resolve, 20));
+      return n + 1;
+    })
+    .stepTimeout(5);
+
+  let threw = false;
+  try {
+    await flow.run(1);
+  } catch (err) {
+    threw = true;
+    assert.match((err as Error).message, /Timeout/);
+  }
+  assert.equal(threw, true);
+});
+
+test('runMany respects concurrency limit', async () => {
+  const concurrencyLimit = 4;
+  let inFlight = 0;
+  let maxInFlight = 0;
+
+  const flow = quantam<number>().step(async (n) => {
+    inFlight++;
+    if (inFlight > maxInFlight) {
+      maxInFlight = inFlight;
+    }
+    await new Promise((resolve) => setTimeout(resolve, 5));
+    inFlight--;
+    return n + 1;
+  });
+
+  const inputs = Array.from({ length: 16 }, (_, i) => i);
+  const results = await flow.runMany(inputs, { concurrency: concurrencyLimit });
+
+  assert.deepEqual(
+    results,
+    inputs.map((n) => n + 1),
+  );
+  assert.ok(maxInFlight <= concurrencyLimit);
+});
+

package/src/types.ts

@@ -0,0 +1,36 @@
+/**
+ * Type definitions for Quantam
+ */
+
+export type AsyncFn<T = any, R = any> = (input: T, context?: ExecutionContext) => Promise<R>;
+
+export interface ExecutionContext {
+  signal?: AbortSignal;
+  retryCount?: number;
+  stepIndex?: number;
+}
+
+export interface FlowOptions {
+  signal?: AbortSignal;
+}
+
+export interface RunManyOptions extends FlowOptions {
+  concurrency?: number;
+}
+
+export interface Flow<T = any> {
+  step<R>(fn: AsyncFn<T, R>): Flow<R>;
+  parallel<R>(fns: AsyncFn<T, any>[]): Flow<R[]>;
+  retry(count: number, delayMs?: number): Flow<T>;
+  timeout(ms: number): Flow<T>;
+  stepTimeout(ms: number): Flow<T>;
+  withSignal(signal: AbortSignal): Flow<T>;
+  run(input: T, options?: FlowOptions): Promise<T>;
+   runMany(inputs: T[], options?: RunManyOptions): Promise<T[]>;
+}
+
+export interface QuantamConfig {
+  retries?: number;
+  retryDelay?: number;
+  timeout?: number;
+}

package/tsconfig.json

@@ -0,0 +1,20 @@
+{
+  "compilerOptions": {
+    "target": "ES2020",
+    "module": "commonjs",
+    "lib": ["ES2020"],
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "declaration": true,
+    "declarationMap": true,
+    "sourceMap": true,
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "resolveJsonModule": true,
+    "moduleResolution": "node"
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist"]
+}