@dxos/errors 0.8.4-main.3f58842 → 0.8.4-main.548089c

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 (15) hide show
  1. package/dist/lib/browser/index.mjs +35 -35
  2. package/dist/lib/browser/index.mjs.map +3 -3
  3. package/dist/lib/browser/meta.json +1 -1
  4. package/dist/lib/node-esm/index.mjs +35 -35
  5. package/dist/lib/node-esm/index.mjs.map +3 -3
  6. package/dist/lib/node-esm/meta.json +1 -1
  7. package/dist/types/src/base.d.ts +31 -32
  8. package/dist/types/src/base.d.ts.map +1 -1
  9. package/dist/types/src/errors.d.ts +186 -222
  10. package/dist/types/src/errors.d.ts.map +1 -1
  11. package/dist/types/tsconfig.tsbuildinfo +1 -1
  12. package/package.json +2 -1
  13. package/src/base.ts +26 -29
  14. package/src/errors.test.ts +23 -4
  15. package/src/errors.ts +6 -6
package/dist/types/src/errors.d.ts CHANGED
@@ -1,369 +1,333 @@
1
1
  import { BaseError } from './base';
2
- declare const TimeoutError_base: {
3
- new (message: string, options?: import("./base").BaseErrorOptions): {
4
- "__#1@#code": "TIMEOUT";
5
- "__#1@#context": Record<string, unknown>;
6
- readonly name: "TIMEOUT";
7
- readonly code: "TIMEOUT";
8
- readonly _tag: "TIMEOUT";
9
- readonly context: Record<string, unknown>;
10
- message: string;
2
+ declare const ApiError_base: {
3
+ new (options?: import("./base").BaseErrorOptions): {
4
+ code: "API";
5
+ context: Record<string, unknown>;
6
+ get name(): "API";
7
+ get message(): string;
8
+ get _tag(): "API";
11
9
  stack?: string;
12
10
  cause?: unknown;
13
11
  };
14
- code: "TIMEOUT";
12
+ code: "API";
15
13
  is(error: unknown): error is BaseError;
16
- wrap(message: string, options?: Omit<import("./base").BaseErrorOptions, "cause">): (error: unknown) => {
17
- "__#1@#code": "TIMEOUT";
18
- "__#1@#context": Record<string, unknown>;
19
- readonly name: "TIMEOUT";
20
- readonly code: "TIMEOUT";
21
- readonly _tag: "TIMEOUT";
22
- readonly context: Record<string, unknown>;
23
- message: string;
14
+ wrap(options?: Omit<import("./base").BaseErrorOptions, "cause">): (error: unknown) => {
15
+ code: "API";
16
+ context: Record<string, unknown>;
17
+ get name(): "API";
18
+ get message(): string;
19
+ get _tag(): "API";
24
20
  stack?: string;
25
21
  cause?: unknown;
26
22
  };
27
- extend<Code extends string>(code: Code): {
28
- new (message: string, options?: import("./base").BaseErrorOptions): {
29
- "__#1@#code": Code;
30
- "__#1@#context": Record<string, unknown>;
31
- readonly name: Code;
32
- readonly code: Code;
33
- readonly _tag: Code;
34
- readonly context: Record<string, unknown>;
35
- message: string;
23
+ extend<Code extends string = string>(code: Code, message?: string): {
24
+ new (options?: import("./base").BaseErrorOptions): {
25
+ code: Code;
26
+ context: Record<string, unknown>;
27
+ get name(): Code;
28
+ get message(): string;
29
+ get _tag(): Code;
36
30
  stack?: string;
37
31
  cause?: unknown;
38
32
  };
39
33
  code: Code;
40
34
  is(error: unknown): error is BaseError;
41
- wrap(message: string, options?: Omit<import("./base").BaseErrorOptions, "cause">): (error: unknown) => {
42
- "__#1@#code": Code;
43
- "__#1@#context": Record<string, unknown>;
44
- readonly name: Code;
45
- readonly code: Code;
46
- readonly _tag: Code;
47
- readonly context: Record<string, unknown>;
48
- message: string;
35
+ wrap(options?: Omit<import("./base").BaseErrorOptions, "cause">): (error: unknown) => {
36
+ code: Code;
37
+ context: Record<string, unknown>;
38
+ get name(): Code;
39
+ get message(): string;
40
+ get _tag(): Code;
49
41
  stack?: string;
50
42
  cause?: unknown;
51
43
  };
52
- extend<Code extends string>(code: Code): /*elided*/ any;
44
+ extend<Code extends string = string>(code: Code, message?: string): /*elided*/ any;
45
+ isError(error: unknown): error is Error;
53
46
  captureStackTrace(targetObject: object, constructorOpt?: Function): void;
54
47
  prepareStackTrace?: ((err: Error, stackTraces: NodeJS.CallSite[]) => any) | undefined;
55
48
  stackTraceLimit: number;
56
49
  };
50
+ isError(error: unknown): error is Error;
57
51
  captureStackTrace(targetObject: object, constructorOpt?: Function): void;
58
52
  prepareStackTrace?: ((err: Error, stackTraces: NodeJS.CallSite[]) => any) | undefined;
59
53
  stackTraceLimit: number;
60
54
  };
61
- export declare class TimeoutError extends TimeoutError_base {
55
+ export declare class ApiError extends ApiError_base {
62
56
  }
63
- declare const AbortedError_base: {
64
- new (message: string, options?: import("./base").BaseErrorOptions): {
65
- "__#1@#code": "ABORTED";
66
- "__#1@#context": Record<string, unknown>;
67
- readonly name: "ABORTED";
68
- readonly code: "ABORTED";
69
- readonly _tag: "ABORTED";
70
- readonly context: Record<string, unknown>;
71
- message: string;
57
+ declare const SystemError_base: {
58
+ new (options?: import("./base").BaseErrorOptions): {
59
+ code: "SYSTEM";
60
+ context: Record<string, unknown>;
61
+ get name(): "SYSTEM";
62
+ get message(): string;
63
+ get _tag(): "SYSTEM";
72
64
  stack?: string;
73
65
  cause?: unknown;
74
66
  };
75
- code: "ABORTED";
67
+ code: "SYSTEM";
76
68
  is(error: unknown): error is BaseError;
77
- wrap(message: string, options?: Omit<import("./base").BaseErrorOptions, "cause">): (error: unknown) => {
78
- "__#1@#code": "ABORTED";
79
- "__#1@#context": Record<string, unknown>;
80
- readonly name: "ABORTED";
81
- readonly code: "ABORTED";
82
- readonly _tag: "ABORTED";
83
- readonly context: Record<string, unknown>;
84
- message: string;
69
+ wrap(options?: Omit<import("./base").BaseErrorOptions, "cause">): (error: unknown) => {
70
+ code: "SYSTEM";
71
+ context: Record<string, unknown>;
72
+ get name(): "SYSTEM";
73
+ get message(): string;
74
+ get _tag(): "SYSTEM";
85
75
  stack?: string;
86
76
  cause?: unknown;
87
77
  };
88
- extend<Code extends string>(code: Code): {
89
- new (message: string, options?: import("./base").BaseErrorOptions): {
90
- "__#1@#code": Code;
91
- "__#1@#context": Record<string, unknown>;
92
- readonly name: Code;
93
- readonly code: Code;
94
- readonly _tag: Code;
95
- readonly context: Record<string, unknown>;
96
- message: string;
78
+ extend<Code extends string = string>(code: Code, message?: string): {
79
+ new (options?: import("./base").BaseErrorOptions): {
80
+ code: Code;
81
+ context: Record<string, unknown>;
82
+ get name(): Code;
83
+ get message(): string;
84
+ get _tag(): Code;
97
85
  stack?: string;
98
86
  cause?: unknown;
99
87
  };
100
88
  code: Code;
101
89
  is(error: unknown): error is BaseError;
102
- wrap(message: string, options?: Omit<import("./base").BaseErrorOptions, "cause">): (error: unknown) => {
103
- "__#1@#code": Code;
104
- "__#1@#context": Record<string, unknown>;
105
- readonly name: Code;
106
- readonly code: Code;
107
- readonly _tag: Code;
108
- readonly context: Record<string, unknown>;
109
- message: string;
90
+ wrap(options?: Omit<import("./base").BaseErrorOptions, "cause">): (error: unknown) => {
91
+ code: Code;
92
+ context: Record<string, unknown>;
93
+ get name(): Code;
94
+ get message(): string;
95
+ get _tag(): Code;
110
96
  stack?: string;
111
97
  cause?: unknown;
112
98
  };
113
- extend<Code extends string>(code: Code): /*elided*/ any;
99
+ extend<Code extends string = string>(code: Code, message?: string): /*elided*/ any;
100
+ isError(error: unknown): error is Error;
114
101
  captureStackTrace(targetObject: object, constructorOpt?: Function): void;
115
102
  prepareStackTrace?: ((err: Error, stackTraces: NodeJS.CallSite[]) => any) | undefined;
116
103
  stackTraceLimit: number;
117
104
  };
105
+ isError(error: unknown): error is Error;
118
106
  captureStackTrace(targetObject: object, constructorOpt?: Function): void;
119
107
  prepareStackTrace?: ((err: Error, stackTraces: NodeJS.CallSite[]) => any) | undefined;
120
108
  stackTraceLimit: number;
121
109
  };
122
- export declare class AbortedError extends AbortedError_base {
110
+ export declare class SystemError extends SystemError_base {
123
111
  }
124
- declare const UnimplementedError_base: {
125
- new (message: string, options?: import("./base").BaseErrorOptions): {
126
- "__#1@#code": "UNIMPLEMENTED";
127
- "__#1@#context": Record<string, unknown>;
128
- readonly name: "UNIMPLEMENTED";
129
- readonly code: "UNIMPLEMENTED";
130
- readonly _tag: "UNIMPLEMENTED";
131
- readonly context: Record<string, unknown>;
132
- message: string;
112
+ declare const InternalError_base: {
113
+ new (options?: import("./base").BaseErrorOptions): {
114
+ code: "INTERNAL";
115
+ context: Record<string, unknown>;
116
+ get name(): "INTERNAL";
117
+ get message(): string;
118
+ get _tag(): "INTERNAL";
133
119
  stack?: string;
134
120
  cause?: unknown;
135
121
  };
136
- code: "UNIMPLEMENTED";
122
+ code: "INTERNAL";
137
123
  is(error: unknown): error is BaseError;
138
- wrap(message: string, options?: Omit<import("./base").BaseErrorOptions, "cause">): (error: unknown) => {
139
- "__#1@#code": "UNIMPLEMENTED";
140
- "__#1@#context": Record<string, unknown>;
141
- readonly name: "UNIMPLEMENTED";
142
- readonly code: "UNIMPLEMENTED";
143
- readonly _tag: "UNIMPLEMENTED";
144
- readonly context: Record<string, unknown>;
145
- message: string;
124
+ wrap(options?: Omit<import("./base").BaseErrorOptions, "cause">): (error: unknown) => {
125
+ code: "INTERNAL";
126
+ context: Record<string, unknown>;
127
+ get name(): "INTERNAL";
128
+ get message(): string;
129
+ get _tag(): "INTERNAL";
146
130
  stack?: string;
147
131
  cause?: unknown;
148
132
  };
149
- extend<Code extends string>(code: Code): {
150
- new (message: string, options?: import("./base").BaseErrorOptions): {
151
- "__#1@#code": Code;
152
- "__#1@#context": Record<string, unknown>;
153
- readonly name: Code;
154
- readonly code: Code;
155
- readonly _tag: Code;
156
- readonly context: Record<string, unknown>;
157
- message: string;
133
+ extend<Code extends string = string>(code: Code, message?: string): {
134
+ new (options?: import("./base").BaseErrorOptions): {
135
+ code: Code;
136
+ context: Record<string, unknown>;
137
+ get name(): Code;
138
+ get message(): string;
139
+ get _tag(): Code;
158
140
  stack?: string;
159
141
  cause?: unknown;
160
142
  };
161
143
  code: Code;
162
144
  is(error: unknown): error is BaseError;
163
- wrap(message: string, options?: Omit<import("./base").BaseErrorOptions, "cause">): (error: unknown) => {
164
- "__#1@#code": Code;
165
- "__#1@#context": Record<string, unknown>;
166
- readonly name: Code;
167
- readonly code: Code;
168
- readonly _tag: Code;
169
- readonly context: Record<string, unknown>;
170
- message: string;
145
+ wrap(options?: Omit<import("./base").BaseErrorOptions, "cause">): (error: unknown) => {
146
+ code: Code;
147
+ context: Record<string, unknown>;
148
+ get name(): Code;
149
+ get message(): string;
150
+ get _tag(): Code;
171
151
  stack?: string;
172
152
  cause?: unknown;
173
153
  };
174
- extend<Code extends string>(code: Code): /*elided*/ any;
154
+ extend<Code extends string = string>(code: Code, message?: string): /*elided*/ any;
155
+ isError(error: unknown): error is Error;
175
156
  captureStackTrace(targetObject: object, constructorOpt?: Function): void;
176
157
  prepareStackTrace?: ((err: Error, stackTraces: NodeJS.CallSite[]) => any) | undefined;
177
158
  stackTraceLimit: number;
178
159
  };
160
+ isError(error: unknown): error is Error;
179
161
  captureStackTrace(targetObject: object, constructorOpt?: Function): void;
180
162
  prepareStackTrace?: ((err: Error, stackTraces: NodeJS.CallSite[]) => any) | undefined;
181
163
  stackTraceLimit: number;
182
164
  };
183
- export declare class UnimplementedError extends UnimplementedError_base {
165
+ export declare class InternalError extends InternalError_base {
184
166
  }
185
- declare const ApiError_base: {
186
- new (message: string, options?: import("./base").BaseErrorOptions): {
187
- "__#1@#code": "API_ERROR";
188
- "__#1@#context": Record<string, unknown>;
189
- readonly name: "API_ERROR";
190
- readonly code: "API_ERROR";
191
- readonly _tag: "API_ERROR";
192
- readonly context: Record<string, unknown>;
193
- message: string;
167
+ declare const TimeoutError_base: {
168
+ new (options?: import("./base").BaseErrorOptions): {
169
+ code: "TIMEOUT";
170
+ context: Record<string, unknown>;
171
+ get name(): "TIMEOUT";
172
+ get message(): string;
173
+ get _tag(): "TIMEOUT";
194
174
  stack?: string;
195
175
  cause?: unknown;
196
176
  };
197
- code: "API_ERROR";
177
+ code: "TIMEOUT";
198
178
  is(error: unknown): error is BaseError;
199
- wrap(message: string, options?: Omit<import("./base").BaseErrorOptions, "cause">): (error: unknown) => {
200
- "__#1@#code": "API_ERROR";
201
- "__#1@#context": Record<string, unknown>;
202
- readonly name: "API_ERROR";
203
- readonly code: "API_ERROR";
204
- readonly _tag: "API_ERROR";
205
- readonly context: Record<string, unknown>;
206
- message: string;
179
+ wrap(options?: Omit<import("./base").BaseErrorOptions, "cause">): (error: unknown) => {
180
+ code: "TIMEOUT";
181
+ context: Record<string, unknown>;
182
+ get name(): "TIMEOUT";
183
+ get message(): string;
184
+ get _tag(): "TIMEOUT";
207
185
  stack?: string;
208
186
  cause?: unknown;
209
187
  };
210
- extend<Code extends string>(code: Code): {
211
- new (message: string, options?: import("./base").BaseErrorOptions): {
212
- "__#1@#code": Code;
213
- "__#1@#context": Record<string, unknown>;
214
- readonly name: Code;
215
- readonly code: Code;
216
- readonly _tag: Code;
217
- readonly context: Record<string, unknown>;
218
- message: string;
188
+ extend<Code extends string = string>(code: Code, message?: string): {
189
+ new (options?: import("./base").BaseErrorOptions): {
190
+ code: Code;
191
+ context: Record<string, unknown>;
192
+ get name(): Code;
193
+ get message(): string;
194
+ get _tag(): Code;
219
195
  stack?: string;
220
196
  cause?: unknown;
221
197
  };
222
198
  code: Code;
223
199
  is(error: unknown): error is BaseError;
224
- wrap(message: string, options?: Omit<import("./base").BaseErrorOptions, "cause">): (error: unknown) => {
225
- "__#1@#code": Code;
226
- "__#1@#context": Record<string, unknown>;
227
- readonly name: Code;
228
- readonly code: Code;
229
- readonly _tag: Code;
230
- readonly context: Record<string, unknown>;
231
- message: string;
200
+ wrap(options?: Omit<import("./base").BaseErrorOptions, "cause">): (error: unknown) => {
201
+ code: Code;
202
+ context: Record<string, unknown>;
203
+ get name(): Code;
204
+ get message(): string;
205
+ get _tag(): Code;
232
206
  stack?: string;
233
207
  cause?: unknown;
234
208
  };
235
- extend<Code extends string>(code: Code): /*elided*/ any;
209
+ extend<Code extends string = string>(code: Code, message?: string): /*elided*/ any;
210
+ isError(error: unknown): error is Error;
236
211
  captureStackTrace(targetObject: object, constructorOpt?: Function): void;
237
212
  prepareStackTrace?: ((err: Error, stackTraces: NodeJS.CallSite[]) => any) | undefined;
238
213
  stackTraceLimit: number;
239
214
  };
215
+ isError(error: unknown): error is Error;
240
216
  captureStackTrace(targetObject: object, constructorOpt?: Function): void;
241
217
  prepareStackTrace?: ((err: Error, stackTraces: NodeJS.CallSite[]) => any) | undefined;
242
218
  stackTraceLimit: number;
243
219
  };
244
- export declare class ApiError extends ApiError_base {
220
+ export declare class TimeoutError extends TimeoutError_base {
245
221
  }
246
- declare const SystemError_base: {
247
- new (message: string, options?: import("./base").BaseErrorOptions): {
248
- "__#1@#code": "SYSTEM_ERROR";
249
- "__#1@#context": Record<string, unknown>;
250
- readonly name: "SYSTEM_ERROR";
251
- readonly code: "SYSTEM_ERROR";
252
- readonly _tag: "SYSTEM_ERROR";
253
- readonly context: Record<string, unknown>;
254
- message: string;
222
+ declare const AbortedError_base: {
223
+ new (options?: import("./base").BaseErrorOptions): {
224
+ code: "ABORTED";
225
+ context: Record<string, unknown>;
226
+ get name(): "ABORTED";
227
+ get message(): string;
228
+ get _tag(): "ABORTED";
255
229
  stack?: string;
256
230
  cause?: unknown;
257
231
  };
258
- code: "SYSTEM_ERROR";
232
+ code: "ABORTED";
259
233
  is(error: unknown): error is BaseError;
260
- wrap(message: string, options?: Omit<import("./base").BaseErrorOptions, "cause">): (error: unknown) => {
261
- "__#1@#code": "SYSTEM_ERROR";
262
- "__#1@#context": Record<string, unknown>;
263
- readonly name: "SYSTEM_ERROR";
264
- readonly code: "SYSTEM_ERROR";
265
- readonly _tag: "SYSTEM_ERROR";
266
- readonly context: Record<string, unknown>;
267
- message: string;
234
+ wrap(options?: Omit<import("./base").BaseErrorOptions, "cause">): (error: unknown) => {
235
+ code: "ABORTED";
236
+ context: Record<string, unknown>;
237
+ get name(): "ABORTED";
238
+ get message(): string;
239
+ get _tag(): "ABORTED";
268
240
  stack?: string;
269
241
  cause?: unknown;
270
242
  };
271
- extend<Code extends string>(code: Code): {
272
- new (message: string, options?: import("./base").BaseErrorOptions): {
273
- "__#1@#code": Code;
274
- "__#1@#context": Record<string, unknown>;
275
- readonly name: Code;
276
- readonly code: Code;
277
- readonly _tag: Code;
278
- readonly context: Record<string, unknown>;
279
- message: string;
243
+ extend<Code extends string = string>(code: Code, message?: string): {
244
+ new (options?: import("./base").BaseErrorOptions): {
245
+ code: Code;
246
+ context: Record<string, unknown>;
247
+ get name(): Code;
248
+ get message(): string;
249
+ get _tag(): Code;
280
250
  stack?: string;
281
251
  cause?: unknown;
282
252
  };
283
253
  code: Code;
284
254
  is(error: unknown): error is BaseError;
285
- wrap(message: string, options?: Omit<import("./base").BaseErrorOptions, "cause">): (error: unknown) => {
286
- "__#1@#code": Code;
287
- "__#1@#context": Record<string, unknown>;
288
- readonly name: Code;
289
- readonly code: Code;
290
- readonly _tag: Code;
291
- readonly context: Record<string, unknown>;
292
- message: string;
255
+ wrap(options?: Omit<import("./base").BaseErrorOptions, "cause">): (error: unknown) => {
256
+ code: Code;
257
+ context: Record<string, unknown>;
258
+ get name(): Code;
259
+ get message(): string;
260
+ get _tag(): Code;
293
261
  stack?: string;
294
262
  cause?: unknown;
295
263
  };
296
- extend<Code extends string>(code: Code): /*elided*/ any;
264
+ extend<Code extends string = string>(code: Code, message?: string): /*elided*/ any;
265
+ isError(error: unknown): error is Error;
297
266
  captureStackTrace(targetObject: object, constructorOpt?: Function): void;
298
267
  prepareStackTrace?: ((err: Error, stackTraces: NodeJS.CallSite[]) => any) | undefined;
299
268
  stackTraceLimit: number;
300
269
  };
270
+ isError(error: unknown): error is Error;
301
271
  captureStackTrace(targetObject: object, constructorOpt?: Function): void;
302
272
  prepareStackTrace?: ((err: Error, stackTraces: NodeJS.CallSite[]) => any) | undefined;
303
273
  stackTraceLimit: number;
304
274
  };
305
- export declare class SystemError extends SystemError_base {
275
+ export declare class AbortedError extends AbortedError_base {
306
276
  }
307
- declare const InternalError_base: {
308
- new (message: string, options?: import("./base").BaseErrorOptions): {
309
- "__#1@#code": "INTERNAL_ERROR";
310
- "__#1@#context": Record<string, unknown>;
311
- readonly name: "INTERNAL_ERROR";
312
- readonly code: "INTERNAL_ERROR";
313
- readonly _tag: "INTERNAL_ERROR";
314
- readonly context: Record<string, unknown>;
315
- message: string;
277
+ declare const NotImplementedError_base: {
278
+ new (options?: import("./base").BaseErrorOptions): {
279
+ code: "NOT_IMPLEMENTED";
280
+ context: Record<string, unknown>;
281
+ get name(): "NOT_IMPLEMENTED";
282
+ get message(): string;
283
+ get _tag(): "NOT_IMPLEMENTED";
316
284
  stack?: string;
317
285
  cause?: unknown;
318
286
  };
319
- code: "INTERNAL_ERROR";
287
+ code: "NOT_IMPLEMENTED";
320
288
  is(error: unknown): error is BaseError;
321
- wrap(message: string, options?: Omit<import("./base").BaseErrorOptions, "cause">): (error: unknown) => {
322
- "__#1@#code": "INTERNAL_ERROR";
323
- "__#1@#context": Record<string, unknown>;
324
- readonly name: "INTERNAL_ERROR";
325
- readonly code: "INTERNAL_ERROR";
326
- readonly _tag: "INTERNAL_ERROR";
327
- readonly context: Record<string, unknown>;
328
- message: string;
289
+ wrap(options?: Omit<import("./base").BaseErrorOptions, "cause">): (error: unknown) => {
290
+ code: "NOT_IMPLEMENTED";
291
+ context: Record<string, unknown>;
292
+ get name(): "NOT_IMPLEMENTED";
293
+ get message(): string;
294
+ get _tag(): "NOT_IMPLEMENTED";
329
295
  stack?: string;
330
296
  cause?: unknown;
331
297
  };
332
- extend<Code extends string>(code: Code): {
333
- new (message: string, options?: import("./base").BaseErrorOptions): {
334
- "__#1@#code": Code;
335
- "__#1@#context": Record<string, unknown>;
336
- readonly name: Code;
337
- readonly code: Code;
338
- readonly _tag: Code;
339
- readonly context: Record<string, unknown>;
340
- message: string;
298
+ extend<Code extends string = string>(code: Code, message?: string): {
299
+ new (options?: import("./base").BaseErrorOptions): {
300
+ code: Code;
301
+ context: Record<string, unknown>;
302
+ get name(): Code;
303
+ get message(): string;
304
+ get _tag(): Code;
341
305
  stack?: string;
342
306
  cause?: unknown;
343
307
  };
344
308
  code: Code;
345
309
  is(error: unknown): error is BaseError;
346
- wrap(message: string, options?: Omit<import("./base").BaseErrorOptions, "cause">): (error: unknown) => {
347
- "__#1@#code": Code;
348
- "__#1@#context": Record<string, unknown>;
349
- readonly name: Code;
350
- readonly code: Code;
351
- readonly _tag: Code;
352
- readonly context: Record<string, unknown>;
353
- message: string;
310
+ wrap(options?: Omit<import("./base").BaseErrorOptions, "cause">): (error: unknown) => {
311
+ code: Code;
312
+ context: Record<string, unknown>;
313
+ get name(): Code;
314
+ get message(): string;
315
+ get _tag(): Code;
354
316
  stack?: string;
355
317
  cause?: unknown;
356
318
  };
357
- extend<Code extends string>(code: Code): /*elided*/ any;
319
+ extend<Code extends string = string>(code: Code, message?: string): /*elided*/ any;
320
+ isError(error: unknown): error is Error;
358
321
  captureStackTrace(targetObject: object, constructorOpt?: Function): void;
359
322
  prepareStackTrace?: ((err: Error, stackTraces: NodeJS.CallSite[]) => any) | undefined;
360
323
  stackTraceLimit: number;
361
324
  };
325
+ isError(error: unknown): error is Error;
362
326
  captureStackTrace(targetObject: object, constructorOpt?: Function): void;
363
327
  prepareStackTrace?: ((err: Error, stackTraces: NodeJS.CallSite[]) => any) | undefined;
364
328
  stackTraceLimit: number;
365
329
  };
366
- export declare class InternalError extends InternalError_base {
330
+ export declare class NotImplementedError extends NotImplementedError_base {
367
331
  }
368
332
  export {};
369
333
  //# sourceMappingURL=errors.d.ts.map
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;;;;;;;;;;;;;;;wFAa6a,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;4FAAd,cAAc;;;;;;;;;;;;;;;;;;;;AAX9d,qBAAa,YAAa,SAAQ,iBAA2B;CAAG;;;;;;;;;;;;;;;wFAWgZ,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;4FAAd,cAAc;;;;;;;;;;;;;;;;;;;;AAT9d,qBAAa,YAAa,SAAQ,iBAA2B;CAAG;;;;;;;;;;;;;;;wFASgZ,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;4FAAd,cAAc;;;;;;;;;;;;;;;;;;;;AAP9d,qBAAa,kBAAmB,SAAQ,uBAAiC;CAAG;;;;;;;;;;;;;;;wFAOoY,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;4FAAd,cAAc;;;;;;;;;;;;;;;;;;;;AAL9d,qBAAa,QAAS,SAAQ,aAA6B;CAAG;;;;;;;;;;;;;;;wFAKkZ,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;4FAAd,cAAc;;;;;;;;;;;;;;;;;;;;AAH9d,qBAAa,WAAY,SAAQ,gBAAgC;CAAG;;;;;;;;;;;;;;;wFAG4Y,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;4FAAd,cAAc;;;;;;;;;;;;;;;;;;;;AAD9d,qBAAa,aAAc,SAAQ,kBAAkC;CAAG"}
1
+ {"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../../../src/errors.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,SAAS,EAAE,MAAM,QAAQ,CAAC;;;;;;;;;;;;;uEAakZ,cAAc;;;;;;;;;;;;;;;;;;;;;2EAAd,cAAc;;;;;;;;;;;;;;;;;;;;AAXnc,qBAAa,QAAS,SAAQ,aAAoC;CAAG;;;;;;;;;;;;;uEAWgX,cAAc;;;;;;;;;;;;;;;;;;;;;2EAAd,cAAc;;;;;;;;;;;;;;;;;;;;AATnc,qBAAa,WAAY,SAAQ,gBAA0C;CAAG;;;;;;;;;;;;;uEASuW,cAAc;;;;;;;;;;;;;;;;;;;;;2EAAd,cAAc;;;;;;;;;;;;;;;;;;;;AAPnc,qBAAa,aAAc,SAAQ,kBAA8C;CAAG;;;;;;;;;;;;;uEAOiW,cAAc;;;;;;;;;;;;;;;;;;;;;2EAAd,cAAc;;;;;;;;;;;;;;;;;;;;AALnc,qBAAa,YAAa,SAAQ,iBAAsC;CAAG;;;;;;;;;;;;;uEAK0W,cAAc;;;;;;;;;;;;;;;;;;;;;2EAAd,cAAc;;;;;;;;;;;;;;;;;;;;AAHnc,qBAAa,YAAa,SAAQ,iBAAsC;CAAG;;;;;;;;;;;;;uEAG0W,cAAc;;;;;;;;;;;;;;;;;;;;;2EAAd,cAAc;;;;;;;;;;;;;;;;;;;;AADnc,qBAAa,mBAAoB,SAAQ,wBAAsD;CAAG"}