1 | import { GlimmerSyntaxError } from '@glimmer/syntax';
|
2 | import { AnyOptionalList } from './list';
|
3 | declare abstract class ResultImpl<T> {
|
4 | static all<T extends Result<unknown>[]>(...results: T): MapAll<T>;
|
5 | abstract mapOk<U>(callback: (value: T) => U): Result<U>;
|
6 | abstract readonly isOk: boolean;
|
7 | abstract readonly isErr: boolean;
|
8 | }
|
9 | export declare const Result: typeof ResultImpl;
|
10 | declare class OkImpl<T> extends ResultImpl<T> {
|
11 | readonly value: T;
|
12 | readonly isOk = true;
|
13 | readonly isErr = false;
|
14 | constructor(value: T);
|
15 | expect(_message?: string): T;
|
16 | ifOk(callback: (value: T) => void): this;
|
17 | andThen<U>(callback: (value: T) => Result<U>): Result<U>;
|
18 | mapOk<U>(callback: (value: T) => U): Result<U>;
|
19 | ifErr(_callback: (value: GlimmerSyntaxError) => void): this;
|
20 | mapErr(_callback: (value: GlimmerSyntaxError) => GlimmerSyntaxError): Result<T>;
|
21 | }
|
22 | declare class ErrImpl<T> extends ResultImpl<T> {
|
23 | readonly reason: GlimmerSyntaxError;
|
24 | readonly isOk = false;
|
25 | readonly isErr = true;
|
26 | constructor(reason: GlimmerSyntaxError);
|
27 | expect(message?: string): T;
|
28 | andThen<U>(_callback: (value: T) => Result<U>): Result<U>;
|
29 | mapOk<U>(_callback: (value: T) => U): Result<U>;
|
30 | ifOk(_callback: (value: T) => void): this;
|
31 | mapErr(callback: (value: GlimmerSyntaxError) => GlimmerSyntaxError): Result<T>;
|
32 | ifErr(callback: (value: GlimmerSyntaxError) => void): this;
|
33 | cast<U>(): Result<U>;
|
34 | }
|
35 | export declare function isResult<T>(input: MaybeResult<T>): input is Result<T>;
|
36 | export declare function intoResult<T>(input: MaybeResult<T>): Result<T>;
|
37 | export declare type Result<T> = OkImpl<T> | ErrImpl<T>;
|
38 | declare type MapAllOk<T extends Result<unknown>[]> = {
|
39 | [P in keyof T]: T[P] extends Result<infer Inner> ? Inner : never;
|
40 | };
|
41 | declare type MapAll<T extends Result<unknown>[]> = Result<MapAllOk<T>>;
|
42 | export declare function Ok<T>(value: T): Result<T>;
|
43 | export declare type Ok<T> = OkImpl<T>;
|
44 | export declare function Err<T>(reason: GlimmerSyntaxError): Result<T>;
|
45 | export declare type Err<T> = ErrImpl<T>;
|
46 | export declare type MaybeResult<T> = T | Result<T>;
|
47 | export declare class MapIntoResultArray<T> {
|
48 | private items;
|
49 | constructor(items: T[]);
|
50 | map<U>(callback: (item: T) => Result<U>): Result<U[]>;
|
51 | }
|
52 | export declare class ResultArray<T> {
|
53 | private items;
|
54 | constructor(items?: Result<T>[]);
|
55 | add(item: Result<T>): void;
|
56 | toArray(): Result<T[]>;
|
57 | toOptionalList(): Result<AnyOptionalList<T>>;
|
58 | }
|
59 | export {};
|
60 | //# sourceMappingURL=result.d.ts.map |
\ | No newline at end of file |