@deessejs/type-testing 0.1.5 → 0.3.0

package/CHANGELOG.md

@@ -1,10 +1,44 @@
 # @deessejs/type-testing
 
+## 0.3.0
+
+### Minor Changes
+
+- feat: add type utility helpers
+
+  Add new type utilities for compile-time type testing:
+
+  ### Property Modifiers
+  - IsReadonly<T> - Check if all properties are readonly
+  - IsRequired<T> - Check if all properties are required
+  - IsPublic<T, K> - Check if property is public
+  - IsPrivate<T, K> - Check if property is private
+  - IsProtected<T, K> - Check if property is protected
+
+  ### Deep Type Manipulation
+  - DeepReadonly<T> - Make all properties readonly recursively
+  - DeepPartial<T> - Make all properties optional recursively
+  - RequiredKeys<T> - Get keys of required properties
+  - OptionalKeys<T> - Get keys of optional properties
+
+  ### Function Types
+  - IsConstructor<T> - Check if type is a constructor
+  - IsAbstract<T> - Check if type is abstract
+
+  ### Other
+  - IsNeverEqual<T, U> - Check if T and U are both never
+
+## 0.2.0
+
+### Minor Changes
+
+- Add runtime type checking utilities with boolean type guards
+
 ## 0.1.2
 
 ### Patch Changes
 
-- Fix ESM exports by adding explicit .js extensions to imports and exports
+- Fix .npmignore to include dist folder in published package
 
 ## 0.1.1
 

package/README.md

@@ -139,6 +139,27 @@ HasProperty<{ a: string }, 'b'>  // false
 PropertyType<{ a: string }, 'a'> // string
 ```
 
+### Property Modifiers
+
+```typescript
+import { IsReadonly, IsRequired, IsPublic, IsPrivate, IsProtected } from '@deessejs/type-testing'
+
+// Check if all properties are readonly
+IsReadonly<{ readonly a: string }>  // true
+IsReadonly<{ a: string }>          // false
+
+// Check if all properties are required
+IsRequired<{ a: string }>          // true
+IsRequired<{ a?: string }>        // false
+
+// Check property visibility (uses naming convention)
+IsPublic<{ a: string }, 'a'>       // true
+IsPrivate<{ __private: string }, '__private'>  // true
+IsProtected<{ _protected: string }, '_protected'> // true
+```
+
+> **Note**: `IsPublic`, `IsPrivate`, and `IsProtected` use TypeScript's private field naming convention (`__` prefix) and common JavaScript convention (`_` prefix for protected). These are naming-convention-based checks, not actual TypeScript access modifiers (which don't exist for object properties).
+
 ### Function Types
 
 ```typescript
