@drunkcod/argis 0.0.13 → 0.0.15

package/README.md

@@ -0,0 +1,203 @@
+# @drunkcod/argis
+
+A tiny, type-first toolkit for runtime argument validation and structural object utilities.
+
+`argis` (Arguments & Is) is designed to bridge the gap between runtime checks and TypeScript inference. It provides a suite of lightweight, zero-dependency utilities to safely narrow types while performing common runtime validations and data transformations.
+
+## Aim & Philosophy
+
+In TypeScript, we often find ourselves writing repetitive type guards or utility functions to handle nulls, property existence, and object shaping. `argis` aims to provide a consistent, high-fidelity set of tools that:
+
+1.  **Prioritize Inference:** Every function is built to provide the strongest possible type narrowing at the call site.
+2.  **Handle Objects Safely:** Deeply nested paths and structural transformations are type-checked at compile time.
+3.  **Stay Minimal:** Only provide what's necessary for robust argument handling and object manipulation without the overhead of a full-blown validation library.
+
+---
+
+## Installation
+
+```bash
+npm install @drunkcod/argis
+```
+
+---
+
+## Utilities
+
+### 1. Guarding & Presence
+
+#### `isNil` / `isNotNil`
+
+Simple checks for `null` or `undefined` that narrow types correctly.
+
+```typescript
+import { isNil, isNotNil } from '@drunkcod/argis';
+
+const value: string | null = getNullableValue();
+
+if (isNotNil(value)) {
+  // value is string
+}
+
+const obj = { data: null };
+if (isNil(obj, 'data')) {
+  // obj.data is null | undefined
+}
+```
+
+#### `assertNotNil` / `argNotNil`
+
+Throws an `ArgumentError` if a value is nil. Useful for early exits in functions.
+
+```typescript
+import { argNotNil } from '@drunkcod/argis';
+
+function process(input: { id: string | null }) {
+  argNotNil(input, 'id');
+  // input.id is now string
+}
+```
+
+---
+
+### 2. Property Access
+
+#### `hasOwn` / `hasKey`
+
+Safely check for the presence of a property and narrow the object type. `hasOwn` uses `Object.hasOwn`, while `hasKey` checks the prototype chain (`in` operator).
+
+```typescript
+import { hasOwn } from '@drunkcod/argis';
+
+const data: unknown = { id: 123, name: 'Argis' };
+
+if (hasOwn(data, 'id', 'number')) {
+  // data is { id: number }
+}
+
+if (hasOwn(data, 'name', (val): val is string => typeof val === 'string')) {
+  // data is { id: number, name: string }
+}
+```
+
+#### `assertOwn` / `assertKey`
+
+Throws a `MissingPropertyError` (subtype of `ArgumentError`) if the property is missing or fails the type check.
+
+```typescript
+import { assertOwn } from '@drunkcod/argis';
+
+function start(config: object) {
+  assertOwn(config, 'apiKey', 'string');
+  // config.apiKey is string
+}
+```
+
+---
+
+### 3. Object Shaping
+
+#### `pick` / `omit`
+
+Type-safe versions of common object subsetting.
+
+```typescript
+import { pick, omit } from '@drunkcod/argis';
+
+const user = { id: 1, name: 'User', secret: '123' };
+
+const publicUser = pick(user, 'id', 'name'); // { id: number, name: string }
+const safeUser = omit(user, 'secret'); // { id: number, name: string }
+```
+
+#### `select`
+
+A transformative pick. Select fields and optionally transform them in one pass.
+
+```typescript
+import { select } from '@drunkcod/argis';
+
+const input = { value: 21, message: 'hello' };
+const result = select(input, {
+  value: (x) => (x * 2).toString(), // Transform number to string
+  message: 1, // Keep as-is (1 acts as 'true')
+});
+// result: { value: '42', message: 'hello' }
+```
+
+#### `Projected<T, P>` (Type only)
+
+High-fidelity type inference for MongoDB-style projections, including dot-notation for nested paths.
+
+```typescript
+import { Projected } from '@drunkcod/argis';
+
+type User = {
+  id: number;
+  profile: {
+    firstName: string;
+    lastName: string;
+    avatar: string;
+  };
+  posts: { title: string; content: string }[];
+};
+
+// Inclusion (1)
+type Summary = Projected<
+  User,
+  {
+    'profile.firstName': 1;
+    'posts.title': 1;
+  }
+>;
+// Result: { profile: { firstName: string }, posts: { title: string }[] }
+
+// Exclusion (0)
+type SansAvatar = Projected<User, { 'profile.avatar': 0 }>;
+// Result: { id: number, profile: { firstName: string, lastName: string }, posts: ... }
+```
+
+---
+
+### 4. Serialization & Parsing
+
+#### `Json<T>` (Type only)
+
+A recursive type that ensures a type is JSON-serializable. It handles `toJSON()` methods and filters out non-serializable members like functions and symbols.
+
+```typescript
+import { Json } from '@drunkcod/argis';
+
+type Valid = Json<{ a: number; b: string }>; // { a: number, b: string }
+type Invalid = Json<{ a: bigint }>; // JsonError<'bigint-not-serializeable'>
+```
+
+#### `parseBool`
+
+A robust boolean parser for strings. Supports `true`, `false`, `1`, `0`, `yes`, `no`, `on`, `off` (case-insensitive).
+
+```typescript
+import { parseBool, isBool } from '@drunkcod/argis';
+
+const enabled = parseBool('on'); // true
+const disabled = parseBool('0'); // false
+const unknown = parseBool('maybe'); // null
+
+if (isBool(unknown)) {
+  // narrows to boolean
+}
+```
+
+---
+
+### 5. Utilities
+
+- **`intOrUndefined(str)`**: Safely parses an integer or returns `undefined`.
+- **`nullIfEmpty(arr)`**: Returns `null` if the array (or object with length) is empty.
+- **`isThenable(obj)`**: Checks if an object is a Promise-like (has `.then()`).
+
+---
+
+## License
+
+MIT

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/Projection.d.ts

