generic-result-type 2.1.0 → 2.2.2
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/index.cjs +49 -12
- package/dist/index.cjs.map +1 -1
- package/dist/index.d.cts +114 -14
- package/dist/index.d.ts +114 -14
- package/dist/index.js +48 -12
- package/dist/index.js.map +1 -1
- package/package.json +1 -1
package/dist/index.cjs
CHANGED
|
@@ -22,6 +22,7 @@ var index_exports = {};
|
|
|
22
22
|
__export(index_exports, {
|
|
23
23
|
combine: () => combine,
|
|
24
24
|
fail: () => fail,
|
|
25
|
+
flatten: () => flatten,
|
|
25
26
|
isErrorResult: () => isErrorResult,
|
|
26
27
|
isSuccessResult: () => isSuccessResult,
|
|
27
28
|
success: () => success
|
|
@@ -36,11 +37,11 @@ var ErrorResult = class _ErrorResult {
|
|
|
36
37
|
}
|
|
37
38
|
// eslint-disable-next-line @typescript-eslint/no-unused-vars, @typescript-eslint/no-unnecessary-type-parameters
|
|
38
39
|
map(mapFunction) {
|
|
39
|
-
return this;
|
|
40
|
+
return new _ErrorResult(this.error);
|
|
40
41
|
}
|
|
41
|
-
// eslint-disable-next-line @typescript-eslint/no-unused-vars, @typescript-eslint/
|
|
42
|
-
|
|
43
|
-
return this;
|
|
42
|
+
// eslint-disable-next-line @typescript-eslint/no-unused-vars, @typescript-eslint/promise-function-async
|
|
43
|
+
mapAsync(mapFunction) {
|
|
44
|
+
return Promise.resolve(new _ErrorResult(this.error));
|
|
44
45
|
}
|
|
45
46
|
mapErr(mapFunction) {
|
|
46
47
|
return new _ErrorResult(mapFunction(this.error));
|
|
@@ -64,11 +65,11 @@ var SuccessResult = class _SuccessResult {
|
|
|
64
65
|
}
|
|
65
66
|
// eslint-disable-next-line @typescript-eslint/no-unused-vars, @typescript-eslint/no-unnecessary-type-parameters
|
|
66
67
|
mapErr(mapFunction) {
|
|
67
|
-
return this;
|
|
68
|
+
return new _SuccessResult(this.value);
|
|
68
69
|
}
|
|
69
|
-
// eslint-disable-next-line @typescript-eslint/no-unused-vars, @typescript-eslint/
|
|
70
|
-
|
|
71
|
-
return this;
|
|
70
|
+
// eslint-disable-next-line @typescript-eslint/no-unused-vars, @typescript-eslint/promise-function-async
|
|
71
|
+
mapErrAsync(mapFunction) {
|
|
72
|
+
return Promise.resolve(new _SuccessResult(this.value));
|
|
72
73
|
}
|
|
73
74
|
};
|
|
74
75
|
|
|
@@ -85,18 +86,54 @@ var isSuccessResult = (result) => {
|
|
|
85
86
|
var isErrorResult = (result) => {
|
|
86
87
|
return !result.success;
|
|
87
88
|
};
|
|
88
|
-
function combine(
|
|
89
|
+
function combine(results) {
|
|
90
|
+
const values = [];
|
|
91
|
+
const errors = [];
|
|
89
92
|
for (const r of results) {
|
|
90
|
-
if (
|
|
91
|
-
|
|
93
|
+
if (r.success) {
|
|
94
|
+
values.push(r.value);
|
|
95
|
+
} else {
|
|
96
|
+
errors.push(r.error);
|
|
92
97
|
}
|
|
93
98
|
}
|
|
94
|
-
|
|
99
|
+
if (errors.length) {
|
|
100
|
+
return new ErrorResult(errors);
|
|
101
|
+
}
|
|
102
|
+
return new SuccessResult(values);
|
|
95
103
|
}
|
|
104
|
+
var flatten = (result) => {
|
|
105
|
+
if (isSuccessResult(result)) {
|
|
106
|
+
return getValue(result);
|
|
107
|
+
}
|
|
108
|
+
return getError(result);
|
|
109
|
+
};
|
|
110
|
+
var getValue = (result) => {
|
|
111
|
+
if (result.value instanceof SuccessResult) {
|
|
112
|
+
return getValue(result.value);
|
|
113
|
+
}
|
|
114
|
+
if (result.value instanceof ErrorResult) {
|
|
115
|
+
return getError(result.value);
|
|
116
|
+
}
|
|
117
|
+
return result;
|
|
118
|
+
};
|
|
119
|
+
var getError = (result) => {
|
|
120
|
+
if (result.error instanceof SuccessResult) {
|
|
121
|
+
const value = getValue(result.error);
|
|
122
|
+
if (isSuccessResult(value)) {
|
|
123
|
+
return fail(value);
|
|
124
|
+
}
|
|
125
|
+
return value;
|
|
126
|
+
}
|
|
127
|
+
if (result.error instanceof ErrorResult) {
|
|
128
|
+
return getError(result.error);
|
|
129
|
+
}
|
|
130
|
+
return result;
|
|
131
|
+
};
|
|
96
132
|
// Annotate the CommonJS export names for ESM import in node:
|
|
97
133
|
0 && (module.exports = {
|
|
98
134
|
combine,
|
|
99
135
|
fail,
|
|
136
|
+
flatten,
|
|
100
137
|
isErrorResult,
|
|
101
138
|
isSuccessResult,
|
|
102
139
|
success
|
package/dist/index.cjs.map
CHANGED
|
@@ -1 +1 @@
|
|
|
1
|
-
{"version":3,"sources":["../src/index.mts","../src/errorResult.mts","../src/successResult.mts"],"sourcesContent":["import type { IErrorResult } from './errorResult.mjs';\nimport { ErrorResult } from './errorResult.mjs';\nimport type {
|
|
1
|
+
{"version":3,"sources":["../src/index.mts","../src/errorResult.mts","../src/successResult.mts"],"sourcesContent":["import type { IErrorResult } from './errorResult.mjs';\nimport { ErrorResult } from './errorResult.mjs';\nimport type { Result } from './result.mjs';\nimport type { ISuccessResult } from './successResult.mjs';\nimport { SuccessResult } from './successResult.mjs';\n\nexport type { Result, ISuccessResult, IErrorResult };\n\nexport function success(): ISuccessResult;\nexport function success<T>(value: T): ISuccessResult<T>;\nexport function success<T>(value?: T): ISuccessResult<T> {\n return new SuccessResult(value as T);\n};\n\nexport function fail<E>(error: E): IErrorResult<E> {\n return new ErrorResult(error);\n}\n\nexport const isSuccessResult = <T, E = Error>(result: Result<T, E>): result is ISuccessResult<T> => {\n return result.success;\n};\n\nexport const isErrorResult = <T, E = Error>(result: Result<T, E>): result is IErrorResult<E> => {\n return !result.success;\n};\n\nexport function combine(results: Result<unknown, unknown>[]): Result<unknown[], unknown[]> {\n const values: unknown[] = [];\n const errors: unknown[] = [];\n\n for (const r of results) {\n if (r.success) {\n values.push(r.value);\n } else {\n errors.push(r.error);\n }\n }\n\n if (errors.length) {\n return new ErrorResult(errors);\n }\n return new SuccessResult(values);\n}\n\nexport const flatten = (result: Result<unknown, unknown>): Result<unknown, unknown> => {\n if (isSuccessResult(result)) {\n return getValue(result);\n }\n return getError(result);\n};\n\nconst getValue = (result: SuccessResult<unknown>): Result<unknown, unknown> => {\n // value is a SuccessResult, drill down\n if (result.value instanceof SuccessResult) {\n return getValue(result.value);\n }\n\n // value is an ErrorResult, drill down\n if (result.value instanceof ErrorResult) {\n return getError(result.value);\n }\n\n // value is not a Result, return current SuccessResult\n return result;\n};\n\nconst getError = (result: ErrorResult<unknown>): ErrorResult<unknown> => {\n // error is a SuccessResult, consider this SuccessResult's value\n if (result.error instanceof SuccessResult) {\n const value = getValue(result.error);\n\n // if the value is a SuccessResult, swallow it into an error\n if (isSuccessResult(value)) {\n return fail(value);\n }\n\n // otherwise the value is an ErrorResult, return it\n return value;\n }\n\n // error is an ErrorResult, swallow it\n if (result.error instanceof ErrorResult) {\n return getError(result.error);\n }\n\n // error is not a Result, the current ErrorResult\n return result;\n};\n","import type { IResult } from './result.mjs';\n\nexport interface IErrorResult<E = Error> extends IResult<never, E> {\n readonly success: false;\n readonly error: E;\n\n /**\n * Returns a new `ErrorResult` with the same `error` property as this one.\n *\n * @param mapFunction the mapping function\n * @returns a new `ErrorResult`\n */\n // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-parameters\n readonly map: <M>(mapFunction: (value: never) => M) => IErrorResult<E>;\n\n /**\n * Asynchronously returns a new `ErrorResult` with the same `error` property as this one.\n * @param mapFunction the mapping function\n * @returns a new `ErrorResult`\n */\n readonly mapAsync: <M>(mapFunction: (value: never) => Promise<M>) => Promise<IErrorResult<E>>;\n\n /**\n * Calls a defined callback function on the `error` property, and returns a new `ErrorResult` with the resulting value.\n *\n * @param mapFunction the mapping function\n * @returns a new `ErrorResult`\n */\n readonly mapErr: <M>(mapFunction: (error: E) => M) => IErrorResult<M>;\n\n /**\n * Asynchronously calls a defined callback function on the `error` property, and returns a new `ErrorResult` with the resulting value.\n *\n * @param mapFunction the mapping function\n * @returns a new `ErrorResult`\n */\n readonly mapErrAsync: <M>(mapFunction: (error: E) => Promise<M>) => Promise<IErrorResult<M>>;\n}\n\nexport class ErrorResult<E> implements IResult<never, E>, IErrorResult<E> {\n public readonly success = false as const;\n\n public constructor(public readonly error: E) { /* empty */ }\n\n // eslint-disable-next-line @typescript-eslint/no-unused-vars, @typescript-eslint/no-unnecessary-type-parameters\n public map<M>(mapFunction: (value: never) => M): ErrorResult<E> {\n return new ErrorResult(this.error);\n }\n\n // eslint-disable-next-line @typescript-eslint/no-unused-vars, @typescript-eslint/promise-function-async\n public mapAsync<M>(mapFunction: (value: never) => Promise<M>): Promise<ErrorResult<E>> {\n return Promise.resolve(new ErrorResult(this.error));\n }\n\n public mapErr<M>(mapFunction: (error: E) => M): ErrorResult<M> {\n return new ErrorResult(mapFunction(this.error));\n }\n\n public async mapErrAsync<M>(mapFunction: (error: E) => Promise<M>): Promise<ErrorResult<M>> {\n return new ErrorResult(await mapFunction(this.error));\n }\n}\n","import type { IResult } from './result.mjs';\n\nexport interface ISuccessResult<T = void> {\n readonly success: true;\n readonly value: T;\n\n /**\n * Calls a defined callback function on the `value` property, and returns a new `SuccessResult` with the resulting value.\n *\n * @param mapFunction the mapping function\n * @returns a new `SuccessResult`\n */\n readonly map: <M>(mapFunction: (value: T) => M) => ISuccessResult<M>;\n\n /**\n * Asynchronously calls a defined callback function on the `value` property, and returns a new `SuccessResult` with the resulting value.\n * @param mapFunction the mapping function\n * @returns a new `SuccessResult`\n */\n readonly mapAsync: <M>(mapFunction: (value: T) => Promise<M>) => Promise<ISuccessResult<M>>;\n\n /**\n * Returns a new `SuccessResult` with the same `value` property as this one.\n *\n * @param mapFunction the mapping function\n * @returns a new `SuccessResult`\n */\n // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-parameters\n readonly mapErr: <M>(mapFunction: (error: never) => M) => ISuccessResult<T>;\n\n /**\n * Asynchronously returns a new `SuccessResult` with the same `value` property as this one.\n *\n * @param mapFunction the mapping function\n * @returns a new `SuccessResult`\n */\n readonly mapErrAsync: <M>(mapFunction: (error: never) => Promise<M>) => Promise<ISuccessResult<T>>;\n}\n\nexport class SuccessResult<T = void> implements IResult<T, never>, ISuccessResult<T> {\n public readonly success = true as const;\n public readonly value: T;\n\n public constructor(value?: T) {\n this.value = value as T;\n }\n\n public map<M>(mapFunction: (value: T) => M): SuccessResult<M> {\n return new SuccessResult(mapFunction(this.value));\n }\n\n public async mapAsync<M>(mapFunction: (value: T) => Promise<M>): Promise<SuccessResult<M>> {\n return new SuccessResult(await mapFunction(this.value));\n }\n\n // eslint-disable-next-line @typescript-eslint/no-unused-vars, @typescript-eslint/no-unnecessary-type-parameters\n public mapErr<M>(mapFunction: (error: never) => M): SuccessResult<T> {\n return new SuccessResult(this.value);\n }\n\n // eslint-disable-next-line @typescript-eslint/no-unused-vars, @typescript-eslint/promise-function-async\n public mapErrAsync<M>(mapFunction: (error: never) => Promise<M>): Promise<SuccessResult<T>> {\n return Promise.resolve(new SuccessResult(this.value));\n }\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;;;ACuCO,IAAM,cAAN,MAAM,aAA6D;AAAA,EAGjE,YAA4B,OAAU;AAAV;AAFnC,SAAgB,UAAU;AAAA,EAEiC;AAAA;AAAA,EAGpD,IAAO,aAAkD;AAC9D,WAAO,IAAI,aAAY,KAAK,KAAK;AAAA,EACnC;AAAA;AAAA,EAGO,SAAY,aAAoE;AACrF,WAAO,QAAQ,QAAQ,IAAI,aAAY,KAAK,KAAK,CAAC;AAAA,EACpD;AAAA,EAEO,OAAU,aAA8C;AAC7D,WAAO,IAAI,aAAY,YAAY,KAAK,KAAK,CAAC;AAAA,EAChD;AAAA,EAEA,MAAa,YAAe,aAAgE;AAC1F,WAAO,IAAI,aAAY,MAAM,YAAY,KAAK,KAAK,CAAC;AAAA,EACtD;AACF;;;ACtBO,IAAM,gBAAN,MAAM,eAAwE;AAAA,EAI5E,YAAY,OAAW;AAH9B,SAAgB,UAAU;AAIxB,SAAK,QAAQ;AAAA,EACf;AAAA,EAEO,IAAO,aAAgD;AAC5D,WAAO,IAAI,eAAc,YAAY,KAAK,KAAK,CAAC;AAAA,EAClD;AAAA,EAEA,MAAa,SAAY,aAAkE;AACzF,WAAO,IAAI,eAAc,MAAM,YAAY,KAAK,KAAK,CAAC;AAAA,EACxD;AAAA;AAAA,EAGO,OAAU,aAAoD;AACnE,WAAO,IAAI,eAAc,KAAK,KAAK;AAAA,EACrC;AAAA;AAAA,EAGO,YAAe,aAAsE;AAC1F,WAAO,QAAQ,QAAQ,IAAI,eAAc,KAAK,KAAK,CAAC;AAAA,EACtD;AACF;;;AFtDO,SAAS,QAAW,OAA8B;AACvD,SAAO,IAAI,cAAc,KAAU;AACrC;AAEO,SAAS,KAAQ,OAA2B;AACjD,SAAO,IAAI,YAAY,KAAK;AAC9B;AAEO,IAAM,kBAAkB,CAAe,WAAsD;AAClG,SAAO,OAAO;AAChB;AAEO,IAAM,gBAAgB,CAAe,WAAoD;AAC9F,SAAO,CAAC,OAAO;AACjB;AAEO,SAAS,QAAQ,SAAmE;AACzF,QAAM,SAAoB,CAAC;AAC3B,QAAM,SAAoB,CAAC;AAE3B,aAAW,KAAK,SAAS;AACvB,QAAI,EAAE,SAAS;AACb,aAAO,KAAK,EAAE,KAAK;AAAA,IACrB,OAAO;AACL,aAAO,KAAK,EAAE,KAAK;AAAA,IACrB;AAAA,EACF;AAEA,MAAI,OAAO,QAAQ;AACjB,WAAO,IAAI,YAAY,MAAM;AAAA,EAC/B;AACA,SAAO,IAAI,cAAc,MAAM;AACjC;AAEO,IAAM,UAAU,CAAC,WAA+D;AACrF,MAAI,gBAAgB,MAAM,GAAG;AAC3B,WAAO,SAAS,MAAM;AAAA,EACxB;AACA,SAAO,SAAS,MAAM;AACxB;AAEA,IAAM,WAAW,CAAC,WAA6D;AAE7E,MAAI,OAAO,iBAAiB,eAAe;AACzC,WAAO,SAAS,OAAO,KAAK;AAAA,EAC9B;AAGA,MAAI,OAAO,iBAAiB,aAAa;AACvC,WAAO,SAAS,OAAO,KAAK;AAAA,EAC9B;AAGA,SAAO;AACT;AAEA,IAAM,WAAW,CAAC,WAAuD;AAEvE,MAAI,OAAO,iBAAiB,eAAe;AACzC,UAAM,QAAQ,SAAS,OAAO,KAAK;AAGnC,QAAI,gBAAgB,KAAK,GAAG;AAC1B,aAAO,KAAK,KAAK;AAAA,IACnB;AAGA,WAAO;AAAA,EACT;AAGA,MAAI,OAAO,iBAAiB,aAAa;AACvC,WAAO,SAAS,OAAO,KAAK;AAAA,EAC9B;AAGA,SAAO;AACT;","names":[]}
|
package/dist/index.d.cts
CHANGED
|
@@ -1,27 +1,127 @@
|
|
|
1
|
-
interface IErrorResult<E = Error> {
|
|
2
|
-
readonly success: false;
|
|
3
|
-
readonly error: E;
|
|
4
|
-
readonly map: <M>(mapFunction: (value: never) => M) => IErrorResult<E>;
|
|
5
|
-
readonly mapAsync: <M>(mapFunction: (value: never) => Promise<M>) => Promise<IErrorResult<E>>;
|
|
6
|
-
readonly mapErr: <M>(mapFunction: (value: E) => M) => IErrorResult<M>;
|
|
7
|
-
readonly mapErrAsync: <M>(mapFunction: (value: E) => Promise<M>) => Promise<IErrorResult<M>>;
|
|
8
|
-
}
|
|
9
|
-
|
|
10
1
|
interface ISuccessResult<T = void> {
|
|
11
2
|
readonly success: true;
|
|
12
3
|
readonly value: T;
|
|
4
|
+
/**
|
|
5
|
+
* Calls a defined callback function on the `value` property, and returns a new `SuccessResult` with the resulting value.
|
|
6
|
+
*
|
|
7
|
+
* @param mapFunction the mapping function
|
|
8
|
+
* @returns a new `SuccessResult`
|
|
9
|
+
*/
|
|
13
10
|
readonly map: <M>(mapFunction: (value: T) => M) => ISuccessResult<M>;
|
|
11
|
+
/**
|
|
12
|
+
* Asynchronously calls a defined callback function on the `value` property, and returns a new `SuccessResult` with the resulting value.
|
|
13
|
+
* @param mapFunction the mapping function
|
|
14
|
+
* @returns a new `SuccessResult`
|
|
15
|
+
*/
|
|
14
16
|
readonly mapAsync: <M>(mapFunction: (value: T) => Promise<M>) => Promise<ISuccessResult<M>>;
|
|
15
|
-
|
|
16
|
-
|
|
17
|
+
/**
|
|
18
|
+
* Returns a new `SuccessResult` with the same `value` property as this one.
|
|
19
|
+
*
|
|
20
|
+
* @param mapFunction the mapping function
|
|
21
|
+
* @returns a new `SuccessResult`
|
|
22
|
+
*/
|
|
23
|
+
readonly mapErr: <M>(mapFunction: (error: never) => M) => ISuccessResult<T>;
|
|
24
|
+
/**
|
|
25
|
+
* Asynchronously returns a new `SuccessResult` with the same `value` property as this one.
|
|
26
|
+
*
|
|
27
|
+
* @param mapFunction the mapping function
|
|
28
|
+
* @returns a new `SuccessResult`
|
|
29
|
+
*/
|
|
30
|
+
readonly mapErrAsync: <M>(mapFunction: (error: never) => Promise<M>) => Promise<ISuccessResult<T>>;
|
|
31
|
+
}
|
|
32
|
+
declare class SuccessResult<T = void> implements IResult<T, never>, ISuccessResult<T> {
|
|
33
|
+
readonly success: true;
|
|
34
|
+
readonly value: T;
|
|
35
|
+
constructor(value?: T);
|
|
36
|
+
map<M>(mapFunction: (value: T) => M): SuccessResult<M>;
|
|
37
|
+
mapAsync<M>(mapFunction: (value: T) => Promise<M>): Promise<SuccessResult<M>>;
|
|
38
|
+
mapErr<M>(mapFunction: (error: never) => M): SuccessResult<T>;
|
|
39
|
+
mapErrAsync<M>(mapFunction: (error: never) => Promise<M>): Promise<SuccessResult<T>>;
|
|
40
|
+
}
|
|
41
|
+
|
|
42
|
+
interface IResult<T, E> {
|
|
43
|
+
readonly success: boolean;
|
|
44
|
+
/**
|
|
45
|
+
* If a `SuccessResult`, calls a defined callback function on the `value` property, and returns a new `SuccessResult` with the resulting value.
|
|
46
|
+
* If an `ErrorResult`, returns a new `ErrorResult` with the same `error` property as this one.
|
|
47
|
+
*
|
|
48
|
+
* @param mapFunction the mapping function
|
|
49
|
+
* @returns a new `Result`
|
|
50
|
+
*/
|
|
51
|
+
map: <M>(fn: (value: T) => M) => IResult<M, E>;
|
|
52
|
+
/**
|
|
53
|
+
* If a `SuccessResult`, asynchronously calls a defined callback function on the `value` property, and returns a new `SuccessResult` with the resulting value.
|
|
54
|
+
* If an `ErrorResult`, asynchronously returns a new `ErrorResult` with the same `error` property as this one.
|
|
55
|
+
* @param mapFunction the mapping function
|
|
56
|
+
* @returns a new `Result`
|
|
57
|
+
*/
|
|
58
|
+
mapAsync: <M>(fn: (value: T) => Promise<M>) => Promise<IResult<M, E>>;
|
|
59
|
+
/**
|
|
60
|
+
* If a `SuccessResult`, returns a new `SuccessResult` with the same `value` property as this one.
|
|
61
|
+
* If an `ErrorResult`, calls a defined callback function on the `error` property, and returns a new `ErrorResult` with the resulting value.
|
|
62
|
+
*
|
|
63
|
+
* @param mapFunction the mapping function
|
|
64
|
+
* @returns a new `Result`
|
|
65
|
+
*/
|
|
66
|
+
mapErr: <M>(fn: (error: E) => M) => IResult<T, M>;
|
|
67
|
+
/**
|
|
68
|
+
* If a `SuccessResult`, asynchronously returns a new `SuccessResult` with the same `value` property as this one.
|
|
69
|
+
* If an `ErrorResult`, asynchronously calls a defined callback function on the `error` property, and returns a new `ErrorResult` with the resulting value.
|
|
70
|
+
*
|
|
71
|
+
* @param mapFunction the mapping function
|
|
72
|
+
* @returns a new `Result`
|
|
73
|
+
*/
|
|
74
|
+
mapErrAsync: <M>(fn: (error: E) => Promise<M>) => Promise<IResult<T, M>>;
|
|
75
|
+
}
|
|
76
|
+
type Result<T = void, E = Error> = SuccessResult<T> | ErrorResult<E>;
|
|
77
|
+
|
|
78
|
+
interface IErrorResult<E = Error> extends IResult<never, E> {
|
|
79
|
+
readonly success: false;
|
|
80
|
+
readonly error: E;
|
|
81
|
+
/**
|
|
82
|
+
* Returns a new `ErrorResult` with the same `error` property as this one.
|
|
83
|
+
*
|
|
84
|
+
* @param mapFunction the mapping function
|
|
85
|
+
* @returns a new `ErrorResult`
|
|
86
|
+
*/
|
|
87
|
+
readonly map: <M>(mapFunction: (value: never) => M) => IErrorResult<E>;
|
|
88
|
+
/**
|
|
89
|
+
* Asynchronously returns a new `ErrorResult` with the same `error` property as this one.
|
|
90
|
+
* @param mapFunction the mapping function
|
|
91
|
+
* @returns a new `ErrorResult`
|
|
92
|
+
*/
|
|
93
|
+
readonly mapAsync: <M>(mapFunction: (value: never) => Promise<M>) => Promise<IErrorResult<E>>;
|
|
94
|
+
/**
|
|
95
|
+
* Calls a defined callback function on the `error` property, and returns a new `ErrorResult` with the resulting value.
|
|
96
|
+
*
|
|
97
|
+
* @param mapFunction the mapping function
|
|
98
|
+
* @returns a new `ErrorResult`
|
|
99
|
+
*/
|
|
100
|
+
readonly mapErr: <M>(mapFunction: (error: E) => M) => IErrorResult<M>;
|
|
101
|
+
/**
|
|
102
|
+
* Asynchronously calls a defined callback function on the `error` property, and returns a new `ErrorResult` with the resulting value.
|
|
103
|
+
*
|
|
104
|
+
* @param mapFunction the mapping function
|
|
105
|
+
* @returns a new `ErrorResult`
|
|
106
|
+
*/
|
|
107
|
+
readonly mapErrAsync: <M>(mapFunction: (error: E) => Promise<M>) => Promise<IErrorResult<M>>;
|
|
108
|
+
}
|
|
109
|
+
declare class ErrorResult<E> implements IResult<never, E>, IErrorResult<E> {
|
|
110
|
+
readonly error: E;
|
|
111
|
+
readonly success: false;
|
|
112
|
+
constructor(error: E);
|
|
113
|
+
map<M>(mapFunction: (value: never) => M): ErrorResult<E>;
|
|
114
|
+
mapAsync<M>(mapFunction: (value: never) => Promise<M>): Promise<ErrorResult<E>>;
|
|
115
|
+
mapErr<M>(mapFunction: (error: E) => M): ErrorResult<M>;
|
|
116
|
+
mapErrAsync<M>(mapFunction: (error: E) => Promise<M>): Promise<ErrorResult<M>>;
|
|
17
117
|
}
|
|
18
118
|
|
|
19
|
-
type Result<T = void, E = Error> = ISuccessResult<T> | IErrorResult<E>;
|
|
20
119
|
declare function success(): ISuccessResult;
|
|
21
120
|
declare function success<T>(value: T): ISuccessResult<T>;
|
|
22
121
|
declare function fail<E>(error: E): IErrorResult<E>;
|
|
23
122
|
declare const isSuccessResult: <T, E = Error>(result: Result<T, E>) => result is ISuccessResult<T>;
|
|
24
123
|
declare const isErrorResult: <T, E = Error>(result: Result<T, E>) => result is IErrorResult<E>;
|
|
25
|
-
declare function combine(
|
|
124
|
+
declare function combine(results: Result<unknown, unknown>[]): Result<unknown[], unknown[]>;
|
|
125
|
+
declare const flatten: (result: Result<unknown, unknown>) => Result<unknown, unknown>;
|
|
26
126
|
|
|
27
|
-
export { type IErrorResult, type ISuccessResult, type Result, combine, fail, isErrorResult, isSuccessResult, success };
|
|
127
|
+
export { type IErrorResult, type ISuccessResult, type Result, combine, fail, flatten, isErrorResult, isSuccessResult, success };
|
package/dist/index.d.ts
CHANGED
|
@@ -1,27 +1,127 @@
|
|
|
1
|
-
interface IErrorResult<E = Error> {
|
|
2
|
-
readonly success: false;
|
|
3
|
-
readonly error: E;
|
|
4
|
-
readonly map: <M>(mapFunction: (value: never) => M) => IErrorResult<E>;
|
|
5
|
-
readonly mapAsync: <M>(mapFunction: (value: never) => Promise<M>) => Promise<IErrorResult<E>>;
|
|
6
|
-
readonly mapErr: <M>(mapFunction: (value: E) => M) => IErrorResult<M>;
|
|
7
|
-
readonly mapErrAsync: <M>(mapFunction: (value: E) => Promise<M>) => Promise<IErrorResult<M>>;
|
|
8
|
-
}
|
|
9
|
-
|
|
10
1
|
interface ISuccessResult<T = void> {
|
|
11
2
|
readonly success: true;
|
|
12
3
|
readonly value: T;
|
|
4
|
+
/**
|
|
5
|
+
* Calls a defined callback function on the `value` property, and returns a new `SuccessResult` with the resulting value.
|
|
6
|
+
*
|
|
7
|
+
* @param mapFunction the mapping function
|
|
8
|
+
* @returns a new `SuccessResult`
|
|
9
|
+
*/
|
|
13
10
|
readonly map: <M>(mapFunction: (value: T) => M) => ISuccessResult<M>;
|
|
11
|
+
/**
|
|
12
|
+
* Asynchronously calls a defined callback function on the `value` property, and returns a new `SuccessResult` with the resulting value.
|
|
13
|
+
* @param mapFunction the mapping function
|
|
14
|
+
* @returns a new `SuccessResult`
|
|
15
|
+
*/
|
|
14
16
|
readonly mapAsync: <M>(mapFunction: (value: T) => Promise<M>) => Promise<ISuccessResult<M>>;
|
|
15
|
-
|
|
16
|
-
|
|
17
|
+
/**
|
|
18
|
+
* Returns a new `SuccessResult` with the same `value` property as this one.
|
|
19
|
+
*
|
|
20
|
+
* @param mapFunction the mapping function
|
|
21
|
+
* @returns a new `SuccessResult`
|
|
22
|
+
*/
|
|
23
|
+
readonly mapErr: <M>(mapFunction: (error: never) => M) => ISuccessResult<T>;
|
|
24
|
+
/**
|
|
25
|
+
* Asynchronously returns a new `SuccessResult` with the same `value` property as this one.
|
|
26
|
+
*
|
|
27
|
+
* @param mapFunction the mapping function
|
|
28
|
+
* @returns a new `SuccessResult`
|
|
29
|
+
*/
|
|
30
|
+
readonly mapErrAsync: <M>(mapFunction: (error: never) => Promise<M>) => Promise<ISuccessResult<T>>;
|
|
31
|
+
}
|
|
32
|
+
declare class SuccessResult<T = void> implements IResult<T, never>, ISuccessResult<T> {
|
|
33
|
+
readonly success: true;
|
|
34
|
+
readonly value: T;
|
|
35
|
+
constructor(value?: T);
|
|
36
|
+
map<M>(mapFunction: (value: T) => M): SuccessResult<M>;
|
|
37
|
+
mapAsync<M>(mapFunction: (value: T) => Promise<M>): Promise<SuccessResult<M>>;
|
|
38
|
+
mapErr<M>(mapFunction: (error: never) => M): SuccessResult<T>;
|
|
39
|
+
mapErrAsync<M>(mapFunction: (error: never) => Promise<M>): Promise<SuccessResult<T>>;
|
|
40
|
+
}
|
|
41
|
+
|
|
42
|
+
interface IResult<T, E> {
|
|
43
|
+
readonly success: boolean;
|
|
44
|
+
/**
|
|
45
|
+
* If a `SuccessResult`, calls a defined callback function on the `value` property, and returns a new `SuccessResult` with the resulting value.
|
|
46
|
+
* If an `ErrorResult`, returns a new `ErrorResult` with the same `error` property as this one.
|
|
47
|
+
*
|
|
48
|
+
* @param mapFunction the mapping function
|
|
49
|
+
* @returns a new `Result`
|
|
50
|
+
*/
|
|
51
|
+
map: <M>(fn: (value: T) => M) => IResult<M, E>;
|
|
52
|
+
/**
|
|
53
|
+
* If a `SuccessResult`, asynchronously calls a defined callback function on the `value` property, and returns a new `SuccessResult` with the resulting value.
|
|
54
|
+
* If an `ErrorResult`, asynchronously returns a new `ErrorResult` with the same `error` property as this one.
|
|
55
|
+
* @param mapFunction the mapping function
|
|
56
|
+
* @returns a new `Result`
|
|
57
|
+
*/
|
|
58
|
+
mapAsync: <M>(fn: (value: T) => Promise<M>) => Promise<IResult<M, E>>;
|
|
59
|
+
/**
|
|
60
|
+
* If a `SuccessResult`, returns a new `SuccessResult` with the same `value` property as this one.
|
|
61
|
+
* If an `ErrorResult`, calls a defined callback function on the `error` property, and returns a new `ErrorResult` with the resulting value.
|
|
62
|
+
*
|
|
63
|
+
* @param mapFunction the mapping function
|
|
64
|
+
* @returns a new `Result`
|
|
65
|
+
*/
|
|
66
|
+
mapErr: <M>(fn: (error: E) => M) => IResult<T, M>;
|
|
67
|
+
/**
|
|
68
|
+
* If a `SuccessResult`, asynchronously returns a new `SuccessResult` with the same `value` property as this one.
|
|
69
|
+
* If an `ErrorResult`, asynchronously calls a defined callback function on the `error` property, and returns a new `ErrorResult` with the resulting value.
|
|
70
|
+
*
|
|
71
|
+
* @param mapFunction the mapping function
|
|
72
|
+
* @returns a new `Result`
|
|
73
|
+
*/
|
|
74
|
+
mapErrAsync: <M>(fn: (error: E) => Promise<M>) => Promise<IResult<T, M>>;
|
|
75
|
+
}
|
|
76
|
+
type Result<T = void, E = Error> = SuccessResult<T> | ErrorResult<E>;
|
|
77
|
+
|
|
78
|
+
interface IErrorResult<E = Error> extends IResult<never, E> {
|
|
79
|
+
readonly success: false;
|
|
80
|
+
readonly error: E;
|
|
81
|
+
/**
|
|
82
|
+
* Returns a new `ErrorResult` with the same `error` property as this one.
|
|
83
|
+
*
|
|
84
|
+
* @param mapFunction the mapping function
|
|
85
|
+
* @returns a new `ErrorResult`
|
|
86
|
+
*/
|
|
87
|
+
readonly map: <M>(mapFunction: (value: never) => M) => IErrorResult<E>;
|
|
88
|
+
/**
|
|
89
|
+
* Asynchronously returns a new `ErrorResult` with the same `error` property as this one.
|
|
90
|
+
* @param mapFunction the mapping function
|
|
91
|
+
* @returns a new `ErrorResult`
|
|
92
|
+
*/
|
|
93
|
+
readonly mapAsync: <M>(mapFunction: (value: never) => Promise<M>) => Promise<IErrorResult<E>>;
|
|
94
|
+
/**
|
|
95
|
+
* Calls a defined callback function on the `error` property, and returns a new `ErrorResult` with the resulting value.
|
|
96
|
+
*
|
|
97
|
+
* @param mapFunction the mapping function
|
|
98
|
+
* @returns a new `ErrorResult`
|
|
99
|
+
*/
|
|
100
|
+
readonly mapErr: <M>(mapFunction: (error: E) => M) => IErrorResult<M>;
|
|
101
|
+
/**
|
|
102
|
+
* Asynchronously calls a defined callback function on the `error` property, and returns a new `ErrorResult` with the resulting value.
|
|
103
|
+
*
|
|
104
|
+
* @param mapFunction the mapping function
|
|
105
|
+
* @returns a new `ErrorResult`
|
|
106
|
+
*/
|
|
107
|
+
readonly mapErrAsync: <M>(mapFunction: (error: E) => Promise<M>) => Promise<IErrorResult<M>>;
|
|
108
|
+
}
|
|
109
|
+
declare class ErrorResult<E> implements IResult<never, E>, IErrorResult<E> {
|
|
110
|
+
readonly error: E;
|
|
111
|
+
readonly success: false;
|
|
112
|
+
constructor(error: E);
|
|
113
|
+
map<M>(mapFunction: (value: never) => M): ErrorResult<E>;
|
|
114
|
+
mapAsync<M>(mapFunction: (value: never) => Promise<M>): Promise<ErrorResult<E>>;
|
|
115
|
+
mapErr<M>(mapFunction: (error: E) => M): ErrorResult<M>;
|
|
116
|
+
mapErrAsync<M>(mapFunction: (error: E) => Promise<M>): Promise<ErrorResult<M>>;
|
|
17
117
|
}
|
|
18
118
|
|
|
19
|
-
type Result<T = void, E = Error> = ISuccessResult<T> | IErrorResult<E>;
|
|
20
119
|
declare function success(): ISuccessResult;
|
|
21
120
|
declare function success<T>(value: T): ISuccessResult<T>;
|
|
22
121
|
declare function fail<E>(error: E): IErrorResult<E>;
|
|
23
122
|
declare const isSuccessResult: <T, E = Error>(result: Result<T, E>) => result is ISuccessResult<T>;
|
|
24
123
|
declare const isErrorResult: <T, E = Error>(result: Result<T, E>) => result is IErrorResult<E>;
|
|
25
|
-
declare function combine(
|
|
124
|
+
declare function combine(results: Result<unknown, unknown>[]): Result<unknown[], unknown[]>;
|
|
125
|
+
declare const flatten: (result: Result<unknown, unknown>) => Result<unknown, unknown>;
|
|
26
126
|
|
|
27
|
-
export { type IErrorResult, type ISuccessResult, type Result, combine, fail, isErrorResult, isSuccessResult, success };
|
|
127
|
+
export { type IErrorResult, type ISuccessResult, type Result, combine, fail, flatten, isErrorResult, isSuccessResult, success };
|
package/dist/index.js
CHANGED
|
@@ -6,11 +6,11 @@ var ErrorResult = class _ErrorResult {
|
|
|
6
6
|
}
|
|
7
7
|
// eslint-disable-next-line @typescript-eslint/no-unused-vars, @typescript-eslint/no-unnecessary-type-parameters
|
|
8
8
|
map(mapFunction) {
|
|
9
|
-
return this;
|
|
9
|
+
return new _ErrorResult(this.error);
|
|
10
10
|
}
|
|
11
|
-
// eslint-disable-next-line @typescript-eslint/no-unused-vars, @typescript-eslint/
|
|
12
|
-
|
|
13
|
-
return this;
|
|
11
|
+
// eslint-disable-next-line @typescript-eslint/no-unused-vars, @typescript-eslint/promise-function-async
|
|
12
|
+
mapAsync(mapFunction) {
|
|
13
|
+
return Promise.resolve(new _ErrorResult(this.error));
|
|
14
14
|
}
|
|
15
15
|
mapErr(mapFunction) {
|
|
16
16
|
return new _ErrorResult(mapFunction(this.error));
|
|
@@ -34,11 +34,11 @@ var SuccessResult = class _SuccessResult {
|
|
|
34
34
|
}
|
|
35
35
|
// eslint-disable-next-line @typescript-eslint/no-unused-vars, @typescript-eslint/no-unnecessary-type-parameters
|
|
36
36
|
mapErr(mapFunction) {
|
|
37
|
-
return this;
|
|
37
|
+
return new _SuccessResult(this.value);
|
|
38
38
|
}
|
|
39
|
-
// eslint-disable-next-line @typescript-eslint/no-unused-vars, @typescript-eslint/
|
|
40
|
-
|
|
41
|
-
return this;
|
|
39
|
+
// eslint-disable-next-line @typescript-eslint/no-unused-vars, @typescript-eslint/promise-function-async
|
|
40
|
+
mapErrAsync(mapFunction) {
|
|
41
|
+
return Promise.resolve(new _SuccessResult(this.value));
|
|
42
42
|
}
|
|
43
43
|
};
|
|
44
44
|
|
|
@@ -55,17 +55,53 @@ var isSuccessResult = (result) => {
|
|
|
55
55
|
var isErrorResult = (result) => {
|
|
56
56
|
return !result.success;
|
|
57
57
|
};
|
|
58
|
-
function combine(
|
|
58
|
+
function combine(results) {
|
|
59
|
+
const values = [];
|
|
60
|
+
const errors = [];
|
|
59
61
|
for (const r of results) {
|
|
60
|
-
if (
|
|
61
|
-
|
|
62
|
+
if (r.success) {
|
|
63
|
+
values.push(r.value);
|
|
64
|
+
} else {
|
|
65
|
+
errors.push(r.error);
|
|
62
66
|
}
|
|
63
67
|
}
|
|
64
|
-
|
|
68
|
+
if (errors.length) {
|
|
69
|
+
return new ErrorResult(errors);
|
|
70
|
+
}
|
|
71
|
+
return new SuccessResult(values);
|
|
65
72
|
}
|
|
73
|
+
var flatten = (result) => {
|
|
74
|
+
if (isSuccessResult(result)) {
|
|
75
|
+
return getValue(result);
|
|
76
|
+
}
|
|
77
|
+
return getError(result);
|
|
78
|
+
};
|
|
79
|
+
var getValue = (result) => {
|
|
80
|
+
if (result.value instanceof SuccessResult) {
|
|
81
|
+
return getValue(result.value);
|
|
82
|
+
}
|
|
83
|
+
if (result.value instanceof ErrorResult) {
|
|
84
|
+
return getError(result.value);
|
|
85
|
+
}
|
|
86
|
+
return result;
|
|
87
|
+
};
|
|
88
|
+
var getError = (result) => {
|
|
89
|
+
if (result.error instanceof SuccessResult) {
|
|
90
|
+
const value = getValue(result.error);
|
|
91
|
+
if (isSuccessResult(value)) {
|
|
92
|
+
return fail(value);
|
|
93
|
+
}
|
|
94
|
+
return value;
|
|
95
|
+
}
|
|
96
|
+
if (result.error instanceof ErrorResult) {
|
|
97
|
+
return getError(result.error);
|
|
98
|
+
}
|
|
99
|
+
return result;
|
|
100
|
+
};
|
|
66
101
|
export {
|
|
67
102
|
combine,
|
|
68
103
|
fail,
|
|
104
|
+
flatten,
|
|
69
105
|
isErrorResult,
|
|
70
106
|
isSuccessResult,
|
|
71
107
|
success
|
package/dist/index.js.map
CHANGED
|
@@ -1 +1 @@
|
|
|
1
|
-
{"version":3,"sources":["../src/errorResult.mts","../src/successResult.mts","../src/index.mts"],"sourcesContent":["
|
|
1
|
+
{"version":3,"sources":["../src/errorResult.mts","../src/successResult.mts","../src/index.mts"],"sourcesContent":["import type { IResult } from './result.mjs';\n\nexport interface IErrorResult<E = Error> extends IResult<never, E> {\n readonly success: false;\n readonly error: E;\n\n /**\n * Returns a new `ErrorResult` with the same `error` property as this one.\n *\n * @param mapFunction the mapping function\n * @returns a new `ErrorResult`\n */\n // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-parameters\n readonly map: <M>(mapFunction: (value: never) => M) => IErrorResult<E>;\n\n /**\n * Asynchronously returns a new `ErrorResult` with the same `error` property as this one.\n * @param mapFunction the mapping function\n * @returns a new `ErrorResult`\n */\n readonly mapAsync: <M>(mapFunction: (value: never) => Promise<M>) => Promise<IErrorResult<E>>;\n\n /**\n * Calls a defined callback function on the `error` property, and returns a new `ErrorResult` with the resulting value.\n *\n * @param mapFunction the mapping function\n * @returns a new `ErrorResult`\n */\n readonly mapErr: <M>(mapFunction: (error: E) => M) => IErrorResult<M>;\n\n /**\n * Asynchronously calls a defined callback function on the `error` property, and returns a new `ErrorResult` with the resulting value.\n *\n * @param mapFunction the mapping function\n * @returns a new `ErrorResult`\n */\n readonly mapErrAsync: <M>(mapFunction: (error: E) => Promise<M>) => Promise<IErrorResult<M>>;\n}\n\nexport class ErrorResult<E> implements IResult<never, E>, IErrorResult<E> {\n public readonly success = false as const;\n\n public constructor(public readonly error: E) { /* empty */ }\n\n // eslint-disable-next-line @typescript-eslint/no-unused-vars, @typescript-eslint/no-unnecessary-type-parameters\n public map<M>(mapFunction: (value: never) => M): ErrorResult<E> {\n return new ErrorResult(this.error);\n }\n\n // eslint-disable-next-line @typescript-eslint/no-unused-vars, @typescript-eslint/promise-function-async\n public mapAsync<M>(mapFunction: (value: never) => Promise<M>): Promise<ErrorResult<E>> {\n return Promise.resolve(new ErrorResult(this.error));\n }\n\n public mapErr<M>(mapFunction: (error: E) => M): ErrorResult<M> {\n return new ErrorResult(mapFunction(this.error));\n }\n\n public async mapErrAsync<M>(mapFunction: (error: E) => Promise<M>): Promise<ErrorResult<M>> {\n return new ErrorResult(await mapFunction(this.error));\n }\n}\n","import type { IResult } from './result.mjs';\n\nexport interface ISuccessResult<T = void> {\n readonly success: true;\n readonly value: T;\n\n /**\n * Calls a defined callback function on the `value` property, and returns a new `SuccessResult` with the resulting value.\n *\n * @param mapFunction the mapping function\n * @returns a new `SuccessResult`\n */\n readonly map: <M>(mapFunction: (value: T) => M) => ISuccessResult<M>;\n\n /**\n * Asynchronously calls a defined callback function on the `value` property, and returns a new `SuccessResult` with the resulting value.\n * @param mapFunction the mapping function\n * @returns a new `SuccessResult`\n */\n readonly mapAsync: <M>(mapFunction: (value: T) => Promise<M>) => Promise<ISuccessResult<M>>;\n\n /**\n * Returns a new `SuccessResult` with the same `value` property as this one.\n *\n * @param mapFunction the mapping function\n * @returns a new `SuccessResult`\n */\n // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-parameters\n readonly mapErr: <M>(mapFunction: (error: never) => M) => ISuccessResult<T>;\n\n /**\n * Asynchronously returns a new `SuccessResult` with the same `value` property as this one.\n *\n * @param mapFunction the mapping function\n * @returns a new `SuccessResult`\n */\n readonly mapErrAsync: <M>(mapFunction: (error: never) => Promise<M>) => Promise<ISuccessResult<T>>;\n}\n\nexport class SuccessResult<T = void> implements IResult<T, never>, ISuccessResult<T> {\n public readonly success = true as const;\n public readonly value: T;\n\n public constructor(value?: T) {\n this.value = value as T;\n }\n\n public map<M>(mapFunction: (value: T) => M): SuccessResult<M> {\n return new SuccessResult(mapFunction(this.value));\n }\n\n public async mapAsync<M>(mapFunction: (value: T) => Promise<M>): Promise<SuccessResult<M>> {\n return new SuccessResult(await mapFunction(this.value));\n }\n\n // eslint-disable-next-line @typescript-eslint/no-unused-vars, @typescript-eslint/no-unnecessary-type-parameters\n public mapErr<M>(mapFunction: (error: never) => M): SuccessResult<T> {\n return new SuccessResult(this.value);\n }\n\n // eslint-disable-next-line @typescript-eslint/no-unused-vars, @typescript-eslint/promise-function-async\n public mapErrAsync<M>(mapFunction: (error: never) => Promise<M>): Promise<SuccessResult<T>> {\n return Promise.resolve(new SuccessResult(this.value));\n }\n};\n","import type { IErrorResult } from './errorResult.mjs';\nimport { ErrorResult } from './errorResult.mjs';\nimport type { Result } from './result.mjs';\nimport type { ISuccessResult } from './successResult.mjs';\nimport { SuccessResult } from './successResult.mjs';\n\nexport type { Result, ISuccessResult, IErrorResult };\n\nexport function success(): ISuccessResult;\nexport function success<T>(value: T): ISuccessResult<T>;\nexport function success<T>(value?: T): ISuccessResult<T> {\n return new SuccessResult(value as T);\n};\n\nexport function fail<E>(error: E): IErrorResult<E> {\n return new ErrorResult(error);\n}\n\nexport const isSuccessResult = <T, E = Error>(result: Result<T, E>): result is ISuccessResult<T> => {\n return result.success;\n};\n\nexport const isErrorResult = <T, E = Error>(result: Result<T, E>): result is IErrorResult<E> => {\n return !result.success;\n};\n\nexport function combine(results: Result<unknown, unknown>[]): Result<unknown[], unknown[]> {\n const values: unknown[] = [];\n const errors: unknown[] = [];\n\n for (const r of results) {\n if (r.success) {\n values.push(r.value);\n } else {\n errors.push(r.error);\n }\n }\n\n if (errors.length) {\n return new ErrorResult(errors);\n }\n return new SuccessResult(values);\n}\n\nexport const flatten = (result: Result<unknown, unknown>): Result<unknown, unknown> => {\n if (isSuccessResult(result)) {\n return getValue(result);\n }\n return getError(result);\n};\n\nconst getValue = (result: SuccessResult<unknown>): Result<unknown, unknown> => {\n // value is a SuccessResult, drill down\n if (result.value instanceof SuccessResult) {\n return getValue(result.value);\n }\n\n // value is an ErrorResult, drill down\n if (result.value instanceof ErrorResult) {\n return getError(result.value);\n }\n\n // value is not a Result, return current SuccessResult\n return result;\n};\n\nconst getError = (result: ErrorResult<unknown>): ErrorResult<unknown> => {\n // error is a SuccessResult, consider this SuccessResult's value\n if (result.error instanceof SuccessResult) {\n const value = getValue(result.error);\n\n // if the value is a SuccessResult, swallow it into an error\n if (isSuccessResult(value)) {\n return fail(value);\n }\n\n // otherwise the value is an ErrorResult, return it\n return value;\n }\n\n // error is an ErrorResult, swallow it\n if (result.error instanceof ErrorResult) {\n return getError(result.error);\n }\n\n // error is not a Result, the current ErrorResult\n return result;\n};\n"],"mappings":";AAuCO,IAAM,cAAN,MAAM,aAA6D;AAAA,EAGjE,YAA4B,OAAU;AAAV;AAFnC,SAAgB,UAAU;AAAA,EAEiC;AAAA;AAAA,EAGpD,IAAO,aAAkD;AAC9D,WAAO,IAAI,aAAY,KAAK,KAAK;AAAA,EACnC;AAAA;AAAA,EAGO,SAAY,aAAoE;AACrF,WAAO,QAAQ,QAAQ,IAAI,aAAY,KAAK,KAAK,CAAC;AAAA,EACpD;AAAA,EAEO,OAAU,aAA8C;AAC7D,WAAO,IAAI,aAAY,YAAY,KAAK,KAAK,CAAC;AAAA,EAChD;AAAA,EAEA,MAAa,YAAe,aAAgE;AAC1F,WAAO,IAAI,aAAY,MAAM,YAAY,KAAK,KAAK,CAAC;AAAA,EACtD;AACF;;;ACtBO,IAAM,gBAAN,MAAM,eAAwE;AAAA,EAI5E,YAAY,OAAW;AAH9B,SAAgB,UAAU;AAIxB,SAAK,QAAQ;AAAA,EACf;AAAA,EAEO,IAAO,aAAgD;AAC5D,WAAO,IAAI,eAAc,YAAY,KAAK,KAAK,CAAC;AAAA,EAClD;AAAA,EAEA,MAAa,SAAY,aAAkE;AACzF,WAAO,IAAI,eAAc,MAAM,YAAY,KAAK,KAAK,CAAC;AAAA,EACxD;AAAA;AAAA,EAGO,OAAU,aAAoD;AACnE,WAAO,IAAI,eAAc,KAAK,KAAK;AAAA,EACrC;AAAA;AAAA,EAGO,YAAe,aAAsE;AAC1F,WAAO,QAAQ,QAAQ,IAAI,eAAc,KAAK,KAAK,CAAC;AAAA,EACtD;AACF;;;ACtDO,SAAS,QAAW,OAA8B;AACvD,SAAO,IAAI,cAAc,KAAU;AACrC;AAEO,SAAS,KAAQ,OAA2B;AACjD,SAAO,IAAI,YAAY,KAAK;AAC9B;AAEO,IAAM,kBAAkB,CAAe,WAAsD;AAClG,SAAO,OAAO;AAChB;AAEO,IAAM,gBAAgB,CAAe,WAAoD;AAC9F,SAAO,CAAC,OAAO;AACjB;AAEO,SAAS,QAAQ,SAAmE;AACzF,QAAM,SAAoB,CAAC;AAC3B,QAAM,SAAoB,CAAC;AAE3B,aAAW,KAAK,SAAS;AACvB,QAAI,EAAE,SAAS;AACb,aAAO,KAAK,EAAE,KAAK;AAAA,IACrB,OAAO;AACL,aAAO,KAAK,EAAE,KAAK;AAAA,IACrB;AAAA,EACF;AAEA,MAAI,OAAO,QAAQ;AACjB,WAAO,IAAI,YAAY,MAAM;AAAA,EAC/B;AACA,SAAO,IAAI,cAAc,MAAM;AACjC;AAEO,IAAM,UAAU,CAAC,WAA+D;AACrF,MAAI,gBAAgB,MAAM,GAAG;AAC3B,WAAO,SAAS,MAAM;AAAA,EACxB;AACA,SAAO,SAAS,MAAM;AACxB;AAEA,IAAM,WAAW,CAAC,WAA6D;AAE7E,MAAI,OAAO,iBAAiB,eAAe;AACzC,WAAO,SAAS,OAAO,KAAK;AAAA,EAC9B;AAGA,MAAI,OAAO,iBAAiB,aAAa;AACvC,WAAO,SAAS,OAAO,KAAK;AAAA,EAC9B;AAGA,SAAO;AACT;AAEA,IAAM,WAAW,CAAC,WAAuD;AAEvE,MAAI,OAAO,iBAAiB,eAAe;AACzC,UAAM,QAAQ,SAAS,OAAO,KAAK;AAGnC,QAAI,gBAAgB,KAAK,GAAG;AAC1B,aAAO,KAAK,KAAK;AAAA,IACnB;AAGA,WAAO;AAAA,EACT;AAGA,MAAI,OAAO,iBAAiB,aAAa;AACvC,WAAO,SAAS,OAAO,KAAK;AAAA,EAC9B;AAGA,SAAO;AACT;","names":[]}
|