@drunkcod/argis 0.0.6 → 0.0.8

package/lib/cjs/index.d.ts

@@ -0,0 +1,39 @@
+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 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 type OfType<K, T> = K extends T ? K : never;
+export declare class ArgumentError extends Error {
+    constructor(message: string);
+    static null(message: string): never;
+    static missing({ key }: {
+        key: PropertyKey;
+    }): 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>;
+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 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;
+export declare function intOrUndefined(x?: string | null): number | undefined;
+export declare function omit<T extends object, K extends OfType<keyof T, string>>(x: T, ...keys: readonly K[]): Omit<T, K>;
+export declare function pick<T extends object, K extends OfType<keyof T, string>>(x: T, ...keys: readonly K[]): Pick<T, K>;
+export {};

package/lib/cjs/index.js

@@ -0,0 +1,75 @@
+"use strict";
+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;
+exports.omit = omit;
+exports.pick = pick;
+class ArgumentError extends Error {
+    constructor(message) {
+        super(message);
+    }
+    static null(message) {
+        const e = new ArgumentError(message);
+        e.name = 'ArgumentNullError';
+        throw e;
+    }
+    static missing({ key }) {
+        const e = new ArgumentError(`Missing property ${String(key)}.`);
+        e.name = 'MissingPropertyError';
+        throw e;
+    }
+}
+exports.ArgumentError = ArgumentError;
+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`);
+}
+function _hasOwn(x, key) {
+    return Object.hasOwn(x, key);
+}
+function hasOwn(x, key, ofType) {
+    return _hasOwn(x, key) && (ofType == undefined || ofType(x[key]));
+}
+function assertOwn(x, key, ofType) {
+    (ofType ? hasOwn(x, key, ofType) : 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;
+}
+function filterEntries(x, p) {
+    if (x == null)
+        return null;
+    if (typeof x !== 'object')
+        return x;
+    return Object.fromEntries(Object.entries(x).filter(p));
+}
+function omit(x, ...keys) {
+    const ks = keys;
+    return filterEntries(x, ([key]) => !ks.includes(key));
+}
+function pick(x, ...keys) {
+    const ks = keys;
+    return filterEntries(x, ([key]) => ks.includes(key));
+}

package/lib/cjs/package.json

@@ -0,0 +1 @@
+{"type": "commonjs"}

package/lib/index.d.ts

@@ -8,6 +8,7 @@ export type WithKey<K extends PropertyKey, V = unknown> = {
 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 type OfType<K, T> = K extends T ? K : never;
 export declare class ArgumentError extends Error {
     constructor(message: string);
     static null(message: string): never;
@@ -33,4 +34,6 @@ export declare function nullIfEmpty<T extends {
     length: number;
 }>(x: T | null): T | null;
 export declare function intOrUndefined(x?: string | null): number | undefined;
+export declare function omit<T extends object, K extends OfType<keyof T, string>>(x: T, ...keys: readonly K[]): Omit<T, K>;
+export declare function pick<T extends object, K extends OfType<keyof T, string>>(x: T, ...keys: readonly K[]): Pick<T, K>;
 export {};

package/lib/index.js

@@ -44,3 +44,18 @@ export function intOrUndefined(x) {
     const v = Number.parseInt(x);
     return Number.isNaN(v) ? undefined : v;
 }
+function filterEntries(x, p) {
+    if (x == null)
+        return null;
+    if (typeof x !== 'object')
+        return x;
+    return Object.fromEntries(Object.entries(x).filter(p));
+}
+export function omit(x, ...keys) {
+    const ks = keys;
+    return filterEntries(x, ([key]) => !ks.includes(key));
+}
+export function pick(x, ...keys) {
+    const ks = keys;
+    return filterEntries(x, ([key]) => ks.includes(key));
+}

package/package.json

@@ -1,12 +1,14 @@
 {
   "name": "@drunkcod/argis",
   "type": "module",
-  "version": "0.0.6",
+  "version": "0.0.8",
   "description": "Tiny method arg checking with strong types.",
   "scripts": {
     "clean": "rimraf lib",
     "compile": "tsc",
-    "build": "npm-run-all clean compile --silent",
+    "cjs:compile": "tsc --module commonjs --outdir lib/cjs",
+    "cjs:fixup": "echo '{\"type\": \"commonjs\"}' > lib/cjs/package.json",
+    "build": "npm-run-all clean -p compile cjs:compile -s cjs:fixup --silent",
     "test": "jest"
   },
   "author": "Tobbe Gyllebring",
@@ -17,12 +19,24 @@
     "lib/**/*",
     "!lib/**/*.spec.*"
   ],
+  "exports": {
+    ".": {
+      "import": {
+        "default": "./lib/index.js",
+        "types": "./lib/index.d.ts"
+      },
+      "require": {
+        "default": "./lib/cjs/index.js",
+        "types": "./lib/cjs/index.d.ts"
+      }
+    }
+  },
   "devDependencies": {
     "@jest/globals": "^29.7.0",
     "jest": "^29.7.0",
     "npm-run-all": "^4.1.5",
     "rimraf": "^6.0.1",
     "ts-jest": "^29.2.5",
-    "typescript": "^5.5.4"
+    "typescript": "^5.7.2"
   }
 }