@noeldemartin/utils 0.6.0 → 0.7.0-next.0a1eb4e99828ddb0081abbcfb8315ecedd45d552

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 (93) hide show
  1. package/README.md +3 -9
  2. package/dist/noeldemartin-utils.d.ts +78 -107
  3. package/dist/noeldemartin-utils.js +1325 -0
  4. package/dist/noeldemartin-utils.js.map +1 -0
  5. package/package.json +44 -59
  6. package/src/fluent/FluentArray.test.ts +119 -0
  7. package/src/fluent/FluentArray.ts +19 -14
  8. package/src/fluent/FluentObject.ts +11 -10
  9. package/src/fluent/FluentString.test.ts +76 -0
  10. package/src/fluent/FluentString.ts +11 -10
  11. package/src/fluent/facade.test.ts +30 -0
  12. package/src/fluent/facade.ts +29 -59
  13. package/src/fluent/index.test.ts +37 -0
  14. package/src/fluent/index.ts +22 -19
  15. package/src/fluent/required.test.ts +34 -0
  16. package/src/fluent/required.ts +7 -10
  17. package/src/fluent/tap.test.ts +70 -0
  18. package/src/fluent/tap.ts +10 -11
  19. package/src/fluent/value.test.ts +12 -0
  20. package/src/fluent/value.ts +1 -3
  21. package/src/fluent/when.test.ts +64 -0
  22. package/src/fluent/when.ts +4 -7
  23. package/src/helpers/IndexedDBMap.ts +92 -0
  24. package/src/helpers/JSError.test.ts +50 -0
  25. package/src/helpers/JSError.ts +3 -3
  26. package/src/helpers/ListenersManager.test.ts +37 -0
  27. package/src/helpers/ListenersManager.ts +47 -0
  28. package/src/helpers/MagicObject.test.ts +114 -0
  29. package/src/helpers/MagicObject.ts +14 -6
  30. package/src/helpers/ObjectsMap.test.ts +87 -0
  31. package/src/helpers/ObjectsMap.ts +10 -9
  32. package/src/helpers/PromisedValue.test.ts +32 -0
  33. package/src/helpers/PromisedValue.ts +4 -6
  34. package/src/helpers/Semaphore.test.ts +90 -0
  35. package/src/helpers/Semaphore.ts +2 -2
  36. package/src/helpers/Storage.ts +7 -12
  37. package/src/helpers/array_helpers.test.ts +270 -0
  38. package/src/helpers/array_helpers.ts +56 -66
  39. package/src/helpers/caching_helpers.test.ts +84 -0
  40. package/src/helpers/caching_helpers.ts +7 -7
  41. package/src/helpers/chaos_helpers.ts +2 -2
  42. package/src/helpers/date_helpers.test.ts +16 -0
  43. package/src/helpers/date_helpers.ts +1 -2
  44. package/src/helpers/deprecated.ts +18 -20
  45. package/src/helpers/error_helpers.test.ts +43 -0
  46. package/src/helpers/error_helpers.ts +19 -5
  47. package/src/helpers/format_helpers.test.ts +33 -0
  48. package/src/helpers/hash_helpers.test.ts +23 -0
  49. package/src/helpers/hash_helpers.ts +10 -13
  50. package/src/helpers/identity_helpers.test.ts +13 -0
  51. package/src/helpers/identity_helpers.ts +1 -1
  52. package/src/helpers/index.ts +15 -10
  53. package/src/helpers/location_helpers.ts +10 -18
  54. package/src/helpers/logical_helpers.test.ts +39 -0
  55. package/src/helpers/logical_helpers.ts +2 -5
  56. package/src/helpers/math_helpers.test.ts +21 -0
  57. package/src/helpers/math_helpers.ts +6 -0
  58. package/src/helpers/mixin_helpers.stubs.ts +6 -5
  59. package/src/helpers/mixin_helpers.test.ts +91 -0
  60. package/src/helpers/mixin_helpers.ts +22 -9
  61. package/src/helpers/object_helpers.test.ts +138 -0
  62. package/src/helpers/object_helpers.ts +70 -61
  63. package/src/helpers/promise_helpers.test.ts +22 -0
  64. package/src/helpers/promise_helpers.ts +4 -4
  65. package/src/helpers/runtime_helpers.ts +3 -3
  66. package/src/helpers/string_helpers.test.ts +59 -0
  67. package/src/helpers/string_helpers.ts +10 -9
  68. package/src/helpers/time_helpers.ts +5 -7
  69. package/src/helpers/url_helpers.test.ts +111 -0
  70. package/src/helpers/url_helpers.ts +8 -16
  71. package/src/helpers/value_helpers.ts +1 -3
  72. package/src/index.ts +3 -0
  73. package/src/types/arrays.test.ts +20 -0
  74. package/src/types/arrays.ts +26 -22
  75. package/src/types/classes.ts +5 -4
  76. package/src/types/helpers.test.ts +33 -0
  77. package/src/types/helpers.ts +11 -5
  78. package/.github/workflows/ci.yml +0 -16
  79. package/.nvmrc +0 -1
  80. package/CHANGELOG.md +0 -50
  81. package/dist/noeldemartin-utils.cjs.js +0 -2
  82. package/dist/noeldemartin-utils.cjs.js.map +0 -1
  83. package/dist/noeldemartin-utils.esm.js +0 -2
  84. package/dist/noeldemartin-utils.esm.js.map +0 -1
  85. package/dist/noeldemartin-utils.umd.js +0 -2
  86. package/dist/noeldemartin-utils.umd.js.map +0 -1
  87. package/noeldemartin.config.js +0 -3
  88. package/src/main.ts +0 -4
  89. package/src/testing/FakeResponse.ts +0 -62
  90. package/src/testing/FakeServer.ts +0 -126
  91. package/src/testing/index.ts +0 -19
  92. package/src/testing/mocking.ts +0 -33
  93. package/src/testing/namespace.ts +0 -15
