clutchit 0.0.5 → 0.0.6

package/dist/circuit/{circuit-breaker.d.ts → circuit.breaker.d.ts}

@@ -48,4 +48,4 @@ export declare class CircuitBreaker {
     private transition;
 }
 export {};
-//# sourceMappingURL=circuit-breaker.d.ts.map
+//# sourceMappingURL=circuit.breaker.d.ts.map

package/dist/circuit/{circuit-breaker.js → circuit.breaker.js}

@@ -106,4 +106,4 @@ export class CircuitBreaker {
         }
     }
 }
-//# sourceMappingURL=circuit-breaker.js.map
+//# sourceMappingURL=circuit.breaker.js.map

package/dist/circuit/index.d.ts

@@ -1,7 +1,10 @@
-import { CircuitBreaker as _CircuitBreaker } from './circuit-breaker.js';
-export type { CircuitState, CircuitBreakerOptions } from './circuit-breaker.js';
-export { CircuitOpenFault } from './circuit-breaker.js';
+import { CircuitBreaker } from './circuit.breaker.js';
+import type { CircuitState, CircuitBreakerOptions } from './circuit.breaker.js';
+export { CircuitOpenFault } from './circuit.breaker.js';
 export declare namespace Circuit {
-    const Breaker: typeof _CircuitBreaker;
+    const Breaker: typeof CircuitBreaker;
+    type Breaker = CircuitBreaker;
+    type BreakerOptions = CircuitBreakerOptions;
+    type State = CircuitState;
 }
 //# sourceMappingURL=index.d.ts.map

package/dist/circuit/index.js

@@ -1,8 +1,8 @@
-import { CircuitBreaker as _CircuitBreaker } from './circuit-breaker.js';
-export { CircuitOpenFault } from './circuit-breaker.js';
+import { CircuitBreaker } from './circuit.breaker.js';
+export { CircuitOpenFault } from './circuit.breaker.js';
 // eslint-disable-next-line @typescript-eslint/no-namespace
 export var Circuit;
 (function (Circuit) {
-    Circuit.Breaker = _CircuitBreaker;
+    Circuit.Breaker = CircuitBreaker;
 })(Circuit || (Circuit = {}));
 //# sourceMappingURL=index.js.map

package/dist/concurrency/index.d.ts

@@ -1,16 +1,23 @@
 import { Semaphore as _Semaphore } from './semaphore.js';
+import type { SemaphoreOptions as _SemaphoreOptions } from './semaphore.js';
 import { RateLimiter as _RateLimiter } from './rate-limiter.js';
+import type { RateLimiterOptions as _RateLimiterOptions } from './rate-limiter.js';
 import { Bulkhead as _Bulkhead } from './bulkhead.js';
+import type { BulkheadOptions as _BulkheadOptions } from './bulkhead.js';
 import { Ref as _Ref } from './ref.js';
-export type { SemaphoreOptions } from './semaphore.js';
-export type { RateLimiterOptions } from './rate-limiter.js';
 export { RateLimitFault } from './rate-limiter.js';
-export type { BulkheadOptions } from './bulkhead.js';
 export { BulkheadRejectedFault } from './bulkhead.js';
 export declare namespace Concurrency {
     const Semaphore: typeof _Semaphore;
+    type Semaphore = _Semaphore;
+    type SemaphoreOptions = _SemaphoreOptions;
     const RateLimiter: typeof _RateLimiter;
+    type RateLimiter = _RateLimiter;
+    type RateLimiterOptions = _RateLimiterOptions;
     const Bulkhead: typeof _Bulkhead;
+    type Bulkhead = _Bulkhead;
+    type BulkheadOptions = _BulkheadOptions;
     const Ref: typeof _Ref;
+    type Ref<T> = _Ref<T>;
 }
 //# sourceMappingURL=index.d.ts.map

package/dist/queue/index.d.ts

@@ -1,11 +1,15 @@
-import { BoundedQueue as _BoundedQueue } from './bounded.queue.js';
-import { DroppingQueue as _DroppingQueue } from './dropping.queue.js';
-import { SlidingQueue as _SlidingQueue } from './sliding.queue.js';
-export type { QueueOptions } from './base.queue.js';
+import type { QueueOptions } from './base.queue.js';
+import { BoundedQueue } from './bounded.queue.js';
+import { DroppingQueue } from './dropping.queue.js';
+import { SlidingQueue } from './sliding.queue.js';
 export { QueueFullFault, QueueEmptyFault } from './faults.js';
 export declare namespace Queue {
-    const Bounded: typeof _BoundedQueue;
-    const Dropping: typeof _DroppingQueue;
-    const Sliding: typeof _SlidingQueue;
+    type Options = QueueOptions;
+    const Bounded: typeof BoundedQueue;
+    type Bounded<T> = BoundedQueue<T>;
+    const Dropping: typeof DroppingQueue;
+    type Dropping<T> = DroppingQueue<T>;
+    const Sliding: typeof SlidingQueue;
+    type Sliding<T> = SlidingQueue<T>;
 }
 //# sourceMappingURL=index.d.ts.map

