@drunkcod/argis 0.0.2 → 0.0.4

package/lib/index.d.ts

@@ -2,24 +2,30 @@ type NoNullMembers<T> = {
     [P in keyof T]: NonNullable<T[P]>;
 };
 export type WithRequired<T, K extends keyof T> = Required<NoNullMembers<Pick<T, K>>> & Omit<T, K>;
-export type WithKey<K extends string | symbol, V = unknown> = {
+export type WithKey<K extends PropertyKey, V = unknown> = {
     [p in K]: V;
 };
 export declare class ArgumentError extends Error {
     constructor(message: string);
     static null(message: string): void;
     static missing({ key }: {
-        key: string;
+        key: PropertyKey;
     }): void;
 }
 export declare function isNil(x: any): x is null | undefined;
+export declare function isNil<T extends object>(x: T | null, key: keyof T): x is T & WithKey<typeof key, null | undefined>;
 export declare function isNotNil<T>(x?: T): x is T;
 export declare function isNotNil<T, K extends keyof T>(x: T, key: K): x is T & {
     [P in K]-?: NonNullable<T[K]>;
 };
+export declare function assertNotNil<T>(x: T | null): asserts x is T;
 export declare function argNotNil<T, K extends keyof T>(x: T, key: K): asserts x is T & {
     [P in K]-?: NonNullable<T[K]>;
 };
-export declare function hasOwn<T extends object, K extends string>(x: T, key: K): x is T & WithKey<K>;
-export declare function assertOwn<T extends object, K extends string>(x: T, key: K): asserts x is T & WithKey<K>;
+export declare function hasOwn<T extends object, K extends PropertyKey>(x: T, key: K): x is T & WithKey<K>;
+export declare function assertOwn<T extends object, K extends PropertyKey>(x: T, key: K): asserts x is T & WithKey<K>;
+export declare function nullIfEmpty<T extends {
+    length: number;
+}>(x: T | null): T | null;
+export declare function intOrUndefined(x?: string | null): number | undefined;
 export {};

package/lib/index.js

@@ -3,9 +3,12 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.ArgumentError = void 0;
 exports.isNil = isNil;
 exports.isNotNil = isNotNil;
+exports.assertNotNil = assertNotNil;
 exports.argNotNil = argNotNil;
 exports.hasOwn = hasOwn;
 exports.assertOwn = assertOwn;
+exports.nullIfEmpty = nullIfEmpty;
+exports.intOrUndefined = intOrUndefined;
 class ArgumentError extends Error {
     constructor(message) {
         super(message);
@@ -16,18 +19,22 @@ class ArgumentError extends Error {
         throw e;
     }
     static missing({ key }) {
-        const e = new ArgumentError(`Missing property ${key}.`);
+        const e = new ArgumentError(`Missing property ${String(key)}.`);
         e.name = 'MissingPropertyError';
         throw e;
     }
 }
 exports.ArgumentError = ArgumentError;
-function isNil(x) {
-    return x == null;
+function isNil(x, key) {
+    return x == null || (key !== undefined && x[key] == null);
 }
 function isNotNil(x, key) {
     return !isNil(x) && (key === undefined || !isNil(x[key]));
 }
+function assertNotNil(x) {
+    if (x == null)
+        ArgumentError.null('Unexpected null');
+}
 function argNotNil(x, key) {
     isNotNil(x, key) || ArgumentError.null(`'${String(key)}' was null or undefined`);
 }
@@ -37,3 +44,12 @@ function hasOwn(x, key) {
 function assertOwn(x, key) {
     hasOwn(x, key) || ArgumentError.missing({ key });
 }
+function nullIfEmpty(x) {
+    return x == null || x.length == 0 ? null : x;
+}
+function intOrUndefined(x) {
+    if (isNil(x))
+        return undefined;
+    const v = Number.parseInt(x);
+    return Number.isNaN(v) ? undefined : v;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@drunkcod/argis",
-  "version": "0.0.2",
+  "version": "0.0.4",
   "description": "Tiny method arg checking with strong types.",
   "scripts": {
     "build": "rimraf lib && tsc",
@@ -8,8 +8,8 @@
   },
   "author": "Tobbe Gyllebring",
   "license": "MIT",
-  "main": "./lib/index.js",
-  "types": "./lib/index.d.ts",
+  "main": "lib/index.js",
+  "types": "lib/index.d.ts",
   "files": [
     "lib/**/*",
     "!lib/**/*.spec.*"