@drunkcod/argis 0.0.12 → 0.0.14

package/lib/Json.d.ts

@@ -0,0 +1,16 @@
+export interface Jsonable<Json> {
+    toJSON(): Json;
+}
+type AnyFn = (...args: any[]) => any;
+type NeverJson = undefined | symbol | AnyFn;
+type EmptyJson = Map<any, any> | Set<any> | WeakMap<any, any> | WeakSet<any> | RegExp;
+declare const JsonErrorSym: unique symbol;
+export type JsonError<T> = {
+    [JsonErrorSym]: T;
+};
+export type Json<T, IsRoot = true> = T extends Jsonable<infer J> ? (IsRoot extends true ? Json<J, false> : Json<Omit<T, 'toJSON'>>) : T extends NeverJson ? never : T extends EmptyJson ? Record<string, never> : T extends bigint ? JsonError<'bigint-not-serializeable'> : T extends readonly any[] ? {
+    [I in keyof T]: [Json<T[I]>] extends [never] ? null : Json<T[I]>;
+} : T extends object ? {
+    [P in keyof T as P extends string | number ? Json<T[P]> extends never ? never : P : never]: Json<T[P]>;
+} : T;
+export {};

package/lib/Json.js

@@ -0,0 +1,2 @@
+const JsonErrorSym = Symbol('JsonError');
+export {};

package/lib/TypeUtils.d.ts

@@ -0,0 +1,36 @@
+type Pretty<T> = {
+    [P in keyof T]: T[P];
+} & {};
+declare const SPECIAL_TAG: unique symbol;
+type SpecialTag<T> = {
+    readonly [SPECIAL_TAG]: T;
+};
+type TagAny = SpecialTag<'any'>;
+type TagOptional = SpecialTag<'?'>;
+type TagUnknown = SpecialTag<'unknown'>;
+export type IsAny<T> = 0 extends 1 & T ? true : false;
+export type IsUnknown<T> = unknown extends T ? (IsAny<T> extends true ? false : true) : false;
+export type IsOptional<T, K extends keyof T> = {
+    [P in K]?: T[K];
+} extends Pick<T, K> ? true : false;
+type TagSpecial<T> = {
+    [P in keyof T]: (IsOptional<T, P> extends true ? TagOptional : never) | (IsAny<T[P]> extends true ? TagAny : IsUnknown<T[P]> extends true ? TagUnknown : T[P]);
+};
+type IsTagged<T, X extends SpecialTag<any>> = [Extract<T, X>] extends [never] ? false : true;
+type UnwrapOptional<T> = {
+    [P in keyof T as IsTagged<T[P], TagOptional> extends false ? P : never]: T[P];
+} & {
+    [P in keyof T as IsTagged<T[P], TagOptional> extends true ? P : never]?: Exclude<T[P], TagOptional>;
+};
+type UnwrapTagsCore<T> = {
+    [P in keyof T]: IsTagged<T[P], TagAny> extends true ? any : IsTagged<T[P], TagUnknown> extends true ? unknown : T[P];
+};
+type UnwrapTags<T> = UnwrapTagsCore<UnwrapOptional<T>>;
+type UnionMergeCore<A, B> = {
+    [K in keyof A | keyof B]: (K extends keyof A ? A[K] : TagOptional) | (K extends keyof B ? B[K] : TagOptional);
+};
+export type UnionMerge<A, B> = Pretty<UnwrapTags<UnionMergeCore<TagSpecial<A>, TagSpecial<B>>>>;
+export type PickRequired<T> = {
+    [P in keyof T as IsOptional<T, P> extends true ? never : P]: T[P];
+};
+export {};

package/lib/TypeUtils.js

@@ -0,0 +1,2 @@
+const SPECIAL_TAG = Symbol('');
+export {};

package/lib/cjs/Json.d.ts

@@ -0,0 +1,16 @@
+export interface Jsonable<Json> {
+    toJSON(): Json;
+}
+type AnyFn = (...args: any[]) => any;
+type NeverJson = undefined | symbol | AnyFn;
+type EmptyJson = Map<any, any> | Set<any> | WeakMap<any, any> | WeakSet<any> | RegExp;
+declare const JsonErrorSym: unique symbol;
+export type JsonError<T> = {
+    [JsonErrorSym]: T;
+};
+export type Json<T, IsRoot = true> = T extends Jsonable<infer J> ? (IsRoot extends true ? Json<J, false> : Json<Omit<T, 'toJSON'>>) : T extends NeverJson ? never : T extends EmptyJson ? Record<string, never> : T extends bigint ? JsonError<'bigint-not-serializeable'> : T extends readonly any[] ? {
+    [I in keyof T]: [Json<T[I]>] extends [never] ? null : Json<T[I]>;
+} : T extends object ? {
+    [P in keyof T as P extends string | number ? Json<T[P]> extends never ? never : P : never]: Json<T[P]>;
+} : T;
+export {};

package/lib/cjs/Json.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const JsonErrorSym = Symbol('JsonError');

package/lib/cjs/TypeUtils.d.ts