package/dist/queue/index.js

@@ -1,12 +1,12 @@
-import { BoundedQueue as _BoundedQueue } from './bounded.queue.js';
-import { DroppingQueue as _DroppingQueue } from './dropping.queue.js';
-import { SlidingQueue as _SlidingQueue } from './sliding.queue.js';
+import { BoundedQueue } from './bounded.queue.js';
+import { DroppingQueue } from './dropping.queue.js';
+import { SlidingQueue } from './sliding.queue.js';
 export { QueueFullFault, QueueEmptyFault } from './faults.js';
 // eslint-disable-next-line @typescript-eslint/no-namespace
 export var Queue;
 (function (Queue) {
-    Queue.Bounded = _BoundedQueue;
-    Queue.Dropping = _DroppingQueue;
-    Queue.Sliding = _SlidingQueue;
+    Queue.Bounded = BoundedQueue;
+    Queue.Dropping = DroppingQueue;
+    Queue.Sliding = SlidingQueue;
 })(Queue || (Queue = {}));
 //# sourceMappingURL=index.js.map

package/dist/retry/index.d.ts

@@ -1,6 +1,8 @@
-import { RetryPolicy as _RetryPolicy } from './retry.js';
-export type { RetryOptions } from './retry.js';
+import { RetryPolicy } from './retry.js';
+import type { RetryOptions } from './retry.js';
 export declare namespace Retry {
-    const Policy: typeof _RetryPolicy;
+    type Options = RetryOptions;
+    const Policy: typeof RetryPolicy;
+    type Policy = RetryPolicy;
 }
 //# sourceMappingURL=index.d.ts.map

package/dist/retry/index.js

@@ -1,7 +1,7 @@
-import { RetryPolicy as _RetryPolicy } from './retry.js';
+import { RetryPolicy } from './retry.js';
 // eslint-disable-next-line @typescript-eslint/no-namespace
 export var Retry;
 (function (Retry) {
-    Retry.Policy = _RetryPolicy;
+    Retry.Policy = RetryPolicy;
 })(Retry || (Retry = {}));
 //# sourceMappingURL=index.js.map

package/dist/schedule/index.d.ts

@@ -1,23 +1,25 @@
-import { Schedule as ScheduleClass } from './schedule.js';
+import { Schedule as _Schedule } from './schedule.js';
+import type { ScheduleStep, ScheduleOperator } from './schedule.js';
 import { recurs as _recurs, cappedDelay as _cappedDelay, jittered as _jittered, upTo as _upTo, andThen as _andThen, union as _union, intersect as _intersect, whileInput as _whileInput, whileOutput as _whileOutput, map as _map } from './operators.js';
 import { repeat as _repeat } from './runner.js';
-export type { ScheduleStep, ScheduleOperator } from './schedule.js';
+import type { RepeatOptions as _RepeatOptions } from './runner.js';
 export { ScheduleInterruptedFault } from './runner.js';
-export type { RepeatOptions } from './runner.js';
-export type Schedule<In = unknown, Out = number> = ScheduleClass<In, Out>;
+export type Schedule<In = unknown, Out = number> = _Schedule<In, Out>;
 export declare namespace Schedule {
-    const spaced: (ms: number) => ScheduleClass;
-    const exponential: (initialDelay: number, multiplier?: number) => ScheduleClass;
-    const linear: (initialDelay: number) => ScheduleClass;
-    const constant: (delay: number) => ScheduleClass;
-    const fixed: (interval: number) => ScheduleClass;
-    const windowed: (interval: number) => ScheduleClass;
-    const forever: ScheduleClass<unknown, number>;
-    const once: ScheduleClass<unknown, number>;
-    const fibonacci: (one: number) => ScheduleClass;
+    type Step = ScheduleStep;
+    type Operator = ScheduleOperator;
+    const spaced: (ms: number) => _Schedule;
+    const exponential: (initialDelay: number, multiplier?: number) => _Schedule;
+    const linear: (initialDelay: number) => _Schedule;
+    const constant: (delay: number) => _Schedule;
+    const fixed: (interval: number) => _Schedule;
+    const windowed: (interval: number) => _Schedule;
+    const forever: _Schedule<unknown, number>;
+    const once: _Schedule<unknown, number>;
+    const fibonacci: (one: number) => _Schedule;
     const cron: (expression: string, options?: {
         timezone?: string;
-    }) => ScheduleClass;
+    }) => _Schedule;
     const recurs: typeof _recurs;
     const cappedDelay: typeof _cappedDelay;
     const jittered: typeof _jittered;
