@noeldemartin/utils 0.7.2 → 0.7.3-next.01aafeb82315a7bdaa8f53a6f2c92e752bc41e9b

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.
@@ -1,3 +1,5 @@
1
+ export declare const __brand: unique symbol;
2
+
1
3
  export declare function after(ms: number): Promise<void>;
2
4
 
3
5
  export declare function after(options?: AfterOptions): Promise<void>;
@@ -13,6 +15,8 @@ export declare interface AfterOptions {
13
15
 
14
16
  export declare function applyMixins<Base extends Constructor>(baseClass: Base, mixinClasses?: Constructor[]): void;
15
17
 
18
+ export declare function applyReplacements(text: string, replacements?: Replacements): string;
19
+
16
20
  export declare function applyStrictChecks(): boolean;
17
21
 
18
22
  export declare function arr<T>(value: Iterable<T>): FluentArrayInstance<FluentArrayDefinition<T>, T>;
@@ -46,7 +50,11 @@ export declare function arrayFlatMap<T, R>(items: T[], map: (item: T, index: num
46
50
 
47
51
  export declare type ArrayFrom<T> = T extends Iterable<infer TItem> ? TItem[] : T[];
48
52
 
49
- export declare function arrayFrom<T>(value: T, ignoreEmptyValues?: boolean): ArrayFrom<T>;
53
+ export declare function arrayFrom<TValue, TOptions extends {
54
+ ignoreEmptyValues?: boolean;
55
+ }>(value: TValue, options?: TOptions): TOptions extends {
56
+ ignoreEmptyValues: true;
57
+ } ? ArrayFrom<NonNullable<TValue>> : ArrayFrom<TValue>;
50
58
 
51
59
  export declare function arrayGroupBy<TItem, TKey extends string>(items: TItem[], groupBy: (item: TItem) => TKey): Partial<Record<TKey, TItem[]>>;
52
60
 
@@ -72,15 +80,25 @@ export declare function arrayRemoveIndex<T>(items: T[], index: number | string):
72
80
 
73
81
  export declare function arrayReplace<T>(items: T[], original: T, replacement: T): boolean;
74
82
 
83
+ export declare function arrayReversed<T>(items: T[]): T[];
84
+
85
+ export declare type ArraySortCompare<T> = (a: T, b: T) => number;
86
+
87
+ export declare type ArraySortDirection = 'asc' | 'desc';
88
+
75
89
  export declare function arraySorted<T>(items: T[]): T[];
76
90
 
77
- export declare function arraySorted<T>(items: T[], direction: 'asc' | 'desc'): T[];
91
+ export declare function arraySorted<T>(items: T[], direction: ArraySortDirection): T[];
92
+
93
+ export declare function arraySorted<T>(items: T[], compareValues: ArraySortCompare<T>): T[];
78
94
 
79
- export declare function arraySorted<T>(items: T[], compareValues: (a: T, b: T) => number): T[];
95
+ export declare function arraySorted<T>(items: T[], field: DeepKeyOf<T>, direction?: ArraySortDirection): T[];
80
96
 
81
- export declare function arraySorted<T>(items: T[], field: DeepKeyOf<T>, direction?: 'asc' | 'desc'): T[];
97
+ export declare function arraySorted<T>(items: T[], fields: DeepKeyOf<T>[], direction?: ArraySortDirection): T[];
82
98
 
83
- export declare function arraySorted<T>(items: T[], fields: DeepKeyOf<T>[], direction?: 'asc' | 'desc'): T[];
99
+ export declare function arraySorted<T>(items: T[], fields: ArraySortFieldDirection<T>[]): T[];
100
+
101
+ export declare type ArraySortFieldDirection<T> = [DeepKeyOf<T>, ArraySortDirection];
84
102
 
85
103
  export declare function arraySwap(items: unknown[], firstIndex: number, secondIndex: number): void;
86
104
 
@@ -106,6 +124,10 @@ export declare function asyncFirst<TValue, TResult>(values: TValue[], operation:
106
124
 
107
125
  export declare function asyncMemo<T>(key: string, operation: () => Promise<T>): Promise<T>;
108
126
 
127
+ export declare type Branded<T, Brand> = T & {
128
+ [__brand]: Brand;
129
+ };
130
+
109
131
  export declare function catchError(callback: () => unknown): Error | null;
110
132
 
111
133
  export declare function clamp(value: number, min: number, max: number): number;
@@ -132,6 +154,10 @@ export declare interface Constructor<T = Object> {
132
154
 
133
155
  export declare type Cr<T> = Constructor<T>;
134
156
 
157
+ export declare const DAY_MILLISECONDS: number;
158
+
159
+ export declare const DAY_SECONDS: number;
160
+
135
161
  export declare function debounce<Args extends ClosureArgs>(callback: (...args: Args) => unknown, delay: number): DebouncedFunction<Args>;
136
162
 
137
163
  export declare interface DebouncedFunction<Args extends ClosureArgs> {
@@ -139,10 +165,16 @@ export declare interface DebouncedFunction<Args extends ClosureArgs> {
139
165
  cancel(): void;
140
166
  }
141
167
 
168
+ export declare type _Decrement<N extends number> = [never, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10][N];
169
+
170
+ export declare function deepAssign<T extends object>(target: T, ...sources: T[]): T;
171
+
142
172
  export declare function deepEquals(a: unknown, b: unknown): boolean;
143
173
 
144
- export declare type DeepKeyOf<T, TRequired extends DeepRequired<T> = DeepRequired<T>> = NonNullable<TRequired extends object ? {
145
- [K in keyof TRequired]: TRequired[K] extends Function ? never : TRequired[K] extends Array<unknown> ? `${Exclude<K, symbol>}` : TRequired[K] extends object ? {
174
+ export declare function deepGet<T extends object, K extends DeepKeyOf<T>>(object: T, key: K): DeepValue<T, K>;
175
+
176
+ export declare type DeepKeyOf<T, TDepth extends number = 5, TRequired extends DeepRequired<T> = DeepRequired<T>> = NonNullable<TRequired extends object ? {
177
+ [K in keyof TRequired]: TRequired[K] extends Function ? never : TRequired[K] extends Array<infer TItem> ? `${Exclude<K, symbol>}` | `${Exclude<K, symbol>}.${number}` | (Equals<0, TDepth> extends true ? never : `${Exclude<K, symbol>}.${number}.${DeepKeyOf<TItem, _Decrement<TDepth>, DeepRequired<TItem>>}`) : TRequired[K] extends object ? {
146
178
  [KK in keyof TRequired[K]]: TRequired[K][KK] extends Function ? never : TRequired[K][KK] extends Array<unknown> ? `${Exclude<K, symbol>}.${Exclude<KK, symbol>}` : TRequired[K][KK] extends object ? {
147
179
  [KKK in keyof TRequired[K][KK]]: TRequired[K][KK][KKK] extends Function ? never : `${Exclude<K, symbol>}.${Exclude<KK, symbol>}.${Exclude<KKK, symbol>}`;
148
180
  }[keyof TRequired[K][KK]] | `${Exclude<K, symbol>}.${Exclude<KK, symbol>}` : `${Exclude<K, symbol>}.${Exclude<KK, symbol>}`;
@@ -153,6 +185,8 @@ export declare type DeepRequired<T> = T extends object ? {
153
185
  [K in keyof T]-?: NonNullable<T[K]> extends Function ? NonNullable<T[K]> : NonNullable<T[K]> extends object ? DeepRequired<NonNullable<T[K]>> : NonNullable<T[K]>;
154
186
  } : T;
155
187
 
188
+ export declare function deepSet<T extends object, K extends DeepKeyOf<T>>(object: T, key: K, value: DeepValue<T, K>): void;
189
+
156
190
  export declare type DeepValue<T extends object, K> = K extends `${infer Key}.${infer Rest}` ? Key extends keyof T ? T[Key] extends object ? DeepValue<T[Key], Rest> : T[Key] : never : K extends keyof T ? T[K] : never;
157
191
 
158
192
  export declare function deleteLocationQueryParameters(parameters: string[]): Promise<void>;
@@ -186,11 +220,11 @@ export declare interface FacadeMethods<TInstance extends object = object> {
186
220
 
187
221
  export declare function fail<T = any>(message?: string): T;
188
222
 
189
- export declare function fail<T = any, E extends Error = Error>(errorClass?: Constructor<E>, ...params: ConstructorParameters<Constructor<E>>): T;
223
+ export declare function fail<T = any, E extends Constructor<Error> = Constructor<Error>>(errorClass?: E, ...params: ConstructorParameters<E>): T;
190
224
 
191
- export declare function fail<T = any, E extends JSError = JSError>(errorClass?: Constructor<E>, ...params: ConstructorParameters<Constructor<E>>): T;
225
+ export declare function fail<T = any, E extends Constructor<JSError> = Constructor<JSError>>(errorClass?: E, ...params: ConstructorParameters<E>): T;
192
226
 
193
- export declare type Falsy = null | undefined | false | 0;
227
+ export declare type Falsy = '' | null | undefined | false | 0;
194
228
 
195
229
  export declare function fluent(value: string): FluentStringInstance<FluentStringDefinition>;
196
230
 
@@ -293,10 +327,6 @@ export declare function getAsyncMemo<T>(key: string): Promise<T | null>;
293
327
 
294
328
  export declare function getClassMethods(target: object): string[];
295
329
 
296
- export declare type GetClosureArgs<T extends Closure> = T extends (...args: infer Args) => ClosureResult ? Args : never;
297
-
298
- export declare type GetClosureResult<T extends Closure> = T extends (...args: any[]) => infer Result ? Result : never;
299
-
300
330
  export declare function getEnv(): string | null;
301
331
 
302
332
  export declare function getFacadeInstance<T extends object>(value: Facade<T>): T;
@@ -351,12 +381,18 @@ export declare type GetRequiredKeysWithoutEmpty<T, U extends Record<keyof T, unk
351
381
 
352
382
  export declare function getWeakMemo<T>(name: string, key: object): T | null;
353
383
 
384
+ export declare function hasItems<T>(array: T[]): array is [T, ...T[]];
385
+
354
386
  export declare function hasLocationQueryParameter(parameter: string): boolean;
355
387
 
356
388
  export declare type Helper<Primitive = unknown> = (value: Primitive, ...args: any[]) => unknown;
357
389
 
358
390
  export declare type HelperParams<TPrimitive, THelper> = THelper extends (value: TPrimitive, ...args: infer P) => unknown ? P : never;
359
391
 
392
+ export declare const HOUR_MILLISECONDS: number;
393
+
394
+ export declare const HOUR_SECONDS: number;
395
+
360
396
  export declare class IndexedDBMap<TItem> {
361
397
  private db;
362
398
  private namespace;
@@ -372,6 +408,12 @@ export declare class IndexedDBMap<TItem> {
372
408
  private connect;
373
409
  }
374
410
 
411
+ export declare function invade<T, TMethods extends string>(object: T, methods: TMethods[]): Override<T, Invaded<T, TMethods>>;
412
+
413
+ export declare type Invaded<TObject, TMethods extends string> = {
414
+ [K in TMethods]: TObject[K];
415
+ };
416
+
375
417
  export declare function invert(map: Record<string, string>): Record<string, string>;
376
418
 
377
419
  export declare type IsAny<T> = {
@@ -404,12 +446,18 @@ export declare function isProduction(): boolean;
404
446
 
405
447
  export declare function isPromise(p: unknown): p is Promise<unknown>;
406
448
 
449
+ export declare function isPromiseLike(value: unknown): value is PromiseLike<unknown>;
450
+
407
451
  export declare function isString(value: unknown): value is string | String;
408
452
 
453
+ export declare function isSubclassOf(value: Constructor, baseClass: Constructor): boolean;
454
+
409
455
  export declare function isSuccessfulResponse(response: Response): boolean;
410
456
 
411
457
  export declare function isTesting(type?: 'unit' | 'e2e'): boolean;
412
458
 
459
+ export declare function isTruthy<T>(value: T): value is Truthy<T>;
460
+
413
461
  export declare function isValidDateString(value: string): boolean;
414
462
 
415
463
  export declare class JSError extends RuntimeErrorClass {
@@ -486,6 +534,10 @@ export declare function md5(message: string): string;
486
534
 
487
535
  export declare function memo<T>(key: string, operation: () => T): T;
488
536
 
537
+ export declare const MINUTE_MILLISECONDS: number;
538
+
539
+ export declare const MINUTE_SECONDS = 60;
540
+
489
541
  export declare function mixed<A>(mixins: [Cr<A>]): Cr<A>;
490
542
 
491
543
  export declare function mixed<A, B>(mixins: [Cr<A>, Cr<B>]): Cr<A & B>;
@@ -514,6 +566,10 @@ export declare function mixedWithoutTypes<Base>(baseClass: Base, mixins: Constru
514
566
 
515
567
  export declare function monkeyPatch<T, K extends GetObjectMethods<T>>(object: T, method: K, callback: VoidClosure<T[K]>): void;
516
568
 
569
+ export declare const MONTH_MILLISECONDS: number;
570
+
571
+ export declare const MONTH_SECONDS: number;
572
+
517
573
  export declare function noop(): void;
518
574
 
519
575
  export declare type Nullable<T> = T | null | undefined;
@@ -532,14 +588,18 @@ export declare type Obj = Record<string, unknown>;
532
588
 
533
589
  export declare function objectDeepClone<T extends Obj>(object: T): T;
534
590
 
535
- export declare function objectDeepValue<T extends object, K extends DeepKeyOf<T>>(object: T, key: K): DeepValue<T, K>;
591
+ export declare const objectEntries: <T extends Parameters<typeof Object.entries>[0]>(obj: T) => [GetObjectKeys<T>, GetObjectValues<T>][];
536
592
 
537
- export declare const objectEntries: <T extends GetClosureArgs<typeof Object.entries>[0]>(obj: T) => [GetObjectKeys<T>, GetObjectValues<T>][];
593
+ export declare const objectFromEntries: <K extends string | number | symbol, V>(value: Iterable<readonly [K, V]>) => Record<K, V>;
538
594
 
539
595
  export declare function objectHasOwnProperty(object: Obj, property: string): boolean;
540
596
 
541
597
  export declare type ObjectKeyExtractor<T> = (item: T) => string;
542
598
 
599
+ export declare const objectKeys: <T extends {
600
+ [k: string]: any;
601
+ } | ArrayLike<any>>(object: T) => GetObjectKeys<T>[];
602
+
543
603
  export declare function objectMap<T>(items: T[], property: KeyOf<T, number | string>): Record<string, T>;
544
604
 
545
605
  export declare function objectOnly<T extends object, K extends keyof T>(obj: T, keys: K | K[]): Pick<T, K>;
@@ -577,6 +637,10 @@ export declare class ObjectsMap<Item extends object> {
577
637
 
578
638
  export declare type ObjectValues<T> = T[keyof T];
579
639
 
640
+ export declare const objectValues: <T extends {
641
+ [k: string]: any;
642
+ } | ArrayLike<any>>(object: T) => GetObjectValues<T>[];
643
+
580
644
  export declare type ObjectWithout<TObj, TExclude> = Pretty<{
581
645
  [K in GetRequiredKeysWithout<TObj, TExclude>]: ValueWithout<TObj[K], TExclude>;
582
646
  } & {
@@ -614,6 +678,8 @@ export declare type OnlyKnownProperties<TGeneric, TKnown> = {
614
678
  [K in keyof TGeneric]: K extends keyof TKnown ? TGeneric[K] : never;
615
679
  };
616
680
 
681
+ export declare type Override<T, TOverrides> = Omit<T, keyof TOverrides> & TOverrides;
682
+
617
683
  export declare function overridePrototypeMethod<T, K extends GetObjectMethods<T>>(target: Constructor<T>, method: K, implementation: T[K]): void;
618
684
 
619
685
  export declare function parseBoolean(value: unknown): boolean;
@@ -669,6 +735,10 @@ export declare function randomInt(min: number, max: number): number;
669
735
 
670
736
  export declare function range(length: number): number[];
671
737
 
738
+ export declare function reduceBy<TItem, TKey extends keyof TItem, TProjection>(items: TItem[], key: TKey, project: (item: TItem) => TProjection): Record<string, TProjection>;
739
+
740
+ export declare function reduceBy<TItem, TKey extends keyof TItem>(items: TItem[], key: TKey): Record<string, TItem>;
741
+
672
742
  export declare type ReplaceConstructorArgs<T, Args extends ClosureArgs> = T extends {
673
743
  new (...args: ClosureArgs): infer Instance;
674
744
  } ? Omit<T, 'new'> & {
@@ -682,6 +752,8 @@ export declare type ReplaceEmpty<T> = {
682
752
  [K in keyof T]: ValueWithoutEmpty<T[K]>;
683
753
  };
684
754
 
755
+ export declare type Replacements = Record<string, unknown>;
756
+
685
757
  export declare type ReplaceValues<TObj, TExclude> = {
686
758
  [K in keyof TObj]: ValueWithout<TObj[K], TExclude>;
687
759
  };
@@ -742,6 +814,12 @@ export declare function silenced<Result>(promise: Promise<Result>): Promise<Resu
742
814
 
743
815
  export declare function silenced<Args extends ClosureArgs, Result, Default>(operation: Closure<Args, Promise<Result>>, defaultValue: Default): Closure<Args, Promise<Result | Default>>;
744
816
 
817
+ export declare function sleep(ms: number): Promise<void>;
818
+
819
+ export declare function sleep(options?: AfterOptions): Promise<void>;
820
+
821
+ export declare type Slug = Branded<string, 'slug'>;
822
+
745
823
  declare const Storage_2: StorageSingleton;
746
824
  export { Storage_2 as Storage }
747
825
 
@@ -775,7 +853,7 @@ export declare function stringSplitWords(text: string): string[];
775
853
 
776
854
  export declare function stringToCamelCase(text: string): string;
777
855
 
778
- export declare function stringToSlug(text: string, separator?: string): string;
856
+ export declare function stringToSlug(text: string, separator?: string): Slug;
779
857
 
780
858
  export declare function stringToStudlyCase(text: string): string;
781
859
 
@@ -800,6 +878,8 @@ export declare function toError(value: unknown): Error;
800
878
  declare function toString_2(value: unknown): string;
801
879
  export { toString_2 as toString }
802
880
 
881
+ export declare type Truthy<T> = Exclude<T, Falsy>;
882
+
803
883
  export declare type Tuple<Item, Length extends number, Optional extends number = number> = CollapseTupleUnion<_TupleRecursion<RequiredTuple<Item, Length>, Optional, []>>;
804
884
 
805
885
  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]>;
@@ -843,6 +923,8 @@ export declare function usesMixin(target: any, mixin: Constructor): boolean;
843
923
 
844
924
  export declare function uuid(): string;
845
925
 
926
+ export declare function validUrl(url: string): string | null;
927
+
846
928
  export declare function value<T>(evaluator: () => T): T;
847
929
 
848
930
  export declare function value<T>(evaluator: T): T;
@@ -858,6 +940,10 @@ export declare type VoidClosure<T> = T extends (...args: infer A) => ClosureResu
858
940
 
859
941
  export declare function weakMemo<T>(name: string, key: object, operation: () => T): T;
860
942
 
943
+ export declare const WEEK_MILLISECONDS: number;
944
+
945
+ export declare const WEEK_SECONDS: number;
946
+
861
947
  export declare function when<T extends object>(target: T, condition: () => boolean): T;
862
948
 
863
949
  export declare function when<T extends object>(target: T, condition: boolean): T;
@@ -868,4 +954,8 @@ export declare type Writable<T> = {
868
954
  -readonly [K in keyof T]: T[K];
869
955
  };
870
956
 
957
+ export declare const YEAR_MILLISECONDS: number;
958
+
959
+ export declare const YEAR_SECONDS: number;
960
+
871
961
  export { }