@zendesk/react-measure-timing-hooks/cjs/v3/typeUtils.d.ts

react hooks for measuring time to interactive and time to render of components

import type { States, TraceStates } from './Trace';
export type DistributiveOmit<T, K extends keyof any> = T extends T ? Omit<T, K> : never;
export type Prettify<T> = {
    [K in keyof T]: T[K];
} & {};
export type RemoveAllUndefinedProperties<T> = Prettify<{
    [K in keyof T as T[K] extends undefined ? never : K]: T[K];
}>;
/**
 * Extract the set of keys in T whose type is not exactly `undefined`.
 * If T[P] is `? undefined`, we treat that key as "unused."
 */
type NonUndefinedKeys<T> = {
    [P in keyof T]-?: T[P] extends undefined ? never : P;
}[keyof T];
type ExactKeySet<T, K extends PropertyKey> = [NonUndefinedKeys<T>] extends [K] ? [K] extends [NonUndefinedKeys<T>] ? true : false : false;
/**
 * Picks from U those members whose *non-undefined* keys
 * are exactly the set K.
 */
export type SelectByAllKeys<K extends PropertyKey, U> = U extends unknown ? ExactKeySet<U, K> extends true ? U : never : never;
/**
 * Picks from U those members that have at least one
 * non-undefined key from K.
 */
export type SelectBySomeKeys<K extends PropertyKey, U> = U extends unknown ? Extract<NonUndefinedKeys<U>, K> extends never ? never : U : never;
/**
 * For T, check if NonUndefinedKeys<T> is exactly equal to the set of keys in K.
 * "Exactly equal" means the two sets are mutual subsets of each other.
 */
type HasExactKeys<T, K extends readonly PropertyKey[]> = NonUndefinedKeys<T> extends K[number] ? K[number] extends NonUndefinedKeys<T> ? true : false : false;
/**
 * For T, check if it has at least one key from K as non-undefined.
 */
type HasSomeKeys<T, K extends readonly PropertyKey[]> = Extract<NonUndefinedKeys<T>, K[number]> extends never ? false : true;
/**
 * From a union of object types U, pick those whose non-undefined keys
 * are *exactly* the set of keys in K (ignoring order).
 */
export type SelectByAllKeysUnion<K extends readonly PropertyKey[], U> = U extends unknown ? (HasExactKeys<U, K> extends true ? U : never) : never;
/**
 * From a union of object types U, pick those that have at least one
 * non-undefined key from K.
 */
export type SelectBySomeKeysUnion<K extends readonly PropertyKey[], U> = U extends unknown ? (HasSomeKeys<U, K> extends true ? U : never) : never;
export type UnionToIntersection<U> = (U extends U ? (x: U) => void : never) extends (x: infer I) => void ? I : never;
type HandlerToPayloadTuples<SelectedRelationNameT extends keyof RelationSchemasT, RelationSchemasT, VariantsT extends string, State extends TraceStates = TraceStates> = State extends State ? {
    [K in keyof States<SelectedRelationNameT, RelationSchemasT, VariantsT>[State]]: States<SelectedRelationNameT, RelationSchemasT, VariantsT>[State][K] extends (...args: infer ArgsT) => infer ReturnT ? [K, ArgsT[0], ReturnT] : never;
}[keyof States<SelectedRelationNameT, RelationSchemasT, VariantsT>[State]] : never;
type TupleToObject<T extends [PropertyKey, any, any]> = Prettify<{
    [K in T[0]]: T extends [K, infer V, any] ? V : never;
}>;
type TupleToObject2<T extends [PropertyKey, any, any]> = Prettify<{
    [K in T[0]]: T extends [K, any, infer V] ? V : never;
}>;
export type StateHandlerPayloads<SelectedRelationNameT extends keyof RelationSchemasT, RelationSchemasT, VariantsT extends string> = TupleToObject<HandlerToPayloadTuples<SelectedRelationNameT, RelationSchemasT, VariantsT>>;
export type StateHandlerReturnTypes<SelectedRelationNameT extends keyof RelationSchemasT, RelationSchemasT, VariantsT extends string> = TupleToObject2<HandlerToPayloadTuples<SelectedRelationNameT, RelationSchemasT, VariantsT>>;
export type MergedStateHandlerMethods<SelectedRelationNameT extends keyof RelationSchemasT, RelationSchemasT, VariantsT extends string> = {
    [K in keyof StateHandlerPayloads<SelectedRelationNameT, RelationSchemasT, VariantsT>]: (payload: StateHandlerPayloads<SelectedRelationNameT, RelationSchemasT, VariantsT>[K]) => StateHandlerReturnTypes<SelectedRelationNameT, RelationSchemasT, VariantsT>[K];
};
export type ArrayWithAtLeastOneElement<T> = readonly [T, ...T[]];
export type MapTuple<KeysTuple extends readonly unknown[], MapToValue> = {
    [Index in keyof KeysTuple]: MapToValue;
};
/** Convert a union of values U into a single tuple type (in an arbitrary order). */
export type UnionToTuple<U, R extends any[] = []> = [U] extends [never] ? R : UnionToTuple<Exclude<U, LastOf<U>>, [LastOf<U>, ...R]>;
type LastOf<U> = UnionToIntersection<U extends any ? (x: U) => void : never> extends (x: infer L) => void ? L : never;
export {};