@@ -164,6 +185,91 @@ Length<['a', 'b', 'c']>            // 3
 Length<[]>                          // 0
 ```
 
+### Deep Type Manipulation
+
+```typescript
+import { DeepReadonly, DeepPartial, RequiredKeys, OptionalKeys } from '@deessejs/type-testing'
+
+// Make all properties readonly recursively
+DeepReadonly<{ a: string; b: { c: number } }>
+// { readonly a: string; readonly b: { readonly c: number } }
+
+// Make all properties optional recursively
+DeepPartial<{ a: string; b: { c: number } }>
+// { a?: string; b?: { c?: number } | undefined }
+
+// Get keys of required properties
+RequiredKeys<{ a: string; b?: number }>  // 'a'
+
+// Get keys of optional properties
+OptionalKeys<{ a: string; b?: number }>  // 'b'
+```
+
+### Constructor & Abstract Types
+
+```typescript
+import { IsConstructor, IsAbstract } from '@deessejs/type-testing'
+
+class Foo {}
+abstract class Bar {}
+
+IsConstructor<typeof Foo>    // true
+IsConstructor<Foo>          // false (instance)
+IsAbstract<typeof Bar>      // true
+IsAbstract<typeof Foo>     // false
+```
+
+### Special Equality
+
+```typescript
+import { IsNeverEqual } from '@deessejs/type-testing'
+
+// Check if both types are never
+// Differs from Equal<never, never> which returns false
+IsNeverEqual<never, never>     // true
+IsNeverEqual<any, any>        // false (any is not never)
+```
+
+## Runtime Type Checking
+
+The library also provides runtime type checking utilities:
+
+```typescript
+import {
+  // Type check functions returning TypeCheckResult objects
+  isString,
+  isNumber,
+  isBoolean,
+  isObject,
+  isArray,
+  isNull,
+  isUndefined,
+
+  // Boolean type guards (for use in conditionals)
+  isStringGuard,
+  isNumberGuard,
+  isBooleanGuard,
+  isObjectGuard,
+  isArrayGuard,
+  isNullGuard,
+  isUndefinedGuard,
+  isSymbolGuard,
+  isBigIntGuard,
+  isFunctionGuard
+} from '@deessejs/type-testing'
+
+// TypeCheckResult objects
+const stringResult = isString('hello')
+stringResult.matches   // true
+stringResult.value     // 'hello'
+stringResult.typeName   // 'string'
+
+// Boolean type guards
+if (isStringGuard(value)) {
+  // value is narrowed to string here
+}
+```
+
 ## Chainable API
 
 ### check() - Soft type checking
@@ -268,6 +374,7 @@ expectFalse<true>()                         // compile error
 | `Equal<T, U>` | Strict equality check |
 | `NotEqual<T, U>` | Inequality check |
 | `SimpleEqual<T, U>` | Simple equality for plain types |
+| `IsNeverEqual<T, U>` | Check if both types are `never` |
 | `IsAny<T>` | Check if type is `any` |
 | `IsNever<T>` | Check if type is `never` |
 | `IsUnknown<T>` | Check if type is `unknown` |
@@ -283,9 +390,20 @@ expectFalse<true>()                         // compile error
 | `IsUninhabited<T>` | Check if type has no values |
 | `HasProperty<T, K>` | Check if type has property K |
 | `PropertyType<T, K>` | Get type of property K |
+| `IsReadonly<T>` | Check if all properties are readonly |
+| `IsRequired<T>` | Check if all properties are required |
+| `IsPublic<T, K>` | Check if property is public |
+| `IsPrivate<T, K>` | Check if property is private (naming convention) |
+| `IsProtected<T, K>` | Check if property is protected (naming convention) |
+| `DeepReadonly<T>` | Make all properties readonly recursively |
+| `DeepPartial<T>` | Make all properties optional recursively |
+| `RequiredKeys<T>` | Get keys of required properties |
+| `OptionalKeys<T>` | Get keys of optional properties |
 | `Parameters<T>` | Get function parameters as tuple |
 | `ReturnType<T>` | Get function return type |
 | `Parameter<T, N>` | Get parameter at index N |
+| `IsConstructor<T>` | Check if type is a constructor |
+| `IsAbstract<T>` | Check if type is abstract |
 | `Length<T>` | Get tuple/array length |
 | `ExpectTrue<T>` | Assert T is true |
 | `ExpectEqual<T, U>` | Assert T equals U |

package/dist/index.d.ts

@@ -6,4 +6,5 @@
 export * from './types/index.js';
 export * from './api/index.js';
 export * from './utils.js';
+export * from './runtime/index.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAGH,cAAc,kBAAkB,CAAA;AAGhC,cAAc,gBAAgB,CAAA;AAG9B,cAAc,YAAY,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAGH,cAAc,kBAAkB,CAAA;AAGhC,cAAc,gBAAgB,CAAA;AAG9B,cAAc,YAAY,CAAA;AAG1B,cAAc,oBAAoB,CAAA"}

package/dist/index.js

@@ -9,4 +9,6 @@ export * from './types/index.js';
 export * from './api/index.js';
 // Re-export utilities
 export * from './utils.js';
+// Re-export runtime utilities
+export * from './runtime/index.js';
 //# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,+BAA+B;AAC/B,cAAc,kBAAkB,CAAA;AAEhC,gBAAgB;AAChB,cAAc,gBAAgB,CAAA;AAE9B,sBAAsB;AACtB,cAAc,YAAY,CAAA"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,+BAA+B;AAC/B,cAAc,kBAAkB,CAAA;AAEhC,gBAAgB;AAChB,cAAc,gBAAgB,CAAA;AAE9B,sBAAsB;AACtB,cAAc,YAAY,CAAA;AAE1B,8BAA8B;AAC9B,cAAc,oBAAoB,CAAA"}

package/dist/runtime/comparison.d.ts

@@ -0,0 +1,122 @@
+/**
+ * Runtime comparison utilities.
+ */
+/**
+ * Result of checking if a value matches a type.
+ */
+export interface TypeCheckResult<T> {
+    matches: boolean;
+    value: T;
+    typeName: string;
+}
+/**
+ * Check if a value is a string.
+ *
+ * @example
+ * ```typescript
+ * const result = isString('hello')
+ * result.matches // true
+ * ```
+ */
+export declare function isString(value: unknown): TypeCheckResult<string>;
+/**
+ * Check if a value is a number.
+ *
+ * @example
+ * ```typescript
+ * const result = isNumber(42)
+ * result.matches // true
+ * ```
+ */
+export declare function isNumber(value: unknown): TypeCheckResult<number>;
+/**
+ * Check if a value is a boolean.
+ *
+ * @example
+ * ```typescript
+ * const result = isBoolean(true)
+ * result.matches // true
+ * ```
+ */
+export declare function isBoolean(value: unknown): TypeCheckResult<boolean>;
+/**
+ * Check if a value is an object.
+ *
+ * @example
+ * ```typescript
+ * const result = isObject({ a: 1 })
+ * result.matches // true
+ * ```
+ */
+export declare function isObject(value: unknown): TypeCheckResult<object>;
+/**
+ * Check if a value is an array.
+ *
+ * @example
+ * ```typescript
+ * const result = isArray([1, 2, 3])
+ * result.matches // true
+ * ```
+ */
+export declare function isArray(value: unknown): TypeCheckResult<unknown[]>;
+/**
+ * Check if a value is null.
+ *
+ * @example
+ * ```typescript
+ * const result = isNull(null)
+ * result.matches // true
+ * ```
+ */
+export declare function isNull(value: unknown): TypeCheckResult<null>;
+/**
+ * Check if a value is undefined.
+ *
+ * @example
+ * ```typescript
+ * const result = isUndefined(undefined)
+ * result.matches // true
+ * ```
+ */
+export declare function isUndefined(value: unknown): TypeCheckResult<undefined>;
+/**
+ * Type guard that returns true if the value is a string.
+ */
+export declare function isStringGuard(value: unknown): value is string;
+/**
+ * Type guard that returns true if the value is a number.
+ */
+export declare function isNumberGuard(value: unknown): value is number;
+/**
+ * Type guard that returns true if the value is a boolean.
+ */
+export declare function isBooleanGuard(value: unknown): value is boolean;
+/**
+ * Type guard that returns true if the value is an object (not null, not array).
+ */
+export declare function isObjectGuard(value: unknown): value is object;
+/**
+ * Type guard that returns true if the value is an array.
+ */
+export declare function isArrayGuard(value: unknown): value is unknown[];
+/**
+ * Type guard that returns true if the value is null.
+ */
+export declare function isNullGuard(value: unknown): value is null;
+/**
+ * Type guard that returns true if the value is undefined.
+ */
+export declare function isUndefinedGuard(value: unknown): value is undefined;
+/**
+ * Type guard that returns true if the value is a symbol.
+ */
+export declare function isSymbolGuard(value: unknown): value is symbol;
+/**
+ * Type guard that returns true if the value is a bigint.
+ */
+export declare function isBigIntGuard(value: unknown): value is bigint;
+/**
+ * Type guard that returns true if the value is a function.
+ */
+export declare function isFunctionGuard(value: unknown): value is Function;
+//# sourceMappingURL=comparison.d.ts.map

package/dist/runtime/comparison.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"comparison.d.ts","sourceRoot":"","sources":["../../src/runtime/comparison.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH;;GAEG;AACH,MAAM,WAAW,eAAe,CAAC,CAAC;IAChC,OAAO,EAAE,OAAO,CAAA;IAChB,KAAK,EAAE,CAAC,CAAA;IACR,QAAQ,EAAE,MAAM,CAAA;CACjB;AAED;;;;;;;;GAQG;AACH,wBAAgB,QAAQ,CAAC,KAAK,EAAE,OAAO,GAAG,eAAe,CAAC,MAAM,CAAC,CAMhE;AAED;;;;;;;;GAQG;AACH,wBAAgB,QAAQ,CAAC,KAAK,EAAE,OAAO,GAAG,eAAe,CAAC,MAAM,CAAC,CAMhE;AAED;;;;;;;;GAQG;AACH,wBAAgB,SAAS,CAAC,KAAK,EAAE,OAAO,GAAG,eAAe,CAAC,OAAO,CAAC,CAMlE;AAED;;;;;;;;GAQG;AACH,wBAAgB,QAAQ,CAAC,KAAK,EAAE,OAAO,GAAG,eAAe,CAAC,MAAM,CAAC,CAMhE;AAED;;;;;;;;GAQG;AACH,wBAAgB,OAAO,CAAC,KAAK,EAAE,OAAO,GAAG,eAAe,CAAC,OAAO,EAAE,CAAC,CAMlE;AAED;;;;;;;;GAQG;AACH,wBAAgB,MAAM,CAAC,KAAK,EAAE,OAAO,GAAG,eAAe,CAAC,IAAI,CAAC,CAM5D;AAED;;;;;;;;GAQG;AACH,wBAAgB,WAAW,CAAC,KAAK,EAAE,OAAO,GAAG,eAAe,CAAC,SAAS,CAAC,CAMtE;AAMD;;GAEG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,MAAM,CAE7D;AAED;;GAEG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,MAAM,CAE7D;AAED;;GAEG;AACH,wBAAgB,cAAc,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,OAAO,CAE/D;AAED;;GAEG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,MAAM,CAE7D;AAED;;GAEG;AACH,wBAAgB,YAAY,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,OAAO,EAAE,CAE/D;AAED;;GAEG;AACH,wBAAgB,WAAW,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,IAAI,CAEzD;AAED;;GAEG;AACH,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,SAAS,CAEnE;AAED;;GAEG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,MAAM,CAE7D;AAED;;GAEG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,MAAM,CAE7D;AAED;;GAEG;AAEH,wBAAgB,eAAe,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,QAAQ,CAEjE"}

package/dist/runtime/comparison.js

@@ -0,0 +1,180 @@
+/**
+ * Runtime comparison utilities.
+ */
+/**
+ * Check if a value is a string.
+ *
+ * @example
+ * ```typescript
+ * const result = isString('hello')
+ * result.matches // true
+ * ```
+ */
+export function isString(value) {
+    return {
+        matches: typeof value === 'string',
+        value: value,
+        typeName: typeof value,
+    };
+}
+/**
+ * Check if a value is a number.
+ *
+ * @example
+ * ```typescript
+ * const result = isNumber(42)
+ * result.matches // true
+ * ```
+ */
+export function isNumber(value) {
+    return {
+        matches: typeof value === 'number',
+        value: value,
+        typeName: typeof value,
+    };
+}
+/**
+ * Check if a value is a boolean.
+ *
+ * @example
+ * ```typescript
+ * const result = isBoolean(true)
+ * result.matches // true
+ * ```
+ */
+export function isBoolean(value) {
+    return {
+        matches: typeof value === 'boolean',
+        value: value,
+        typeName: typeof value,
+    };
+}
+/**
+ * Check if a value is an object.
+ *
+ * @example
+ * ```typescript
+ * const result = isObject({ a: 1 })
+ * result.matches // true
+ * ```
+ */
+export function isObject(value) {
+    return {
+        matches: typeof value === 'object' && value !== null,
+        value: value,
+        typeName: typeof value,
+    };
+}
+/**
+ * Check if a value is an array.
+ *
+ * @example
+ * ```typescript
+ * const result = isArray([1, 2, 3])
+ * result.matches // true
+ * ```
+ */
+export function isArray(value) {
+    return {
+        matches: Array.isArray(value),
+        value: value,
+        typeName: Array.isArray(value) ? 'array' : typeof value,
+    };
+}
+/**
+ * Check if a value is null.
+ *
+ * @example
+ * ```typescript
+ * const result = isNull(null)
+ * result.matches // true
+ * ```
+ */
+export function isNull(value) {
+    return {
+        matches: value === null,
+        value: value,
+        typeName: value === null ? 'null' : typeof value,
+    };
+}
+/**
+ * Check if a value is undefined.
+ *
+ * @example
+ * ```typescript
+ * const result = isUndefined(undefined)
+ * result.matches // true
+ * ```
+ */
+export function isUndefined(value) {
+    return {
+        matches: value === undefined,
+        value: value,
+        typeName: value === undefined ? 'undefined' : typeof value,
+    };
+}
+// ============================================
+// Simple boolean type guards
+// ============================================
+/**
+ * Type guard that returns true if the value is a string.
+ */
+export function isStringGuard(value) {
+    return typeof value === 'string';
+}
+/**
+ * Type guard that returns true if the value is a number.
+ */
+export function isNumberGuard(value) {
+    return typeof value === 'number';
+}
+/**
+ * Type guard that returns true if the value is a boolean.
+ */
+export function isBooleanGuard(value) {
+    return typeof value === 'boolean';
+}
+/**
+ * Type guard that returns true if the value is an object (not null, not array).
+ */
+export function isObjectGuard(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+/**
+ * Type guard that returns true if the value is an array.
+ */
+export function isArrayGuard(value) {
+    return Array.isArray(value);
+}
+/**
+ * Type guard that returns true if the value is null.
+ */
+export function isNullGuard(value) {
+    return value === null;
+}
+/**
+ * Type guard that returns true if the value is undefined.
+ */
+export function isUndefinedGuard(value) {
+    return value === undefined;
+}
+/**
+ * Type guard that returns true if the value is a symbol.
+ */
+export function isSymbolGuard(value) {
+    return typeof value === 'symbol';
+}
+/**
+ * Type guard that returns true if the value is a bigint.
+ */
+export function isBigIntGuard(value) {
+    return typeof value === 'bigint';
+}
+/**
+ * Type guard that returns true if the value is a function.
+ */
+// eslint-disable-next-line @typescript-eslint/no-unsafe-function-type
+export function isFunctionGuard(value) {
+    return typeof value === 'function';
+}
+//# sourceMappingURL=comparison.js.map

package/dist/runtime/comparison.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"comparison.js","sourceRoot":"","sources":["../../src/runtime/comparison.ts"],"names":[],"mappings":"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"}

package/dist/runtime/index.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Runtime type testing utilities.
+ */
+export * from './comparison.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/runtime/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/runtime/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,cAAc,iBAAiB,CAAA"}

package/dist/runtime/index.js

@@ -0,0 +1,5 @@
+/**
+ * Runtime type testing utilities.
+ */
+export * from './comparison.js';
+//# sourceMappingURL=index.js.map

package/dist/runtime/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/runtime/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,cAAc,iBAAiB,CAAA"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@deessejs/type-testing",
-  "version": "0.1.5",
+  "version": "0.3.0",
   "type": "module",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
@@ -16,6 +16,7 @@
     "lint": "eslint src --ext .ts,.tsx",
     "typecheck": "tsc --noEmit",
     "test": "vitest run",
+    "test:coverage": "vitest run --coverage",
     "test:watch": "vitest",
     "clean": "rm -rf dist"
   },