package/README.md CHANGED
@@ -46,7 +46,7 @@ For example, this is the kind of code I'd write often:
46
46
  ```js
47
47
  const items = ['my', 'array', 'of', 'cool', 'array', 'items'];
48
48
 
49
- return arrayUnique(items.filter(item => item.startsWith('a')));
49
+ return arrayUnique(items.filter((item) => item.startsWith('a')));
50
50
  ```
51
51
 
52
52
  Where `arrayUnique` is a custom helper (which you can find in this package), and `Array.filter` is a native method. My only option was to combine method chaining with nesting function calls. And the end result wasn't too readable.
@@ -55,7 +55,7 @@ Now, with the fluent API I created in this package, I can write it like this:
55
55
 
56
56
  ```js
57
57
  return fluent(['my', 'array', 'of', 'cool', 'array', 'items']) // or, to be explicit, arr([...])
58
- .filter(item => item.startsWith('a'))
58
+ .filter((item) => item.startsWith('a'))
59
59
  .unique()
60
60
  .toArray(); // returns ['array']
61
61
  ```
@@ -89,7 +89,7 @@ return foo;
89
89
  Like this:
90
90
 
91
91
  ```js
92
- return tap(new Foo(), foo => {
92
+ return tap(new Foo(), (foo) => {
93
93
  foo.bar = 'bar';
94
94
  });
95
95
  ```
@@ -120,10 +120,4 @@ export default facade(new UsersService());
120
120
  import Users from './Users';
121
121
 
122
122
  const users = await Users.all();