@@ -0,0 +1,51 @@
+import { IsAny, IsUnknown } from 'TypeUtils.js';
+type Split<X extends string> = X extends `${infer H}.${infer R}` ? [H, R] : [X, never];
+type UnionToIntersection<U> = (U extends any ? (k: U) => void : never) extends (k: infer I) => void ? I : never;
+declare const PROJECTION_ERROR: unique symbol;
+export type ProjectionError<T extends string> = {
+    readonly [PROJECTION_ERROR]: T;
+};
+declare const PROJECTION_TYPE: unique symbol;
+type ProjectionType<T extends 0 | 1, P> = {
+    readonly [PROJECTION_TYPE]: T;
+    P: P;
+};
+type Leafs<T> = T extends object ? {
+    [K in keyof T]: Leafs<T[K]>;
+}[keyof T] : T;
+type Errors<T> = T extends ProjectionError<any> ? T : T extends object ? {
+    [K in keyof T]: Errors<T[K]>;
+}[keyof T] : never;
+type Splut<T> = {
+    [K in keyof T as K extends string ? Split<K>[0] : never]: K extends string ? Split<K> extends [infer _, infer R] ? [R] extends [never] ? T[K] : Splut<{
+        [P in R extends string ? R : never]: T[K];
+    }> : never : never;
+};
+type Squish<T> = T extends object ? {
+    [P in keyof T]: Squish<UnionToIntersection<T[P]>>;
+} : T;
+type _EnsureValidProjection<Leafs, Ok> = [
+    Leafs
+] extends [1] ? ProjectionType<1, Ok> : [
+    Leafs
+] extends [0] ? ProjectionType<0, Ok> : ProjectionError<'ERROR: Projections can only include *either* inclusions (1) or exclusions(0)'>;
+type EnsureValidProjection<P> = _EnsureValidProjection<Leafs<P>, P>;
+type UnwrapProjection<T> = T extends ProjectionType<any, infer P> ? P : T;
+type EnsureNoError<T> = [Errors<T>] extends [never] ? T : Errors<T>;
+type _ProjectInclusion<T, P> = P extends 1 ? T : T extends (infer U)[] ? _ProjectInclusion<U, P>[] : {
+    [K in keyof T as K extends keyof P ? K : never]: K extends keyof P ? _ProjectInclusion<T[K], P[K]> : never;
+};
+type _ProjectExclusion<T, P> = T extends (infer U)[] ? _ProjectExclusion<U, P>[] : {
+    [K in keyof T as K extends keyof P ? (P[K] extends 0 ? never : K) : K]: K extends keyof P ? _ProjectExclusion<T[K], P[K]> : T[K];
+};
+type _ProjectParsed<T, P> = P extends ProjectionType<1, infer Inclusion> ? _ProjectInclusion<T, Inclusion> : P extends ProjectionType<0, infer Exclusion> ? _ProjectExclusion<T, Exclusion> : ProjectionError<`ERROR: Unknown Projection type.`>;
+type _ParsedProjection<T> = EnsureValidProjection<Squish<Splut<T>>>;
+export type Projection<T> = EnsureNoError<UnwrapProjection<_ParsedProjection<T>>>;
+/**
+ * Ungarbage is a post-processor that detects if a projection has collapsed into
+ * an empty object (common when mapping over 'any' or 'unknown') and restores
+ * the original input type if the input was 'any' or 'unknown'.
+ */
+type Ungarbage<T, P> = {} extends P ? (IsAny<T> extends true ? T : IsUnknown<T> extends true ? T : P) : P;
+export type Projected<T, P> = Ungarbage<T, _ProjectParsed<T, _ParsedProjection<P>>>;
+export {};

package/lib/Projection.js

@@ -0,0 +1,3 @@
+const PROJECTION_ERROR = Symbol('ProjectionError');
+const PROJECTION_TYPE = Symbol('ProjectionType');
+export {};

package/lib/TypeUtils.d.ts

