@drunkcod/argis 0.0.12 → 0.0.13

package/lib/cjs/index.d.ts

@@ -33,10 +33,25 @@ 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]>;
 };
+interface TypeGuard<T> {
+    (x: unknown): x is T;
+}
+type TypeOf = {
+    boolean: boolean;
+    number: number;
+    bigint: bigint;
+    string: string;
+    object: object;
+    symbol: symbol;
+    function: Function;
+    undefined: undefined;
+};
+type TypeGuardOrType<T = any> = T extends TypeGuard<infer V> ? TypeGuard<V> : T extends keyof TypeOf ? T : never;
+type TypeFrom<T> = T extends TypeGuard<infer V> ? V : T extends keyof TypeOf ? TypeOf[T] : never;
 export declare function hasOwn<T extends object, K extends PropertyKey>(x: T | unknown, key: K): x is T & WithKey<K>;
-export declare function hasOwn<T extends object, K extends PropertyKey, V>(x: T | unknown, key: K, ofType: (found: unknown) => found is V): x is T & WithKey<K, V>;
+export declare function hasOwn<T extends object, K extends PropertyKey, V>(x: T, key: K, ofType?: TypeGuardOrType<V>): x is T & WithKey<K, TypeFrom<V>>;
 export declare function hasKey<T extends object, K extends PropertyKey>(x: T | unknown, key: K): x is T & WithKey<K>;
