项目作者: janjakubnanista

项目描述 :
Type inspection utilities for TypeScript
高级语言: TypeScript
项目地址: git://github.com/janjakubnanista/ts-reflection.git
创建时间: 2020-06-15T20:13:49Z
项目社区:https://github.com/janjakubnanista/ts-reflection

开源协议:MIT License

下载





ts-reflection


Type inspection utilities for TypeScript



CircleCI Build Status

NPM Version

Dev Dependency Status

Known Vulnerabilities

License


ts-reflection allows you to access information about your types in runtime - e.g. get properties of a type or possible values of a union. It is compatible with rollup, webpack, and ttypescript projects and works nicely with jest or ts-node


Motivation
|
API
|
Installation
|
Acknowledgement

Wait what?

As they say an example is worth a thousand API docs so why not start with one.

  1. import { propertiesOf } from 'ts-reflection';
  2. interface MyInterface {
  3. name: string;
  4. hobbies: string[];
  5. }
  6. // You can now use propertiesOf utility to get properties of a type
  7. const properties = propertiesOf<MyInterface>(); // ['name', 'hobbies']

Let’s do another one!

  1. import { valuesOf } from 'ts-reflection';
  2. type ButtonType = 'primary' | 'secondary' | 'link';
  3. // You can use valuesOf utility to get all the possible union type values
  4. const buttonTypes = valuesOf<ButtonType>(); // ['primary', 'secondary', 'link']

Motivation

I can’t count the number of times I needed to type all the possible values of a union type to create e.g. a dropdown with all the button types:

  1. type ButtonType = 'primary' | 'secondary' | 'link';
  2. const buttonTypes: ButtonType[] = ['primary', 'secondary', 'link'];

I was always aware of fragility of such solution and the fact you need to update it by hand every time ButtonType changes. Now I can write just

  1. const buttonTypes: ButtonType[] = valuesOf<ButtonType>;

The same goes for a list of type properties - typing those lists of keyof type values:

  1. interface MyInterface {
  2. property: number;
  3. anotherProperty: string;
  4. }
  5. type Key = keyof MyInterface;
  6. const keys: Key[] = ['property', 'anotherProperty']

Which now becomes

  1. const keys: Key[] = propertiesOf<MyInterface>();

API

You can find comprehensive API documentation in the API docs.

ts-reflection exports two functions: valuesOf (for accessing values of union types) and propertiesOf (for accessing properties of types).

valuesOf

valuesOf is a function that returns all the possible literal values of union types:

  1. import { valuesOf } from 'ts-reflection';
  2. type UnionType = 'string value' | 1 | true | Symbol.toStringTag;
  3. // You can use valuesOf utility to get all the possible union type values
  4. const unionTypeValues = valuesOf<UnionType>(); // ['string value', 1, true, Symbol.toStringTag]

Please read the full API docs for more information about valuesOf.

propertiesOf

propertiesOf is a function that returns property names of types:

  1. import { propertiesOf } from 'ts-reflection';
  2. interface MyInterface {
  3. name: string;
  4. displayName?: string;
  5. readonly hobbies: string[];
  6. }
  7. // When called with no arguments, propertiesOf() returns all public properties of a type
  8. const properties = propertiesOf<MyInterface>(); // ['name', 'displayName', 'hobbies']
  9. // You can also call it with "queries" to be more specific about what properties you want to get
  10. const readonlyProperties = propertiesOf<MyInterface>({ readonly: true }); // ['hobbies']
  11. const mutableProperties = propertiesOf<MyInterface>({ readonly: false }); // ['name', 'displayName']
  12. const optionalProperties = propertiesOf<MyInterface>({ optional: true }); // ['displayName']
  13. const requiredProperties = propertiesOf<MyInterface>({ optional: false }); // ['name', 'hobbies']

Please read the full API docs for more information about propertiesOf and the queries it supports.

Installation

You can find comprehensive installation instructions in the installation docs.

Acknowledgement

This idea was inspired by ts-transformer-keys NPM module. The E2E testing infrastructure that ensures compatibility with all minor TypeScript versions is based on my ts-type-checked project.