@freeword/meta/built/src/types/TSTools.d.ts

Meta package for Freeword: exports all core types, constants, and utilities from the src/ directory.

type Bag<TT> = {
    [key: string]: TT;
};
export type ArrRO<T> = readonly T[];
export type ArrNZRO<T> = readonly [T, ...T[]];
export type StrArrNZRO = ArrNZRO<string>;
export type ArrNZ<T> = [T, ...T[]];
export type StrArrNZ = ArrNZ<string>;
export type NonEmptyArray<T> = ArrNZ<T>;
export type NonEmptyStringArray = StrArrNZ;
export type Optionally<T> = {
    [P in keyof T]?: T[P] | undefined;
};
export type Nullablize2<OT, KT extends keyof OT> = Omit<OT, KT> & {
    [P in KT]: OT[P] | null;
};
export type Optionalize2<OT, KT extends keyof OT> = Omit<OT, KT> & {
    [P in KT]?: OT[P] | undefined;
};
export type Optnullablize2<OT, KT extends keyof OT> = Omit<OT, KT> & {
    [P in KT]?: OT[P] | undefined | null;
};
export type Unnullablize2<OT, KT extends keyof OT> = Omit<OT, KT> & {
    [P in KT]: Exclude<OT[P], null>;
};
export type Unoptionalize2<OT, KT extends keyof OT> = Omit<OT, KT> & {
    [P in KT]-?: Exclude<OT[P], undefined>;
};
export type Requireize2<OT, KT extends keyof OT = keyof OT> = Omit<OT, KT> & {
    [P in KT]-?: Exclude<OT[P], undefined | null>;
};
export type Nullablize<OT, KT extends string = keyof OT & string> = Omit<OT, KT> & {
    [P in KT & keyof OT]: OT[P] | null;
};
export type Partialize<OT, KT extends string = keyof OT & string> = Omit<OT, KT> & {
    [P in KT & keyof OT]?: OT[P];
};
export type Optionalize<OT, KT extends string = keyof OT & string> = Omit<OT, KT> & {
    [P in KT & keyof OT]?: OT[P] | undefined;
};
export type Optnullablize<OT, KT extends string = keyof OT & string> = Omit<OT, KT> & {
    [P in KT & keyof OT]?: OT[P] | undefined | null;
};
export type Unnullablize<OT, KT extends string = keyof OT & string> = Omit<OT, KT> & {
    [P in KT & keyof OT]: Exclude<OT[P], null>;
};
export type Unoptionalize<OT, KT extends string = keyof OT & string> = Omit<OT, KT> & {
    [P in KT & keyof OT]-?: Exclude<OT[P], undefined>;
};
export type UnPartialize<OT, KT extends string = keyof OT & string> = Omit<OT, KT> & {
    [P in KT & keyof OT]-?: OT[P];
};
export type Requireize<OT, KT extends string = keyof OT & string> = Omit<OT, KT> & {
    [P in KT & keyof OT]-?: Exclude<OT[P], undefined | null>;
};
export type OptionalizePick<OT, KT extends keyof OT> = Pick<OT, KT> & {
    [P in Exclude<keyof OT, KT>]?: OT[P] | undefined;
};
export type Invert<BagT extends Record<string, string>> = {
    [KT in keyof BagT as BagT[KT]]: KT;
};
/** Get the inner keys of a Bag of Bags */ export type BagBagKeys<BBT extends Bag<Bag<any>>> = keyof {
    [K in keyof BBT as keyof BBT[K]]: true;
};
export type BagBagMerge<BBT extends Bag<Bag<any>>> = {
    [InnerKey in BagBagKeys<BBT>]: {
        [OuterKey in keyof BBT]: InnerKey extends keyof BBT[OuterKey] ? BBT[OuterKey][InnerKey] : never;
    }[keyof BBT];
};
export type MapKeys<BBT extends Bag<Bag<any>>, InnerKey extends keyof BBT[keyof BBT]> = {
    [IK in BBT[keyof BBT][InnerKey]]: {
        [KT in keyof BBT]: BBT[KT][InnerKey] extends IK ? BBT[KT] : never;
    }[keyof BBT];
};
/**
 * Use this to strip a static method from the parent class
 * to work around TY's broken static inheritance
 *
 * Ex:
 * ```ts
 *   class Animal { static make(props: AnimalProps): Animal { return new Animal(props) } }
 *   class Dog extends (Animal as OmitStatics<typeof Animal, { make(props: DogProps): Dog }>) { static make(...) { ...; return super.make(props) } }
 * ```
 *
 */