-export declare function hasKey<T extends object, K extends PropertyKey, V>(x: T | unknown, key: K, ofType: (found: unknown) => found is V): x is T & WithKey<K, V>;
+export declare function hasKey<T extends object, K extends PropertyKey, V>(x: T, key: K, ofType?: TypeGuardOrType<V>): x is T & WithKey<K, TypeFrom<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 assertKey<T extends object, K extends PropertyKey>(x: T, key: K): asserts x is T & WithKey<K>;
@@ -47,4 +62,4 @@ export declare function nullIfEmpty<T extends {
 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 {};
+export { select } from './select.js';

package/lib/cjs/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ArgumentError = void 0;
+exports.select = exports.ArgumentError = void 0;
 exports.isNil = isNil;
 exports.isNotNil = isNotNil;
 exports.isThenable = isThenable;
@@ -46,17 +46,18 @@ function assertNotNil(x) {
 function argNotNil(x, key) {
     isNotNil(x, key) || ArgumentError.null(`'${String(key)}' was null or undefined`);
 }
+const isObject = (x) => !!x && (typeof x === 'object' || typeof x === 'function');
 function _hasOwn(x, key) {
     return Object.hasOwn(x, key);
 }
 function hasOwn(x, key, ofType) {
-    return _hasOwn(x, key) && (ofType == undefined || ofType(x[key]));
+    return isObject(x) && _hasOwn(x, key) && (ofType === undefined || (typeof ofType === 'string' ? typeof x[key] === ofType : ofType(x[key])));
 }
 function _hasKey(x, key) {
-    return typeof x === 'object' && key in x;
+    return key in x;
 }
 function hasKey(x, key, ofType) {
-    return _hasKey(x, key) && (ofType == undefined || ofType(x[key]));
+    return isObject(x) && _hasKey(x, key) && (ofType === undefined || (typeof ofType === 'string' ? typeof x[key] === ofType : ofType(x[key])));
 }
 function assertOwn(x, key, ofType) {
     (ofType ? hasOwn(x, key, ofType) : hasOwn(x, key)) || ArgumentError.missing({ key });
@@ -82,5 +83,7 @@ function omit(x, ...keys) {
     return Object.fromEntries(excludeEntries(x, Array.prototype.includes.bind(keys)));
 }
 function pick(x, ...keys) {
-    return Object.fromEntries(keys.map((k) => [keys, x[k]]));
+    return Object.fromEntries(keys.map((k) => [k, x[k]]));
 }
+var select_js_1 = require("./select.js");
+Object.defineProperty(exports, "select", { enumerable: true, get: function () { return select_js_1.select; } });

package/lib/cjs/select.d.ts

@@ -0,0 +1,19 @@
+interface Fn1<T, R> {
+    (arg0: T): R;
+}
+declare const error: unique symbol;
+type SelectError<T extends string> = T & {
+    [error]: void;
+};
+type Select<T, S> = {
+    [P in keyof S]: P extends keyof T ? S[P] extends Fn1<infer In, unknown> ? In extends T[P] ? S[P] : SelectError<`wrong-parameter-type:${string & P})`> : S[P] extends 1 ? 1 : SelectError<`not-a-function:${string & P}`> : SelectError<`not-in-source:${string & P}`>;
+};
+type Errors<T> = {
+    [P in keyof T as T[P] extends SelectError<string> ? P : never]: T[P];
+};
+type Transform<T, S> = S extends Select<T, S> ? S : Errors<Select<T, S>>;
+type Selected<T, S> = {
+    [P in keyof Transform<T, S>]: Transform<T, S>[P] extends Fn1<any, infer R> ? R : P extends keyof T ? T[P] : never;
+};
+export declare function select<T extends object, S>(x: T, transform: Transform<T, S>): Selected<T, S>;
+export {};

package/lib/cjs/select.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.select = select;
+function select(x, transform) {
+    return Object.fromEntries({
+        *[Symbol.iterator]() {
+            for (const k in transform) {
+                const fn = transform[k];
+                const v = Reflect.get(x, k);
+                if (fn === 1)
+                    yield [k, v];
+                else if (typeof fn === 'function')
+                    yield [k, fn(v)];
+            }
+        },
+    });
+}

package/lib/index.d.ts

@@ -33,10 +33,25 @@ 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]>;
 };
+interface TypeGuard<T> {
+    (x: unknown): x is T;
+}
+type TypeOf = {
+    boolean: boolean;
+    number: number;
+    bigint: bigint;
+    string: string;
+    object: object;
+    symbol: symbol;
+    function: Function;
+    undefined: undefined;
+};
+type TypeGuardOrType<T = any> = T extends TypeGuard<infer V> ? TypeGuard<V> : T extends keyof TypeOf ? T : never;
+type TypeFrom<T> = T extends TypeGuard<infer V> ? V : T extends keyof TypeOf ? TypeOf[T] : never;
 export declare function hasOwn<T extends object, K extends PropertyKey>(x: T | unknown, key: K): x is T & WithKey<K>;
-export declare function hasOwn<T extends object, K extends PropertyKey, V>(x: T | unknown, key: K, ofType: (found: unknown) => found is V): x is T & WithKey<K, V>;
+export declare function hasOwn<T extends object, K extends PropertyKey, V>(x: T, key: K, ofType?: TypeGuardOrType<V>): x is T & WithKey<K, TypeFrom<V>>;
 export declare function hasKey<T extends object, K extends PropertyKey>(x: T | unknown, key: K): x is T & WithKey<K>;
-export declare function hasKey<T extends object, K extends PropertyKey, V>(x: T | unknown, key: K, ofType: (found: unknown) => found is V): x is T & WithKey<K, V>;
+export declare function hasKey<T extends object, K extends PropertyKey, V>(x: T, key: K, ofType?: TypeGuardOrType<V>): x is T & WithKey<K, TypeFrom<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 assertKey<T extends object, K extends PropertyKey>(x: T, key: K): asserts x is T & WithKey<K>;
@@ -47,4 +62,4 @@ export declare function nullIfEmpty<T extends {
 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 {};
+export { select } from './select.js';

package/lib/index.js

@@ -29,17 +29,18 @@ export function assertNotNil(x) {
 export function argNotNil(x, key) {
     isNotNil(x, key) || ArgumentError.null(`'${String(key)}' was null or undefined`);
 }
+const isObject = (x) => !!x && (typeof x === 'object' || typeof x === 'function');
 function _hasOwn(x, key) {
     return Object.hasOwn(x, key);
 }
 export function hasOwn(x, key, ofType) {
-    return _hasOwn(x, key) && (ofType == undefined || ofType(x[key]));
+    return isObject(x) && _hasOwn(x, key) && (ofType === undefined || (typeof ofType === 'string' ? typeof x[key] === ofType : ofType(x[key])));
 }
 function _hasKey(x, key) {
-    return typeof x === 'object' && key in x;
+    return key in x;
 }
 export function hasKey(x, key, ofType) {
-    return _hasKey(x, key) && (ofType == undefined || ofType(x[key]));
+    return isObject(x) && _hasKey(x, key) && (ofType === undefined || (typeof ofType === 'string' ? typeof x[key] === ofType : ofType(x[key])));
 }
 export function assertOwn(x, key, ofType) {
     (ofType ? hasOwn(x, key, ofType) : hasOwn(x, key)) || ArgumentError.missing({ key });
@@ -65,5 +66,6 @@ export function omit(x, ...keys) {
     return Object.fromEntries(excludeEntries(x, Array.prototype.includes.bind(keys)));
 }
 export function pick(x, ...keys) {
-    return Object.fromEntries(keys.map((k) => [keys, x[k]]));
+    return Object.fromEntries(keys.map((k) => [k, x[k]]));
 }
+export { select } from './select.js';

package/lib/select.d.ts

@@ -0,0 +1,19 @@
+interface Fn1<T, R> {
+    (arg0: T): R;
+}
+declare const error: unique symbol;
+type SelectError<T extends string> = T & {
+    [error]: void;
+};
+type Select<T, S> = {
+    [P in keyof S]: P extends keyof T ? S[P] extends Fn1<infer In, unknown> ? In extends T[P] ? S[P] : SelectError<`wrong-parameter-type:${string & P})`> : S[P] extends 1 ? 1 : SelectError<`not-a-function:${string & P}`> : SelectError<`not-in-source:${string & P}`>;
+};
+type Errors<T> = {
+    [P in keyof T as T[P] extends SelectError<string> ? P : never]: T[P];
+};
+type Transform<T, S> = S extends Select<T, S> ? S : Errors<Select<T, S>>;
+type Selected<T, S> = {
+    [P in keyof Transform<T, S>]: Transform<T, S>[P] extends Fn1<any, infer R> ? R : P extends keyof T ? T[P] : never;
+};
+export declare function select<T extends object, S>(x: T, transform: Transform<T, S>): Selected<T, S>;
+export {};

package/lib/select.js

@@ -0,0 +1,14 @@
+export function select(x, transform) {
+    return Object.fromEntries({
+        *[Symbol.iterator]() {
+            for (const k in transform) {
+                const fn = transform[k];
+                const v = Reflect.get(x, k);
+                if (fn === 1)
+                    yield [k, v];
+                else if (typeof fn === 'function')
+                    yield [k, fn(v)];
+            }
+        },
+    });
+}

package/package.json

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