type-opsType-ops -- a collection of useful operators to make type-level programming in TypeScript easier.
Table of contents
TypeScript ~2.9.0, ^3.0.1.
npm i type-ops
For some operators to work properly, strict mode must be enabled.
None.
MIT.
dtslint.These types can be used to test an arbitrary type for being conformant to a certain constraint.
expectInduce a compilation error if TActual does not resolve to the type of expected.
declare const expect: <TActual>() => { toBe(expected: TActual): void; };
interface I1 {
p1: string;
}
interface I2 {
p1: number;
}
// There will be a compilation error if `IsSameT<I1, I2>' does not resolve to `false':
expect<IsSameT<I1, I2>>().toBe(false);
ExpectTInduce a compilation error if TActual does not resolve to TExpected.
type ExpectT<TActual extends TExpected, TExpected extends boolean> = never;
interface I1 { p1: string; }
interface I2 { p1: number; }
// Compilation will fail if `IsSameT<I1, I2>' does not resolve to `false':
type E1 = ExpectT<IsSameT<I1, I2>, false>;
IsFalseTCheck if T is false.
Does not distribute over unions.
type IsFalseT<T extends boolean> = IsSameT<T, false>;
IsNeverTCheck if T is never.
Does not distribute over unions.
type IsNeverT<T> = IsSameT<T, never>;
IsNullableTCheck if T is nullable.
Does not distribute over unions.
type IsNullableT<T> = IsSubtypeOfT<undefined | null, T>;
IsOptionalTCheck if T is optional.
Does not distribute over unions.
type IsOptionalT<T> = IsSubtypeOfT<undefined, T>;
IsSameTCheck if T and U are of the same shape.
Does not distribute over unions.
type IsSameT<T, U> = AndT<IsSubtypeOfT<T, U>, IsSubtypeOfT<U, T>>;
IsSubtypeOfTCheck if T is a subtype of U.
Does not distribute over unions.
type IsSubtypeOfT<T, U> = NoDistributeT<T> extends U
? true
: false;
IsTrueTCheck if T is true.
Does not distribute over unions.
type IsTrueT<T extends boolean> = NotT<IsFalseT<T>>;
These types can be thought of as "filters" on property keys of a particular type.
KeyofTExtract all properties of T.
Distributes over unions.
type KeyofT<T> = T extends any
? keyof T
: never;
NotPropertiesOfSubtypeTExtract all properties of T which are not a subtype of U.
type NotPropertiesOfSubtypeT<T, U> = Exclude<keyof T, PropertiesOfSubtypeT<T, U>>;
NotPropertiesOfTypeTExtract all properties of T which are not of the same shape as U.
type NotPropertiesOfTypeT<T, U> = Exclude<keyof T, PropertiesOfTypeT<T, U>>;
OptionalPropertiesTExtract all optional properties of T.
type OptionalPropertiesT<T> = {
[K in keyof T]-?: IsOptionalT<T[K]> extends false
? never
: K;
}[keyof T];
PropertiesOfSubtypeTExtract all properties of T which are a subtype of U.
type PropertiesOfSubtypeT<T, U> = {
[K in keyof T]: IsSubtypeOfT<T[K], U> extends false
? never
: K;
}[keyof T];
PropertiesOfTypeTExtract all properties of T which are of the same shape as U.
type PropertiesOfTypeT<T, U> = {
[K in keyof T]: IsSameT<T[K], U> extends false
? never
: K;
}[keyof T];
RequiredPropertiesTExtract all required properties of T.
type RequiredPropertiesT<T> = {
[K in keyof T]-?: IsOptionalT<T[K]> extends false
? K
: never;
}[keyof T];
These are just mapped conditional types.
JsonTRepresent T after JSON serialization round-trip.
Distributes over unions.
interface _JsonArrayT<T> extends Array<JsonT<T>> { }
type _CleanT<T> = OmitT<T, PropertiesOfTypeT<T, never>>;
type _JsonObjectT<T> = {
[K in keyof T]: JsonT<T[K]>;
};
type JsonT<T> = T extends string | number | boolean | null
? T
: T extends Function | symbol | undefined
? never
: T extends Array<infer U> | ReadonlyArray<infer U>
? _JsonArrayT<U>
: T extends Map<any, any> | ReadonlyMap<any, any> | WeakMap<any, any> | Set<any> | ReadonlySet<any> | WeakSet<any>
? { }
: T extends { toJSON(key?: any): infer U; }
? U
: _CleanT<_JsonObjectT<T>>;
OmitTOmit properties K from T.
type OmitT<T, K extends keyof T> = Pick<T, Exclude<keyof T, K>>;
OverwriteTOverwrite properties K of T with matching properties of U and add properties which are unique to U.
type OverwriteT<T, U, K extends keyof T & keyof U = keyof T & keyof U> = OmitT<T, K> & U;
interface I1 {
p1: string;
p2: string;
p3: string;
}
interface I2 {
p2: number;
p3: number;
p4: number;
}
type I3 = OverrideT<I1, I2>;
const i3: I3 = {
p1: 'v1',
p2: 2,
p3: 3,
p4: 4,
};
PartialDeepTRecursively make all properties of T optional.
interface _PartialDeepArray<T> extends Array<PartialDeepT<T>> { }
interface _PartialDeepReadonlyArray<T> extends ReadonlyArray<PartialDeepT<T>> { }
type _PartialDeepObjectT<T> = {
[K in keyof T]: PartialDeepT<T[K]>;
};
export type PartialDeepT<T> = T extends Array<infer U>
? _PartialDeepArray<U>
: T extends ReadonlyArray<infer U>
? _PartialDeepReadonlyArray<U>
: T extends Function | PrimitiveT
? T
: Partial<_PartialDeepObjectT<T>>;
ReadonlyDeepTRecursively make all properties of T readonly.
interface _ReadonlyDeepArray<T> extends Array<ReadonlyDeepT<T>> { }
interface _ReadonlyDeepReadonlyArray<T> extends ReadonlyArray<ReadonlyDeepT<T>> { }
type _ReadonlyDeepObjectT<T> = {
[K in keyof T]: ReadonlyDeepT<T[K]>;
};
export type ReadonlyDeepT<T> = T extends Array<infer U>
? _ReadonlyDeepArray<U>
: T extends ReadonlyArray<infer U>
? _ReadonlyDeepReadonlyArray<U>
: T extends Function | PrimitiveT
? T
: Readonly<_ReadonlyDeepObjectT<T>>;
ReplaceTReplace properties K of T with matching properties of U.
type ReplaceT<T, U, K extends keyof T & keyof U = keyof T & keyof U> = OmitT<T, K> & Pick<U, K>;
interface I1 {
p1: string;
p2: string;
p3: string;
p4: string;
}
interface I2 {
p2: number;
p3: number;
p4: number;
p5: number;
}
type I3 = ReplaceT<I1, I2, 'p2' | 'p4'>;
const i3: I3 = {
p1: 'v1',
p2: 2,
p3: 'v3',
p4: 4,
};
RequiredDeepTRecursively make all properties of T required.
interface _RequiredDeepArray<T> extends Array<RequiredDeepT<T>> { }
interface _RequiredDeepReadonlyArray<T> extends ReadonlyArray<RequiredDeepT<T>> { }
type _RequiredDeepObjectT<T> = {
[K in keyof T]: RequiredDeepT<T[K]>;
};
export type RequiredDeepT<T> = T extends Array<infer U>
? _RequiredDeepArray<U>
: T extends ReadonlyArray<infer U>
? _RequiredDeepReadonlyArray<U>
: T extends Function | PrimitiveT
? T
: _RequiredDeepObjectT<Required<T>>;
WithMutableTMake properties K of T mutable.
type WithMutableT<T, K extends keyof T> = ReplaceT<T, MutableT<T>, K>;
WithPartialTMake properties K of T optional.
type WithPartialT<T, K extends keyof T> = ReplaceT<T, Partial<T>, K>;
WithReadonlyTMake properties K of T readonly.
type WithReadonlyT<T, K extends keyof T> = ReplaceT<T, Readonly<T>, K>;
WithRequiredTMake properties K of T required.
type WithRequiredT<T, K extends keyof T> = ReplaceT<T, Required<T>, K>;
WritableDeepTRecursively make all properties of T mutable.
interface _MutableDeepArray<T> extends Array<MutableDeepT<T>> { }
interface _MutableDeepReadonlyArray<T> extends ReadonlyArray<MutableDeepT<T>> { }
type _MutableDeepObjectT<T> = {
[K in keyof T]: MutableDeepT<T[K]>;
};
type MutableDeepT<T> = T extends Array<infer U>
? _MutableDeepArray<U>
: T extends ReadonlyArray<infer U>
? _MutableDeepReadonlyArray<U>
: T extends Function | PrimitiveT
? T
: _MutableDeepObjectT<MutableT<T>>;
MutableTMake all properties of T mutable.
type MutableT<T> = {
-readonly [K in keyof T]: T[K];
};
ConstructorTA constructor of TInstances from TArguments.
type ConstructorT<TInstance = object, TArguments extends any[] = any[]> = new(...args: TArguments) => TInstance;
DictTA dictionary of TValues.
interface DictT<TValue = any> {
[propertyKey: string]: TValue;
}
FunctionTA function mapping TArguments to TResult.
type FunctionT<TResult = any, TArguments extends any[] = any[]> = (...args: TArguments) => TResult;
NullableTMake T nullable.
type NullableT<T> = OptionalT<T> | null;
OptionalTMake T optional.
type OptionalT<T> = T | undefined;
PrimitiveTA primitive.
type PrimitiveT = string | symbol | number | boolean | undefined | null;
TaggedTMake tagged type from T using tag TTag.
It can be used to create an opaque alias of T.
declare const _RAW_TYPE: unique symbol;
declare const _TAG_TYPE: unique symbol;
type TaggedT<T, TTag extends PropertyKey> = T & {
[_RAW_TYPE]: T;
[_TAG_TYPE]: TTag;
};
// `I1' is an opaque type alias of `string' tagged w/ `A':
type I1 = UniqueT<string, 'A'>;
// Type assertion must be used to assign raw `string' to its opaque typedef:
let i1: I1 = 'v1' as I1;
i1 = 'v2' as I1;
// i1 = 'v3'; // Compilation will fail.
// Underlying raw type (`string') can be retrieved through lookup type:
const i11: RawT<I1> = i1;
// `I2' has the same shape as `I1':
type I2 = UniqueT<string, 'A'>;
let i2: I2 = 'v4' as I2;
i2 = i1;
i1 = i2;
const i21: RawT<I1> = i1;
// `I3' is an opaque type alias of `string' tagged w/ `B'.
type I3 = UniqueT<string, 'B'>;
let i3: I3 = 'v5' as I3;
// `I1' and `I3' are incompatible:
// i1 = i3;
// i1 = i3 as I1; // Type assertion will not make any difference.
// i3 = i1;
// i3 = i1 as I3; // Ditto.
const i31: RawT<I1> = i1;
// `I4' has the same shape as `I1':
type I4 = RetaggedT<U3, 'A'>;
let i4: I4 = i3 as RawT<I3> as I4;
i4 = i1;
i1 = i4;
RawTExtract raw type of tagged T.
Distributes over unions.
type RawT<T> = T extends UniqueT<infer U, infer TTag_>
? U
: T;
TagTExtract tag from tagged T.
Distributes over unions.
type TagT<T> = T extends UniqueT<infer U_, infer TTag>
? TTag
: never;
RetaggedTRetag a tagged T using tag TTag.
Distributes over unions.
type RetaggedT<T, TTag extends PropertyKey> = T extends TaggedT<infer U, infer TTag_>
? TaggedT<U, TTag>
: TaggedT<T, TTag>;
AndTLogical "and" of T and U.
Distributes over unions.
type AndT<T extends boolean, U extends boolean> = T extends false
? false
: U extends false
? false
: true;
NotTLogical "not" of T.
Distributes over unions.
type NotT<T extends boolean> = T extends false
? true
: false;
OrTLogical "or" of T and U.
Distributes over unions.
type OrT<T extends boolean, U extends boolean> = T extends false
? U extends false
? false
: true
: true;
XorTLogical "xor" of T and U.
Distributes over unions.
type XorT<T extends boolean, U extends boolean> = T extends false
? U extends false
? false
: true
: U extends false
? true
: false;
NoDistributeTPrevent distribution over T.
type NoDistributeT<T> = T extends any
? T
: never;
NoInferTPrevent type inference on T.
type NoInferT<T> = T & Pick<T, keyof T>;
declare const f1: <T>(i1: T, i2: T) => void;
f1({ p1: 'v1', p2: 'v2' }, { p1: 'v1' }); // An error sneaks in.
declare const f2: <T>(i1: T, i2: NoInferT<T>) => void;
// f2({ p1: 'v1', p2: 'v2' }, { p1: 'v1' }); // Causes compilation error.
f2({ p1: 'v1', p2: 'v2' }, { p1: 'v1', p2: 'v2' });
SelectTExtract a member of a tagged union T using TTagKey as a tag property and TValue as its type.
type SelectT<T, TTagKey extends keyof T, TTagValue extends T[TTagKey]> = Extract<T, Record<TTagKey, TTagValue>>;
declare const TAG: unique symbol;
interface I1 {
[TAG]: 'I1';
p1: string;
}
interface I2 {
[TAG]: 'I2';
p1: number;
}
type I3 = I1 | I2;
type A11 = TaggedUnionMemberT<I3, typeof TAG, 'I1'>; // Resolves to `I1'.
FAQs
Type-ops -- type-level operators for TypeScript
The npm package type-ops receives a total of 120 weekly downloads. As such, type-ops popularity was classified as not popular.
We found that type-ops demonstrated a not healthy version release cadence and project activity because the last version was released a year ago. It has 1 open source maintainer collaborating on the project.
Did you know?
Socket for GitHub automatically highlights issues in each pull request and monitors the health of all your open source dependencies. Discover the contents of your packages and block harmful activity before you install or update your dependencies.
Security News
The Socket Research team breaks down a malicious npm package targeting the legitimate DOMPurify library. It uses obfuscated code to hide that it is exfiltrating browser and crypto wallet data.
Security News
ENISA’s 2024 report highlights the EU’s top cybersecurity threats, including rising DDoS attacks, ransomware, supply chain vulnerabilities, and weaponized AI.
Security News
NIST's new password guidelines remove periodic changes and special character requirements, focusing on longer, more secure passwords for better authentication practices.