export type OmitStatics<T, Replacement> = T extends {
    new (...args: infer CtorArgs): infer BaseInstanceT;
} ? Omit<T, keyof Replacement> & Replacement & {
    new (...args: CtorArgs): BaseInstanceT;
} : Omit<T, keyof Replacement>;
export type BlendUnion<U> = {
    [K in (U extends unknown ? keyof U : never)]: U extends unknown ? K extends keyof U ? U[K] : never : never;
};
export type NotNil = NonNullable<unknown>;
export type NotNull = NotNil | null;
export type NotUnd = NotNil | undefined;
export type Idk = NotNull;
/** Scrub undefined values from an array */
export type ArrDefinedVals<A extends readonly unknown[]> = A extends readonly [infer First, ...infer Rest] ? [undefined] extends [First] ? [First] extends [undefined] ? ArrDefinedVals<Rest> : [...([] | [First]), ...ArrDefinedVals<Rest>] : [First, ...ArrDefinedVals<Rest>] : A extends readonly [] ? [] : Exclude<A[number], undefined>[];
/** Scrub undefined values from an object */
export type ObjDefinedVals<O extends object> = {
    [K in keyof O as O[K] extends undefined ? never : K]: Exclude<O[K], undefined>;
};
/** Scrub undefined values from a collection */
export type DefinedVals<O extends unknown[] | object> = O extends unknown[] ? ArrDefinedVals<O> : O extends object ? ObjDefinedVals<O> : never;
export type Simplify<TooManyBags> = {
    [KeyType in keyof TooManyBags]: TooManyBags[KeyType];
} & {};
export type MapNth<Arr extends readonly (readonly unknown[])[], Idx extends number> = Arr extends readonly [infer Curr, ...infer Rest] ? Rest extends readonly unknown[][] ? Curr extends readonly unknown[] ? [Curr[Idx], ...MapNth<Rest, Idx>] : [never, ...MapNth<Rest, Idx>] : never : [];
export type MapPick<Key extends KT, Arr extends readonly NT[], KT extends string = string, NT extends Record<KT, unknown> = Record<KT, unknown>> = Arr extends readonly [infer Curr, ...infer Rest] ? Rest extends readonly NT[] ? Curr extends NT ? [Pick<Curr, Key>, ...MapPick<Key, Rest, KT, NT>] : [never, ...MapPick<Key, Rest, KT, NT>] : never : [];
export type ListLength<Arr extends readonly unknown[]> = Arr["length"];
export type MapHeads<Arr extends readonly (readonly unknown[])[]> = MapNth<Arr, 0>;
export type MapSeconds<Arr extends readonly (readonly unknown[])[]> = MapNth<Arr, 1>;
export type UnzipPairs<Arr extends readonly (readonly unknown[])[]> = IfEmpty<Arr, [], [MapHeads<Arr>, MapSeconds<Arr>]>;
export type IfEmpty<Arr extends readonly unknown[], EmptyCase, SomeCase> = ListLength<Arr> extends 0 ? EmptyCase : SomeCase;
export type Defined<VT> = VT extends undefined ? never : VT;
/** Use as
 *  const __ckConst1 = [[1, 1], [true, true]] as const
 *  type  __ckConst2 = CheckTests<typeof __ckConst1>
 *  type  __ckTypes1 = [[CrazyDerivedType<...>, string], [...]]
 *  type  __ckTypes2 = CheckTests<__ckTypes1>
 *
 * The quality of these goes down sharply if your tsconfig has lax settings.
 */