@@ -0,0 +1,36 @@
+type Pretty<T> = {
+    [P in keyof T]: T[P];
+} & {};
+declare const SPECIAL_TAG: unique symbol;
+type SpecialTag<T> = {
+    readonly [SPECIAL_TAG]: T;
+};
+type TagAny = SpecialTag<'any'>;
+type TagOptional = SpecialTag<'?'>;
+type TagUnknown = SpecialTag<'unknown'>;
+export type IsAny<T> = 0 extends 1 & T ? true : false;
+export type IsUnknown<T> = unknown extends T ? (IsAny<T> extends true ? false : true) : false;
+export type IsOptional<T, K extends keyof T> = {
+    [P in K]?: T[K];
+} extends Pick<T, K> ? true : false;
+type TagSpecial<T> = {
+    [P in keyof T]: (IsOptional<T, P> extends true ? TagOptional : never) | (IsAny<T[P]> extends true ? TagAny : IsUnknown<T[P]> extends true ? TagUnknown : T[P]);
+};
+type IsTagged<T, X extends SpecialTag<any>> = [Extract<T, X>] extends [never] ? false : true;
+type UnwrapOptional<T> = {
+    [P in keyof T as IsTagged<T[P], TagOptional> extends false ? P : never]: T[P];
+} & {
+    [P in keyof T as IsTagged<T[P], TagOptional> extends true ? P : never]?: Exclude<T[P], TagOptional>;
+};
+type UnwrapTagsCore<T> = {
+    [P in keyof T]: IsTagged<T[P], TagAny> extends true ? any : IsTagged<T[P], TagUnknown> extends true ? unknown : T[P];
+};
+type UnwrapTags<T> = UnwrapTagsCore<UnwrapOptional<T>>;
+type UnionMergeCore<A, B> = {
+    [K in keyof A | keyof B]: (K extends keyof A ? A[K] : TagOptional) | (K extends keyof B ? B[K] : TagOptional);
+};
+export type UnionMerge<A, B> = Pretty<UnwrapTags<UnionMergeCore<TagSpecial<A>, TagSpecial<B>>>>;
+export type PickRequired<T> = {
+    [P in keyof T as IsOptional<T, P> extends true ? never : P]: T[P];
+};
+export {};

package/lib/cjs/TypeUtils.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const SPECIAL_TAG = Symbol('');

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,7 @@ 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';
+export { parseBool, isBool } from './parseBool.js';
+export type { Json } from './Json.js';
+export type * from './TypeUtils.js';

package/lib/cjs/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ArgumentError = void 0;
+exports.isBool = exports.parseBool = 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,10 @@ 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; } });
+var parseBool_js_1 = require("./parseBool.js");
+Object.defineProperty(exports, "parseBool", { enumerable: true, get: function () { return parseBool_js_1.parseBool; } });
+Object.defineProperty(exports, "isBool", { enumerable: true, get: function () { return parseBool_js_1.isBool; } });

package/lib/cjs/parseBool.d.ts

@@ -0,0 +1,2 @@
+export declare const parseBool: (b?: string | null) => boolean | null;
+export declare function isBool(x: true | false | null): x is true | false;

package/lib/cjs/parseBool.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseBool = void 0;
+exports.isBool = isBool;
+const parseBool = (b) => {
+    if (b == null)
+        return null;
+    const p = b.match(/^(?:\s*)(?:(t(?:rue)?|1|y(?:es)?|on)|(?:f(?:alse)?|0|n(?:o)?|off))(?:\s*)$/i);
+    if (p)
+        return p[1] !== undefined;
+    return null;
+};
+exports.parseBool = parseBool;
+function isBool(x) {
+    return x !== null;
+}

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,7 @@ 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';
+export { parseBool, isBool } from './parseBool.js';
+export type { Json } from './Json.js';
+export type * from './TypeUtils.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,7 @@ 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';
+export { parseBool, isBool } from './parseBool.js';

package/lib/parseBool.d.ts

@@ -0,0 +1,2 @@
+export declare const parseBool: (b?: string | null) => boolean | null;
+export declare function isBool(x: true | false | null): x is true | false;

package/lib/parseBool.js

@@ -0,0 +1,11 @@
+export const parseBool = (b) => {
+    if (b == null)
+        return null;
+    const p = b.match(/^(?:\s*)(?:(t(?:rue)?|1|y(?:es)?|on)|(?:f(?:alse)?|0|n(?:o)?|off))(?:\s*)$/i);
+    if (p)
+        return p[1] !== undefined;
+    return null;
+};
+export function isBool(x) {
+    return x !== null;
+}

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,15 +1,16 @@
 {
   "name": "@drunkcod/argis",
   "type": "module",
-  "version": "0.0.12",
-  "description": "Tiny method arg checking with strong types.",
+  "version": "0.0.14",
+  "description": "A tiny, type-first toolkit for runtime argument validation and structural object utilities.",
   "scripts": {
     "clean": "rimraf lib",
     "compile": "tsc",
     "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": "node --experimental-vm-modules --disable-warning=ExperimentalWarning node_modules/jest/bin/jest.js"
+    "test": "node --experimental-vm-modules --disable-warning=ExperimentalWarning node_modules/jest/bin/jest.js",
+    "test:typecheck": "tsc --project tsconfig.test.json --noEmit"
   },
   "author": "Tobbe Gyllebring",
   "license": "MIT",
@@ -33,10 +34,10 @@
   },
   "devDependencies": {
     "@jest/globals": "^30.0.4",
-    "jest": "^30.0.4",
+    "jest": "^30.1.1",
     "npm-run-all": "^4.1.5",
     "rimraf": "^6.0.1",
-    "ts-jest": "^29.4.0",
-    "typescript": "^5.8.3"
+    "ts-jest": "^29.4.1",
+    "typescript": "^5.9.2"
   }
 }