123
-
124
- // In your tests...
125
- import Users from './Users';
126
- import UsersServiceMock from './UsersServiceMock';
127
-
128
- Users.setInstance(new UsersServiceMock());
129
123
  ```
@@ -19,7 +19,7 @@ export declare function arrayChunk<T>(items: T[], chunkSize: number): T[][];
19
19
 
20
20
  export declare function arrayClear(items: unknown[]): void;
21
21
 
22
- export declare function arrayDiff<T>(original: T[], updated: T[], compare?: (a: T, b: T) => boolean): {
22
+ export declare function arrayDiff<T>(original: T[], updated: T[], compareValues?: (a: T, b: T) => boolean): {
23
23
  added: T[];
24
24
  removed: T[];
25
25
  };
@@ -66,7 +66,7 @@ export declare function arraySorted<T>(items: T[]): T[];
66
66
 
67
67
  export declare function arraySorted<T>(items: T[], direction: 'asc' | 'desc'): T[];
68
68
 
69
- export declare function arraySorted<T>(items: T[], compare: (a: T, b: T) => number): T[];
69
+ export declare function arraySorted<T>(items: T[], compareValues: (a: T, b: T) => number): T[];
70
70
 
71
71
  export declare function arraySorted<T>(items: T[], field: keyof T, direction?: 'asc' | 'desc'): T[];
72
72
 
@@ -88,8 +88,6 @@ export declare function arrayWithoutIndexes<T>(items: T[], indexes: number[]): T
88
88
 
89
89
  export declare function arrayZip<T>(...arrays: T[][]): T[][];
90
90
 
91
- export declare type Assert<T> = T extends undefined ? never : T;
92
-
93
91
  export declare function assert(assertion: EvaluatesTo<boolean>, message?: string): void;
94
92
 
95
93
  export declare function assert<E extends Error = Error>(assertion: EvaluatesTo<boolean>, errorClass?: Constructor<E>, ...params: ConstructorParameters<Constructor<E>>): void;
@@ -137,7 +135,7 @@ export declare function deleteLocationQueryParameters(parameters: string[]): Pro
137
135
 
138
136
  export declare function downloadFile(filename: string, content: string, mediaType: string): void;
139
137
 
140
- export declare type Equals<X, Y> = (<T>() => T extends X ? 1 : 2) extends (<T>() => T extends Y ? 1 : 2) ? true : false;
138
+ export declare type Equals<X, Y> = (<T>() => T extends X ? 1 : 2) extends <T>() => T extends Y ? 1 : 2 ? true : false;
141
139
 
142
140
  export declare function escapeHtmlEntities(text: string): string;
143
141
 
@@ -147,91 +145,25 @@ export declare function evaluate<T>(value: EvaluatesTo<T>): T;
147
145
 
148
146
  export declare type EvaluatesTo<T> = T | (() => T);
149
147
 
150
- export declare type Expect<T extends true> = T;
151
-
152
- export declare type Extends<X, Y> = Y extends X ? true : false;
153
-
154
- export declare type Facade<TInstance, TMock extends TInstance = TInstance> = TInstance & FacadeMethods<TInstance, TMock>;
148
+ export declare type Facade<TInstance> = TInstance & FacadeMethods<TInstance>;
155
149
 
156
- export declare function facade<TInstance extends object, TMock extends TInstance>(defaultClassOrFactory: (() => TInstance) | Constructor<TInstance>): Facade<TInstance, TMock>;
150
+ export declare function facade<TInstance extends object>(defaultClassOrFactory: (() => TInstance) | Constructor<TInstance>): Facade<TInstance>;
157
151
 
158
- export declare type FacadeMethods<TInstance, TMock extends TInstance> = {
159
- setInstance(instance: TInstance): TInstance;
160
- setMockClass(mockClass: Constructor<TMock>): void;
161
- setMockFactory(mockFactory: () => TMock): void;
162
- setMockFacade(mockFacade: Facade<TMock>): void;
152
+ export declare type FacadeMethods<TInstance> = {
153
+ newInstance(): TInstance;
163
154
  requireInstance(): TInstance;
164
- mock(partialInstance?: Partial<TInstance>): TMock;
155
+ setInstance(instance: TInstance): TInstance;
165
156
  reset(): TInstance;
166
157
  };
167
158
 
168
- declare function fail_2<T = any>(message?: string): T;
169
-
170
- declare function fail_2<T = any, E extends Error = Error>(errorClass?: Constructor<E>, ...params: ConstructorParameters<Constructor<E>>): T;
171
-
172
- declare function fail_2<T = any, E extends JSError = JSError>(errorClass?: Constructor<E>, ...params: ConstructorParameters<Constructor<E>>): T;
173
- export { fail_2 as fail }
174
-
175
- export declare class FakeResponse implements Response {
176
- static created(body?: string, headers?: Record<string, string>): FakeResponse;
177
- static success(body?: string, headers?: Record<string, string>): FakeResponse;
178
- static notFound(body?: string, headers?: Record<string, string>): FakeResponse;
179
- readonly body: ReadableStream<Uint8Array> | null;
180
- readonly bodyUsed: boolean;
181
- readonly headers: Headers;
182
- readonly ok: boolean;
183
- readonly redirected: boolean;
184
- readonly status: number;
185
- readonly statusText: string;
186
- readonly trailer: Promise<Headers>;
187
- readonly type: ResponseType;
188
- readonly url: string;
189
- private rawBody;
190
- constructor(rawBody?: string, headers?: Record<string, string>, status?: number);
191
- arrayBuffer(): Promise<ArrayBuffer>;
192
- blob(): Promise<Blob>;
193
- bytes(): Promise<Uint8Array>;
194
- formData(): Promise<FormData>;
195
- json(): Promise<unknown>;
196
- text(): Promise<string>;
197
- clone(): Response;
198
- }
199
-
200
- export declare class FakeServer {
201
- readonly fetch: typeof fetch;
202
- protected fetchSpy: FetchSpy | null;
203
- protected requests: FakeServerRequest[];
204
- protected responses: Record<string, FakeServerResponse[]>;
205
- constructor();
206
- spy(fetchSpy: FetchSpy): void;
207
- getRequest(url: string): FakeServerRequest | null;
208
- getRequest(method: string, url: string): FakeServerRequest | null;
209
- getRequests(url?: string): FakeServerRequest[];
210
- getRequests(method: string, url: string): FakeServerRequest[];
211
- respond(url: string, response: Response | FakeServerResponse): void;
212
- respondOnce(url: string, response: Response): void;
213
- reset(): void;
214
- protected matchResponse(request: FakeServerRequest): GetClosureResult<typeof fetch>;
215
- }
159
+ export declare function fail<T = any>(message?: string): T;
216
160
 
217
- export declare interface FakeServerRequest {
218
- url: string;
219
- method: string;
220
- body: string;
221
- headers: Record<string, string>;
222
- response?: Response;
223
- }
161
+ export declare function fail<T = any, E extends Error = Error>(errorClass?: Constructor<E>, ...params: ConstructorParameters<Constructor<E>>): T;
224
162
 
225
- export declare interface FakeServerResponse {
226
- response: Response;
227
- method?: string;
228
- times?: number;
229
- }
163
+ export declare function fail<T = any, E extends JSError = JSError>(errorClass?: Constructor<E>, ...params: ConstructorParameters<Constructor<E>>): T;
230
164
 
231
165
  export declare type Falsy = null | undefined | false | 0;
232
166
 
233
- export declare type FetchSpy = (request: FakeServerRequest) => unknown;
234
-
235
167
  export declare function fluent(value: string): FluentStringInstance<FluentStringDefinition>;
236
168
 
237
169
  export declare function fluent<T>(value: T[]): FluentArrayInstance<FluentArrayDefinition<T>, T>;
@@ -348,14 +280,14 @@ export declare type GetOptionalKeys<T> = {
348
280
  }[keyof T];
349
281
 
350
282
  export declare type GetOptionalKeysWithout<TObj, TExclude, U extends Record<keyof TObj, unknown> = ReplaceValues<TObj, TExclude>> = {
351
- [K in keyof TObj]: Record<string, never> extends Pick<TObj, K> ? K : (U[K] extends never ? never : (Equals<TObj[K], U[K]> extends true ? never : K));
283
+ [K in keyof TObj]: Record<string, never> extends Pick<TObj, K> ? K : U[K] extends never ? never : Equals<TObj[K], U[K]> extends true ? never : K;
352
284
  }[keyof TObj];
353
285
 
354
286
  /**
355
287
  * @deprecated use GetOptionalKeysWithout<T, null | undefined> instead.
356
288
  */
357
289
  export declare type GetOptionalKeysWithoutEmpty<T, U extends Record<keyof T, unknown> = ReplaceEmpty<T>> = {
358
- [K in keyof T]: Record<string, never> extends Pick<T, K> ? K : (U[K] extends never ? never : (Equals<T[K], U[K]> extends true ? never : K));
290
+ [K in keyof T]: Record<string, never> extends Pick<T, K> ? K : U[K] extends never ? never : Equals<T[K], U[K]> extends true ? never : K;
359
291
  }[keyof T];
360
292
 
361
293
  export declare type GetRequiredKeys<T> = {
@@ -363,23 +295,36 @@ export declare type GetRequiredKeys<T> = {
363
295
  }[keyof T];
364
296
 
365
297
  export declare type GetRequiredKeysWithout<TObj, TExclude, U extends Record<keyof TObj, unknown> = ReplaceValues<TObj, TExclude>> = {
366
- [K in keyof TObj]: Record<string, never> extends Pick<TObj, K> ? never : (U[K] extends never ? never : (Equals<TObj[K], U[K]> extends true ? K : never));
298
+ [K in keyof TObj]: Record<string, never> extends Pick<TObj, K> ? never : U[K] extends never ? never : Equals<TObj[K], U[K]> extends true ? K : never;
367
299
  }[keyof TObj];
368
300
 
369
301
  /**
370
302
  * @deprecated use GetRequiredKeysWithout<T, null | undefined> instead.
371
303
  */
372
304
  export declare type GetRequiredKeysWithoutEmpty<T, U extends Record<keyof T, unknown> = ReplaceEmpty<T>> = {
373
- [K in keyof T]: Record<string, never> extends Pick<T, K> ? never : (U[K] extends never ? never : (Equals<T[K], U[K]> extends true ? K : never));
305
+ [K in keyof T]: Record<string, never> extends Pick<T, K> ? never : U[K] extends never ? never : Equals<T[K], U[K]> extends true ? K : never;
374
306
  }[keyof T];
375
307
 
376
- export declare type HasKey<T, K extends string> = K extends keyof T ? true : false;
377
-
378
308
  export declare function hasLocationQueryParameter(parameter: string): boolean;
379
309
 
380
310
  export declare type Helper<Primitive = unknown> = (value: Primitive, ...args: any[]) => unknown;
381
311
 
382
- export declare type HelperParams<Primitive, Helper> = Helper extends (value: Primitive, ...args: infer P) => unknown ? P : never;
312
+ export declare type HelperParams<TPrimitive, THelper> = THelper extends (value: TPrimitive, ...args: infer P) => unknown ? P : never;
313
+
314
+ export declare class IndexedDBMap<TItem> {
315
+ private db;
316
+ private namespace;
317
+ constructor(namespace: string);
318
+ has(key: string): Promise<boolean>;
319
+ get(key: string): Promise<TItem | undefined>;
320
+ require(key: string): Promise<TItem>;
321
+ set(key: string, value: TItem): Promise<void>;
322
+ delete(key: string): Promise<void>;
323
+ clear(): Promise<void>;
324
+ close(): void;
325
+ private getConnection;
326
+ private connect;
327
+ }
383
328
 
384
329
  export declare function invert(map: Record<string, string>): Record<string, string>;
385
330
 
@@ -407,7 +352,7 @@ export declare function isSuccessfulResponse(response: Response): boolean;
407
352
 
408
353
  export declare function isValidDateString(value: string): boolean;
409
354
 
410
- export declare class JSError {
355
+ export declare class JSError extends RuntimeErrorClass {
411
356
  name: string;
412
357
  message: string;
413
358
  stack?: string;
@@ -423,6 +368,26 @@ export declare type KeyOf<Object, Values> = {
423
368
  [k in keyof Object]: Object[k] extends Values ? k : never;
424
369
  }[keyof Object];
425
370
 
371
+ export declare type ListenerEvents<TListener extends object> = Required<{
372
+ [K in keyof TListener]: NonNullable<TListener[K]> extends (...args: any[]) => any ? K : never;
373
+ }>[keyof TListener];
374
+
375
+ export declare type ListenerPayload<TListener extends object, TEvent extends keyof TListener> = Required<{
376
+ [K in keyof TListener]: NonNullable<TListener[K]> extends (...args: infer TPayload) => any ? TPayload : never;
377
+ }>[TEvent];
378
+
379
+ export declare interface Listeners<Listener extends object> {
380
+ add(listener: Listener): () => void;
381
+ remove(listener: Listener): void;
382
+ }
383
+
384
+ export declare class ListenersManager<Listener extends object> implements Listeners<Listener> {
385
+ private listeners;
386
+ add(listener: Listener): () => void;
387
+ remove(listener: Listener): void;
388
+ emit<Event extends ListenerEvents<Listener>>(event: Event, ...payload: ListenerPayload<Listener, Event>): Promise<void>;
389
+ }
390
+
426
391
  export declare class MagicObject {
427
392
  private static __conjuring;
428
393
  private static __reservedProperties;
@@ -432,9 +397,10 @@ export declare class MagicObject {
432
397
  protected static isReservedProperty(property: string): boolean;
433
398
  protected _proxy: MagicObjectProxy<this>;
434
399
  constructor(...args: ClosureArgs);
400
+ static<T extends typeof MagicObject>(): T;
401
+ static<T extends typeof MagicObject, K extends keyof T>(property: K): T[K];
435
402
  protected reserveProperty(property: string): void;
436
403
  protected initialize(...args: ClosureArgs): void;
437
- protected static(): MagicObjectConstructor<this>;
438
404
  protected __get(property: string): unknown;
439
405
  protected __set(property: string, value: unknown): void;
440
406
  protected __delete(property: string): void;
@@ -448,11 +414,11 @@ export declare interface MagicObjectProxy<T> {
448
414
  instance: T;
449
415
  }
450
416
 
451
- export declare function map<T>(items: string[], getKey?: ((item: string) => T)): Record<string, T>;
417
+ export declare function map<T>(items: string[], getKey?: (item: string) => T): Record<string, T>;
452
418
 
453
419
  export declare function map<T extends object>(items: []): ObjectsMap<T>;
454
420
 
455
- export declare function map<T extends object>(items: Iterable<T>, getKey?: ((item: T) => string)): ObjectsMap<T>;
421
+ export declare function map<T extends object>(items: Iterable<T>, getKey?: (item: T) => string): ObjectsMap<T>;
456
422
 
457
423
  export declare function map<T extends object, S extends keyof T>(items: Iterable<T>, key: S): ObjectsMap<T>;
458
424
 
@@ -476,21 +442,31 @@ export declare function mixed<Base, A, B, C>(baseClass: Base, mixins: [Cr<A>, Cr
476
442
 
477
443
  export declare function mixed<Base, A, B, C, D>(baseClass: Base, mixins: [Cr<A>, Cr<B>, Cr<C>, Cr<D>]): Base & Cr<A & B & C & D>;
478
444
 
479
- export declare function mixedWithoutTypes(mixins: Constructor[]): Object;
445
+ export declare function mixed<Base, A, B, C, D, E>(baseClass: Base, mixins: [Cr<A>, Cr<B>, Cr<C>, Cr<D>, Cr<E>]): Base & Cr<A & B & C & D & E>;
480
446
 
481
- export declare function mixedWithoutTypes<Base>(baseClass: Base, mixins: Constructor[]): Base;
447
+ export declare function mixed<Base, A, B, C, D, E, F>(baseClass: Base, mixins: [Cr<A>, Cr<B>, Cr<C>, Cr<D>, Cr<E>, Cr<F>]): Base & Cr<A & B & C & D & E & F>;
482
448
 
483
- export declare type Mock<T> = T;
449
+ export declare function mixed<Base, A, B, C, D, E, F, G>(baseClass: Base, mixins: [Cr<A>, Cr<B>, Cr<C>, Cr<D>, Cr<E>, Cr<F>, Cr<G>]): Base & Cr<A & B & C & D & E & F & G>;
484
450
 
485
- export declare function mock<T extends object>(instance?: T | Obj | object): Mock<T>;
451
+ export declare function mixedWithoutTypes(mixins: Constructor[]): Object;
486
452
 
487
- export declare function mock<T extends object>(methods: string[], instance?: T | Obj | object): Mock<T>;
453
+ export declare function mixedWithoutTypes<Base>(baseClass: Base, mixins: Constructor[]): Base;
488
454
 
489
455
  export declare function monkeyPatch<T, K extends GetObjectMethods<T>>(object: T, method: K, callback: VoidClosure<T[K]>): void;
490
456
 
491
457
  export declare function noop(): void;
492
458
 
493
- export declare type Not<X> = X extends true ? false : true;
459
+ export declare type Nullable<T> = T | null | undefined;
460
+
461
+ export declare type NullableOptional<T> = Pretty<{
462
+ [P in GetOptionalKeys<T>]?: Nullable<T[P]>;
463
+ } & {
464
+ [P in GetRequiredKeys<T>]: T[P];
465
+ }>;
466
+
467
+ export declare type NullablePartial<T> = {
468
+ [P in keyof T]?: Nullable<T[P]>;
469
+ };
494
470
 
495
471
  export declare type Obj = Record<string, unknown>;
496
472
 
@@ -547,9 +523,9 @@ export declare type ObjectWithout<TObj, TExclude> = Pretty<{
547
523
  [K in GetOptionalKeysWithout<TObj, TExclude>]?: ValueWithout<TObj[K], TExclude>;
548
524
  }>;
549
525
 
550
- export declare function objectWithout<TObj extends Obj, TKey extends keyof TObj>(obj: TObj, keys: TKey): Omit<TObj, TKey>;
526
+ export declare function objectWithout<TObj extends Obj, TKey extends keyof TObj>(obj: TObj, key: TKey): Omit<TObj, TKey>;
551
527
 
552
- export declare function objectWithout<TObj extends object, TKey extends keyof TObj>(obj: TObj, keys: TKey): Omit<TObj, TKey>;
528
+ export declare function objectWithout<TObj extends object, TKey extends keyof TObj>(obj: TObj, key: TKey): Omit<TObj, TKey>;
553
529
 
554
530
  export declare function objectWithout<TObj extends Obj, TKey extends keyof TObj>(obj: TObj, keys: TKey[]): Omit<TObj, TKey>;
555
531
 
@@ -666,6 +642,9 @@ export declare function resetAsyncMemo(key?: string): void;
666
642
 
667
643
  export declare function resetMemo(key?: string): void;
668
644
 
645
+ export declare function round(value: number, places?: number): number;
646
+
647
+ export declare const RuntimeErrorClass: ErrorConstructor;
669
648
 
670
649
  export declare function runtimeGlobal<T = any>(): T;
671
650
 
@@ -687,8 +666,6 @@ export declare function setAsyncMemo(key: string, value: unknown): void;
687
666
 
688
667
  export declare function setMemo(key: string, value: unknown): void;
689
668
 
690
- export declare function setTestingNamespace(namespace: TestingNamespace): void;
691
-
692
669
  export declare function shortId(length?: number): string;
693
670
 
694
671
  export declare function silenced<Args extends ClosureArgs, Result>(operation: Closure<Args, Promise<Result>>): Closure<Args, Promise<Result | null>>;
@@ -752,17 +729,11 @@ export declare type Tapped<Target extends object> = {
752
729
  [prop in keyof Target]: Target[prop] extends (...params: infer Params) => unknown ? (...params: Params) => Tapped<Target> : Target[prop];
753
730
  };
754
731
 
755
- export declare function testing(): TestingNamespace;
756
-
757
- export declare interface TestingNamespace {
758
- fn<T extends Closure>(method?: T): T;
759
- }
732
+ export declare function toError(value: unknown): Error;
760
733
 
761
734
  declare function toString_2(value: unknown): string;
762
735
  export { toString_2 as toString }
763
736
 
764
- export declare const tt: <T>() => () => any;
765
-
766
737
  export declare type Tuple<Item, Length extends number, Optional extends number = number> = CollapseTupleUnion<_TupleRecursion<RequiredTuple<Item, Length>, Optional, []>>;
767
738
 
768
739
  export declare type _TupleRecursion<Tuple extends unknown[], Optional extends number, Rest extends unknown[]> = Tuple['length'] extends Rest['length'] ? Rest : Optional extends Rest['length'] ? _TupleRecursion<Tuple, Optional, [Tuple[Rest['length']] | undefined, ...Rest]> : _TupleRecursion<Tuple, Optional, [Tuple[Rest['length']], ...Rest]>;