ts-type-safe

Usefuly utility functions and types for a more type-safe TypeScript

Modules

types

Helper types to improve type-safety.

classNames

Helper function to simplify type-safe interaction with classNames.

validators

Validators to improve type-safety.

Functions

isMathematicalNumber()

consider mathematical number if:

• typeof number
• can parse to int without need to remove anything (i.e. leading zeroes)
• can parse to float without need to remove anything

types

Helper types to improve type-safety.

• types
  • ~Prettify : Prettify
  • ~ValuesOf : ValuesOf
  • ~KeysOf : KeysOf
  • ~PrefixedKeys<T, : PrefixedKeys
  • ~PartialBy<T, : PartialBy

types~Prettify : Prettify

Helper type to show all properties of a complex base-type

Kind: inner typedef of types

types~ValuesOf : ValuesOf

Helper type to generate values of a given type

NOTE: not for enum-types!

To create values of an enum-type, use:

type EnumVals = `${EnumType}`;

Kind: inner typedef of types
Example

const Foo = { A: "a", B: "b"} as const;
type FooVals = ValuesOf<typeof Foo>;
// type FooVals = "a" | "b"

// equivalent to: type FooVals = (typeof Foo)[keyof typeof Foo];

types~KeysOf : KeysOf

Helper type to generate keys of a given type

Kind: inner typedef of types
Example

const Foo = { A: "a", B: "b"};
type FooKeys = KeysOf<typeof Foo>;
// type FooKeys = "A" | "B"

// equivalent to: type FooKeys = keyof typeof Foo;

types~PrefixedKeys<T, : PrefixedKeys

Helper type to generate prefixed keys of a given type

Kind: inner typedef of types
Example

const Foo = { A: "a", B: "b"};
type FooType = typeof Foo;
// type FooType = { "A": string; "B": string; }

type PrefixedFooKeys = PrefixedKeys<typeof Foo, 'foo.'>;
// type PrefixedFooKeys = { "foo.A": string; "foo.B": string; }

types~PartialBy<T, : PartialBy

Helper type to make a single property optional

Kind: inner typedef of types
Example

type Person = {
  id: string;
  name: string;
  age: number;
};

type NewPerson = PartialBy<Person, 'id'>
//    ^? type NewPerson = Omit<Person, "id"> & Partial<Pick<Person, "id">>
type PrettyNewPerson = Prettify<NewPerson>;
//    ^? type PrettyNewPerson = { name: string; age: number; id? : string | undefined; }

Example

type NewPerson = PartialBy<Person, 'id' | 'age'>;
//    ^? type NewPerson = Omit<Person, "id" | "age"> & Partial<Pick<Person, "id" | "age">>

classNames

Helper function to simplify type-safe interaction with classNames.

classNames~classNames(...names)

Joins classes and avoids complicated checks and usage of nasty string-literals.

note: exported also as cns-shorthand

Kind: inner method of classNames

Example

<div className={cns('primary', !isValid && 'disabled')} />

validators

Validators to improve type-safety.

• validators
  • ~isObject(value)
  • ~isDefined(value)
  • ~hasOwnProperty(obj, propKey)
  • ~hasOwnProperties(obj, propKeys)
  • ~isNonEmptyArray(obj)
  • ~isEmptyArray(obj)
  • ~isEnumKey(enumType, value)
  • ~isEnumValue(enumType, value)

validators~isObject(value)

Checks if value is not null and of object-type.

Kind: inner method of validators

validators~isDefined(value)

Returns true if value is not undefined and not null.

Kind: inner method of validators

validators~hasOwnProperty(obj, propKey)

Checks existence of @propKey on an object and retypes the @obj as an object having that property of unknown-type.

Kind: inner method of validators

validators~hasOwnProperties(obj, propKeys)

Checks existence of @propKeys on an object and retypes the @obj as an object having these properties, all of which of unknown-type.

Kind: inner method of validators

validators~isNonEmptyArray(obj)

Checks if @obj is an array with at least one entry.

Kind: inner method of validators

validators~isEmptyArray(obj)

Checks if @obj is an array with zero entries.

Kind: inner method of validators

validators~isEnumKey(enumType, value)

Typeguard for enums-keys

note: not for number-enums

Kind: inner method of validators

Example

enum MyEnum {
 Thing1 = 'thing one',
 Thing2 = 'thing two',
}

function onlyKeys(key: keyof typeof MyEnum) {
  console.log(key, MyEnum[key]);
}

const testStr = "Thing2";

if (isEnumKey(MyEnum, testStr)) {
  // compiler knows that testStr is of type `keyof typeof MyEnum`
  onlyKeys(testStr);
}

validators~isEnumValue(enumType, value)

Typeguard for enum values

note: not for number-enums

Kind: inner method of validators

Example

enum MyEnum {
 Thing1 = 'thing one',
 Thing2 = 'thing two',
}

function onlyVals(val: MyEnum) {
  console.log("onlyVals", val);
}

const testStr = "thing two";

if (isEnumValue(MyEnum, testStr)) {
  // compiler knows that testStr is of type `MyEnum`
  onlyVals(testStr);
}

isMathematicalNumber()

consider mathematical number if:

• typeof number
• can parse to int without need to remove anything (i.e. leading zeroes)
• can parse to float without need to remove anything

Kind: global function

© 2023 Hans Krebs