@mll-lab/js-utils 2.15.3 → 2.17.0

package/dist/pick.d.ts

@@ -0,0 +1,7 @@
+/**
+ * A version of lodash.pick() that forces the strict signature.
+ *
+ * lodash.pick({}, 'dummy') -> ok
+ * pick({}, 'dummy') -> error
+ */
+export declare function pick<T extends object, K extends keyof T>(object: T, ...props: Array<K>): Pick<T, K>;

package/dist/pick.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/typeGuards.d.ts

@@ -1,2 +1,2 @@
 export declare function isString(value: unknown): value is string;
-export declare function isNotNullish<T>(value: T): value is Exclude<T, null | undefined>;
+export declare function isNotNullish<T>(value: T): value is NonNullable<T>;

package/dist/types.check.d.ts

@@ -0,0 +1,28 @@
+import { DeepPartial, Either, Exact, Maybe, MaybePromise, Modify, ValueOf } from './types';
+declare type Bar = {
+    baz: number;
+};
+declare type Obj = {
+    foo: string;
+    bar: Bar;
+};
+export declare const allowsAssigningEmptyObjectToDeepPartial: DeepPartial<Obj>;
+export declare function acceptsMaybePromise(v: MaybePromise<number>): Promise<number>;
+export declare const modifiedType: Modify<Obj, {
+    foo: number;
+}>;
+export declare function acceptsValueOf(v: ValueOf<Obj>): string | Bar;
+export declare const maybeAllowsNull: Maybe<number>;
+export declare const maybeAllowsUndefined: Maybe<number>;
+export declare const maybeAllowsT: Maybe<number>;
+export declare const maybeDoesNotAllowOtherType: Maybe<number>;
+declare type BarOrObj = Either<Bar, Obj>;
+export declare const onlyFoo: BarOrObj;
+export declare const onlyBar: BarOrObj;
+export declare const both: BarOrObj;
+export declare const none: BarOrObj;
+declare type ExactlyBar = Exact<Bar>;
+export declare const exactlyBar: ExactlyBar;
+export declare const lessThanBar: ExactlyBar;
+export declare const moreThanBar: ExactlyBar;
+export {};

package/dist/types.d.ts

@@ -0,0 +1,27 @@
+/** Recursively optional deep partial type. */
+export declare type DeepPartial<T> = {
+    [P in keyof T]?: DeepPartial<T[P]>;
+};
+/** Either a value or a promise that will resolve to that value. */
+export declare type MaybePromise<T> = T | Promise<T>;
+/** Modify a given type, e.g. to make some properties optional. */
+export declare type Modify<T, R> = Pick<T, Exclude<keyof T, keyof R>> & R;
+/** The missing counterpart to keyof. */
+export declare type ValueOf<T> = T[keyof T];
+/** Add null and undefined to a type. */
+export declare type Maybe<T> = T | null | undefined;
+/** Only props that are contained in T but not U. */
+declare type Subtract<T, U> = {
+    [P in keyof T]: T[P];
+} & {
+    [P in keyof U]?: never;
+};
+/** Only one of both types (exclusively). */
+export declare type Either<T, U> = Subtract<T, U> | Subtract<U, T>;
+/** Only the given keys and no others. */
+export declare type Exact<T extends {
+    [key: string]: unknown;
+}> = {
+    [K in keyof T]: T[K];
+};
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mll-lab/js-utils",
-  "version": "2.15.3",
+  "version": "2.17.0",
   "main": "dist/index.common.js",
   "module": "dist/index.js",
   "types": "dist/index.d.ts",