@@ -0,0 +1,37 @@
+export 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 Assign<Target, Source> = Omit<Target, keyof Source> & Source;
+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/Projection.d.ts

@@ -0,0 +1,51 @@
+import { IsAny, IsUnknown } from 'TypeUtils.js';
+type Split<X extends string> = X extends `${infer H}.${infer R}` ? [H, R] : [X, never];
+type UnionToIntersection<U> = (U extends any ? (k: U) => void : never) extends (k: infer I) => void ? I : never;
+declare const PROJECTION_ERROR: unique symbol;
+export type ProjectionError<T extends string> = {
+    readonly [PROJECTION_ERROR]: T;
+};
+declare const PROJECTION_TYPE: unique symbol;
+type ProjectionType<T extends 0 | 1, P> = {
+    readonly [PROJECTION_TYPE]: T;
+    P: P;
+};
+type Leafs<T> = T extends object ? {
+    [K in keyof T]: Leafs<T[K]>;
+}[keyof T] : T;
+type Errors<T> = T extends ProjectionError<any> ? T : T extends object ? {
+    [K in keyof T]: Errors<T[K]>;
+}[keyof T] : never;
+type Splut<T> = {
+    [K in keyof T as K extends string ? Split<K>[0] : never]: K extends string ? Split<K> extends [infer _, infer R] ? [R] extends [never] ? T[K] : Splut<{
+        [P in R extends string ? R : never]: T[K];
+    }> : never : never;
+};
+type Squish<T> = T extends object ? {
+    [P in keyof T]: Squish<UnionToIntersection<T[P]>>;
+} : T;
+type _EnsureValidProjection<Leafs, Ok> = [
+    Leafs
+] extends [1] ? ProjectionType<1, Ok> : [
+    Leafs
+] extends [0] ? ProjectionType<0, Ok> : ProjectionError<'ERROR: Projections can only include *either* inclusions (1) or exclusions(0)'>;
+type EnsureValidProjection<P> = _EnsureValidProjection<Leafs<P>, P>;
+type UnwrapProjection<T> = T extends ProjectionType<any, infer P> ? P : T;
+type EnsureNoError<T> = [Errors<T>] extends [never] ? T : Errors<T>;
+type _ProjectInclusion<T, P> = P extends 1 ? T : T extends (infer U)[] ? _ProjectInclusion<U, P>[] : {
+    [K in keyof T as K extends keyof P ? K : never]: K extends keyof P ? _ProjectInclusion<T[K], P[K]> : never;
+};
+type _ProjectExclusion<T, P> = T extends (infer U)[] ? _ProjectExclusion<U, P>[] : {
+    [K in keyof T as K extends keyof P ? (P[K] extends 0 ? never : K) : K]: K extends keyof P ? _ProjectExclusion<T[K], P[K]> : T[K];
+};
+type _ProjectParsed<T, P> = P extends ProjectionType<1, infer Inclusion> ? _ProjectInclusion<T, Inclusion> : P extends ProjectionType<0, infer Exclusion> ? _ProjectExclusion<T, Exclusion> : ProjectionError<`ERROR: Unknown Projection type.`>;
+type _ParsedProjection<T> = EnsureValidProjection<Squish<Splut<T>>>;
+export type Projection<T> = EnsureNoError<UnwrapProjection<_ParsedProjection<T>>>;
+/**
+ * Ungarbage is a post-processor that detects if a projection has collapsed into
+ * an empty object (common when mapping over 'any' or 'unknown') and restores
+ * the original input type if the input was 'any' or 'unknown'.
+ */
+type Ungarbage<T, P> = {} extends P ? (IsAny<T> extends true ? T : IsUnknown<T> extends true ? T : P) : P;
+export type Projected<T, P> = Ungarbage<T, _ProjectParsed<T, _ParsedProjection<P>>>;
+export {};

package/lib/cjs/Projection.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const PROJECTION_ERROR = Symbol('ProjectionError');
+const PROJECTION_TYPE = Symbol('ProjectionType');

package/lib/cjs/TypeUtils.d.ts

@@ -0,0 +1,37 @@
+export 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 Assign<Target, Source> = Omit<Target, keyof Source> & Source;
+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

@@ -63,3 +63,7 @@ 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 { select } from './select.js';
+export { parseBool, isBool } from './parseBool.js';
+export type { Projection, Projected, ProjectionError } from './Projection.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.select = exports.ArgumentError = void 0;
+exports.isBool = exports.parseBool = exports.select = exports.ArgumentError = void 0;
 exports.isNil = isNil;
 exports.isNotNil = isNotNil;
 exports.isThenable = isThenable;
@@ -87,3 +87,6 @@ function pick(x, ...keys) {
 }
 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/index.d.ts

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

package/lib/index.js

@@ -69,3 +69,4 @@ export function pick(x, ...keys) {
     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/package.json

@@ -1,15 +1,16 @@
 {
   "name": "@drunkcod/argis",
   "type": "module",
-  "version": "0.0.13",
-  "description": "Tiny method arg checking with strong types.",
+  "version": "0.0.15",
+  "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"
   }
 }