export type CheckTests<Tests extends readonly unknown[]> = AllTestsPassed<EqualPairs<Tests>>;
export type AsExpected<Tests extends readonly unknown[]> = EqualPairs<Tests> extends true[] ? true : EqualPairs<Tests>;
export type AllTestsPassed<Tests> = Tests extends true[] ? true : Tests;
export type EqualPairs<Tests extends readonly unknown[]> = Tests extends readonly [infer First, ...infer Rest] ? First extends [infer A, infer B, ...infer R2] | readonly [infer A, infer B, ...infer R2] ? IsEqual<A, B> extends (R2[1] extends boolean ? R2[1] : true) ? EqualPairs<Rest> : [['oops', A, B, ...R2], ...EqualPairs<Rest>] : [['not an [actual, wanted] pair', First], ...EqualPairs<Rest>] : [true];
export type EqualPairsBasic<Tests extends readonly unknown[]> = Tests extends readonly [infer First, ...infer Rest] ? First extends [infer A, infer B] | readonly [infer A, infer B] ? IsEqual<A, B> extends true ? EqualPairs<Rest> : [['unequal', A, B], ...EqualPairs<Rest>] : [['not an [actual, wanted] pair', First], ...EqualPairs<Rest>] : [];
export type Expect<VT extends true> = VT;
export type ExpectTrue<VT extends true> = VT;
export type ExpectFalse<VT extends false> = VT;
export type IsTrue<VT extends true> = VT;
export type IsFalse<VT extends false> = VT;
export type XExpect<VT> = VT;
export type ClashingFields<AA, BB> = {
    [K in keyof AA & keyof BB as AA[K] extends BB[K] ? (BB[K] extends AA[K] ? never : K) : K]: [AA[K], BB[K]];
};
export type AOnlyFieldNames<AA, BB> = Exclude<keyof AA, keyof BB>;
export type BOnlyFieldNames<AA, BB> = Exclude<keyof BB, keyof AA>;
export type AOnlyFields<AA, BB> = {
    [KT in Exclude<keyof AA, keyof BB>]: [AA[KT], 'aonly'];
};
export type BOnlyFields<AA, BB> = {
    [KT in Exclude<keyof BB, keyof AA>]: ['bonly', BB[KT]];
};
export type TSDiff<AA, BB> = Debug<AOnlyFields<AA, BB> & BOnlyFields<AA, BB> & ClashingFields<AA, BB>>;
export type SimplePropertyNames<OT> = {
    [K in keyof OT]: OT[K] extends Function ? never : K;
}[keyof OT] & string;
export type MergeInsertions<VT> = VT extends object ? {
    [K in keyof VT]: MergeInsertions<VT[K]>;
} : VT;
export type Alike<X, Y> = IsEqual<MergeInsertions<X>, MergeInsertions<Y>>;
export type ExpectExtends<VALUE, EXPECTED> = EXPECTED extends VALUE ? true : false;
export type ExpectValidArgs<FUNC extends (...args: any[]) => any, ARGS extends any[]> = ARGS extends Parameters<FUNC> ? true : false;
export type AextendsB<AA, BB> = AA extends BB ? true : false;
export type TSCompare<AA, BB> = [AA extends BB ? true : false, BB extends AA ? true : false, IsEqual<AA, BB>];
export type IsEqual<X, Y> = (<T>() => T extends X ? 1 : 2) extends (<T>() => T extends Y ? 1 : 2) ? true : false;
export type NotEqual<X, Y> = true extends IsEqual<X, Y> ? false : true;
export type IsAny<VT> = 0 extends (1 & VT) ? true : false;
export type NotAny<VT> = true extends IsAny<VT> ? false : true;
export type ConflictingKeys<T, U> = {
    [K in keyof T & keyof U]: T[K] extends U[K] ? never : K;
}[keyof T & keyof U];
export type ConflictingFields<T, U> = Pick<T & U, ConflictingKeys<T, U>>;
export type Debug<VT> = {
    [K in keyof VT]: VT[K];
};
export type Bake<VT> = {
    [K in keyof VT]: VT[K];
};
export type UnionToIntersection<U> = (U extends any ? (k: U) => void : never) extends (k: infer I) => void ? I : never;
export type PrefixCapfirst<prefix extends string, thingName extends string> = `${prefix}${Capitalize<thingName>}`;
export type UnderscoreType<TNT> = TNT extends `${infer A}${infer Rest}` ? Rest extends Uncapitalize<Rest> ? `${Lowercase<A>}${UnderscoreType<Rest>}` : A extends Capitalize<A> ? Rest extends `${infer B}${infer Tail}` ? Tail extends Capitalize<Tail> ? `${Lowercase<A>}${UnderscoreType<Rest>}` : `${Lowercase<A>}_${Lowercase<B>}${UnderscoreType<Tail>}` : `${Lowercase<A>}${Lowercase<Rest>}` : `${Lowercase<A>}_${UnderscoreType<Rest>}` : TNT;
export type Casing = 'Cap' | 'uncap' | 'UP' | 'low' | 'keep';
export type Recase<T extends string, CC extends Casing> = CC extends 'Cap' ? Capitalize<T> : CC extends 'uncap' ? Uncapitalize<T> : CC extends 'UP' ? Uppercase<T> : CC extends 'low' ? Lowercase<T> : CC extends 'keep' ? T : `WeirdShouldNotGetHere${T}`;
declare const CamelSpecialsVals: readonly ["ASIN", "DID", "ID", "ISODuration", "GUID", "HSL", "HSLA", "IBAN", "ISBN", "JWT", "MAC", "RGB", "RGBA", "UUID", "JSON", "URL", "DNA"];
type SpecialCasing = typeof CamelSpecialsVals[number];
export type TypeSuffixes = 'Connection' | 'DNA' | 'Core' | 'Inst' | 'Dry' | 'Full';
export type RecaseUpperSpecials<T extends string, CC extends Casing = 'keep'> = Uppercase<T> extends SpecialCasing ? Uppercase<T> : Uppercase<T> extends `${SpecialCasing}S` ? Lowercase<T> extends `${infer Seg}s` ? `${Uppercase<Seg>}s` : 'OOPS' : Recase<T, CC>;
export type CamelUnderscoredType<TNT extends string, CC extends 'Cap' | 'uncap' | 'keep' = 'Cap'> = TNT extends '_' ? '_' : TNT extends SpecialCasing ? TNT : TNT extends `${infer A}_${infer B}` ? `${A extends '' ? '_' : RecaseUpperSpecials<A, CC>}${B extends '' ? '_' : CamelType<B, 'Cap'>}` : RecaseUpperSpecials<TNT, CC>;
export type CamelType<TNT extends string, CC extends 'Cap' | 'uncap' | 'keep' = 'Cap'> = TNT extends SpecialCasing ? TNT : TNT extends `${infer Body}_${TypeSuffixes}` ? TNT extends `${Body}_${infer SS}` ? `${CamelType<Body, CC>}${SS}` : `OOPS: ${TNT} ${Body}` : TNT extends `${infer Body}${TypeSuffixes}` ? TNT extends `${Body}${infer SS}` ? `${CamelType<Body, CC>}${SS}` : `OOPS: ${TNT} ${Body}` : CamelUnderscoredType<UnderscoreType<TNT>, CC>;
export type SnakeType<KT extends string> = CamelType<KT, 'uncap'>;
export type CompareTypes<TA, TB> = [Exclude<TA, TB>, Exclude<TB, TA>];
export type FlattenBagbag1<U> = (U extends U ? (u: U) => 0 : never) extends (i: infer I) => 0 ? Extract<I, U> : never;
export type FlattenBagbag<U> = Simplify<FlattenBagbag1<U>>;
export type U2I<U> = FlattenBagbag<U>;
export type EqualStrPairs<Tests extends readonly unknown[]> = Tests extends readonly [infer First, ...infer Rest] ? First extends [infer A, infer B, infer C] | [infer A, infer B] ? IsEqual<A, B> extends true ? EqualStrPairs<Rest> : [['unequal', Exclude<A, B>, Exclude<B, A>, C], ...EqualStrPairs<Rest>] : [['not an [actual, wanted] pair', First], ...EqualStrPairs<Rest>] : [];
export {};
//# sourceMappingURL=TSTools.d.ts.map