@noego/trust 0.5.1-dev.2 → 0.5.1-dev.4
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/README.md +155 -0
- package/dist/{baseline-D0Ok-NGU.d.ts → baseline-DsqHPLAg.d.ts} +27 -2
- package/dist/{chunk-P4VFMA2A.js → chunk-35ETSKEC.js} +414 -12
- package/dist/chunk-35ETSKEC.js.map +1 -0
- package/dist/{chunk-RVTPDLEW.js → chunk-4XGOH7JE.js} +3491 -3456
- package/dist/chunk-4XGOH7JE.js.map +1 -0
- package/dist/{chunk-V4FYZG5Q.js → chunk-6K5I3ZRI.js} +2 -2
- package/dist/cli/index.js +6 -6
- package/dist/cli/index.js.map +1 -1
- package/dist/core/index.d.ts +2 -2
- package/dist/core/index.js +2 -2
- package/dist/eslint/index.d.ts +6 -2
- package/dist/eslint/index.js +84 -12
- package/dist/eslint/index.js.map +1 -1
- package/dist/index.cjs +253 -7
- package/dist/index.cjs.map +1 -1
- package/dist/index.d.cts +112 -6
- package/dist/index.d.ts +112 -6
- package/dist/index.js +248 -6
- package/dist/index.js.map +1 -1
- package/dist/native/trust_native_wasm.wasm +0 -0
- package/package.json +4 -4
- package/dist/chunk-P4VFMA2A.js.map +0 -1
- package/dist/chunk-RVTPDLEW.js.map +0 -1
- /package/dist/{chunk-V4FYZG5Q.js.map → chunk-6K5I3ZRI.js.map} +0 -0
package/dist/index.d.ts
CHANGED
|
@@ -9,6 +9,7 @@
|
|
|
9
9
|
* Result.ok / Result.err — make a result
|
|
10
10
|
* Trust.try / Trust.tryAsync — the only boundary that may catch a throw
|
|
11
11
|
* Trust.decide / Trust.translate — the only places a failure may stop or change
|
|
12
|
+
* Trust.using / Trust.usingAsync — acquire, use and always release a Result resource
|
|
12
13
|
*
|
|
13
14
|
* The underlying functions are exported as well because the `@noego/trust/eslint`
|
|
14
15
|
* rules recognise calls by their declaration (not by name): `Trust.try(...)` resolves
|
|
@@ -22,6 +23,24 @@ type Err<E> = {
|
|
|
22
23
|
readonly ok: false;
|
|
23
24
|
readonly error: E;
|
|
24
25
|
};
|
|
26
|
+
type StatedOk<T, S extends string> = {
|
|
27
|
+
[K in S]: {
|
|
28
|
+
readonly ok: true;
|
|
29
|
+
readonly state: K;
|
|
30
|
+
readonly value: T;
|
|
31
|
+
};
|
|
32
|
+
}[S];
|
|
33
|
+
type StatedResult<T, E, S extends string> = StatedOk<T, S> | Err<E>;
|
|
34
|
+
type LiteralState<S extends string> = string extends S ? never : S;
|
|
35
|
+
type Stateless<R> = Extract<R, {
|
|
36
|
+
readonly state: unknown;
|
|
37
|
+
}> extends never ? R : never;
|
|
38
|
+
type NotResult<T> = unknown extends T ? never : Extract<T, Ok<unknown> | Err<unknown>> extends never ? T : never;
|
|
39
|
+
declare function state<const S extends string>(state: LiteralState<S>): StatedOk<void, S>;
|
|
40
|
+
declare function state<const S extends string, R extends Result<unknown, unknown>>(state: LiteralState<S>, result: R & Stateless<R> & (0 extends (1 & R) ? never : unknown)): StatedOk<OkOf<R>, S> | Extract<R, {
|
|
41
|
+
readonly ok: false;
|
|
42
|
+
}>;
|
|
43
|
+
declare function state<const S extends string, T>(state: LiteralState<S>, value: T, ...check: [T] extends [NotResult<T>] ? unknown extends T ? [problem: never] : [] : [problem: never]): StatedOk<T, S>;
|
|
25
44
|
/** A failure is an object with a literal `kind` plus any fields. */
|
|
26
45
|
type Failure<K extends string = string, Fields extends object = {}> = {
|
|
27
46
|
readonly kind: K;
|
|
@@ -116,32 +135,119 @@ type KindCheck<M> = [
|
|
|
116
135
|
type Remaining<E, H> = Exclude<E, {
|
|
117
136
|
readonly kind: keyof H & string;
|
|
118
137
|
}>;
|
|
119
|
-
type
|
|
120
|
-
|
|
138
|
+
type StatedMembersOf<R> = Extract<R, {
|
|
139
|
+
readonly ok: true;
|
|
140
|
+
readonly state: string;
|
|
141
|
+
}>;
|
|
142
|
+
type HasStates<R> = [StatedMembersOf<R>] extends [never] ? false : true;
|
|
143
|
+
type StateGuard<R> = HasStates<R> extends true ? Exclude<Extract<R, Ok<unknown>>, StatedMembersOf<R>> extends never ? unknown : {
|
|
144
|
+
readonly __trust: 'mixed stated and stateless successes are not supported';
|
|
145
|
+
} : unknown;
|
|
146
|
+
type SuccessOf<R, H> = HasStates<R> extends true ? StatedMembersOf<R> | H[keyof H] : Ok<OkOf<R> | H[keyof H]>;
|
|
147
|
+
type RecoveryCheck<R, H> = {
|
|
148
|
+
[K in keyof H]: HasStates<R> extends true ? H[K] extends StatedOk<unknown, infer S extends string> ? string extends S ? 1 : never : 1 : Extract<H[K], {
|
|
149
|
+
readonly state: unknown;
|
|
150
|
+
}> extends never ? never : 1;
|
|
151
|
+
}[keyof H] extends never ? [] : [problem: {
|
|
152
|
+
readonly __trust: 'recovery must preserve the success state discipline';
|
|
153
|
+
}];
|
|
154
|
+
type Decided<R, H> = [Remaining<ErrorOf<R>, H>] extends [never] ? SuccessOf<R, H> : SuccessOf<R, H> | Err<Remaining<ErrorOf<R>, H>>;
|
|
155
|
+
type Translated<R, M> = (HasStates<R> extends true ? StatedMembersOf<R> : Ok<OkOf<R>>) | Err<M[keyof M] | Remaining<ErrorOf<R>, M>>;
|
|
121
156
|
/**
|
|
122
157
|
* The only place a failure may stop: a failure whose kind has a handler becomes
|
|
123
158
|
* `ok(handler(failure))`; anything else is returned untouched. Handlers are synchronous
|
|
124
159
|
* and must return a value (never `undefined`/`void`).
|
|
125
160
|
*/
|
|
126
|
-
declare function decide<R extends Result<unknown, unknown>, H extends HandlerBase<ErrorOf<R>, H>>(result: R & FailureGuard<R>, handlers: HandlerFns<ErrorOf<R>, H>): Decided<R, H>;
|
|
161
|
+
declare function decide<R extends Result<unknown, unknown>, H extends HandlerBase<ErrorOf<R>, H>>(result: R & FailureGuard<R> & StateGuard<R>, handlers: HandlerFns<ErrorOf<R>, H>, ...check: RecoveryCheck<R, H>): Decided<R, H>;
|
|
127
162
|
/** Turns failures into different failures; unmapped failures and successes pass through untouched. */
|
|
128
|
-
declare function translate<R extends Result<unknown, unknown>, M extends MapperBase<ErrorOf<R>, M>>(result: R & FailureGuard<R>, mappers: MapperFns<ErrorOf<R>, M>, ...check: KindCheck<M>): Translated<R, M>;
|
|
163
|
+
declare function translate<R extends Result<unknown, unknown>, M extends MapperBase<ErrorOf<R>, M>>(result: R & FailureGuard<R> & StateGuard<R>, mappers: MapperFns<ErrorOf<R>, M>, ...check: KindCheck<M>): Translated<R, M>;
|
|
164
|
+
type MatchGuard<R> = [RawErrorOf<R>] extends [never] ? HasStates<R> extends true ? StateGuard<R> : {
|
|
165
|
+
readonly __trust: 'match needs stated successes';
|
|
166
|
+
} : {
|
|
167
|
+
readonly __trust: 'match requires all failures to be handled first';
|
|
168
|
+
};
|
|
169
|
+
type StatesOf<R> = StatedMembersOf<R>['state'];
|
|
170
|
+
type MatchFns<R, H> = {
|
|
171
|
+
[K in keyof H]-?: (value: OkOf<Extract<R, {
|
|
172
|
+
readonly state: K;
|
|
173
|
+
}>>) => H[K];
|
|
174
|
+
};
|
|
175
|
+
type MatchBase<R, H> = {
|
|
176
|
+
[K in StatesOf<R>]: {} | null;
|
|
177
|
+
} & {
|
|
178
|
+
[K in keyof H]: K extends StatesOf<R> ? {} | null : never;
|
|
179
|
+
};
|
|
180
|
+
type Matched<H> = [H[keyof H]] extends [StatedOk<unknown, string>] ? H[keyof H] : Ok<H[keyof H]>;
|
|
181
|
+
type MatchCheck<H> = [Extract<H[keyof H], {
|
|
182
|
+
readonly state: unknown;
|
|
183
|
+
}>] extends [never] ? [] : [H[keyof H]] extends [StatedOk<unknown, infer S extends string>] ? string extends S ? [problem: {
|
|
184
|
+
readonly __trust: 'match needs literal output states';
|
|
185
|
+
}] : [] : [problem: {
|
|
186
|
+
readonly __trust: 'match cannot mix stated and bare returns';
|
|
187
|
+
}];
|
|
188
|
+
declare function match<R extends Result<unknown, unknown>, H extends MatchBase<R, H>>(result: R & MatchGuard<R>, handlers: MatchFns<R, H>, ...check: MatchCheck<H>): Matched<H>;
|
|
189
|
+
type MaybePromise<T> = T | PromiseLike<T>;
|
|
190
|
+
type ResourceOf<A> = OkOf<Awaited<A>>;
|
|
191
|
+
type SyncOf<T> = Exclude<T, PromiseLike<unknown>>;
|
|
192
|
+
type AsyncOf<T> = Extract<T, PromiseLike<unknown>>;
|
|
193
|
+
type HasType<T> = [T] extends [never] ? false : true;
|
|
194
|
+
type HasOk<R> = [Extract<R, Ok<unknown>>] extends [never] ? false : true;
|
|
195
|
+
type ErrUnion<E> = [E] extends [never] ? never : Err<E>;
|
|
196
|
+
type UsingSuccess<U> = HasOk<U> extends false ? never : HasStates<U> extends true ? StatedMembersOf<U> : Ok<OkOf<U>>;
|
|
197
|
+
type UsingResult<A, U, C> = HasOk<A> extends false ? ErrUnion<RawErrorOf<A>> : HasOk<U> extends false ? ErrUnion<RawErrorOf<A> | RawErrorOf<U>> : HasOk<C> extends false ? ErrUnion<RawErrorOf<A> | RawErrorOf<U> | RawErrorOf<C>> : UsingSuccess<U> | ErrUnion<RawErrorOf<A> | RawErrorOf<U> | RawErrorOf<C>>;
|
|
198
|
+
type SyncAcquireOk<A> = Extract<SyncOf<A>, Ok<unknown>>;
|
|
199
|
+
type SyncAcquireErr<A> = ErrUnion<RawErrorOf<SyncOf<A>>>;
|
|
200
|
+
type UsingSyncOut<A, U, C> = HasType<SyncAcquireOk<A>> extends true ? HasType<SyncOf<U>> extends true ? HasType<SyncOf<C>> extends true ? UsingResult<SyncOf<A>, SyncOf<U>, SyncOf<C>> : SyncAcquireErr<A> : SyncAcquireErr<A> : SyncAcquireErr<A>;
|
|
201
|
+
type UsingAsyncOut<A, U, C> = HasType<AsyncOf<A>> extends true ? Promise<UsingResult<Awaited<A>, Awaited<U>, Awaited<C>>> : HasType<SyncAcquireOk<A>> extends true ? HasType<AsyncOf<U> | AsyncOf<C>> extends true ? Promise<UsingResult<Awaited<A>, Awaited<U>, Awaited<C>>> : never : never;
|
|
202
|
+
type UsingOut<A, U, C> = HasType<AsyncOf<A | U | C>> extends false ? UsingResult<A, U, C> : UsingSyncOut<A, U, C> | UsingAsyncOut<A, U, C>;
|
|
203
|
+
type UsingCheck<A, U, C> = HasStates<A> extends true ? [problem: {
|
|
204
|
+
readonly __trust: 'acquire must return a stateless Result';
|
|
205
|
+
}] : HasStates<C> extends true ? [problem: {
|
|
206
|
+
readonly __trust: 'release must return a stateless Result';
|
|
207
|
+
}] : HasStates<U> extends true ? Exclude<Extract<U, Ok<unknown>>, StatedMembersOf<U>> extends never ? [] : [problem: {
|
|
208
|
+
readonly __trust: 'mixed stated and stateless successes are not supported';
|
|
209
|
+
}] : [];
|
|
210
|
+
type UsingNoInfer<T> = [T][T extends unknown ? 0 : never];
|
|
211
|
+
/**
|
|
212
|
+
* Acquires a resource, runs `use(resource)`, and always runs `release(resource)` once acquired.
|
|
213
|
+
* Preserves `use`'s `Err` when both `use` and `release` return `Err`, returns `release`'s `Err` when
|
|
214
|
+
* `use` succeeded and `release` returned `Err`, and preserves `StatedOk` states from `use`.
|
|
215
|
+
*
|
|
216
|
+
* Unexpected throws or rejections are never converted into `Result`s (only `Trust.try` / `Trust.tryAsync`
|
|
217
|
+
* catch throws): if both `use` and `release` throw/reject, `use`'s exception propagates with `release`'s
|
|
218
|
+
* exception retained on `suppressed`; if `use` returned `Err` and `release` throws/rejects unexpectedly,
|
|
219
|
+
* `release`'s exception propagates with `use`'s `Err` retained on `primaryResult` / `primaryError`.
|
|
220
|
+
*
|
|
221
|
+
* When `acquire` can fail synchronously while `use` or `release` returns a `Promise`, an early
|
|
222
|
+
* `acquire` failure is returned synchronously (reflected in the return type); use `Trust.usingAsync`
|
|
223
|
+
* when you always want a `Promise`.
|
|
224
|
+
*/
|
|
225
|
+
declare function using<A extends MaybePromise<Result<unknown, unknown>>, U extends MaybePromise<Result<unknown, unknown>>, C extends MaybePromise<Result<unknown, unknown>>>(acquire: () => A, use: (resource: ResourceOf<A>) => U, release: (resource: ResourceOf<A>) => C, ...check: UsingCheck<Awaited<A>, Awaited<U>, Awaited<C>>): UsingOut<A, U, C>;
|
|
226
|
+
declare function using<A extends MaybePromise<Result<unknown, unknown>>, U extends MaybePromise<Result<unknown, unknown>>, C extends MaybePromise<Result<unknown, unknown>>>(acquire: () => A, use: (resource: ResourceOf<A>) => U, release: (resource: ResourceOf<A>) => C, onReleaseError: ((releaseError: UsingNoInfer<RawErrorOf<Awaited<C>>>, useError: UsingNoInfer<RawErrorOf<Awaited<U>>>) => void) | undefined, ...check: UsingCheck<Awaited<A>, Awaited<U>, Awaited<C>>): UsingOut<A, U, C>;
|
|
227
|
+
/** Async form of `Trust.using`: always returns a `Promise`. */
|
|
228
|
+
declare function usingAsync<A extends MaybePromise<Result<unknown, unknown>>, U extends MaybePromise<Result<unknown, unknown>>, C extends MaybePromise<Result<unknown, unknown>>>(acquire: () => A, use: (resource: ResourceOf<A>) => U, release: (resource: ResourceOf<A>) => C, ...check: UsingCheck<Awaited<A>, Awaited<U>, Awaited<C>>): Promise<UsingResult<Awaited<A>, Awaited<U>, Awaited<C>>>;
|
|
229
|
+
declare function usingAsync<A extends MaybePromise<Result<unknown, unknown>>, U extends MaybePromise<Result<unknown, unknown>>, C extends MaybePromise<Result<unknown, unknown>>>(acquire: () => A, use: (resource: ResourceOf<A>) => U, release: (resource: ResourceOf<A>) => C, onReleaseError: ((releaseError: UsingNoInfer<RawErrorOf<Awaited<C>>>, useError: UsingNoInfer<RawErrorOf<Awaited<U>>>) => void) | undefined, ...check: UsingCheck<Awaited<A>, Awaited<U>, Awaited<C>>): Promise<UsingResult<Awaited<A>, Awaited<U>, Awaited<C>>>;
|
|
129
230
|
type Result<T, E> = Ok<T> | Err<E>;
|
|
130
231
|
/** Make a result: `Result.ok(value)`, `Result.err({ kind: 'x', ... })`. */
|
|
131
232
|
declare const Result: {
|
|
132
233
|
readonly ok: typeof ok;
|
|
133
234
|
readonly err: typeof err;
|
|
235
|
+
readonly state: typeof state;
|
|
134
236
|
};
|
|
135
237
|
/**
|
|
136
238
|
* Apply the discipline:
|
|
137
239
|
* `Trust.try` / `Trust.tryAsync` are the only boundary that may catch a throw;
|
|
138
|
-
* `Trust.decide` is the only place a failure may stop; `Trust.translate` the only place it may change kind
|
|
240
|
+
* `Trust.decide` is the only place a failure may stop; `Trust.translate` the only place it may change kind;
|
|
241
|
+
* `Trust.using` / `Trust.usingAsync` acquire, use and always release a Result resource.
|
|
139
242
|
*/
|
|
140
243
|
declare const Trust: {
|
|
141
244
|
readonly try: typeof tryResult;
|
|
142
245
|
readonly tryAsync: typeof tryResultAsync;
|
|
143
246
|
readonly decide: typeof decide;
|
|
144
247
|
readonly translate: typeof translate;
|
|
248
|
+
readonly match: typeof match;
|
|
249
|
+
readonly using: typeof using;
|
|
250
|
+
readonly usingAsync: typeof usingAsync;
|
|
145
251
|
};
|
|
146
252
|
|
|
147
|
-
export { type Err, type Failure, type Ok, Result, Trust, decide, err, ok, translate, tryResult, tryResultAsync };
|
|
253
|
+
export { type Err, type Failure, type Ok, Result, type StatedOk, type StatedResult, Trust, decide, err, match, ok, state, translate, tryResult, tryResultAsync, using, usingAsync };
|
package/dist/index.js
CHANGED
|
@@ -1,9 +1,24 @@
|
|
|
1
1
|
// src/index.ts
|
|
2
|
+
var resultBrand = /* @__PURE__ */ Symbol.for("@noego/trust/result");
|
|
3
|
+
function brand(value) {
|
|
4
|
+
return Object.defineProperty(value, resultBrand, { value: true });
|
|
5
|
+
}
|
|
6
|
+
function isResult(value) {
|
|
7
|
+
return (typeof value === "object" && value !== null || typeof value === "function") && resultBrand in value;
|
|
8
|
+
}
|
|
9
|
+
function state(state2, value) {
|
|
10
|
+
if (arguments.length === 1) return brand({ ok: true, state: state2, value: void 0 });
|
|
11
|
+
if (isResult(value)) {
|
|
12
|
+
if (value.ok === false) return value;
|
|
13
|
+
return brand({ ok: true, state: state2, value: value.value });
|
|
14
|
+
}
|
|
15
|
+
return brand({ ok: true, state: state2, value });
|
|
16
|
+
}
|
|
2
17
|
function ok(value) {
|
|
3
|
-
return { ok: true, value };
|
|
18
|
+
return brand({ ok: true, value });
|
|
4
19
|
}
|
|
5
20
|
function err(error) {
|
|
6
|
-
return { ok: false, error };
|
|
21
|
+
return brand({ ok: false, error });
|
|
7
22
|
}
|
|
8
23
|
function tryResult(fn, onError) {
|
|
9
24
|
try {
|
|
@@ -26,23 +41,250 @@ function pick(table, kind) {
|
|
|
26
41
|
function decide(result, handlers) {
|
|
27
42
|
if (result.ok) return result;
|
|
28
43
|
const handler = pick(handlers, result.error?.kind);
|
|
29
|
-
|
|
44
|
+
if (handler === void 0) return result;
|
|
45
|
+
const value = handler(result.error);
|
|
46
|
+
return isResult(value) ? value : ok(value);
|
|
30
47
|
}
|
|
31
48
|
function translate(result, mappers) {
|
|
32
49
|
if (result.ok) return result;
|
|
33
50
|
const mapper = pick(mappers, result.error?.kind);
|
|
34
51
|
return mapper === void 0 ? result : err(mapper(result.error));
|
|
35
52
|
}
|
|
36
|
-
|
|
37
|
-
|
|
53
|
+
function match(result, handlers) {
|
|
54
|
+
if (!result.ok) return result;
|
|
55
|
+
const handler = pick(handlers, result.state);
|
|
56
|
+
if (handler === void 0) return result;
|
|
57
|
+
const value = handler(result.value);
|
|
58
|
+
return isResult(value) ? value : ok(value);
|
|
59
|
+
}
|
|
60
|
+
function getThen(value) {
|
|
61
|
+
if ((typeof value !== "object" || value === null) && typeof value !== "function") return void 0;
|
|
62
|
+
const then = value.then;
|
|
63
|
+
return typeof then === "function" ? then : void 0;
|
|
64
|
+
}
|
|
65
|
+
function adoptThenable(target, then) {
|
|
66
|
+
return Promise.resolve({
|
|
67
|
+
then(resolve, reject) {
|
|
68
|
+
Reflect.apply(then, target, [resolve, reject]);
|
|
69
|
+
}
|
|
70
|
+
});
|
|
71
|
+
}
|
|
72
|
+
function attachCleanupException(primary, cleanupError) {
|
|
73
|
+
if (primary !== cleanupError && (typeof primary === "object" && primary !== null || typeof primary === "function")) {
|
|
74
|
+
try {
|
|
75
|
+
const existing = "suppressed" in primary ? primary.suppressed : void 0;
|
|
76
|
+
const list = Array.isArray(primary.suppressedErrors) ? [...primary.suppressedErrors, cleanupError] : existing !== void 0 ? [existing, cleanupError] : [cleanupError];
|
|
77
|
+
Object.defineProperty(primary, "suppressed", {
|
|
78
|
+
value: cleanupError,
|
|
79
|
+
configurable: true,
|
|
80
|
+
writable: true
|
|
81
|
+
});
|
|
82
|
+
Object.defineProperty(primary, "suppressedErrors", {
|
|
83
|
+
value: list,
|
|
84
|
+
configurable: true,
|
|
85
|
+
writable: true
|
|
86
|
+
});
|
|
87
|
+
if (!("cause" in primary)) {
|
|
88
|
+
Object.defineProperty(primary, "cause", {
|
|
89
|
+
value: cleanupError,
|
|
90
|
+
configurable: true,
|
|
91
|
+
writable: true
|
|
92
|
+
});
|
|
93
|
+
}
|
|
94
|
+
} catch {
|
|
95
|
+
}
|
|
96
|
+
}
|
|
97
|
+
return primary;
|
|
98
|
+
}
|
|
99
|
+
function attachPrimaryResultToCleanupException(cleanupException, primaryErr) {
|
|
100
|
+
if (typeof cleanupException === "object" && cleanupException !== null || typeof cleanupException === "function") {
|
|
101
|
+
try {
|
|
102
|
+
Object.defineProperty(cleanupException, "primaryResult", {
|
|
103
|
+
value: primaryErr,
|
|
104
|
+
configurable: true,
|
|
105
|
+
writable: true
|
|
106
|
+
});
|
|
107
|
+
Object.defineProperty(cleanupException, "primaryError", {
|
|
108
|
+
value: primaryErr.error,
|
|
109
|
+
configurable: true,
|
|
110
|
+
writable: true
|
|
111
|
+
});
|
|
112
|
+
if (!("cause" in cleanupException)) {
|
|
113
|
+
Object.defineProperty(cleanupException, "cause", {
|
|
114
|
+
value: primaryErr.error,
|
|
115
|
+
configurable: true,
|
|
116
|
+
writable: true
|
|
117
|
+
});
|
|
118
|
+
}
|
|
119
|
+
} catch {
|
|
120
|
+
}
|
|
121
|
+
}
|
|
122
|
+
return cleanupException;
|
|
123
|
+
}
|
|
124
|
+
function rethrowReleaseException(releaseCause, used) {
|
|
125
|
+
throw !used.ok ? attachPrimaryResultToCleanupException(releaseCause, used) : releaseCause;
|
|
126
|
+
}
|
|
127
|
+
function runReleaseErrorHook(onReleaseError, releaseError, useError) {
|
|
128
|
+
try {
|
|
129
|
+
const out = onReleaseError(releaseError, useError);
|
|
130
|
+
const then = getThen(out);
|
|
131
|
+
if (then !== void 0) {
|
|
132
|
+
adoptThenable(out, then).then(void 0, () => {
|
|
133
|
+
});
|
|
134
|
+
}
|
|
135
|
+
} catch {
|
|
136
|
+
}
|
|
137
|
+
}
|
|
138
|
+
function combineUsing(used, released, onReleaseError) {
|
|
139
|
+
if (!used.ok) {
|
|
140
|
+
if (!released.ok && onReleaseError) runReleaseErrorHook(onReleaseError, released.error, used.error);
|
|
141
|
+
return used;
|
|
142
|
+
}
|
|
143
|
+
return released.ok ? used : released;
|
|
144
|
+
}
|
|
145
|
+
async function releaseAfterFailureAsync(resource, release, cause) {
|
|
146
|
+
let released;
|
|
147
|
+
try {
|
|
148
|
+
released = await release(resource);
|
|
149
|
+
} catch (releaseCause) {
|
|
150
|
+
throw attachCleanupException(cause, releaseCause);
|
|
151
|
+
}
|
|
152
|
+
throw !released.ok ? attachCleanupException(cause, released.error) : cause;
|
|
153
|
+
}
|
|
154
|
+
async function finishUsingAsync(resource, usedPromise, release, onReleaseError) {
|
|
155
|
+
let used;
|
|
156
|
+
try {
|
|
157
|
+
used = await usedPromise;
|
|
158
|
+
} catch (cause) {
|
|
159
|
+
return releaseAfterFailureAsync(resource, release, cause);
|
|
160
|
+
}
|
|
161
|
+
let released;
|
|
162
|
+
try {
|
|
163
|
+
released = await release(resource);
|
|
164
|
+
} catch (releaseCause) {
|
|
165
|
+
rethrowReleaseException(releaseCause, used);
|
|
166
|
+
}
|
|
167
|
+
return combineUsing(used, released, onReleaseError);
|
|
168
|
+
}
|
|
169
|
+
async function runUsingAsync(resource, use, release, onReleaseError) {
|
|
170
|
+
let used;
|
|
171
|
+
try {
|
|
172
|
+
used = await use(resource);
|
|
173
|
+
} catch (cause) {
|
|
174
|
+
return releaseAfterFailureAsync(resource, release, cause);
|
|
175
|
+
}
|
|
176
|
+
let released;
|
|
177
|
+
try {
|
|
178
|
+
released = await release(resource);
|
|
179
|
+
} catch (releaseCause) {
|
|
180
|
+
rethrowReleaseException(releaseCause, used);
|
|
181
|
+
}
|
|
182
|
+
return combineUsing(used, released, onReleaseError);
|
|
183
|
+
}
|
|
184
|
+
function using(acquire, use, release, ...rest) {
|
|
185
|
+
const onReleaseError = typeof rest[0] === "function" ? rest[0] : void 0;
|
|
186
|
+
const acquired = acquire();
|
|
187
|
+
let acquiredThen;
|
|
188
|
+
try {
|
|
189
|
+
acquiredThen = getThen(acquired);
|
|
190
|
+
} catch (probeCause) {
|
|
191
|
+
return Promise.reject(probeCause);
|
|
192
|
+
}
|
|
193
|
+
if (acquiredThen !== void 0) {
|
|
194
|
+
return (async () => {
|
|
195
|
+
const resolved = await adoptThenable(acquired, acquiredThen);
|
|
196
|
+
if (!resolved.ok) return resolved;
|
|
197
|
+
return runUsingAsync(resolved.value, use, release, onReleaseError);
|
|
198
|
+
})();
|
|
199
|
+
}
|
|
200
|
+
const syncAcquired = acquired;
|
|
201
|
+
if (!syncAcquired.ok) return syncAcquired;
|
|
202
|
+
const resource = syncAcquired.value;
|
|
203
|
+
let rawUsed;
|
|
204
|
+
try {
|
|
205
|
+
rawUsed = use(resource);
|
|
206
|
+
} catch (cause) {
|
|
207
|
+
let rel;
|
|
208
|
+
try {
|
|
209
|
+
rel = release(resource);
|
|
210
|
+
} catch (releaseCause) {
|
|
211
|
+
throw attachCleanupException(cause, releaseCause);
|
|
212
|
+
}
|
|
213
|
+
let relThen;
|
|
214
|
+
try {
|
|
215
|
+
relThen = getThen(rel);
|
|
216
|
+
} catch (relProbeCause) {
|
|
217
|
+
return Promise.reject(attachCleanupException(cause, relProbeCause));
|
|
218
|
+
}
|
|
219
|
+
if (relThen !== void 0) {
|
|
220
|
+
return (async () => {
|
|
221
|
+
let released;
|
|
222
|
+
try {
|
|
223
|
+
released = await adoptThenable(rel, relThen);
|
|
224
|
+
} catch (releaseCause) {
|
|
225
|
+
throw attachCleanupException(cause, releaseCause);
|
|
226
|
+
}
|
|
227
|
+
throw !released.ok ? attachCleanupException(cause, released.error) : cause;
|
|
228
|
+
})();
|
|
229
|
+
}
|
|
230
|
+
const syncReleased = rel;
|
|
231
|
+
throw !syncReleased.ok ? attachCleanupException(cause, syncReleased.error) : cause;
|
|
232
|
+
}
|
|
233
|
+
let usedThen;
|
|
234
|
+
try {
|
|
235
|
+
usedThen = getThen(rawUsed);
|
|
236
|
+
} catch (probeCause) {
|
|
237
|
+
return releaseAfterFailureAsync(resource, release, probeCause);
|
|
238
|
+
}
|
|
239
|
+
if (usedThen !== void 0) {
|
|
240
|
+
return finishUsingAsync(resource, adoptThenable(rawUsed, usedThen), release, onReleaseError);
|
|
241
|
+
}
|
|
242
|
+
const used = rawUsed;
|
|
243
|
+
let releasedOrPromise;
|
|
244
|
+
try {
|
|
245
|
+
releasedOrPromise = release(resource);
|
|
246
|
+
} catch (releaseCause) {
|
|
247
|
+
rethrowReleaseException(releaseCause, used);
|
|
248
|
+
}
|
|
249
|
+
let releasedThen;
|
|
250
|
+
try {
|
|
251
|
+
releasedThen = getThen(releasedOrPromise);
|
|
252
|
+
} catch (probeCause) {
|
|
253
|
+
return Promise.reject(!used.ok ? attachPrimaryResultToCleanupException(probeCause, used) : probeCause);
|
|
254
|
+
}
|
|
255
|
+
if (releasedThen !== void 0) {
|
|
256
|
+
return (async () => {
|
|
257
|
+
let released;
|
|
258
|
+
try {
|
|
259
|
+
released = await adoptThenable(releasedOrPromise, releasedThen);
|
|
260
|
+
} catch (releaseCause) {
|
|
261
|
+
rethrowReleaseException(releaseCause, used);
|
|
262
|
+
}
|
|
263
|
+
return combineUsing(used, released, onReleaseError);
|
|
264
|
+
})();
|
|
265
|
+
}
|
|
266
|
+
return combineUsing(used, releasedOrPromise, onReleaseError);
|
|
267
|
+
}
|
|
268
|
+
async function usingAsync(acquire, use, release, ...rest) {
|
|
269
|
+
const onReleaseError = typeof rest[0] === "function" ? rest[0] : void 0;
|
|
270
|
+
const acquired = await acquire();
|
|
271
|
+
if (!acquired.ok) return acquired;
|
|
272
|
+
return runUsingAsync(acquired.value, use, release, onReleaseError);
|
|
273
|
+
}
|
|
274
|
+
var Result = { ok, err, state };
|
|
275
|
+
var Trust = { try: tryResult, tryAsync: tryResultAsync, decide, translate, match, using, usingAsync };
|
|
38
276
|
export {
|
|
39
277
|
Result,
|
|
40
278
|
Trust,
|
|
41
279
|
decide,
|
|
42
280
|
err,
|
|
281
|
+
match,
|
|
43
282
|
ok,
|
|
283
|
+
state,
|
|
44
284
|
translate,
|
|
45
285
|
tryResult,
|
|
46
|
-
tryResultAsync
|
|
286
|
+
tryResultAsync,
|
|
287
|
+
using,
|
|
288
|
+
usingAsync
|
|
47
289
|
};
|
|
48
290
|
//# sourceMappingURL=index.js.map
|
package/dist/index.js.map
CHANGED
|
@@ -1 +1 @@
|
|
|
1
|
-
{"version":3,"sources":["../src/index.ts"],"sourcesContent":["/**\n * Closed result primitive: expected failures are values, not exceptions.\n *\n * `Result<T, E>` is `Ok<T> | Err<E>`, discriminated by `ok`. This module has no\n * imports so it is safe in any bundle (Node, Electron main, renderer, browser).\n *\n * Public surface is two namespaces:\n *\n * Result.ok / Result.err — make a result\n * Trust.try / Trust.tryAsync — the only boundary that may catch a throw\n * Trust.decide / Trust.translate — the only places a failure may stop or change\n *\n * The underlying functions are exported as well because the `@noego/trust/eslint`\n * rules recognise calls by their declaration (not by name): `Trust.try(...)` resolves\n * to `tryResult`, `Result.err(...)` to `err`. Write the namespace form in application code.\n */\nexport type Ok<T> = { readonly ok: true; readonly value: T };\nexport type Err<E> = { readonly ok: false; readonly error: E };\nexport type Result<T, E> = Ok<T> | Err<E>;\n\n/** A failure is an object with a literal `kind` plus any fields. */\nexport type Failure<K extends string = string, Fields extends object = {}> = { readonly kind: K } & Readonly<Fields>;\n\n/** Wraps a success value. */\nexport function ok<T>(value: T): Ok<T> {\n return { ok: true, value };\n}\n\n/**\n * Wraps a failure value. Pass a typed error, not a raw caught value.\n *\n * The first overload keeps a literal `kind` for inline failures (`err({ kind: 'X' })`\n * gives `Err<{ kind: 'X' }>`) through the `K` hint in the intersection, so no `as const`\n * is needed. `E` itself is still a plain type parameter, so a declared `Result` return\n * type sets it and other literal fields keep their declared union types. The second\n * overload covers arguments that cannot meet the intersection (generic, unknown, null).\n */\nexport function err<E, K extends string = string>(error: E & { readonly kind?: K }): Err<E>;\nexport function err<E>(error: E): Err<E>;\nexport function err<E>(error: E): Err<E> {\n return { ok: false, error };\n}\n\n/**\n * Runs `fn` and converts anything it throws into `Err` via `onError`.\n * Calls made directly inside `fn` count as guarded for the trust lint rules.\n */\nexport function tryResult<T, E, K extends string = string>(\n fn: () => T,\n onError: (cause: unknown) => E & { readonly kind?: K },\n): Result<T, E>;\nexport function tryResult<T, E>(fn: () => T, onError: (cause: unknown) => E): Result<T, E>;\nexport function tryResult<T, E>(fn: () => T, onError: (cause: unknown) => E): Result<T, E> {\n try {\n return ok(fn());\n } catch (cause) {\n return err(onError(cause));\n }\n}\n\n/**\n * Awaits `fn` and converts a throw or rejection into `Err` via `onError`.\n * Calls made directly inside `fn` count as guarded for the trust lint rules.\n */\nexport function tryResultAsync<T, E, K extends string = string>(\n fn: () => T | PromiseLike<T>,\n onError: (cause: unknown) => E & { readonly kind?: K },\n): Promise<Result<T, E>>;\nexport function tryResultAsync<T, E>(\n fn: () => T | PromiseLike<T>,\n onError: (cause: unknown) => E,\n): Promise<Result<T, E>>;\nexport async function tryResultAsync<T, E>(\n fn: () => T | PromiseLike<T>,\n onError: (cause: unknown) => E,\n): Promise<Result<T, E>> {\n try {\n return ok(await fn());\n } catch (cause) {\n return err(onError(cause));\n }\n}\n\ntype IsUnion<T, U = T> = T extends unknown ? ([U] extends [T] ? false : true) : never;\n/**\n * One failure per kind. A single declared failure whose `kind` is a union\n * (`{ kind: 'a' | 'b'; op: string }`) is split into `{...; kind: 'a'} | {...; kind: 'b'}`\n * so that handlers narrow to one kind each; failures that already have one\n * literal kind are left as they are.\n */\ntype SplitByKind<E> = E extends { readonly kind: infer K extends string }\n ? IsUnion<K> extends true\n ? K extends unknown\n ? E & { readonly kind: K }\n : never\n : E\n : never;\n\ntype KindsOf<E> = E extends { readonly kind: infer K extends string } ? K : never;\ntype ErrorOf<R> = R extends Err<infer E> ? SplitByKind<E> : never;\ntype OkOf<R> = R extends Ok<infer T> ? T : never;\ntype CannotFail = { readonly __trust: 'decide needs a result that can fail (it has no Err member)' };\ntype BadFailure = { readonly __trust: 'every failure needs a string `kind` (string and Error are not failures)' };\ntype NeedsLiteralKind = { readonly __trust: 'a translate mapper must return an object with a literal string kind' };\n\ntype RawErrorOf<R> = R extends Err<infer E> ? E : never;\ntype FailureGuard<R> = [RawErrorOf<R>] extends [never]\n ? CannotFail\n : [RawErrorOf<R>] extends [{ readonly kind: string }]\n ? unknown\n : BadFailure;\n\ntype HandlerBase<E, H> = { [K in keyof H]: K extends KindsOf<E> ? {} | null : never };\ntype HandlerFns<E, H> = {\n [K in keyof H]-?: (failure: Extract<E, { readonly kind: K }>) => H[K];\n};\ntype LiteralKind = '' | (string & {});\ntype MapperBase<E, M> = { [K in keyof M]: K extends KindsOf<E> ? { readonly kind: LiteralKind } : never };\ntype MapperFns<E, M> = {\n [K in keyof M]-?: (failure: Extract<E, { readonly kind: K }>) => M[K];\n};\ntype KindCheck<M> = [\n { [K in keyof M]-?: M[K] extends { readonly kind: infer Kd } ? (string extends Kd ? 1 : never) : 1 }[keyof M],\n] extends [never]\n ? []\n : [problem: NeedsLiteralKind];\n\ntype Remaining<E, H> = Exclude<E, { readonly kind: keyof H & string }>;\ntype Decided<R, H> = [Remaining<ErrorOf<R>, H>] extends [never]\n ? Ok<OkOf<R> | H[keyof H]>\n : Ok<OkOf<R> | H[keyof H]> | Err<Remaining<ErrorOf<R>, H>>;\ntype Translated<R, M> = Ok<OkOf<R>> | Err<M[keyof M] | Remaining<ErrorOf<R>, M>>;\n\nfunction pick(table: object, kind: unknown): ((failure: unknown) => unknown) | undefined {\n if (typeof kind !== 'string' || !Object.prototype.hasOwnProperty.call(table, kind)) return undefined;\n return (table as Record<string, (failure: unknown) => unknown>)[kind];\n}\n\n/**\n * The only place a failure may stop: a failure whose kind has a handler becomes\n * `ok(handler(failure))`; anything else is returned untouched. Handlers are synchronous\n * and must return a value (never `undefined`/`void`).\n */\nexport function decide<R extends Result<unknown, unknown>, H extends HandlerBase<ErrorOf<R>, H>>(\n result: R & FailureGuard<R>,\n handlers: HandlerFns<ErrorOf<R>, H>,\n): Decided<R, H>;\nexport function decide(result: Result<unknown, unknown>, handlers: object): unknown {\n if (result.ok) return result;\n const handler = pick(handlers, (result.error as { kind?: unknown } | null)?.kind);\n return handler === undefined ? result : ok(handler(result.error));\n}\n\n/** Turns failures into different failures; unmapped failures and successes pass through untouched. */\nexport function translate<R extends Result<unknown, unknown>, M extends MapperBase<ErrorOf<R>, M>>(\n result: R & FailureGuard<R>,\n mappers: MapperFns<ErrorOf<R>, M>,\n ...check: KindCheck<M>\n): Translated<R, M>;\nexport function translate(result: Result<unknown, unknown>, mappers: object): unknown {\n if (result.ok) return result;\n const mapper = pick(mappers, (result.error as { kind?: unknown } | null)?.kind);\n return mapper === undefined ? result : err(mapper(result.error));\n}\n\n/** Make a result: `Result.ok(value)`, `Result.err({ kind: 'x', ... })`. */\nexport const Result: {\n readonly ok: typeof ok;\n readonly err: typeof err;\n} = { ok, err };\n\n/**\n * Apply the discipline:\n * `Trust.try` / `Trust.tryAsync` are the only boundary that may catch a throw;\n * `Trust.decide` is the only place a failure may stop; `Trust.translate` the only place it may change kind.\n */\nexport const Trust: {\n readonly try: typeof tryResult;\n readonly tryAsync: typeof tryResultAsync;\n readonly decide: typeof decide;\n readonly translate: typeof translate;\n} = { try: tryResult, tryAsync: tryResultAsync, decide, translate };\n"],"mappings":";AAwBO,SAAS,GAAM,OAAiB;AACrC,SAAO,EAAE,IAAI,MAAM,MAAM;AAC3B;AAaO,SAAS,IAAO,OAAkB;AACvC,SAAO,EAAE,IAAI,OAAO,MAAM;AAC5B;AAWO,SAAS,UAAgB,IAAa,SAA8C;AACzF,MAAI;AACF,WAAO,GAAG,GAAG,CAAC;AAAA,EAChB,SAAS,OAAO;AACd,WAAO,IAAI,QAAQ,KAAK,CAAC;AAAA,EAC3B;AACF;AAcA,eAAsB,eACpB,IACA,SACuB;AACvB,MAAI;AACF,WAAO,GAAG,MAAM,GAAG,CAAC;AAAA,EACtB,SAAS,OAAO;AACd,WAAO,IAAI,QAAQ,KAAK,CAAC;AAAA,EAC3B;AACF;AAoDA,SAAS,KAAK,OAAe,MAA4D;AACvF,MAAI,OAAO,SAAS,YAAY,CAAC,OAAO,UAAU,eAAe,KAAK,OAAO,IAAI,EAAG,QAAO;AAC3F,SAAQ,MAAwD,IAAI;AACtE;AAWO,SAAS,OAAO,QAAkC,UAA2B;AAClF,MAAI,OAAO,GAAI,QAAO;AACtB,QAAM,UAAU,KAAK,UAAW,OAAO,OAAqC,IAAI;AAChF,SAAO,YAAY,SAAY,SAAS,GAAG,QAAQ,OAAO,KAAK,CAAC;AAClE;AAQO,SAAS,UAAU,QAAkC,SAA0B;AACpF,MAAI,OAAO,GAAI,QAAO;AACtB,QAAM,SAAS,KAAK,SAAU,OAAO,OAAqC,IAAI;AAC9E,SAAO,WAAW,SAAY,SAAS,IAAI,OAAO,OAAO,KAAK,CAAC;AACjE;AAGO,IAAM,SAGT,EAAE,IAAI,IAAI;AAOP,IAAM,QAKT,EAAE,KAAK,WAAW,UAAU,gBAAgB,QAAQ,UAAU;","names":[]}
|
|
1
|
+
{"version":3,"sources":["../src/index.ts"],"sourcesContent":["/**\n * Closed result primitive: expected failures are values, not exceptions.\n *\n * `Result<T, E>` is `Ok<T> | Err<E>`, discriminated by `ok`. This module has no\n * imports so it is safe in any bundle (Node, Electron main, renderer, browser).\n *\n * Public surface is two namespaces:\n *\n * Result.ok / Result.err — make a result\n * Trust.try / Trust.tryAsync — the only boundary that may catch a throw\n * Trust.decide / Trust.translate — the only places a failure may stop or change\n * Trust.using / Trust.usingAsync — acquire, use and always release a Result resource\n *\n * The underlying functions are exported as well because the `@noego/trust/eslint`\n * rules recognise calls by their declaration (not by name): `Trust.try(...)` resolves\n * to `tryResult`, `Result.err(...)` to `err`. Write the namespace form in application code.\n */\nexport type Ok<T> = { readonly ok: true; readonly value: T };\nexport type Err<E> = { readonly ok: false; readonly error: E };\nexport type Result<T, E> = Ok<T> | Err<E>;\n\nexport type StatedOk<T, S extends string> = { [K in S]: { readonly ok: true; readonly state: K; readonly value: T } }[S];\nexport type StatedResult<T, E, S extends string> = StatedOk<T, S> | Err<E>;\n\ntype LiteralState<S extends string> = string extends S ? never : S;\ntype Stateless<R> = Extract<R, { readonly state: unknown }> extends never ? R : never;\ntype NotResult<T> = unknown extends T ? never : Extract<T, Ok<unknown> | Err<unknown>> extends never ? T : never;\n\nconst resultBrand = Symbol.for('@noego/trust/result');\nfunction brand<T extends object>(value: T): T {\n return Object.defineProperty(value, resultBrand, { value: true });\n}\nfunction isResult(value: unknown): value is Result<unknown, unknown> {\n return ((typeof value === 'object' && value !== null) || typeof value === 'function')\n && resultBrand in value;\n}\n\nexport function state<const S extends string>(state: LiteralState<S>): StatedOk<void, S>;\nexport function state<const S extends string, R extends Result<unknown, unknown>>(\n state: LiteralState<S>, result: R & Stateless<R> & (0 extends (1 & R) ? never : unknown),\n): StatedOk<OkOf<R>, S> | Extract<R, { readonly ok: false }>;\nexport function state<const S extends string, T>(\n state: LiteralState<S>, value: T,\n ...check: [T] extends [NotResult<T>] ? unknown extends T ? [problem: never] : [] : [problem: never]\n): StatedOk<T, S>;\nexport function state(state: string, value?: unknown): Result<unknown, unknown> {\n if (arguments.length === 1) return brand({ ok: true, state, value: undefined });\n if (isResult(value)) {\n if (value.ok === false) return value;\n return brand({ ok: true, state, value: value.value });\n }\n return brand({ ok: true, state, value });\n}\n\n/** A failure is an object with a literal `kind` plus any fields. */\nexport type Failure<K extends string = string, Fields extends object = {}> = { readonly kind: K } & Readonly<Fields>;\n\n/** Wraps a success value. */\nexport function ok<T>(value: T): Ok<T> {\n return brand({ ok: true, value });\n}\n\n/**\n * Wraps a failure value. Pass a typed error, not a raw caught value.\n *\n * The first overload keeps a literal `kind` for inline failures (`err({ kind: 'X' })`\n * gives `Err<{ kind: 'X' }>`) through the `K` hint in the intersection, so no `as const`\n * is needed. `E` itself is still a plain type parameter, so a declared `Result` return\n * type sets it and other literal fields keep their declared union types. The second\n * overload covers arguments that cannot meet the intersection (generic, unknown, null).\n */\nexport function err<E, K extends string = string>(error: E & { readonly kind?: K }): Err<E>;\nexport function err<E>(error: E): Err<E>;\nexport function err<E>(error: E): Err<E> {\n return brand({ ok: false, error });\n}\n\n/**\n * Runs `fn` and converts anything it throws into `Err` via `onError`.\n * Calls made directly inside `fn` count as guarded for the trust lint rules.\n */\nexport function tryResult<T, E, K extends string = string>(\n fn: () => T,\n onError: (cause: unknown) => E & { readonly kind?: K },\n): Result<T, E>;\nexport function tryResult<T, E>(fn: () => T, onError: (cause: unknown) => E): Result<T, E>;\nexport function tryResult<T, E>(fn: () => T, onError: (cause: unknown) => E): Result<T, E> {\n try {\n return ok(fn());\n } catch (cause) {\n return err(onError(cause));\n }\n}\n\n/**\n * Awaits `fn` and converts a throw or rejection into `Err` via `onError`.\n * Calls made directly inside `fn` count as guarded for the trust lint rules.\n */\nexport function tryResultAsync<T, E, K extends string = string>(\n fn: () => T | PromiseLike<T>,\n onError: (cause: unknown) => E & { readonly kind?: K },\n): Promise<Result<T, E>>;\nexport function tryResultAsync<T, E>(\n fn: () => T | PromiseLike<T>,\n onError: (cause: unknown) => E,\n): Promise<Result<T, E>>;\nexport async function tryResultAsync<T, E>(\n fn: () => T | PromiseLike<T>,\n onError: (cause: unknown) => E,\n): Promise<Result<T, E>> {\n try {\n return ok(await fn());\n } catch (cause) {\n return err(onError(cause));\n }\n}\n\ntype IsUnion<T, U = T> = T extends unknown ? ([U] extends [T] ? false : true) : never;\n/**\n * One failure per kind. A single declared failure whose `kind` is a union\n * (`{ kind: 'a' | 'b'; op: string }`) is split into `{...; kind: 'a'} | {...; kind: 'b'}`\n * so that handlers narrow to one kind each; failures that already have one\n * literal kind are left as they are.\n */\ntype SplitByKind<E> = E extends { readonly kind: infer K extends string }\n ? IsUnion<K> extends true\n ? K extends unknown\n ? E & { readonly kind: K }\n : never\n : E\n : never;\n\ntype KindsOf<E> = E extends { readonly kind: infer K extends string } ? K : never;\ntype ErrorOf<R> = R extends Err<infer E> ? SplitByKind<E> : never;\ntype OkOf<R> = R extends Ok<infer T> ? T : never;\ntype CannotFail = { readonly __trust: 'decide needs a result that can fail (it has no Err member)' };\ntype BadFailure = { readonly __trust: 'every failure needs a string `kind` (string and Error are not failures)' };\ntype NeedsLiteralKind = { readonly __trust: 'a translate mapper must return an object with a literal string kind' };\n\ntype RawErrorOf<R> = R extends Err<infer E> ? E : never;\ntype FailureGuard<R> = [RawErrorOf<R>] extends [never]\n ? CannotFail\n : [RawErrorOf<R>] extends [{ readonly kind: string }]\n ? unknown\n : BadFailure;\n\ntype HandlerBase<E, H> = { [K in keyof H]: K extends KindsOf<E> ? {} | null : never };\ntype HandlerFns<E, H> = {\n [K in keyof H]-?: (failure: Extract<E, { readonly kind: K }>) => H[K];\n};\ntype LiteralKind = '' | (string & {});\ntype MapperBase<E, M> = { [K in keyof M]: K extends KindsOf<E> ? { readonly kind: LiteralKind } : never };\ntype MapperFns<E, M> = {\n [K in keyof M]-?: (failure: Extract<E, { readonly kind: K }>) => M[K];\n};\ntype KindCheck<M> = [\n { [K in keyof M]-?: M[K] extends { readonly kind: infer Kd } ? (string extends Kd ? 1 : never) : 1 }[keyof M],\n] extends [never]\n ? []\n : [problem: NeedsLiteralKind];\n\ntype Remaining<E, H> = Exclude<E, { readonly kind: keyof H & string }>;\ntype StatedMembersOf<R> = Extract<R, { readonly ok: true; readonly state: string }>;\ntype HasStates<R> = [StatedMembersOf<R>] extends [never] ? false : true;\ntype StateGuard<R> = HasStates<R> extends true\n ? Exclude<Extract<R, Ok<unknown>>, StatedMembersOf<R>> extends never ? unknown\n : { readonly __trust: 'mixed stated and stateless successes are not supported' }\n : unknown;\ntype SuccessOf<R, H> = HasStates<R> extends true ? StatedMembersOf<R> | H[keyof H] : Ok<OkOf<R> | H[keyof H]>;\ntype RecoveryCheck<R, H> = {\n [K in keyof H]: HasStates<R> extends true\n ? H[K] extends StatedOk<unknown, infer S extends string> ? string extends S ? 1 : never : 1\n : Extract<H[K], { readonly state: unknown }> extends never ? never : 1\n}[keyof H] extends never ? [] : [problem: { readonly __trust: 'recovery must preserve the success state discipline' }];\ntype Decided<R, H> = [Remaining<ErrorOf<R>, H>] extends [never]\n ? SuccessOf<R, H>\n : SuccessOf<R, H> | Err<Remaining<ErrorOf<R>, H>>;\ntype Translated<R, M> = (HasStates<R> extends true ? StatedMembersOf<R> : Ok<OkOf<R>>) | Err<M[keyof M] | Remaining<ErrorOf<R>, M>>;\n\nfunction pick(table: object, kind: unknown): ((failure: unknown) => unknown) | undefined {\n if (typeof kind !== 'string' || !Object.prototype.hasOwnProperty.call(table, kind)) return undefined;\n return (table as Record<string, (failure: unknown) => unknown>)[kind];\n}\n\n/**\n * The only place a failure may stop: a failure whose kind has a handler becomes\n * `ok(handler(failure))`; anything else is returned untouched. Handlers are synchronous\n * and must return a value (never `undefined`/`void`).\n */\nexport function decide<R extends Result<unknown, unknown>, H extends HandlerBase<ErrorOf<R>, H>>(\n result: R & FailureGuard<R> & StateGuard<R>,\n handlers: HandlerFns<ErrorOf<R>, H>,\n ...check: RecoveryCheck<R, H>\n): Decided<R, H>;\nexport function decide(result: Result<unknown, unknown>, handlers: object): unknown {\n if (result.ok) return result;\n const handler = pick(handlers, (result.error as { kind?: unknown } | null)?.kind);\n if (handler === undefined) return result;\n const value = handler(result.error);\n return isResult(value) ? value : ok(value);\n}\n\n/** Turns failures into different failures; unmapped failures and successes pass through untouched. */\nexport function translate<R extends Result<unknown, unknown>, M extends MapperBase<ErrorOf<R>, M>>(\n result: R & FailureGuard<R> & StateGuard<R>,\n mappers: MapperFns<ErrorOf<R>, M>,\n ...check: KindCheck<M>\n): Translated<R, M>;\nexport function translate(result: Result<unknown, unknown>, mappers: object): unknown {\n if (result.ok) return result;\n const mapper = pick(mappers, (result.error as { kind?: unknown } | null)?.kind);\n return mapper === undefined ? result : err(mapper(result.error));\n}\n\ntype MatchGuard<R> = [RawErrorOf<R>] extends [never]\n ? HasStates<R> extends true ? StateGuard<R> : { readonly __trust: 'match needs stated successes' }\n : { readonly __trust: 'match requires all failures to be handled first' };\ntype StatesOf<R> = StatedMembersOf<R>['state'];\ntype MatchFns<R, H> = {\n [K in keyof H]-?: (value: OkOf<Extract<R, { readonly state: K }>>) => H[K];\n};\ntype MatchBase<R, H> = { [K in StatesOf<R>]: {} | null } & {\n [K in keyof H]: K extends StatesOf<R> ? {} | null : never;\n};\ntype Matched<H> = [H[keyof H]] extends [StatedOk<unknown, string>] ? H[keyof H] : Ok<H[keyof H]>;\ntype MatchCheck<H> = [Extract<H[keyof H], { readonly state: unknown }>] extends [never]\n ? [] : [H[keyof H]] extends [StatedOk<unknown, infer S extends string>]\n ? string extends S ? [problem: { readonly __trust: 'match needs literal output states' }] : []\n : [problem: { readonly __trust: 'match cannot mix stated and bare returns' }];\n\nexport function match<R extends Result<unknown, unknown>, H extends MatchBase<R, H>>(\n result: R & MatchGuard<R>, handlers: MatchFns<R, H>, ...check: MatchCheck<H>\n): Matched<H>;\nexport function match(result: Result<unknown, unknown>, handlers: object): unknown {\n if (!result.ok) return result;\n const handler = pick(handlers, (result as { state?: unknown }).state);\n if (handler === undefined) return result;\n const value = handler(result.value);\n return isResult(value) ? value : ok(value);\n}\n\ntype MaybePromise<T> = T | PromiseLike<T>;\ntype ResourceOf<A> = OkOf<Awaited<A>>;\ntype SyncOf<T> = Exclude<T, PromiseLike<unknown>>;\ntype AsyncOf<T> = Extract<T, PromiseLike<unknown>>;\ntype HasType<T> = [T] extends [never] ? false : true;\ntype HasOk<R> = [Extract<R, Ok<unknown>>] extends [never] ? false : true;\ntype ErrUnion<E> = [E] extends [never] ? never : Err<E>;\ntype UsingSuccess<U> = HasOk<U> extends false\n ? never\n : HasStates<U> extends true\n ? StatedMembersOf<U>\n : Ok<OkOf<U>>;\ntype UsingResult<A, U, C> = HasOk<A> extends false\n ? ErrUnion<RawErrorOf<A>>\n : HasOk<U> extends false\n ? ErrUnion<RawErrorOf<A> | RawErrorOf<U>>\n : HasOk<C> extends false\n ? ErrUnion<RawErrorOf<A> | RawErrorOf<U> | RawErrorOf<C>>\n : UsingSuccess<U> | ErrUnion<RawErrorOf<A> | RawErrorOf<U> | RawErrorOf<C>>;\ntype SyncAcquireOk<A> = Extract<SyncOf<A>, Ok<unknown>>;\ntype SyncAcquireErr<A> = ErrUnion<RawErrorOf<SyncOf<A>>>;\ntype UsingSyncOut<A, U, C> = HasType<SyncAcquireOk<A>> extends true\n ? HasType<SyncOf<U>> extends true\n ? HasType<SyncOf<C>> extends true\n ? UsingResult<SyncOf<A>, SyncOf<U>, SyncOf<C>>\n : SyncAcquireErr<A>\n : SyncAcquireErr<A>\n : SyncAcquireErr<A>;\ntype UsingAsyncOut<A, U, C> = HasType<AsyncOf<A>> extends true\n ? Promise<UsingResult<Awaited<A>, Awaited<U>, Awaited<C>>>\n : HasType<SyncAcquireOk<A>> extends true\n ? HasType<AsyncOf<U> | AsyncOf<C>> extends true\n ? Promise<UsingResult<Awaited<A>, Awaited<U>, Awaited<C>>>\n : never\n : never;\ntype UsingOut<A, U, C> = HasType<AsyncOf<A | U | C>> extends false\n ? UsingResult<A, U, C>\n : UsingSyncOut<A, U, C> | UsingAsyncOut<A, U, C>;\ntype UsingCheck<A, U, C> = HasStates<A> extends true\n ? [problem: { readonly __trust: 'acquire must return a stateless Result' }]\n : HasStates<C> extends true\n ? [problem: { readonly __trust: 'release must return a stateless Result' }]\n : HasStates<U> extends true\n ? Exclude<Extract<U, Ok<unknown>>, StatedMembersOf<U>> extends never\n ? []\n : [problem: { readonly __trust: 'mixed stated and stateless successes are not supported' }]\n : [];\n\n// Deferred conditional blocks hook inference on all supported TypeScript 5.x versions.\ntype UsingNoInfer<T> = [T][T extends unknown ? 0 : never];\n\ntype ThenFn = (\n onfulfilled?: (value: never) => unknown,\n onrejected?: (reason: unknown) => unknown,\n) => unknown;\n\nfunction getThen(value: unknown): ThenFn | undefined {\n if ((typeof value !== 'object' || value === null) && typeof value !== 'function') return undefined;\n const then = (value as { then?: unknown }).then;\n return typeof then === 'function' ? (then as ThenFn) : undefined;\n}\n\nfunction adoptThenable<T>(target: unknown, then: ThenFn): Promise<T> {\n return Promise.resolve<T>({\n then(resolve, reject) {\n Reflect.apply(then, target, [resolve, reject]);\n },\n } as PromiseLike<T>);\n}\n\nfunction attachCleanupException(primary: unknown, cleanupError: unknown): unknown {\n if (\n primary !== cleanupError\n && ((typeof primary === 'object' && primary !== null) || typeof primary === 'function')\n ) {\n try {\n const existing = 'suppressed' in primary ? (primary as { suppressed?: unknown }).suppressed : undefined;\n const list = Array.isArray((primary as { suppressedErrors?: unknown }).suppressedErrors)\n ? [...((primary as { suppressedErrors: unknown[] }).suppressedErrors), cleanupError]\n : existing !== undefined\n ? [existing, cleanupError]\n : [cleanupError];\n Object.defineProperty(primary, 'suppressed', {\n value: cleanupError,\n configurable: true,\n writable: true,\n });\n Object.defineProperty(primary, 'suppressedErrors', {\n value: list,\n configurable: true,\n writable: true,\n });\n if (!('cause' in primary)) {\n Object.defineProperty(primary, 'cause', {\n value: cleanupError,\n configurable: true,\n writable: true,\n });\n }\n } catch {\n // Ignore non-extensible primary values; still preserve `primary`.\n }\n }\n return primary;\n}\n\nfunction attachPrimaryResultToCleanupException(cleanupException: unknown, primaryErr: Err<unknown>): unknown {\n if ((typeof cleanupException === 'object' && cleanupException !== null) || typeof cleanupException === 'function') {\n try {\n Object.defineProperty(cleanupException, 'primaryResult', {\n value: primaryErr,\n configurable: true,\n writable: true,\n });\n Object.defineProperty(cleanupException, 'primaryError', {\n value: primaryErr.error,\n configurable: true,\n writable: true,\n });\n if (!('cause' in cleanupException)) {\n Object.defineProperty(cleanupException, 'cause', {\n value: primaryErr.error,\n configurable: true,\n writable: true,\n });\n }\n } catch {\n // Ignore non-extensible cleanup exceptions; still propagate the unexpected throw.\n }\n }\n return cleanupException;\n}\n\nfunction rethrowReleaseException(releaseCause: unknown, used: Result<unknown, unknown>): never {\n throw !used.ok ? attachPrimaryResultToCleanupException(releaseCause, used) : releaseCause;\n}\n\nfunction runReleaseErrorHook(\n onReleaseError: (releaseError: never, useError: never) => void,\n releaseError: unknown,\n useError: unknown,\n): void {\n try {\n const out: unknown = onReleaseError(releaseError as never, useError as never);\n const then = getThen(out);\n if (then !== undefined) {\n adoptThenable(out, then).then(undefined, () => {});\n }\n } catch {\n // Isolate reporting-hook failures so the primary `use` Err is preserved.\n }\n}\n\nfunction combineUsing(\n used: Result<unknown, unknown>,\n released: Result<unknown, unknown>,\n onReleaseError?: (releaseError: never, useError: never) => void,\n): Result<unknown, unknown> {\n if (!used.ok) {\n if (!released.ok && onReleaseError) runReleaseErrorHook(onReleaseError, released.error, used.error);\n return used;\n }\n return released.ok ? used : released;\n}\n\nasync function releaseAfterFailureAsync(\n resource: never,\n release: (resource: never) => Result<unknown, unknown> | PromiseLike<Result<unknown, unknown>>,\n cause: unknown,\n): Promise<never> {\n let released: Result<unknown, unknown>;\n try {\n released = await release(resource);\n } catch (releaseCause) {\n throw attachCleanupException(cause, releaseCause);\n }\n throw !released.ok ? attachCleanupException(cause, released.error) : cause;\n}\n\nasync function finishUsingAsync(\n resource: never,\n usedPromise: Promise<Result<unknown, unknown>>,\n release: (resource: never) => Result<unknown, unknown> | PromiseLike<Result<unknown, unknown>>,\n onReleaseError?: (releaseError: never, useError: never) => void,\n): Promise<Result<unknown, unknown>> {\n let used: Result<unknown, unknown>;\n try {\n used = await usedPromise;\n } catch (cause) {\n return releaseAfterFailureAsync(resource, release, cause);\n }\n let released: Result<unknown, unknown>;\n try {\n released = await release(resource);\n } catch (releaseCause) {\n rethrowReleaseException(releaseCause, used);\n }\n return combineUsing(used, released, onReleaseError);\n}\n\nasync function runUsingAsync(\n resource: unknown,\n use: (resource: never) => Result<unknown, unknown> | PromiseLike<Result<unknown, unknown>>,\n release: (resource: never) => Result<unknown, unknown> | PromiseLike<Result<unknown, unknown>>,\n onReleaseError?: (releaseError: never, useError: never) => void,\n): Promise<Result<unknown, unknown>> {\n let used: Result<unknown, unknown>;\n try {\n used = await use(resource as never);\n } catch (cause) {\n return releaseAfterFailureAsync(resource as never, release, cause);\n }\n let released: Result<unknown, unknown>;\n try {\n released = await release(resource as never);\n } catch (releaseCause) {\n rethrowReleaseException(releaseCause, used);\n }\n return combineUsing(used, released, onReleaseError);\n}\n\n/**\n * Acquires a resource, runs `use(resource)`, and always runs `release(resource)` once acquired.\n * Preserves `use`'s `Err` when both `use` and `release` return `Err`, returns `release`'s `Err` when\n * `use` succeeded and `release` returned `Err`, and preserves `StatedOk` states from `use`.\n *\n * Unexpected throws or rejections are never converted into `Result`s (only `Trust.try` / `Trust.tryAsync`\n * catch throws): if both `use` and `release` throw/reject, `use`'s exception propagates with `release`'s\n * exception retained on `suppressed`; if `use` returned `Err` and `release` throws/rejects unexpectedly,\n * `release`'s exception propagates with `use`'s `Err` retained on `primaryResult` / `primaryError`.\n *\n * When `acquire` can fail synchronously while `use` or `release` returns a `Promise`, an early\n * `acquire` failure is returned synchronously (reflected in the return type); use `Trust.usingAsync`\n * when you always want a `Promise`.\n */\nexport function using<\n A extends MaybePromise<Result<unknown, unknown>>,\n U extends MaybePromise<Result<unknown, unknown>>,\n C extends MaybePromise<Result<unknown, unknown>>,\n>(\n acquire: () => A,\n use: (resource: ResourceOf<A>) => U,\n release: (resource: ResourceOf<A>) => C,\n ...check: UsingCheck<Awaited<A>, Awaited<U>, Awaited<C>>\n): UsingOut<A, U, C>;\nexport function using<\n A extends MaybePromise<Result<unknown, unknown>>,\n U extends MaybePromise<Result<unknown, unknown>>,\n C extends MaybePromise<Result<unknown, unknown>>,\n>(\n acquire: () => A,\n use: (resource: ResourceOf<A>) => U,\n release: (resource: ResourceOf<A>) => C,\n onReleaseError: ((releaseError: UsingNoInfer<RawErrorOf<Awaited<C>>>, useError: UsingNoInfer<RawErrorOf<Awaited<U>>>) => void) | undefined,\n ...check: UsingCheck<Awaited<A>, Awaited<U>, Awaited<C>>\n): UsingOut<A, U, C>;\nexport function using(\n acquire: () => Result<unknown, unknown> | PromiseLike<Result<unknown, unknown>>,\n use: (resource: never) => Result<unknown, unknown> | PromiseLike<Result<unknown, unknown>>,\n release: (resource: never) => Result<unknown, unknown> | PromiseLike<Result<unknown, unknown>>,\n ...rest: unknown[]\n): unknown {\n const onReleaseError = typeof rest[0] === 'function' ? (rest[0] as (releaseError: never, useError: never) => void) : undefined;\n const acquired = acquire();\n let acquiredThen: ThenFn | undefined;\n try {\n acquiredThen = getThen(acquired);\n } catch (probeCause) {\n return Promise.reject(probeCause);\n }\n if (acquiredThen !== undefined) {\n return (async () => {\n const resolved = await adoptThenable<Result<unknown, unknown>>(acquired, acquiredThen);\n if (!resolved.ok) return resolved;\n return runUsingAsync(resolved.value, use, release, onReleaseError);\n })();\n }\n const syncAcquired = acquired as Result<unknown, unknown>;\n if (!syncAcquired.ok) return syncAcquired;\n const resource = syncAcquired.value as never;\n let rawUsed: Result<unknown, unknown> | PromiseLike<Result<unknown, unknown>>;\n try {\n rawUsed = use(resource);\n } catch (cause) {\n let rel: Result<unknown, unknown> | PromiseLike<Result<unknown, unknown>>;\n try {\n rel = release(resource);\n } catch (releaseCause) {\n throw attachCleanupException(cause, releaseCause);\n }\n let relThen: ThenFn | undefined;\n try {\n relThen = getThen(rel);\n } catch (relProbeCause) {\n return Promise.reject(attachCleanupException(cause, relProbeCause));\n }\n if (relThen !== undefined) {\n return (async () => {\n let released: Result<unknown, unknown>;\n try {\n released = await adoptThenable<Result<unknown, unknown>>(rel, relThen);\n } catch (releaseCause) {\n throw attachCleanupException(cause, releaseCause);\n }\n throw !released.ok ? attachCleanupException(cause, released.error) : cause;\n })();\n }\n const syncReleased = rel as Result<unknown, unknown>;\n throw !syncReleased.ok ? attachCleanupException(cause, syncReleased.error) : cause;\n }\n let usedThen: ThenFn | undefined;\n try {\n usedThen = getThen(rawUsed);\n } catch (probeCause) {\n return releaseAfterFailureAsync(resource, release, probeCause);\n }\n if (usedThen !== undefined) {\n return finishUsingAsync(resource, adoptThenable<Result<unknown, unknown>>(rawUsed, usedThen), release, onReleaseError);\n }\n const used = rawUsed as Result<unknown, unknown>;\n let releasedOrPromise: Result<unknown, unknown> | PromiseLike<Result<unknown, unknown>>;\n try {\n releasedOrPromise = release(resource);\n } catch (releaseCause) {\n rethrowReleaseException(releaseCause, used);\n }\n let releasedThen: ThenFn | undefined;\n try {\n releasedThen = getThen(releasedOrPromise);\n } catch (probeCause) {\n return Promise.reject(!used.ok ? attachPrimaryResultToCleanupException(probeCause, used) : probeCause);\n }\n if (releasedThen !== undefined) {\n return (async () => {\n let released: Result<unknown, unknown>;\n try {\n released = await adoptThenable<Result<unknown, unknown>>(releasedOrPromise, releasedThen);\n } catch (releaseCause) {\n rethrowReleaseException(releaseCause, used);\n }\n return combineUsing(used, released, onReleaseError);\n })();\n }\n return combineUsing(used, releasedOrPromise as Result<unknown, unknown>, onReleaseError);\n}\n\n/** Async form of `Trust.using`: always returns a `Promise`. */\nexport function usingAsync<\n A extends MaybePromise<Result<unknown, unknown>>,\n U extends MaybePromise<Result<unknown, unknown>>,\n C extends MaybePromise<Result<unknown, unknown>>,\n>(\n acquire: () => A,\n use: (resource: ResourceOf<A>) => U,\n release: (resource: ResourceOf<A>) => C,\n ...check: UsingCheck<Awaited<A>, Awaited<U>, Awaited<C>>\n): Promise<UsingResult<Awaited<A>, Awaited<U>, Awaited<C>>>;\nexport function usingAsync<\n A extends MaybePromise<Result<unknown, unknown>>,\n U extends MaybePromise<Result<unknown, unknown>>,\n C extends MaybePromise<Result<unknown, unknown>>,\n>(\n acquire: () => A,\n use: (resource: ResourceOf<A>) => U,\n release: (resource: ResourceOf<A>) => C,\n onReleaseError: ((releaseError: UsingNoInfer<RawErrorOf<Awaited<C>>>, useError: UsingNoInfer<RawErrorOf<Awaited<U>>>) => void) | undefined,\n ...check: UsingCheck<Awaited<A>, Awaited<U>, Awaited<C>>\n): Promise<UsingResult<Awaited<A>, Awaited<U>, Awaited<C>>>;\nexport async function usingAsync(\n acquire: () => Result<unknown, unknown> | PromiseLike<Result<unknown, unknown>>,\n use: (resource: never) => Result<unknown, unknown> | PromiseLike<Result<unknown, unknown>>,\n release: (resource: never) => Result<unknown, unknown> | PromiseLike<Result<unknown, unknown>>,\n ...rest: unknown[]\n): Promise<Result<unknown, unknown>> {\n const onReleaseError = typeof rest[0] === 'function' ? (rest[0] as (releaseError: never, useError: never) => void) : undefined;\n const acquired = await acquire();\n if (!acquired.ok) return acquired;\n return runUsingAsync(acquired.value, use, release, onReleaseError);\n}\n\n/** Make a result: `Result.ok(value)`, `Result.err({ kind: 'x', ... })`. */\nexport const Result: {\n readonly ok: typeof ok;\n readonly err: typeof err;\n readonly state: typeof state;\n} = { ok, err, state };\n\n/**\n * Apply the discipline:\n * `Trust.try` / `Trust.tryAsync` are the only boundary that may catch a throw;\n * `Trust.decide` is the only place a failure may stop; `Trust.translate` the only place it may change kind;\n * `Trust.using` / `Trust.usingAsync` acquire, use and always release a Result resource.\n */\nexport const Trust: {\n readonly try: typeof tryResult;\n readonly tryAsync: typeof tryResultAsync;\n readonly decide: typeof decide;\n readonly translate: typeof translate;\n readonly match: typeof match;\n readonly using: typeof using;\n readonly usingAsync: typeof usingAsync;\n} = { try: tryResult, tryAsync: tryResultAsync, decide, translate, match, using, usingAsync };\n"],"mappings":"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","names":["state"]}
|
|
Binary file
|
package/package.json
CHANGED
|
@@ -1,6 +1,6 @@
|
|
|
1
1
|
{
|
|
2
2
|
"name": "@noego/trust",
|
|
3
|
-
"version": "0.5.1-dev.
|
|
3
|
+
"version": "0.5.1-dev.4",
|
|
4
4
|
"description": "Result type plus type-aware ESLint rules that make failure handling explicit: untrusted calls and throws must be caught locally and returned as Result.err.",
|
|
5
5
|
"type": "module",
|
|
6
6
|
"main": "dist/index.cjs",
|
|
@@ -73,9 +73,9 @@
|
|
|
73
73
|
}
|
|
74
74
|
},
|
|
75
75
|
"optionalDependencies": {
|
|
76
|
-
"@noego/trust-darwin-arm64": "0.5.1",
|
|
77
|
-
"@noego/trust-linux-x64-gnu": "0.5.1",
|
|
78
|
-
"@noego/trust-win32-x64-msvc": "0.5.1"
|
|
76
|
+
"@noego/trust-darwin-arm64": "0.5.1-dev.1",
|
|
77
|
+
"@noego/trust-linux-x64-gnu": "0.5.1-dev.1",
|
|
78
|
+
"@noego/trust-win32-x64-msvc": "0.5.1-dev.1"
|
|
79
79
|
},
|
|
80
80
|
"devDependencies": {
|
|
81
81
|
"@jridgewell/trace-mapping": "^0.3.31",
|