JSPM – ts-essentials@2.0.4

Package Exports

ts-essentials
ts-essentials/dist/types

This package does not declare an exports field, so the exports above have been automatically detected and optimized by JSPM instead. If any package subpath is missing, it is recommended to post an issue to the original package (ts-essentials) to support the "exports" field. If that is not possible, create a JSPM override to customize the exports field for this package.

Readme

TypeStrict

ts-essentials

All essential TypeScript types in one place 🤙

Downloads Build status

Install

npm add --save-dev ts-essentials

yarn add --dev ts-essentials

What's inside?

Basic
- Primitive
Dictionaries
- Dictionary
- DictionaryValues
Deep Partial & DeepRequired & Deep Readonly
Writable & DeepWritable
Omit
OmitProperties
NonNever
Merge
UnionToIntersection
Opaque types
Tuple constraint
Literal types
Exhaustive switch cases
ValueOf

Basic:

Primitive type matching all primitive values.

Dictionaries

const stringDict: Dictionary<string> = {
  a: "A",
  b: "B",
};

// Specify second type argument to change dictionary keys type
const dictOfNumbers: Dictionary<string, number> = {
  420: "four twenty",
  1337: "HAX",
};

// You may specify union types as key to cover all possible cases. It acts the same as Record from TS's standard library
export type DummyOptions = "open" | "closed" | "unknown";
const dictFromUnionType: Dictionary<number, DummyOptions> = {
  closed: 1,
  open: 2,
  unknown: 3,
};

// and get dictionary values
type stringDictValues = DictionaryValues<typeof stringDict>;

Deep Partial & Deep Required & Deep Readonly

type ComplexObject = {
  simple: number;
  nested: {
    a: string;
    array: [{ bar: number }];
  };
};

type ComplexObjectPartial = DeepPartial<ComplexObject>;
const samplePartial: ComplexObjectPartial = {
  nested: {
    array: [{}],
  },
};

type ComplexObjectAgain = DeepRequired<ComplexObjectPartial>;
const sampleRequired: ComplexObjectAgain = {
  simple: 5,
  nested: {
    a: "test",
    array: [],
  },
};

type ComplexObjectReadonly = DeepReadonly<ComplexObject>;

Writable

Make all attributes of object writable.

type Foo = {
  readonly a: number,
  readonly b: string,
}

const foo: Foo = { a: 1, b: 'b' }

(foo as Writable<typeof foo>).a = 42

type Foo = {
  readonly foo: string;
  bar: {
    readonly x: number;
  };
}[];

const test: DeepWritable<Foo> = [{
  foo: "a",
  bar: {
    x: 5,
  },
}];

// we can freely write to this object
test[0].foo = "b";
test[0].bar.x = 2;

Omit

type SimplifiedComplexObject = Omit<ComplexObject, "nested">;

OmitProperties

Removes all properties extending type P in type T.

interface Example {
  log(): void;
  version: string;
}

type ExampleWithoutMethods = OmitProperties<Example, Function>;

// Result:
// {
//   version: string;
// }

NonNever

Useful for purifying object types. It improves intellisense but also allows for extracting keys satisfying a conditional type.

type GetDefined<TypesMap extends { [key: string]: any }> =
  keyof NonNever<{ [T in keyof TypesMap]: TypesMap[T] extends undefined ? never : TypesMap[T] }>;

Merge

type Foo = {
  a: number,
  b: string
};

type Bar = {
  b: number
};

const xyz: Merge<Foo, Bar> = { a: 4, b: 2 };

UnionToIntersection

Useful for converting mapped types with function values to intersection type (so in this case - overloaded function).

type Foo = {
  bar: string,
  xyz: number
};

type Fn = UnionToIntersection<
  { [K in keyof Foo]: (type: K, arg: Foo[K]) => any }[keyof Foo]
>;

Opaque types

type PositiveNumber = Opaque<number, "positive-number">;

function makePositiveNumber(n: number): PositiveNumber {
  if (n <= 0) {
    throw new Error("Value not positive !!!");
  }
  return (n as any) as PositiveNumber; // this ugly cast is required but only when "producing" opaque types
}

Tuple constraint

function foo<T extends Tuple>(tuple: T): T {
    return tuple;
}

const ret = foo(["s", 1]);
// return type of [string, number]

You can also parametrize Tuple type with a type argument to constraint it to certain types, i.e. Tuple<string | number>.

Literal types

// prevent type widening https://blog.mariusschulz.com/2017/02/04/typescript-2-1-literal-type-widening
const t = {
  letter: literal("a"), // type stays "a" not string
  digit: literal(5), // type stays 5 not number
};

Exhaustive switch cases

function actOnDummyOptions(options: DummyOptions): string {
  switch (options) {
    case "open":
      return "it's open!";
    case "closed":
      return "it's closed";
    case "unknown":
      return "i have no idea";
    default:
      // if you would add another option to DummyOptions, you'll get error here!
      throw new UnreachableCaseError(options);
  }
}

ValueOf type

const obj = {
  id: "123e4567-e89b-12d3-a456-426655440000",
  name: "Test object",
  timestamp: 1548768231486,
};

type objKeys = ValueOf<typeof obj>; // string | number

Contributing

All contributions are welcomed Read more