Press n or j to go to the next uncovered block, b, p or k for the previous block.
| 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 | 50x 17x 7x 10x 50x 85x 50x 58x 50x 17x 50x 29x 50x 12x 50x 18x 50x 6x 50x 346x 50x 102x 9x 9x 6x 3x 50x 50x 50x 50x 50x 50x 50x 50x 50x 19x 19x 220x 111x 19x | export type JsonValue = string | number | boolean | null;
declare const __brand: unique symbol;
type Brand<B> = { [__brand]: B };
export type Branded<T, B> = T & Brand<B>;
export type DeepReadonly<T> = {
readonly [Key in keyof T]: T[Key] extends unknown[] | Record<string, unknown>
? DeepReadonly<T[Key]>
: T[Key];
};
/* KeysMatching<T, V>
*
* Find all keys in T which have the type V
* e.g. KeysMatching<Actor, boolean> to return "animate" | "isPinned"
*/
export type KeysMatching<T, V> = {
[K in keyof T]-?: T[K] extends V ? K : never;
}[keyof T];
export const isStringArray = (value: unknown): value is string[] => {
if (!Array.isArray(value)) {
return false;
}
return value.every(isString);
};
export const isString = (value: unknown): value is string => {
return typeof value === "string";
};
export const isNumber = (value: unknown): value is number => {
return typeof value === "number" && !isNaN(value) && isFinite(value);
};
export const isBoolean = (value: unknown): value is boolean => {
return typeof value === "boolean";
};
export const isUndefined = (value: unknown): value is undefined => {
return value === undefined;
};
export const isMaybeString = (value: unknown): value is string | undefined => {
return isString(value) || isUndefined(value);
};
export const isMaybeNumber = (value: unknown): value is number | undefined => {
return isNumber(value) || isUndefined(value);
};
export const ensureType = <T>(
value: unknown,
fallback: T,
isType: (value: unknown) => value is T,
): T => {
return isType(value) ? value : fallback;
};
export const ensureTypeGenerator = <T>(
isType: (value: unknown) => value is T,
): ((value: unknown, fallback: T) => T) => {
return (value: unknown, fallback: T) => (isType(value) ? value : fallback);
};
export const ensurePromisedTypeGenerator = <T>(
isType: (value: unknown) => value is T,
): ((promise: Promise<unknown>, fallback: T) => Promise<T>) => {
return async (promise: Promise<unknown>, fallback: T): Promise<T> => {
try {
const value = await promise;
return isType(value) ? value : fallback;
} catch {
return fallback;
}
};
};
export const ensureString = ensureTypeGenerator(isString);
export const ensureStringArray = ensureTypeGenerator(isStringArray);
export const ensureNumber = ensureTypeGenerator(isNumber);
export const ensureBoolean = ensureTypeGenerator(isBoolean);
export const ensurePromisedString = ensurePromisedTypeGenerator(isString);
export const ensurePromisedNumber = ensurePromisedTypeGenerator(isNumber);
export const ensureMaybeString = ensureTypeGenerator(isMaybeString);
export const ensureMaybeNumber = ensureTypeGenerator(isMaybeNumber);
export const omit = <T, O extends keyof T>(
obj: T,
...keys: O[]
): Omit<T, O> => {
const ret = {} as {
[K in keyof typeof obj]: (typeof obj)[K];
};
let key: keyof typeof obj;
for (key in obj) {
if (!keys.includes(key as O)) {
ret[key] = obj[key];
}
}
return ret;
};
|