@@ -29,5 +31,6 @@ export declare namespace Schedule {
     const whileOutput: typeof _whileOutput;
     const map: typeof _map;
     const repeat: typeof _repeat;
+    type RepeatOptions = _RepeatOptions;
 }
 //# sourceMappingURL=index.d.ts.map

package/dist/schedule/index.js

@@ -1,20 +1,20 @@
-import { Schedule as ScheduleClass } from './schedule.js';
+import { Schedule as _Schedule } from './schedule.js';
 import { recurs as _recurs, cappedDelay as _cappedDelay, jittered as _jittered, upTo as _upTo, andThen as _andThen, union as _union, intersect as _intersect, whileInput as _whileInput, whileOutput as _whileOutput, map as _map, } from './operators.js';
 import { repeat as _repeat } from './runner.js';
 export { ScheduleInterruptedFault } from './runner.js';
 // eslint-disable-next-line @typescript-eslint/no-namespace
 export var Schedule;
 (function (Schedule) {
-    Schedule.spaced = ScheduleClass.spaced;
-    Schedule.exponential = ScheduleClass.exponential;
-    Schedule.linear = ScheduleClass.linear;
-    Schedule.constant = ScheduleClass.constant;
-    Schedule.fixed = ScheduleClass.fixed;
-    Schedule.windowed = ScheduleClass.windowed;
-    Schedule.forever = ScheduleClass.forever;
-    Schedule.once = ScheduleClass.once;
-    Schedule.fibonacci = ScheduleClass.fibonacci;
-    Schedule.cron = ScheduleClass.cron;
+    Schedule.spaced = _Schedule.spaced;
+    Schedule.exponential = _Schedule.exponential;
+    Schedule.linear = _Schedule.linear;
+    Schedule.constant = _Schedule.constant;
+    Schedule.fixed = _Schedule.fixed;
+    Schedule.windowed = _Schedule.windowed;
+    Schedule.forever = _Schedule.forever;
+    Schedule.once = _Schedule.once;
+    Schedule.fibonacci = _Schedule.fibonacci;
+    Schedule.cron = _Schedule.cron;
     Schedule.recurs = _recurs;
     Schedule.cappedDelay = _cappedDelay;
     Schedule.jittered = _jittered;

package/dist/timeout/index.d.ts

@@ -1,8 +1,7 @@
-import { TimeoutFault as _TimeoutFault, withTimeout as _withTimeout, createTimeout as _createTimeout } from './timeout.js';
+import { withTimeout as _withTimeout, createTimeout as _createTimeout } from './timeout.js';
 export { TimeoutFault } from './timeout.js';
 export declare namespace Timeout {
     const wrap: typeof _withTimeout;
     const create: typeof _createTimeout;
-    const Fault: typeof _TimeoutFault;
 }
 //# sourceMappingURL=index.d.ts.map

package/dist/timeout/index.js

@@ -1,10 +1,9 @@
-import { TimeoutFault as _TimeoutFault, withTimeout as _withTimeout, createTimeout as _createTimeout, } from './timeout.js';
+import { withTimeout as _withTimeout, createTimeout as _createTimeout, } from './timeout.js';
 export { TimeoutFault } from './timeout.js';
 // eslint-disable-next-line @typescript-eslint/no-namespace
 export var Timeout;
 (function (Timeout) {
     Timeout.wrap = _withTimeout;
     Timeout.create = _createTimeout;
-    Timeout.Fault = _TimeoutFault;
 })(Timeout || (Timeout = {}));
 //# sourceMappingURL=index.js.map

package/dist/unthrow/index.d.ts

@@ -1,24 +1,26 @@
-import { ResultAsync as ResultAsyncClass, okAsync, errAsync } from './result.async.js';
-import { DoAsync } from './do.js';
+import { ok as _ok, err as _err } from './result.js';
+import { ResultAsync as _ResultAsync, okAsync, errAsync } from './result.async.js';
+import { fromPromise as _fromPromise, fromThrowable as _fromThrowable } from './helpers.js';
+import { Do as _Do, DoAsync } from './do.js';
 import { Fault as _Fault, isDomainFault as _isDomainFault, isInfrastructureFault as _isInfrastructureFault, isTransientFault as _isTransientFault } from './fault.js';
 export { Ok, Err } from './result.js';
 export type Result<T, E> = import('./result.js').Ok<T, E> | import('./result.js').Err<T, E>;
 type _Result<T, E> = Result<T, E>;
 export declare namespace Result {
-    const ok: typeof import("./result.js").ok;
-    const err: typeof import("./result.js").err;
-    const fromThrowable: typeof import("./helpers.js").fromThrowable;
+    const ok: typeof _ok;
+    const err: typeof _err;
+    const fromThrowable: typeof _fromThrowable;
     function combine<T, E>(results: _Result<T, E>[]): _Result<T[], E>;
     function combineWithAllErrors<T, E>(results: _Result<T, E>[]): _Result<T[], E[]>;
-    const Do: typeof import("./do.js").Do;
+    const Do: typeof _Do;
 }
-export type ResultAsync<T, E> = ResultAsyncClass<T, E>;
+export type ResultAsync<T, E> = _ResultAsync<T, E>;
 export declare namespace ResultAsync {
     const ok: typeof okAsync;
     const err: typeof errAsync;
-    const fromPromise: typeof import("./helpers.js").fromPromise;
-    function combine<T, E>(results: ResultAsyncClass<T, E>[]): ResultAsyncClass<T[], E>;
-    function combineWithAllErrors<T, E>(results: ResultAsyncClass<T, E>[]): ResultAsyncClass<T[], E[]>;
+    const fromPromise: typeof _fromPromise;
+    function combine<T, E>(results: _ResultAsync<T, E>[]): _ResultAsync<T[], E>;
+    function combineWithAllErrors<T, E>(results: _ResultAsync<T, E>[]): _ResultAsync<T[], E[]>;
     const Do: typeof DoAsync;
 }
 export type Fault = import('./fault.js').Fault;

package/dist/unthrow/index.js

@@ -1,16 +1,10 @@
-import { ok, err } from './result.js';
+import { ok as _ok, err as _err } from './result.js';
 import { okAsync, errAsync, } from './result.async.js';
-import { fromPromise, fromThrowable, combine as combineFn, combineWithAllErrors as combineWithAllErrorsFn, } from './helpers.js';
-import { Do, DoAsync } from './do.js';
+import { fromPromise as _fromPromise, fromThrowable as _fromThrowable, combine as _combine, combineWithAllErrors as _combineWithAllErrors, } from './helpers.js';
+import { Do as _Do, DoAsync } from './do.js';
 import { Fault as _Fault, isDomainFault as _isDomainFault, isInfrastructureFault as _isInfrastructureFault, isTransientFault as _isTransientFault, } from './fault.js';
 // Re-export instance types (needed in user signatures)
 export { Ok, Err } from './result.js';
-// Internal aliases (must precede namespaces that reference them)
-const _ok = ok;
-const _err = err;
-const _fromThrowable = fromThrowable;
-const _fromPromise = fromPromise;
-const _Do = Do;
 // eslint-disable-next-line @typescript-eslint/no-namespace
 export var Result;
 (function (Result) {
@@ -18,11 +12,11 @@ export var Result;
     Result.err = _err;
     Result.fromThrowable = _fromThrowable;
     function combine(results) {
-        return combineFn(results);
+        return _combine(results);
     }
     Result.combine = combine;
     function combineWithAllErrors(results) {
-        return combineWithAllErrorsFn(results);
+        return _combineWithAllErrors(results);
     }
     Result.combineWithAllErrors = combineWithAllErrors;
     Result.Do = _Do;
@@ -34,11 +28,11 @@ export var ResultAsync;
     ResultAsync.err = errAsync;
     ResultAsync.fromPromise = _fromPromise;
     function combine(results) {
-        return combineFn(results);
+        return _combine(results);
     }
     ResultAsync.combine = combine;
     function combineWithAllErrors(results) {
-        return combineWithAllErrorsFn(results);
+        return _combineWithAllErrors(results);
     }
     ResultAsync.combineWithAllErrors = combineWithAllErrors;
     ResultAsync.Do = DoAsync;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "clutchit",
-  "version": "0.0.5",
+  "version": "0.0.6",
   "description": "",
   "author": {
     "name": "hexac",
@@ -69,6 +69,9 @@
       "prettier --check"
     ]
   },
+  "dependencies": {
+    "croner": "^10.0.1"
+  },
   "devDependencies": {
     "@eslint/js": "^10.0.1",
     "@types/bun": "^1.3.9",
@@ -94,9 +97,6 @@
     "node": ">=20",
     "bun": ">=1"
   },
-  "dependencies": {
-    "croner": "^10.0.1"
-  },
   "scripts": {
     "build": "rimraf dist && tsc -p tsconfig.build.json",
     "format": "prettier --write \"src/**/*.ts\" \"test/**/*.ts\"",