@drunkcod/argis 0.0.5 → 0.0.6

package/lib/index.d.ts

@@ -5,12 +5,15 @@ export type WithRequired<T, K extends keyof T> = Required<NoNullMembers<Pick<T,
 export type WithKey<K extends PropertyKey, V = unknown> = {
     [p in K]: V;
 };
+export type OmitIndex<T> = {
+    [K in keyof T as string extends K ? never : number extends K ? never : symbol extends K ? never : K]: T[K];
+};
 export declare class ArgumentError extends Error {
     constructor(message: string);
-    static null(message: string): void;
+    static null(message: string): never;
     static missing({ key }: {
         key: PropertyKey;
-    }): void;
+    }): never;
 }
 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>;
@@ -23,7 +26,9 @@ export declare function argNotNil<T, K extends keyof T>(x: T, key: K): asserts x
     [P in K]-?: NonNullable<T[K]>;
 };
 export declare function hasOwn<T extends object, K extends PropertyKey>(x: T, key: K): x is T & WithKey<K>;
+export declare function hasOwn<T extends object, K extends PropertyKey, V>(x: T, key: K, ofType: (found: unknown) => found is V): x is T & WithKey<K, V>;
 export declare function assertOwn<T extends object, K extends PropertyKey>(x: T, key: K): asserts x is T & WithKey<K>;
+export declare function assertOwn<T extends object, K extends PropertyKey, V>(x: T, key: K, ofType: (found: unknown) => found is V): asserts x is T & WithKey<K, V>;
 export declare function nullIfEmpty<T extends {
     length: number;
 }>(x: T | null): T | null;

package/lib/index.js

@@ -26,11 +26,14 @@ export function assertNotNil(x) {
 export function argNotNil(x, key) {
     isNotNil(x, key) || ArgumentError.null(`'${String(key)}' was null or undefined`);
 }
-export function hasOwn(x, key) {
+function _hasOwn(x, key) {
     return Object.hasOwn(x, key);
 }
-export function assertOwn(x, key) {
-    hasOwn(x, key) || ArgumentError.missing({ key });
+export function hasOwn(x, key, ofType) {
+    return _hasOwn(x, key) && (ofType == undefined || ofType(x[key]));
+}
+export function assertOwn(x, key, ofType) {
+    (ofType ? hasOwn(x, key, ofType) : hasOwn(x, key)) || ArgumentError.missing({ key });
 }
 export function nullIfEmpty(x) {
     return x == null || x.length == 0 ? null : x;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@drunkcod/argis",
   "type": "module",
-  "version": "0.0.5",
+  "version": "0.0.6",
   "description": "Tiny method arg checking with strong types.",
   "scripts": {
     "clean": "rimraf lib",