@dxos/errors 0.8.4-main.74a063c4e0 → 0.8.4-main.765dc60934

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.
Files changed (9) hide show
  1. package/LICENSE +102 -5
  2. package/dist/lib/browser/meta.json +1 -1
  3. package/dist/lib/node-esm/meta.json +1 -1
  4. package/dist/types/src/base.d.ts +6 -6
  5. package/dist/types/src/base.d.ts.map +1 -1
  6. package/dist/types/src/errors.d.ts +78 -78
  7. package/dist/types/src/errors.d.ts.map +1 -1
  8. package/dist/types/tsconfig.tsbuildinfo +1 -1
  9. package/package.json +2 -5
package/LICENSE CHANGED
@@ -1,8 +1,105 @@
1
- MIT License
2
- Copyright (c) 2022 DXOS
1
+ # Functional Source License, Version 1.1, ALv2 Future License
3
2
 
4
- Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
3
+ ## Abbreviation
5
4
 
6
- The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
5
+ FSL-1.1-Apache-2.0
7
6
 
8
- THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
7
+ ## Notice
8
+
9
+ Copyright 2026 DXOS
10
+
11
+ ## Terms and Conditions
12
+
13
+ ### Licensor ("We")
14
+
15
+ The party offering the Software under these Terms and Conditions.
16
+
17
+ ### The Software
18
+
19
+ The "Software" is each version of the software that we make available under
20
+ these Terms and Conditions, as indicated by our inclusion of these Terms and
21
+ Conditions with the Software.
22
+
23
+ ### License Grant
24
+
25
+ Subject to your compliance with this License Grant and the Patents,
26
+ Redistribution and Trademark clauses below, we hereby grant you the right to
27
+ use, copy, modify, create derivative works, publicly perform, publicly display
28
+ and redistribute the Software for any Permitted Purpose identified below.
29
+
30
+ ### Permitted Purpose
31
+
32
+ A Permitted Purpose is any purpose other than a Competing Use. A Competing Use
33
+ means making the Software available to others in a commercial product or
34
+ service that:
35
+
36
+ 1. substitutes for the Software;
37
+
38
+ 2. substitutes for any other product or service we offer using the Software
39
+ that exists as of the date we make the Software available; or
40
+
41
+ 3. offers the same or substantially similar functionality as the Software.
42
+
43
+ Permitted Purposes specifically include using the Software:
44
+
45
+ 1. for your internal use and access;
46
+
47
+ 2. for non-commercial education;
48
+
49
+ 3. for non-commercial research; and
50
+
51
+ 4. in connection with professional services that you provide to a licensee
52
+ using the Software in accordance with these Terms and Conditions.
53
+
54
+ ### Patents
55
+
56
+ To the extent your use for a Permitted Purpose would necessarily infringe our
57
+ patents, the license grant above includes a license under our patents. If you
58
+ make a claim against any party that the Software infringes or contributes to
59
+ the infringement of any patent, then your patent license to the Software ends
60
+ immediately.
61
+
62
+ ### Redistribution
63
+
64
+ The Terms and Conditions apply to all copies, modifications and derivatives of
65
+ the Software.
66
+
67
+ If you redistribute any copies, modifications or derivatives of the Software,
68
+ you must include a copy of or a link to these Terms and Conditions and not
69
+ remove any copyright notices provided in or with the Software.
70
+
71
+ ### Disclaimer
72
+
73
+ THE SOFTWARE IS PROVIDED "AS IS" AND WITHOUT WARRANTIES OF ANY KIND, EXPRESS OR
74
+ IMPLIED, INCLUDING WITHOUT LIMITATION WARRANTIES OF FITNESS FOR A PARTICULAR
75
+ PURPOSE, MERCHANTABILITY, TITLE OR NON-INFRINGEMENT.
76
+
77
+ IN NO EVENT WILL WE HAVE ANY LIABILITY TO YOU ARISING OUT OF OR RELATED TO THE
78
+ SOFTWARE, INCLUDING INDIRECT, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES,
79
+ EVEN IF WE HAVE BEEN INFORMED OF THEIR POSSIBILITY IN ADVANCE.
80
+
81
+ ### Trademarks
82
+
83
+ Except for displaying the License Details and identifying us as the origin of
84
+ the Software, you have no right under these Terms and Conditions to use our
85
+ trademarks, trade names, service marks or product names.
86
+
87
+ ## Grant of Future License
88
+
89
+ We hereby irrevocably grant you an additional license to use the Software under
90
+ the Apache License, Version 2.0 that is effective on the second anniversary of
91
+ the date we make the Software available. On or after that date, you may use the
92
+ Software under the Apache License, Version 2.0, in which case the following
93
+ will apply:
94
+
95
+ Licensed under the Apache License, Version 2.0 (the "License"); you may not use
96
+ this file except in compliance with the License.
97
+
98
+ You may obtain a copy of the License at
99
+
100
+ http://www.apache.org/licenses/LICENSE-2.0
101
+
102
+ Unless required by applicable law or agreed to in writing, software distributed
103
+ under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
104
+ CONDITIONS OF ANY KIND, either express or implied. See the License for the
105
+ specific language governing permissions and limitations under the License.
package/dist/lib/browser/meta.json CHANGED
@@ -1 +1 @@
1
- {"inputs":{"src/base.ts":{"bytes":7713,"imports":[],"format":"esm"},"src/errors.ts":{"bytes":2648,"imports":[{"path":"src/base.ts","kind":"import-statement","original":"./base"}],"format":"esm"},"src/index.ts":{"bytes":523,"imports":[{"path":"src/base.ts","kind":"import-statement","original":"./base"},{"path":"src/errors.ts","kind":"import-statement","original":"./errors"}],"format":"esm"}},"outputs":{"dist/lib/browser/index.mjs.map":{"imports":[],"exports":[],"inputs":{},"bytes":5162},"dist/lib/browser/index.mjs":{"imports":[],"exports":["AbortedError","ApiError","BaseError","InternalError","NotImplementedError","RuntimeServiceError","SystemError","TimeoutError"],"entryPoint":"src/index.ts","inputs":{"src/base.ts":{"bytesInOutput":1726},"src/index.ts":{"bytesInOutput":0},"src/errors.ts":{"bytesInOutput":630}},"bytes":2570}}}
1
+ {"inputs":{"src/base.ts":{"bytes":7641,"imports":[],"format":"esm"},"src/errors.ts":{"bytes":2574,"imports":[{"path":"src/base.ts","kind":"import-statement","original":"./base"}],"format":"esm"},"src/index.ts":{"bytes":450,"imports":[{"path":"src/base.ts","kind":"import-statement","original":"./base"},{"path":"src/errors.ts","kind":"import-statement","original":"./errors"}],"format":"esm"}},"outputs":{"dist/lib/browser/index.mjs.map":{"imports":[],"exports":[],"inputs":{},"bytes":5162},"dist/lib/browser/index.mjs":{"imports":[],"exports":["AbortedError","ApiError","BaseError","InternalError","NotImplementedError","RuntimeServiceError","SystemError","TimeoutError"],"entryPoint":"src/index.ts","inputs":{"src/base.ts":{"bytesInOutput":1726},"src/index.ts":{"bytesInOutput":0},"src/errors.ts":{"bytesInOutput":630}},"bytes":2570}}}
package/dist/lib/node-esm/meta.json CHANGED
@@ -1 +1 @@
1
- {"inputs":{"src/base.ts":{"bytes":7713,"imports":[],"format":"esm"},"src/errors.ts":{"bytes":2648,"imports":[{"path":"src/base.ts","kind":"import-statement","original":"./base"}],"format":"esm"},"src/index.ts":{"bytes":523,"imports":[{"path":"src/base.ts","kind":"import-statement","original":"./base"},{"path":"src/errors.ts","kind":"import-statement","original":"./errors"}],"format":"esm"}},"outputs":{"dist/lib/node-esm/index.mjs.map":{"imports":[],"exports":[],"inputs":{},"bytes":5164},"dist/lib/node-esm/index.mjs":{"imports":[],"exports":["AbortedError","ApiError","BaseError","InternalError","NotImplementedError","RuntimeServiceError","SystemError","TimeoutError"],"entryPoint":"src/index.ts","inputs":{"src/base.ts":{"bytesInOutput":1726},"src/index.ts":{"bytesInOutput":0},"src/errors.ts":{"bytesInOutput":630}},"bytes":2663}}}
1
+ {"inputs":{"src/base.ts":{"bytes":7641,"imports":[],"format":"esm"},"src/errors.ts":{"bytes":2574,"imports":[{"path":"src/base.ts","kind":"import-statement","original":"./base"}],"format":"esm"},"src/index.ts":{"bytes":450,"imports":[{"path":"src/base.ts","kind":"import-statement","original":"./base"},{"path":"src/errors.ts","kind":"import-statement","original":"./errors"}],"format":"esm"}},"outputs":{"dist/lib/node-esm/index.mjs.map":{"imports":[],"exports":[],"inputs":{},"bytes":5164},"dist/lib/node-esm/index.mjs":{"imports":[],"exports":["AbortedError","ApiError","BaseError","InternalError","NotImplementedError","RuntimeServiceError","SystemError","TimeoutError"],"entryPoint":"src/index.ts","inputs":{"src/base.ts":{"bytesInOutput":1726},"src/index.ts":{"bytesInOutput":0},"src/errors.ts":{"bytesInOutput":630}},"bytes":2663}}}
package/dist/types/src/base.d.ts CHANGED
@@ -23,29 +23,29 @@ export declare class BaseError<Name extends string = string> extends Error {
23
23
  */
24
24
  static extend<Name extends string = string>(name: Name, message?: string): {
25
25
  new (options?: BaseErrorOptions): {
26
+ cause?: unknown;
27
+ stack?: string;
26
28
  name: Name;
27
29
  context: Record<string, unknown>;
28
30
  /** Fallback message. */
29
31
  get message(): string;
30
32
  get _tag(): Name;
31
- stack?: string;
32
- cause?: unknown;
33
33
  };
34
+ isError(error: unknown): error is Error;
34
35
  name: Name;
35
36
  is(error: unknown): error is BaseError;
36
- wrap(options?: Omit<BaseErrorOptions, "cause"> & {
37
+ wrap(options?: Omit<BaseErrorOptions, 'cause'> & {
37
38
  ifTypeDiffers?: boolean;
38
39
  }): (error: unknown) => {
40
+ cause?: unknown;
41
+ stack?: string;
39
42
  name: Name;
40
43
  context: Record<string, unknown>;
41
44
  /** Fallback message. */
42
45
  get message(): string;
43
46
  get _tag(): Name;
44
- stack?: string;
45
- cause?: unknown;
46
47
  };
47
48
  extend<Name extends string = string>(name: Name, message?: string): /*elided*/ any;
48
- isError(error: unknown): error is Error;
49
49
  captureStackTrace(targetObject: object, constructorOpt?: Function): void;
50
50
  prepareStackTrace?: ((err: Error, stackTraces: NodeJS.CallSite[]) => any) | undefined;
51
51
  stackTraceLimit: number;
package/dist/types/src/base.d.ts.map CHANGED
@@ -1 +1 @@
1
- {"version":3,"file":"base.d.ts","sourceRoot":"","sources":["../../../src/base.ts"],"names":[],"mappings":"AAIA;;GAEG;AACH,MAAM,MAAM,gBAAgB,GAAG,YAAY,GAAG;IAC5C;;OAEG;IACH,OAAO,CAAC,EAAE,MAAM,CAAC;IAEjB;;OAEG;IACH,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACnC,CAAC;AAEF;;GAEG;AACH,qBAAa,SAAS,CAAC,IAAI,SAAS,MAAM,GAAG,MAAM,CAAE,SAAQ,KAAK;IAChE;;;;;OAKG;IACH,MAAM,CAAC,MAAM,CAAC,IAAI,SAAS,MAAM,GAAG,MAAM,EAAE,IAAI,EAAE,IAAI,EAAE,OAAO,CAAC,EAAE,MAAM;uBAsB9C,gBAAgB;;qBAQjC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;YAgBhC,wBAAwB;;;;;;cA5CE,IAAI;kBAET,OAAO,GAAG,KAAK,IAAI,SAAS;uBAKjC,IAAI,CAAC,gBAAgB,EAAE,OAAO,CAAC,GAAG;YAAE,aAAa,CAAC,EAAE,OAAO,CAAA;SAAE,GACtE,CAAC,KAAK,EAAE,OAAO;;qBAoBb,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;YAgBhC,wBAAwB;;;;;SApCgB;eAV1B,IAAI,SAAS,MAAM,iBAAiB,IAAI,YAAY,MAAM;;;;;;IA6B/D,IAAI,EAAE,IAAI,CAAC;IACpB,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;gBAErB,IAAI,EAAE,IAAI,EAAE,OAAO,CAAC,EAAE,gBAAgB;IAclD,wBAAwB;IACxB,IAAa,OAAO,WAEnB;IAGD,IAAI,IAAI,IAAI,IAAI,CAEf;CACF"}
1
+ {"version":3,"file":"base.d.ts","sourceRoot":"","sources":["../../../src/base.ts"],"names":[],"mappings":"AAIA;;GAEG;AACH,MAAM,MAAM,gBAAgB,GAAG,YAAY,GAAG;IAC5C;;OAEG;IACH,OAAO,CAAC,EAAE,MAAM,CAAC;IAEjB;;OAEG;IACH,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACnC,CAAC;AAEF;;GAEG;AACH,qBAAa,SAAS,CAAC,IAAI,SAAS,MAAM,GAAG,MAAM,CAAE,SAAQ,KAAK;IAChE;;;;;OAKG;IACH,MAAM,CAAC,MAAM,CAAC,IAAI,SAAS,MAAM,GAAG,MAAM,EAAE,IAAI,EAAE,IAAI,EAAE,OAAO,CAAC,EAAE,MAAM;uBAsB9C,gBAAgB;;;;qBAQjC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;YAgBhC,wBAAwB;;;;;cA5CE,IAAI;kBAET,OAAO,GAAG,KAAK,IAAI,SAAS;uBAKjC,IAAI,CAAC,gBAAgB,EAAE,OAAO,CAAC,GAAG;YAAE,aAAa,CAAC,EAAE,OAAO,CAAA;SAAE,GACtE,CAAC,KAAK,EAAE,OAAO;;;;qBAoBb,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;YAgBhC,wBAAwB;;;SApCgB;eAV1B,IAAI,SAAS,MAAM,iBAAiB,IAAI,YAAY,MAAM;;;;MA0BvE;IAGQ,IAAI,EAAE,IAAI,CAAC;IACpB,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAEjC,YAAY,IAAI,EAAE,IAAI,EAAE,OAAO,CAAC,EAAE,gBAAgB,EAYjD;IAED,wBAAwB;IACxB,IAAa,OAAO,WAEnB;IAGD,IAAI,IAAI,IAAI,IAAI,CAEf;CACF"}
package/dist/types/src/errors.d.ts CHANGED
@@ -1,53 +1,53 @@
1
1
  import { BaseError } from './base';
2
2
  declare const ApiError_base: {
3
3
  new (options?: import("./base").BaseErrorOptions): {
4
+ cause?: unknown;
5
+ stack?: string;
4
6
  name: "ApiError";
5
7
  context: Record<string, unknown>;
6
8
  get message(): string;
7
9
  get _tag(): "ApiError";
8
- stack?: string;
9
- cause?: unknown;
10
10
  };
11
+ isError(error: unknown): error is Error;
11
12
  name: "ApiError";
12
- is(error: unknown): error is BaseError;
13
+ is(error: unknown): boolean;
13
14
  wrap(options?: (Omit<import("./base").BaseErrorOptions, "cause"> & {
14
15
  ifTypeDiffers?: boolean;
15
16
  }) | undefined): (error: unknown) => {
17
+ cause?: unknown;
18
+ stack?: string;
16
19
  name: "ApiError";
17
20
  context: Record<string, unknown>;
18
21
  get message(): string;
19
22
  get _tag(): "ApiError";
20
- stack?: string;
21
- cause?: unknown;
22
23
  };
23
24
  extend<Name extends string = string>(name: Name, message?: string): {
24
25
  new (options?: import("./base").BaseErrorOptions): {
26
+ cause?: unknown;
27
+ stack?: string;
25
28
  name: Name;
26
29
  context: Record<string, unknown>;
27
30
  get message(): string;
28
31
  get _tag(): Name;
29
- stack?: string;
30
- cause?: unknown;
31
32
  };
33
+ isError(error: unknown): error is Error;
32
34
  name: Name;
33
35
  is(error: unknown): error is BaseError;
34
- wrap(options?: Omit<import("./base").BaseErrorOptions, "cause"> & {
36
+ wrap(options?: Omit<import("./base").BaseErrorOptions, 'cause'> & {
35
37
  ifTypeDiffers?: boolean;
36
38
  }): (error: unknown) => {
39
+ cause?: unknown;
40
+ stack?: string;
37
41
  name: Name;
38
42
  context: Record<string, unknown>;
39
43
  get message(): string;
40
44
  get _tag(): Name;
41
- stack?: string;
42
- cause?: unknown;
43
45
  };
44
46
  extend<Name extends string = string>(name: Name, message?: string): /*elided*/ any;
45
- isError(error: unknown): error is Error;
46
47
  captureStackTrace(targetObject: object, constructorOpt?: Function): void;
47
48
  prepareStackTrace?: ((err: Error, stackTraces: NodeJS.CallSite[]) => any) | undefined;
48
49
  stackTraceLimit: number;
49
50
  };
50
- isError(error: unknown): error is Error;
51
51
  captureStackTrace(targetObject: object, constructorOpt?: Function): void;
52
52
  prepareStackTrace?: ((err: Error, stackTraces: NodeJS.CallSite[]) => any) | undefined;
53
53
  stackTraceLimit: number;
@@ -56,53 +56,53 @@ export declare class ApiError extends ApiError_base {
56
56
  }
57
57
  declare const SystemError_base: {
58
58
  new (options?: import("./base").BaseErrorOptions): {
59
+ cause?: unknown;
60
+ stack?: string;
59
61
  name: "SystemError";
60
62
  context: Record<string, unknown>;
61
63
  get message(): string;
62
64
  get _tag(): "SystemError";
63
- stack?: string;
64
- cause?: unknown;
65
65
  };
66
+ isError(error: unknown): error is Error;
66
67
  name: "SystemError";
67
68
  is(error: unknown): error is BaseError;
68
69
  wrap(options?: (Omit<import("./base").BaseErrorOptions, "cause"> & {
69
70
  ifTypeDiffers?: boolean;
70
71
  }) | undefined): (error: unknown) => {
72
+ cause?: unknown;
73
+ stack?: string;
71
74
  name: "SystemError";
72
75
  context: Record<string, unknown>;
73
76
  get message(): string;
74
77
  get _tag(): "SystemError";
75
- stack?: string;
76
- cause?: unknown;
77
78
  };
78
79
  extend<Name extends string = string>(name: Name, message?: string): {
79
80
  new (options?: import("./base").BaseErrorOptions): {
81
+ cause?: unknown;
82
+ stack?: string;
80
83
  name: Name;
81
84
  context: Record<string, unknown>;
82
85
  get message(): string;
83
86
  get _tag(): Name;
84
- stack?: string;
85
- cause?: unknown;
86
87
  };
88
+ isError(error: unknown): error is Error;
87
89
  name: Name;
88
90
  is(error: unknown): error is BaseError;
89
- wrap(options?: Omit<import("./base").BaseErrorOptions, "cause"> & {
91
+ wrap(options?: Omit<import("./base").BaseErrorOptions, 'cause'> & {
90
92
  ifTypeDiffers?: boolean;
91
93
  }): (error: unknown) => {
94
+ cause?: unknown;
95
+ stack?: string;
92
96
  name: Name;
93
97
  context: Record<string, unknown>;
94
98
  get message(): string;
95
99
  get _tag(): Name;
96
- stack?: string;
97
- cause?: unknown;
98
100
  };
99
101
  extend<Name extends string = string>(name: Name, message?: string): /*elided*/ any;
100
- isError(error: unknown): error is Error;
101
102
  captureStackTrace(targetObject: object, constructorOpt?: Function): void;
102
103
  prepareStackTrace?: ((err: Error, stackTraces: NodeJS.CallSite[]) => any) | undefined;
103
104
  stackTraceLimit: number;
104
105
  };
105
- isError(error: unknown): error is Error;
106
106
  captureStackTrace(targetObject: object, constructorOpt?: Function): void;
107
107
  prepareStackTrace?: ((err: Error, stackTraces: NodeJS.CallSite[]) => any) | undefined;
108
108
  stackTraceLimit: number;
@@ -111,53 +111,53 @@ export declare class SystemError extends SystemError_base {
111
111
  }
112
112
  declare const InternalError_base: {
113
113
  new (options?: import("./base").BaseErrorOptions): {
114
+ cause?: unknown;
115
+ stack?: string;
114
116
  name: "InternalError";
115
117
  context: Record<string, unknown>;
116
118
  get message(): string;
117
119
  get _tag(): "InternalError";
118
- stack?: string;
119
- cause?: unknown;
120
120
  };
121
+ isError(error: unknown): error is Error;
121
122
  name: "InternalError";
122
123
  is(error: unknown): error is BaseError;
123
124
  wrap(options?: (Omit<import("./base").BaseErrorOptions, "cause"> & {
124
125
  ifTypeDiffers?: boolean;
125
126
  }) | undefined): (error: unknown) => {
127
+ cause?: unknown;
128
+ stack?: string;
126
129
  name: "InternalError";
127
130
  context: Record<string, unknown>;
128
131
  get message(): string;
129
132
  get _tag(): "InternalError";
130
- stack?: string;
131
- cause?: unknown;
132
133
  };
133
134
  extend<Name extends string = string>(name: Name, message?: string): {
134
135
  new (options?: import("./base").BaseErrorOptions): {
136
+ cause?: unknown;
137
+ stack?: string;
135
138
  name: Name;
136
139
  context: Record<string, unknown>;
137
140
  get message(): string;
138
141
  get _tag(): Name;
139
- stack?: string;
140
- cause?: unknown;
141
142
  };
143
+ isError(error: unknown): error is Error;
142
144
  name: Name;
143
145
  is(error: unknown): error is BaseError;
144
- wrap(options?: Omit<import("./base").BaseErrorOptions, "cause"> & {
146
+ wrap(options?: Omit<import("./base").BaseErrorOptions, 'cause'> & {
145
147
  ifTypeDiffers?: boolean;
146
148
  }): (error: unknown) => {
149
+ cause?: unknown;
150
+ stack?: string;
147
151
  name: Name;
148
152
  context: Record<string, unknown>;
149
153
  get message(): string;
150
154
  get _tag(): Name;
151
- stack?: string;
152
- cause?: unknown;
153
155
  };
154
156
  extend<Name extends string = string>(name: Name, message?: string): /*elided*/ any;
155
- isError(error: unknown): error is Error;
156
157
  captureStackTrace(targetObject: object, constructorOpt?: Function): void;
157
158
  prepareStackTrace?: ((err: Error, stackTraces: NodeJS.CallSite[]) => any) | undefined;
158
159
  stackTraceLimit: number;
159
160
  };
160
- isError(error: unknown): error is Error;
161
161
  captureStackTrace(targetObject: object, constructorOpt?: Function): void;
162
162
  prepareStackTrace?: ((err: Error, stackTraces: NodeJS.CallSite[]) => any) | undefined;
163
163
  stackTraceLimit: number;
@@ -166,53 +166,53 @@ export declare class InternalError extends InternalError_base {
166
166
  }
167
167
  declare const TimeoutError_base: {
168
168
  new (options?: import("./base").BaseErrorOptions): {
169
+ cause?: unknown;
170
+ stack?: string;
169
171
  name: "TimeoutError";
170
172
  context: Record<string, unknown>;
171
173
  get message(): string;
172
174
  get _tag(): "TimeoutError";
173
- stack?: string;
174
- cause?: unknown;
175
175
  };
176
+ isError(error: unknown): error is Error;
176
177
  name: "TimeoutError";
177
178
  is(error: unknown): error is BaseError;
178
179
  wrap(options?: (Omit<import("./base").BaseErrorOptions, "cause"> & {
179
180
  ifTypeDiffers?: boolean;
180
181
  }) | undefined): (error: unknown) => {
182
+ cause?: unknown;
183
+ stack?: string;
181
184
  name: "TimeoutError";
182
185
  context: Record<string, unknown>;
183
186
  get message(): string;
184
187
  get _tag(): "TimeoutError";
185
- stack?: string;
186
- cause?: unknown;
187
188
  };
188
189
  extend<Name extends string = string>(name: Name, message?: string): {
189
190
  new (options?: import("./base").BaseErrorOptions): {
191
+ cause?: unknown;
192
+ stack?: string;
190
193
  name: Name;
191
194
  context: Record<string, unknown>;
192
195
  get message(): string;
193
196
  get _tag(): Name;
194
- stack?: string;
195
- cause?: unknown;
196
197
  };
198
+ isError(error: unknown): error is Error;
197
199
  name: Name;
198
200
  is(error: unknown): error is BaseError;
199
- wrap(options?: Omit<import("./base").BaseErrorOptions, "cause"> & {
201
+ wrap(options?: Omit<import("./base").BaseErrorOptions, 'cause'> & {
200
202
  ifTypeDiffers?: boolean;
201
203
  }): (error: unknown) => {
204
+ cause?: unknown;
205
+ stack?: string;
202
206
  name: Name;
203
207
  context: Record<string, unknown>;
204
208
  get message(): string;
205
209
  get _tag(): Name;
206
- stack?: string;
207
- cause?: unknown;
208
210
  };
209
211
  extend<Name extends string = string>(name: Name, message?: string): /*elided*/ any;
210
- isError(error: unknown): error is Error;
211
212
  captureStackTrace(targetObject: object, constructorOpt?: Function): void;
212
213
  prepareStackTrace?: ((err: Error, stackTraces: NodeJS.CallSite[]) => any) | undefined;
213
214
  stackTraceLimit: number;
214
215
  };
215
- isError(error: unknown): error is Error;
216
216
  captureStackTrace(targetObject: object, constructorOpt?: Function): void;
217
217
  prepareStackTrace?: ((err: Error, stackTraces: NodeJS.CallSite[]) => any) | undefined;
218
218
  stackTraceLimit: number;
@@ -221,53 +221,53 @@ export declare class TimeoutError extends TimeoutError_base {
221
221
  }
222
222
  declare const AbortedError_base: {
223
223
  new (options?: import("./base").BaseErrorOptions): {
224
+ cause?: unknown;
225
+ stack?: string;
224
226
  name: "AbortedError";
225
227
  context: Record<string, unknown>;
226
228
  get message(): string;
227
229
  get _tag(): "AbortedError";
228
- stack?: string;
229
- cause?: unknown;
230
230
  };
231
+ isError(error: unknown): error is Error;
231
232
  name: "AbortedError";
232
233
  is(error: unknown): error is BaseError;
233
234
  wrap(options?: (Omit<import("./base").BaseErrorOptions, "cause"> & {
234
235
  ifTypeDiffers?: boolean;
235
236
  }) | undefined): (error: unknown) => {
237
+ cause?: unknown;
238
+ stack?: string;
236
239
  name: "AbortedError";
237
240
  context: Record<string, unknown>;
238
241
  get message(): string;
239
242
  get _tag(): "AbortedError";
240
- stack?: string;
241
- cause?: unknown;
242
243
  };
243
244
  extend<Name extends string = string>(name: Name, message?: string): {
244
245
  new (options?: import("./base").BaseErrorOptions): {
246
+ cause?: unknown;
247
+ stack?: string;
245
248
  name: Name;
246
249
  context: Record<string, unknown>;
247
250
  get message(): string;
248
251
  get _tag(): Name;
249
- stack?: string;
250
- cause?: unknown;
251
252
  };
253
+ isError(error: unknown): error is Error;
252
254
  name: Name;
253
255
  is(error: unknown): error is BaseError;
254
- wrap(options?: Omit<import("./base").BaseErrorOptions, "cause"> & {
256
+ wrap(options?: Omit<import("./base").BaseErrorOptions, 'cause'> & {
255
257
  ifTypeDiffers?: boolean;
256
258
  }): (error: unknown) => {
259
+ cause?: unknown;
260
+ stack?: string;
257
261
  name: Name;
258
262
  context: Record<string, unknown>;
259
263
  get message(): string;
260
264
  get _tag(): Name;
261
- stack?: string;
262
- cause?: unknown;
263
265
  };
264
266
  extend<Name extends string = string>(name: Name, message?: string): /*elided*/ any;
265
- isError(error: unknown): error is Error;
266
267
  captureStackTrace(targetObject: object, constructorOpt?: Function): void;
267
268
  prepareStackTrace?: ((err: Error, stackTraces: NodeJS.CallSite[]) => any) | undefined;
268
269
  stackTraceLimit: number;
269
270
  };
270
- isError(error: unknown): error is Error;
271
271
  captureStackTrace(targetObject: object, constructorOpt?: Function): void;
272
272
  prepareStackTrace?: ((err: Error, stackTraces: NodeJS.CallSite[]) => any) | undefined;
273
273
  stackTraceLimit: number;
@@ -276,53 +276,53 @@ export declare class AbortedError extends AbortedError_base {
276
276
  }
277
277
  declare const NotImplementedError_base: {
278
278
  new (options?: import("./base").BaseErrorOptions): {
279
+ cause?: unknown;
280
+ stack?: string;
279
281
  name: "NotImplementedError";
280
282
  context: Record<string, unknown>;
281
283
  get message(): string;
282
284
  get _tag(): "NotImplementedError";
283
- stack?: string;
284
- cause?: unknown;
285
285
  };
286
+ isError(error: unknown): error is Error;
286
287
  name: "NotImplementedError";
287
288
  is(error: unknown): error is BaseError;
288
289
  wrap(options?: (Omit<import("./base").BaseErrorOptions, "cause"> & {
289
290
  ifTypeDiffers?: boolean;
290
291
  }) | undefined): (error: unknown) => {
292
+ cause?: unknown;
293
+ stack?: string;
291
294
  name: "NotImplementedError";
292
295
  context: Record<string, unknown>;
293
296
  get message(): string;
294
297
  get _tag(): "NotImplementedError";
295
- stack?: string;
296
- cause?: unknown;
297
298
  };
298
299
  extend<Name extends string = string>(name: Name, message?: string): {
299
300
  new (options?: import("./base").BaseErrorOptions): {
301
+ cause?: unknown;
302
+ stack?: string;
300
303
  name: Name;
301
304
  context: Record<string, unknown>;
302
305
  get message(): string;
303
306
  get _tag(): Name;
304
- stack?: string;
305
- cause?: unknown;
306
307
  };
308
+ isError(error: unknown): error is Error;
307
309
  name: Name;
308
310
  is(error: unknown): error is BaseError;
309
- wrap(options?: Omit<import("./base").BaseErrorOptions, "cause"> & {
311
+ wrap(options?: Omit<import("./base").BaseErrorOptions, 'cause'> & {
310
312
  ifTypeDiffers?: boolean;
311
313
  }): (error: unknown) => {
314
+ cause?: unknown;
315
+ stack?: string;
312
316
  name: Name;
313
317
  context: Record<string, unknown>;
314
318
  get message(): string;
315
319
  get _tag(): Name;
316
- stack?: string;
317
- cause?: unknown;
318
320
  };
319
321
  extend<Name extends string = string>(name: Name, message?: string): /*elided*/ any;
320
- isError(error: unknown): error is Error;
321
322
  captureStackTrace(targetObject: object, constructorOpt?: Function): void;
322
323
  prepareStackTrace?: ((err: Error, stackTraces: NodeJS.CallSite[]) => any) | undefined;
323
324
  stackTraceLimit: number;
324
325
  };
325
- isError(error: unknown): error is Error;
326
326
  captureStackTrace(targetObject: object, constructorOpt?: Function): void;
327
327
  prepareStackTrace?: ((err: Error, stackTraces: NodeJS.CallSite[]) => any) | undefined;
328
328
  stackTraceLimit: number;
@@ -331,53 +331,53 @@ export declare class NotImplementedError extends NotImplementedError_base {
331
331
  }
332
332
  declare const RuntimeServiceError_base: {
333
333
  new (options?: import("./base").BaseErrorOptions): {
334
+ cause?: unknown;
335
+ stack?: string;
334
336
  name: "RuntimeServiceError";
335
337
  context: Record<string, unknown>;
336
338
  get message(): string;
337
339
  get _tag(): "RuntimeServiceError";
338
- stack?: string;
339
- cause?: unknown;
340
340
  };
341
+ isError(error: unknown): error is Error;
341
342
  name: "RuntimeServiceError";
342
343
  is(error: unknown): error is BaseError;
343
344
  wrap(options?: (Omit<import("./base").BaseErrorOptions, "cause"> & {
344
345
  ifTypeDiffers?: boolean;
345
346
  }) | undefined): (error: unknown) => {
347
+ cause?: unknown;
348
+ stack?: string;
346
349
  name: "RuntimeServiceError";
347
350
  context: Record<string, unknown>;
348
351
  get message(): string;
349
352
  get _tag(): "RuntimeServiceError";
350
- stack?: string;
351
- cause?: unknown;
352
353
  };
353
354
  extend<Name extends string = string>(name: Name, message?: string): {
354
355
  new (options?: import("./base").BaseErrorOptions): {
356
+ cause?: unknown;
357
+ stack?: string;
355
358
  name: Name;
356
359
  context: Record<string, unknown>;
357
360
  get message(): string;
358
361
  get _tag(): Name;
359
- stack?: string;
360
- cause?: unknown;
361
362
  };
363
+ isError(error: unknown): error is Error;
362
364
  name: Name;
363
365
  is(error: unknown): error is BaseError;
364
- wrap(options?: Omit<import("./base").BaseErrorOptions, "cause"> & {
366
+ wrap(options?: Omit<import("./base").BaseErrorOptions, 'cause'> & {
365
367
  ifTypeDiffers?: boolean;
366
368
  }): (error: unknown) => {
369
+ cause?: unknown;
370
+ stack?: string;
367
371
  name: Name;
368
372
  context: Record<string, unknown>;
369
373
  get message(): string;
370
374
  get _tag(): Name;
371
- stack?: string;
372
- cause?: unknown;
373
375
  };
374
376
  extend<Name extends string = string>(name: Name, message?: string): /*elided*/ any;
375
- isError(error: unknown): error is Error;
376
377
  captureStackTrace(targetObject: object, constructorOpt?: Function): void;
377
378
  prepareStackTrace?: ((err: Error, stackTraces: NodeJS.CallSite[]) => any) | undefined;
378
379
  stackTraceLimit: number;
379
380
  };
380
- isError(error: unknown): error is Error;
381
381
  captureStackTrace(targetObject: object, constructorOpt?: Function): void;
382
382
  prepareStackTrace?: ((err: Error, stackTraces: NodeJS.CallSite[]) => any) | undefined;
383
383
  stackTraceLimit: number;
package/dist/types/src/errors.d.ts.map CHANGED
@@ -1 +1 @@
1
- {"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../../../src/errors.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,SAAS,EAAE,MAAM,QAAQ,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;yBAe2S,CAAC;;;;;;;;;;;;;;;;;;;;AAb/U,qBAAa,QAAS,SAAQ,aAAyC;CAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;yBAaoQ,CAAC;;;;;;;;;;;;;;;;;;;;AAX/U,qBAAa,WAAY,SAAQ,gBAA+C;CAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;yBAW2P,CAAC;;;;;;;;;;;;;;;;;;;;AAT/U,qBAAa,aAAc,SAAQ,kBAAmD;CAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;yBASqP,CAAC;;;;;;;;;;;;;;;;;;;;AAP/U,qBAAa,YAAa,SAAQ,iBAA2C;CAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;yBAO8P,CAAC;;;;;;;;;;;;;;;;;;;;AAL/U,qBAAa,YAAa,SAAQ,iBAA2C;CAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;yBAK8P,CAAC;;;;;;;;;;;;;;;;;;;;AAH/U,qBAAa,mBAAoB,SAAQ,wBAA0D;CAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;yBAGwO,CAAC;;;;;;;;;;;;;;;;;;;;AAD/U,qBAAa,mBAAoB,SAAQ,wBAAgE;CAAG"}
1
+ {"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../../../src/errors.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,SAAS,EAAE,MAAM,QAAQ,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEnC,qBAAa,QAAS,SAAQ,aAAyC;CAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAE1E,qBAAa,WAAY,SAAQ,gBAA+C;CAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEnF,qBAAa,aAAc,SAAQ,kBAAmD;CAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEzF,qBAAa,YAAa,SAAQ,iBAA2C;CAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEhF,qBAAa,YAAa,SAAQ,iBAA2C;CAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEhF,qBAAa,mBAAoB,SAAQ,wBAA0D;CAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEtG,qBAAa,mBAAoB,SAAQ,wBAAgE;CAAG"}