@noego/trust 0.5.1-dev.3 → 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/dist/{baseline-DMNO7IAl.d.ts → baseline-DsqHPLAg.d.ts} +9 -2
- package/dist/{chunk-3IIEQHH2.js → chunk-35ETSKEC.js} +34 -2
- package/dist/chunk-35ETSKEC.js.map +1 -0
- package/dist/{chunk-VJGGEY4G.js → chunk-4XGOH7JE.js} +11 -1
- package/dist/{chunk-VJGGEY4G.js.map → chunk-4XGOH7JE.js.map} +1 -1
- package/dist/{chunk-2MSSO67W.js → chunk-6K5I3ZRI.js} +2 -2
- package/dist/cli/index.js +5 -5
- 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 +3 -2
- package/dist/eslint/index.js +49 -14
- package/dist/eslint/index.js.map +1 -1
- package/dist/index.cjs +221 -3
- package/dist/index.cjs.map +1 -1
- package/dist/index.d.cts +47 -2
- package/dist/index.d.ts +47 -2
- package/dist/index.js +218 -2
- package/dist/index.js.map +1 -1
- package/dist/native/trust_native_wasm.wasm +0 -0
- package/package.json +4 -4
- package/dist/chunk-3IIEQHH2.js.map +0 -1
- /package/dist/{chunk-2MSSO67W.js.map → chunk-6K5I3ZRI.js.map} +0 -0
package/dist/index.cjs
CHANGED
|
@@ -29,7 +29,9 @@ __export(src_exports, {
|
|
|
29
29
|
state: () => state,
|
|
30
30
|
translate: () => translate,
|
|
31
31
|
tryResult: () => tryResult,
|
|
32
|
-
tryResultAsync: () => tryResultAsync
|
|
32
|
+
tryResultAsync: () => tryResultAsync,
|
|
33
|
+
using: () => using,
|
|
34
|
+
usingAsync: () => usingAsync
|
|
33
35
|
});
|
|
34
36
|
module.exports = __toCommonJS(src_exports);
|
|
35
37
|
var resultBrand = /* @__PURE__ */ Symbol.for("@noego/trust/result");
|
|
@@ -90,8 +92,222 @@ function match(result, handlers) {
|
|
|
90
92
|
const value = handler(result.value);
|
|
91
93
|
return isResult(value) ? value : ok(value);
|
|
92
94
|
}
|
|
95
|
+
function getThen(value) {
|
|
96
|
+
if ((typeof value !== "object" || value === null) && typeof value !== "function") return void 0;
|
|
97
|
+
const then = value.then;
|
|
98
|
+
return typeof then === "function" ? then : void 0;
|
|
99
|
+
}
|
|
100
|
+
function adoptThenable(target, then) {
|
|
101
|
+
return Promise.resolve({
|
|
102
|
+
then(resolve, reject) {
|
|
103
|
+
Reflect.apply(then, target, [resolve, reject]);
|
|
104
|
+
}
|
|
105
|
+
});
|
|
106
|
+
}
|
|
107
|
+
function attachCleanupException(primary, cleanupError) {
|
|
108
|
+
if (primary !== cleanupError && (typeof primary === "object" && primary !== null || typeof primary === "function")) {
|
|
109
|
+
try {
|
|
110
|
+
const existing = "suppressed" in primary ? primary.suppressed : void 0;
|
|
111
|
+
const list = Array.isArray(primary.suppressedErrors) ? [...primary.suppressedErrors, cleanupError] : existing !== void 0 ? [existing, cleanupError] : [cleanupError];
|
|
112
|
+
Object.defineProperty(primary, "suppressed", {
|
|
113
|
+
value: cleanupError,
|
|
114
|
+
configurable: true,
|
|
115
|
+
writable: true
|
|
116
|
+
});
|
|
117
|
+
Object.defineProperty(primary, "suppressedErrors", {
|
|
118
|
+
value: list,
|
|
119
|
+
configurable: true,
|
|
120
|
+
writable: true
|
|
121
|
+
});
|
|
122
|
+
if (!("cause" in primary)) {
|
|
123
|
+
Object.defineProperty(primary, "cause", {
|
|
124
|
+
value: cleanupError,
|
|
125
|
+
configurable: true,
|
|
126
|
+
writable: true
|
|
127
|
+
});
|
|
128
|
+
}
|
|
129
|
+
} catch {
|
|
130
|
+
}
|
|
131
|
+
}
|
|
132
|
+
return primary;
|
|
133
|
+
}
|
|
134
|
+
function attachPrimaryResultToCleanupException(cleanupException, primaryErr) {
|
|
135
|
+
if (typeof cleanupException === "object" && cleanupException !== null || typeof cleanupException === "function") {
|
|
136
|
+
try {
|
|
137
|
+
Object.defineProperty(cleanupException, "primaryResult", {
|
|
138
|
+
value: primaryErr,
|
|
139
|
+
configurable: true,
|
|
140
|
+
writable: true
|
|
141
|
+
});
|
|
142
|
+
Object.defineProperty(cleanupException, "primaryError", {
|
|
143
|
+
value: primaryErr.error,
|
|
144
|
+
configurable: true,
|
|
145
|
+
writable: true
|
|
146
|
+
});
|
|
147
|
+
if (!("cause" in cleanupException)) {
|
|
148
|
+
Object.defineProperty(cleanupException, "cause", {
|
|
149
|
+
value: primaryErr.error,
|
|
150
|
+
configurable: true,
|
|
151
|
+
writable: true
|
|
152
|
+
});
|
|
153
|
+
}
|
|
154
|
+
} catch {
|
|
155
|
+
}
|
|
156
|
+
}
|
|
157
|
+
return cleanupException;
|
|
158
|
+
}
|
|
159
|
+
function rethrowReleaseException(releaseCause, used) {
|
|
160
|
+
throw !used.ok ? attachPrimaryResultToCleanupException(releaseCause, used) : releaseCause;
|
|
161
|
+
}
|
|
162
|
+
function runReleaseErrorHook(onReleaseError, releaseError, useError) {
|
|
163
|
+
try {
|
|
164
|
+
const out = onReleaseError(releaseError, useError);
|
|
165
|
+
const then = getThen(out);
|
|
166
|
+
if (then !== void 0) {
|
|
167
|
+
adoptThenable(out, then).then(void 0, () => {
|
|
168
|
+
});
|
|
169
|
+
}
|
|
170
|
+
} catch {
|
|
171
|
+
}
|
|
172
|
+
}
|
|
173
|
+
function combineUsing(used, released, onReleaseError) {
|
|
174
|
+
if (!used.ok) {
|
|
175
|
+
if (!released.ok && onReleaseError) runReleaseErrorHook(onReleaseError, released.error, used.error);
|
|
176
|
+
return used;
|
|
177
|
+
}
|
|
178
|
+
return released.ok ? used : released;
|
|
179
|
+
}
|
|
180
|
+
async function releaseAfterFailureAsync(resource, release, cause) {
|
|
181
|
+
let released;
|
|
182
|
+
try {
|
|
183
|
+
released = await release(resource);
|
|
184
|
+
} catch (releaseCause) {
|
|
185
|
+
throw attachCleanupException(cause, releaseCause);
|
|
186
|
+
}
|
|
187
|
+
throw !released.ok ? attachCleanupException(cause, released.error) : cause;
|
|
188
|
+
}
|
|
189
|
+
async function finishUsingAsync(resource, usedPromise, release, onReleaseError) {
|
|
190
|
+
let used;
|
|
191
|
+
try {
|
|
192
|
+
used = await usedPromise;
|
|
193
|
+
} catch (cause) {
|
|
194
|
+
return releaseAfterFailureAsync(resource, release, cause);
|
|
195
|
+
}
|
|
196
|
+
let released;
|
|
197
|
+
try {
|
|
198
|
+
released = await release(resource);
|
|
199
|
+
} catch (releaseCause) {
|
|
200
|
+
rethrowReleaseException(releaseCause, used);
|
|
201
|
+
}
|
|
202
|
+
return combineUsing(used, released, onReleaseError);
|
|
203
|
+
}
|
|
204
|
+
async function runUsingAsync(resource, use, release, onReleaseError) {
|
|
205
|
+
let used;
|
|
206
|
+
try {
|
|
207
|
+
used = await use(resource);
|
|
208
|
+
} catch (cause) {
|
|
209
|
+
return releaseAfterFailureAsync(resource, release, cause);
|
|
210
|
+
}
|
|
211
|
+
let released;
|
|
212
|
+
try {
|
|
213
|
+
released = await release(resource);
|
|
214
|
+
} catch (releaseCause) {
|
|
215
|
+
rethrowReleaseException(releaseCause, used);
|
|
216
|
+
}
|
|
217
|
+
return combineUsing(used, released, onReleaseError);
|
|
218
|
+
}
|
|
219
|
+
function using(acquire, use, release, ...rest) {
|
|
220
|
+
const onReleaseError = typeof rest[0] === "function" ? rest[0] : void 0;
|
|
221
|
+
const acquired = acquire();
|
|
222
|
+
let acquiredThen;
|
|
223
|
+
try {
|
|
224
|
+
acquiredThen = getThen(acquired);
|
|
225
|
+
} catch (probeCause) {
|
|
226
|
+
return Promise.reject(probeCause);
|
|
227
|
+
}
|
|
228
|
+
if (acquiredThen !== void 0) {
|
|
229
|
+
return (async () => {
|
|
230
|
+
const resolved = await adoptThenable(acquired, acquiredThen);
|
|
231
|
+
if (!resolved.ok) return resolved;
|
|
232
|
+
return runUsingAsync(resolved.value, use, release, onReleaseError);
|
|
233
|
+
})();
|
|
234
|
+
}
|
|
235
|
+
const syncAcquired = acquired;
|
|
236
|
+
if (!syncAcquired.ok) return syncAcquired;
|
|
237
|
+
const resource = syncAcquired.value;
|
|
238
|
+
let rawUsed;
|
|
239
|
+
try {
|
|
240
|
+
rawUsed = use(resource);
|
|
241
|
+
} catch (cause) {
|
|
242
|
+
let rel;
|
|
243
|
+
try {
|
|
244
|
+
rel = release(resource);
|
|
245
|
+
} catch (releaseCause) {
|
|
246
|
+
throw attachCleanupException(cause, releaseCause);
|
|
247
|
+
}
|
|
248
|
+
let relThen;
|
|
249
|
+
try {
|
|
250
|
+
relThen = getThen(rel);
|
|
251
|
+
} catch (relProbeCause) {
|
|
252
|
+
return Promise.reject(attachCleanupException(cause, relProbeCause));
|
|
253
|
+
}
|
|
254
|
+
if (relThen !== void 0) {
|
|
255
|
+
return (async () => {
|
|
256
|
+
let released;
|
|
257
|
+
try {
|
|
258
|
+
released = await adoptThenable(rel, relThen);
|
|
259
|
+
} catch (releaseCause) {
|
|
260
|
+
throw attachCleanupException(cause, releaseCause);
|
|
261
|
+
}
|
|
262
|
+
throw !released.ok ? attachCleanupException(cause, released.error) : cause;
|
|
263
|
+
})();
|
|
264
|
+
}
|
|
265
|
+
const syncReleased = rel;
|
|
266
|
+
throw !syncReleased.ok ? attachCleanupException(cause, syncReleased.error) : cause;
|
|
267
|
+
}
|
|
268
|
+
let usedThen;
|
|
269
|
+
try {
|
|
270
|
+
usedThen = getThen(rawUsed);
|
|
271
|
+
} catch (probeCause) {
|
|
272
|
+
return releaseAfterFailureAsync(resource, release, probeCause);
|
|
273
|
+
}
|
|
274
|
+
if (usedThen !== void 0) {
|
|
275
|
+
return finishUsingAsync(resource, adoptThenable(rawUsed, usedThen), release, onReleaseError);
|
|
276
|
+
}
|
|
277
|
+
const used = rawUsed;
|
|
278
|
+
let releasedOrPromise;
|
|
279
|
+
try {
|
|
280
|
+
releasedOrPromise = release(resource);
|
|
281
|
+
} catch (releaseCause) {
|
|
282
|
+
rethrowReleaseException(releaseCause, used);
|
|
283
|
+
}
|
|
284
|
+
let releasedThen;
|
|
285
|
+
try {
|
|
286
|
+
releasedThen = getThen(releasedOrPromise);
|
|
287
|
+
} catch (probeCause) {
|
|
288
|
+
return Promise.reject(!used.ok ? attachPrimaryResultToCleanupException(probeCause, used) : probeCause);
|
|
289
|
+
}
|
|
290
|
+
if (releasedThen !== void 0) {
|
|
291
|
+
return (async () => {
|
|
292
|
+
let released;
|
|
293
|
+
try {
|
|
294
|
+
released = await adoptThenable(releasedOrPromise, releasedThen);
|
|
295
|
+
} catch (releaseCause) {
|
|
296
|
+
rethrowReleaseException(releaseCause, used);
|
|
297
|
+
}
|
|
298
|
+
return combineUsing(used, released, onReleaseError);
|
|
299
|
+
})();
|
|
300
|
+
}
|
|
301
|
+
return combineUsing(used, releasedOrPromise, onReleaseError);
|
|
302
|
+
}
|
|
303
|
+
async function usingAsync(acquire, use, release, ...rest) {
|
|
304
|
+
const onReleaseError = typeof rest[0] === "function" ? rest[0] : void 0;
|
|
305
|
+
const acquired = await acquire();
|
|
306
|
+
if (!acquired.ok) return acquired;
|
|
307
|
+
return runUsingAsync(acquired.value, use, release, onReleaseError);
|
|
308
|
+
}
|
|
93
309
|
var Result = { ok, err, state };
|
|
94
|
-
var Trust = { try: tryResult, tryAsync: tryResultAsync, decide, translate, match };
|
|
310
|
+
var Trust = { try: tryResult, tryAsync: tryResultAsync, decide, translate, match, using, usingAsync };
|
|
95
311
|
// Annotate the CommonJS export names for ESM import in node:
|
|
96
312
|
0 && (module.exports = {
|
|
97
313
|
Result,
|
|
@@ -103,6 +319,8 @@ var Trust = { try: tryResult, tryAsync: tryResultAsync, decide, translate, match
|
|
|
103
319
|
state,
|
|
104
320
|
translate,
|
|
105
321
|
tryResult,
|
|
106
|
-
tryResultAsync
|
|
322
|
+
tryResultAsync,
|
|
323
|
+
using,
|
|
324
|
+
usingAsync
|
|
107
325
|
});
|
|
108
326
|
//# sourceMappingURL=index.cjs.map
|
package/dist/index.cjs.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\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\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 */\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} = { try: tryResult, tryAsync: tryResultAsync, decide, translate, match };\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AA2BA,IAAM,cAAc,uBAAO,IAAI,qBAAqB;AACpD,SAAS,MAAwB,OAAa;AAC5C,SAAO,OAAO,eAAe,OAAO,aAAa,EAAE,OAAO,KAAK,CAAC;AAClE;AACA,SAAS,SAAS,OAAmD;AACnE,UAAS,OAAO,UAAU,YAAY,UAAU,QAAS,OAAO,UAAU,eACrE,eAAe;AACtB;AAUO,SAAS,MAAMA,QAAe,OAA2C;AAC9E,MAAI,UAAU,WAAW,EAAG,QAAO,MAAM,EAAE,IAAI,MAAM,OAAAA,QAAO,OAAO,OAAU,CAAC;AAC9E,MAAI,SAAS,KAAK,GAAG;AACnB,QAAI,MAAM,OAAO,MAAO,QAAO;AAC/B,WAAO,MAAM,EAAE,IAAI,MAAM,OAAAA,QAAO,OAAO,MAAM,MAAM,CAAC;AAAA,EACtD;AACA,SAAO,MAAM,EAAE,IAAI,MAAM,OAAAA,QAAO,MAAM,CAAC;AACzC;AAMO,SAAS,GAAM,OAAiB;AACrC,SAAO,MAAM,EAAE,IAAI,MAAM,MAAM,CAAC;AAClC;AAaO,SAAS,IAAO,OAAkB;AACvC,SAAO,MAAM,EAAE,IAAI,OAAO,MAAM,CAAC;AACnC;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;AAgEA,SAAS,KAAK,OAAe,MAA4D;AACvF,MAAI,OAAO,SAAS,YAAY,CAAC,OAAO,UAAU,eAAe,KAAK,OAAO,IAAI,EAAG,QAAO;AAC3F,SAAQ,MAAwD,IAAI;AACtE;AAYO,SAAS,OAAO,QAAkC,UAA2B;AAClF,MAAI,OAAO,GAAI,QAAO;AACtB,QAAM,UAAU,KAAK,UAAW,OAAO,OAAqC,IAAI;AAChF,MAAI,YAAY,OAAW,QAAO;AAClC,QAAM,QAAQ,QAAQ,OAAO,KAAK;AAClC,SAAO,SAAS,KAAK,IAAI,QAAQ,GAAG,KAAK;AAC3C;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;AAqBO,SAAS,MAAM,QAAkC,UAA2B;AACjF,MAAI,CAAC,OAAO,GAAI,QAAO;AACvB,QAAM,UAAU,KAAK,UAAW,OAA+B,KAAK;AACpE,MAAI,YAAY,OAAW,QAAO;AAClC,QAAM,QAAQ,QAAQ,OAAO,KAAK;AAClC,SAAO,SAAS,KAAK,IAAI,QAAQ,GAAG,KAAK;AAC3C;AAGO,IAAM,SAIT,EAAE,IAAI,KAAK,MAAM;AAOd,IAAM,QAMT,EAAE,KAAK,WAAW,UAAU,gBAAgB,QAAQ,WAAW,MAAM;","names":["state"]}
|
|
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":";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AA4BA,IAAM,cAAc,uBAAO,IAAI,qBAAqB;AACpD,SAAS,MAAwB,OAAa;AAC5C,SAAO,OAAO,eAAe,OAAO,aAAa,EAAE,OAAO,KAAK,CAAC;AAClE;AACA,SAAS,SAAS,OAAmD;AACnE,UAAS,OAAO,UAAU,YAAY,UAAU,QAAS,OAAO,UAAU,eACrE,eAAe;AACtB;AAUO,SAAS,MAAMA,QAAe,OAA2C;AAC9E,MAAI,UAAU,WAAW,EAAG,QAAO,MAAM,EAAE,IAAI,MAAM,OAAAA,QAAO,OAAO,OAAU,CAAC;AAC9E,MAAI,SAAS,KAAK,GAAG;AACnB,QAAI,MAAM,OAAO,MAAO,QAAO;AAC/B,WAAO,MAAM,EAAE,IAAI,MAAM,OAAAA,QAAO,OAAO,MAAM,MAAM,CAAC;AAAA,EACtD;AACA,SAAO,MAAM,EAAE,IAAI,MAAM,OAAAA,QAAO,MAAM,CAAC;AACzC;AAMO,SAAS,GAAM,OAAiB;AACrC,SAAO,MAAM,EAAE,IAAI,MAAM,MAAM,CAAC;AAClC;AAaO,SAAS,IAAO,OAAkB;AACvC,SAAO,MAAM,EAAE,IAAI,OAAO,MAAM,CAAC;AACnC;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;AAgEA,SAAS,KAAK,OAAe,MAA4D;AACvF,MAAI,OAAO,SAAS,YAAY,CAAC,OAAO,UAAU,eAAe,KAAK,OAAO,IAAI,EAAG,QAAO;AAC3F,SAAQ,MAAwD,IAAI;AACtE;AAYO,SAAS,OAAO,QAAkC,UAA2B;AAClF,MAAI,OAAO,GAAI,QAAO;AACtB,QAAM,UAAU,KAAK,UAAW,OAAO,OAAqC,IAAI;AAChF,MAAI,YAAY,OAAW,QAAO;AAClC,QAAM,QAAQ,QAAQ,OAAO,KAAK;AAClC,SAAO,SAAS,KAAK,IAAI,QAAQ,GAAG,KAAK;AAC3C;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;AAqBO,SAAS,MAAM,QAAkC,UAA2B;AACjF,MAAI,CAAC,OAAO,GAAI,QAAO;AACvB,QAAM,UAAU,KAAK,UAAW,OAA+B,KAAK;AACpE,MAAI,YAAY,OAAW,QAAO;AAClC,QAAM,QAAQ,QAAQ,OAAO,KAAK;AAClC,SAAO,SAAS,KAAK,IAAI,QAAQ,GAAG,KAAK;AAC3C;AA0DA,SAAS,QAAQ,OAAoC;AACnD,OAAK,OAAO,UAAU,YAAY,UAAU,SAAS,OAAO,UAAU,WAAY,QAAO;AACzF,QAAM,OAAQ,MAA6B;AAC3C,SAAO,OAAO,SAAS,aAAc,OAAkB;AACzD;AAEA,SAAS,cAAiB,QAAiB,MAA0B;AACnE,SAAO,QAAQ,QAAW;AAAA,IACxB,KAAK,SAAS,QAAQ;AACpB,cAAQ,MAAM,MAAM,QAAQ,CAAC,SAAS,MAAM,CAAC;AAAA,IAC/C;AAAA,EACF,CAAmB;AACrB;AAEA,SAAS,uBAAuB,SAAkB,cAAgC;AAChF,MACE,YAAY,iBACP,OAAO,YAAY,YAAY,YAAY,QAAS,OAAO,YAAY,aAC5E;AACA,QAAI;AACF,YAAM,WAAW,gBAAgB,UAAW,QAAqC,aAAa;AAC9F,YAAM,OAAO,MAAM,QAAS,QAA2C,gBAAgB,IACnF,CAAC,GAAK,QAA4C,kBAAmB,YAAY,IACjF,aAAa,SACX,CAAC,UAAU,YAAY,IACvB,CAAC,YAAY;AACnB,aAAO,eAAe,SAAS,cAAc;AAAA,QAC3C,OAAO;AAAA,QACP,cAAc;AAAA,QACd,UAAU;AAAA,MACZ,CAAC;AACD,aAAO,eAAe,SAAS,oBAAoB;AAAA,QACjD,OAAO;AAAA,QACP,cAAc;AAAA,QACd,UAAU;AAAA,MACZ,CAAC;AACD,UAAI,EAAE,WAAW,UAAU;AACzB,eAAO,eAAe,SAAS,SAAS;AAAA,UACtC,OAAO;AAAA,UACP,cAAc;AAAA,UACd,UAAU;AAAA,QACZ,CAAC;AAAA,MACH;AAAA,IACF,QAAQ;AAAA,IAER;AAAA,EACF;AACA,SAAO;AACT;AAEA,SAAS,sCAAsC,kBAA2B,YAAmC;AAC3G,MAAK,OAAO,qBAAqB,YAAY,qBAAqB,QAAS,OAAO,qBAAqB,YAAY;AACjH,QAAI;AACF,aAAO,eAAe,kBAAkB,iBAAiB;AAAA,QACvD,OAAO;AAAA,QACP,cAAc;AAAA,QACd,UAAU;AAAA,MACZ,CAAC;AACD,aAAO,eAAe,kBAAkB,gBAAgB;AAAA,QACtD,OAAO,WAAW;AAAA,QAClB,cAAc;AAAA,QACd,UAAU;AAAA,MACZ,CAAC;AACD,UAAI,EAAE,WAAW,mBAAmB;AAClC,eAAO,eAAe,kBAAkB,SAAS;AAAA,UAC/C,OAAO,WAAW;AAAA,UAClB,cAAc;AAAA,UACd,UAAU;AAAA,QACZ,CAAC;AAAA,MACH;AAAA,IACF,QAAQ;AAAA,IAER;AAAA,EACF;AACA,SAAO;AACT;AAEA,SAAS,wBAAwB,cAAuB,MAAuC;AAC7F,QAAM,CAAC,KAAK,KAAK,sCAAsC,cAAc,IAAI,IAAI;AAC/E;AAEA,SAAS,oBACP,gBACA,cACA,UACM;AACN,MAAI;AACF,UAAM,MAAe,eAAe,cAAuB,QAAiB;AAC5E,UAAM,OAAO,QAAQ,GAAG;AACxB,QAAI,SAAS,QAAW;AACtB,oBAAc,KAAK,IAAI,EAAE,KAAK,QAAW,MAAM;AAAA,MAAC,CAAC;AAAA,IACnD;AAAA,EACF,QAAQ;AAAA,EAER;AACF;AAEA,SAAS,aACP,MACA,UACA,gBAC0B;AAC1B,MAAI,CAAC,KAAK,IAAI;AACZ,QAAI,CAAC,SAAS,MAAM,eAAgB,qBAAoB,gBAAgB,SAAS,OAAO,KAAK,KAAK;AAClG,WAAO;AAAA,EACT;AACA,SAAO,SAAS,KAAK,OAAO;AAC9B;AAEA,eAAe,yBACb,UACA,SACA,OACgB;AAChB,MAAI;AACJ,MAAI;AACF,eAAW,MAAM,QAAQ,QAAQ;AAAA,EACnC,SAAS,cAAc;AACrB,UAAM,uBAAuB,OAAO,YAAY;AAAA,EAClD;AACA,QAAM,CAAC,SAAS,KAAK,uBAAuB,OAAO,SAAS,KAAK,IAAI;AACvE;AAEA,eAAe,iBACb,UACA,aACA,SACA,gBACmC;AACnC,MAAI;AACJ,MAAI;AACF,WAAO,MAAM;AAAA,EACf,SAAS,OAAO;AACd,WAAO,yBAAyB,UAAU,SAAS,KAAK;AAAA,EAC1D;AACA,MAAI;AACJ,MAAI;AACF,eAAW,MAAM,QAAQ,QAAQ;AAAA,EACnC,SAAS,cAAc;AACrB,4BAAwB,cAAc,IAAI;AAAA,EAC5C;AACA,SAAO,aAAa,MAAM,UAAU,cAAc;AACpD;AAEA,eAAe,cACb,UACA,KACA,SACA,gBACmC;AACnC,MAAI;AACJ,MAAI;AACF,WAAO,MAAM,IAAI,QAAiB;AAAA,EACpC,SAAS,OAAO;AACd,WAAO,yBAAyB,UAAmB,SAAS,KAAK;AAAA,EACnE;AACA,MAAI;AACJ,MAAI;AACF,eAAW,MAAM,QAAQ,QAAiB;AAAA,EAC5C,SAAS,cAAc;AACrB,4BAAwB,cAAc,IAAI;AAAA,EAC5C;AACA,SAAO,aAAa,MAAM,UAAU,cAAc;AACpD;AAqCO,SAAS,MACd,SACA,KACA,YACG,MACM;AACT,QAAM,iBAAiB,OAAO,KAAK,CAAC,MAAM,aAAc,KAAK,CAAC,IAAuD;AACrH,QAAM,WAAW,QAAQ;AACzB,MAAI;AACJ,MAAI;AACF,mBAAe,QAAQ,QAAQ;AAAA,EACjC,SAAS,YAAY;AACnB,WAAO,QAAQ,OAAO,UAAU;AAAA,EAClC;AACA,MAAI,iBAAiB,QAAW;AAC9B,YAAQ,YAAY;AAClB,YAAM,WAAW,MAAM,cAAwC,UAAU,YAAY;AACrF,UAAI,CAAC,SAAS,GAAI,QAAO;AACzB,aAAO,cAAc,SAAS,OAAO,KAAK,SAAS,cAAc;AAAA,IACnE,GAAG;AAAA,EACL;AACA,QAAM,eAAe;AACrB,MAAI,CAAC,aAAa,GAAI,QAAO;AAC7B,QAAM,WAAW,aAAa;AAC9B,MAAI;AACJ,MAAI;AACF,cAAU,IAAI,QAAQ;AAAA,EACxB,SAAS,OAAO;AACd,QAAI;AACJ,QAAI;AACF,YAAM,QAAQ,QAAQ;AAAA,IACxB,SAAS,cAAc;AACrB,YAAM,uBAAuB,OAAO,YAAY;AAAA,IAClD;AACA,QAAI;AACJ,QAAI;AACF,gBAAU,QAAQ,GAAG;AAAA,IACvB,SAAS,eAAe;AACtB,aAAO,QAAQ,OAAO,uBAAuB,OAAO,aAAa,CAAC;AAAA,IACpE;AACA,QAAI,YAAY,QAAW;AACzB,cAAQ,YAAY;AAClB,YAAI;AACJ,YAAI;AACF,qBAAW,MAAM,cAAwC,KAAK,OAAO;AAAA,QACvE,SAAS,cAAc;AACrB,gBAAM,uBAAuB,OAAO,YAAY;AAAA,QAClD;AACA,cAAM,CAAC,SAAS,KAAK,uBAAuB,OAAO,SAAS,KAAK,IAAI;AAAA,MACvE,GAAG;AAAA,IACL;AACA,UAAM,eAAe;AACrB,UAAM,CAAC,aAAa,KAAK,uBAAuB,OAAO,aAAa,KAAK,IAAI;AAAA,EAC/E;AACA,MAAI;AACJ,MAAI;AACF,eAAW,QAAQ,OAAO;AAAA,EAC5B,SAAS,YAAY;AACnB,WAAO,yBAAyB,UAAU,SAAS,UAAU;AAAA,EAC/D;AACA,MAAI,aAAa,QAAW;AAC1B,WAAO,iBAAiB,UAAU,cAAwC,SAAS,QAAQ,GAAG,SAAS,cAAc;AAAA,EACvH;AACA,QAAM,OAAO;AACb,MAAI;AACJ,MAAI;AACF,wBAAoB,QAAQ,QAAQ;AAAA,EACtC,SAAS,cAAc;AACrB,4BAAwB,cAAc,IAAI;AAAA,EAC5C;AACA,MAAI;AACJ,MAAI;AACF,mBAAe,QAAQ,iBAAiB;AAAA,EAC1C,SAAS,YAAY;AACnB,WAAO,QAAQ,OAAO,CAAC,KAAK,KAAK,sCAAsC,YAAY,IAAI,IAAI,UAAU;AAAA,EACvG;AACA,MAAI,iBAAiB,QAAW;AAC9B,YAAQ,YAAY;AAClB,UAAI;AACJ,UAAI;AACF,mBAAW,MAAM,cAAwC,mBAAmB,YAAY;AAAA,MAC1F,SAAS,cAAc;AACrB,gCAAwB,cAAc,IAAI;AAAA,MAC5C;AACA,aAAO,aAAa,MAAM,UAAU,cAAc;AAAA,IACpD,GAAG;AAAA,EACL;AACA,SAAO,aAAa,MAAM,mBAA+C,cAAc;AACzF;AAwBA,eAAsB,WACpB,SACA,KACA,YACG,MACgC;AACnC,QAAM,iBAAiB,OAAO,KAAK,CAAC,MAAM,aAAc,KAAK,CAAC,IAAuD;AACrH,QAAM,WAAW,MAAM,QAAQ;AAC/B,MAAI,CAAC,SAAS,GAAI,QAAO;AACzB,SAAO,cAAc,SAAS,OAAO,KAAK,SAAS,cAAc;AACnE;AAGO,IAAM,SAIT,EAAE,IAAI,KAAK,MAAM;AAQd,IAAM,QAQT,EAAE,KAAK,WAAW,UAAU,gBAAgB,QAAQ,WAAW,OAAO,OAAO,WAAW;","names":["state"]}
|
package/dist/index.d.cts
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
|
|
@@ -185,6 +186,47 @@ type MatchCheck<H> = [Extract<H[keyof H], {
|
|
|
185
186
|
readonly __trust: 'match cannot mix stated and bare returns';
|
|
186
187
|
}];
|
|
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>>>;
|
|
188
230
|
type Result<T, E> = Ok<T> | Err<E>;
|
|
189
231
|
/** Make a result: `Result.ok(value)`, `Result.err({ kind: 'x', ... })`. */
|
|
190
232
|
declare const Result: {
|
|
@@ -195,7 +237,8 @@ declare const Result: {
|
|
|
195
237
|
/**
|
|
196
238
|
* Apply the discipline:
|
|
197
239
|
* `Trust.try` / `Trust.tryAsync` are the only boundary that may catch a throw;
|
|
198
|
-
* `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.
|
|
199
242
|
*/
|
|
200
243
|
declare const Trust: {
|
|
201
244
|
readonly try: typeof tryResult;
|
|
@@ -203,6 +246,8 @@ declare const Trust: {
|
|
|
203
246
|
readonly decide: typeof decide;
|
|
204
247
|
readonly translate: typeof translate;
|
|
205
248
|
readonly match: typeof match;
|
|
249
|
+
readonly using: typeof using;
|
|
250
|
+
readonly usingAsync: typeof usingAsync;
|
|
206
251
|
};
|
|
207
252
|
|
|
208
|
-
export { type Err, type Failure, type Ok, Result, type StatedOk, type StatedResult, Trust, decide, err, match, ok, state, 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.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
|
|
@@ -185,6 +186,47 @@ type MatchCheck<H> = [Extract<H[keyof H], {
|
|
|
185
186
|
readonly __trust: 'match cannot mix stated and bare returns';
|
|
186
187
|
}];
|
|
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>>>;
|
|
188
230
|
type Result<T, E> = Ok<T> | Err<E>;
|
|
189
231
|
/** Make a result: `Result.ok(value)`, `Result.err({ kind: 'x', ... })`. */
|
|
190
232
|
declare const Result: {
|
|
@@ -195,7 +237,8 @@ declare const Result: {
|
|
|
195
237
|
/**
|
|
196
238
|
* Apply the discipline:
|
|
197
239
|
* `Trust.try` / `Trust.tryAsync` are the only boundary that may catch a throw;
|
|
198
|
-
* `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.
|
|
199
242
|
*/
|
|
200
243
|
declare const Trust: {
|
|
201
244
|
readonly try: typeof tryResult;
|
|
@@ -203,6 +246,8 @@ declare const Trust: {
|
|
|
203
246
|
readonly decide: typeof decide;
|
|
204
247
|
readonly translate: typeof translate;
|
|
205
248
|
readonly match: typeof match;
|
|
249
|
+
readonly using: typeof using;
|
|
250
|
+
readonly usingAsync: typeof usingAsync;
|
|
206
251
|
};
|
|
207
252
|
|
|
208
|
-
export { type Err, type Failure, type Ok, Result, type StatedOk, type StatedResult, Trust, decide, err, match, ok, state, 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 };
|