reliant-type 1.0.0 → 2.1.3

package/docs/FUNCTION-TYPES.md

@@ -0,0 +1,120 @@
+# Function Types
+
+ReliantType introduces powerful runtime and compile-time validation for function signatures using the `fn` type. This feature allows you to define strict contracts for functions within your schema, ensuring that both arguments and return values adhere to specified types during execution.
+
+## Overview
+
+The `fn` type enables you to describe function signatures using a syntax similar to TypeScript arrow functions. These definitions are used to:
+
+1.  **Validate at Runtime**: Wraps the function to strictly enforce argument types, argument count, and return types every time the function is called.
+2.  **Infer TypeScript Types**: Automatically generates accurate TypeScript definitions for your IDE, including argument names, types, and return values.
+
+## Syntax
+
+The general syntax follows the pattern:
+
+```typescript
+"fn((argument_list) => return_type)";
+```
+
+### Components
+
+- **`fn(...)`**: The wrapper indicating a function type.
+- **`argument_list`**: A comma-separated list of arguments in the format `name: type`.
+- **`return_type`**: The expected return type of the function.
+
+## Features
+
+### 1. Basic Function Signatures
+
+Define functions with specific argument types and return types.
+
+```typescript
+const schema = Interface({
+  // Function taking a string and returning a boolean
+  isValid: "fn((input: string) => boolean)",
+
+  // Function taking two numbers and returning a number
+  add: "fn((a: number, b: number) => number)",
+});
+```
+
+### 2. Optional Arguments
+
+Mark arguments as optional using the `?` suffix on the argument name or type.
+
+```typescript
+const schema = Interface({
+  // 'context' is optional
+  log: "fn((message: string, context?: object) => void)",
+});
+```
+
+### 3. Rest Parameters (Spread Operator)
+
+Support for variadic functions using the spread operator (`...`). This is fully supported in both runtime validation and TypeScript inference.
+
+```typescript
+const schema = Interface({
+  // Accepts any number of numeric arguments
+  sum: "fn((...numbers: number[]) => number)",
+});
+```
+
+### 4. The `TYPE` Placeholder
+
+Use `TYPE` as a placeholder for `any`. This is useful when you want to enforce the presence of an argument or a return value without strictly validating its content, or when the type is too complex to describe in a string.
+
+```typescript
+const schema = Interface({
+  // Accepts a generic input and returns a generic output
+  transform: "fn((input: TYPE) => TYPE)",
+});
+```
+
+### 5. Void Return Type
+
+Use `void` to indicate that the function should not return a value (or that the return value should be ignored).
+
+```typescript
+const schema = Interface({
+  callback: "fn(() => void)",
+});
+```
+
+## Runtime Validation Behavior
+
+ReliantType enforces a **Strict Contract** policy for functions. When a function defined in a schema is accessed, it is wrapped in a validation proxy.
+
+- **Argument Count**: Throws an error if required arguments are missing.
+- **Argument Types**: Throws an error if an argument does not match its defined type.
+- **Return Type**: Throws an error if the function returns a value that does not match the defined return type.
+
+### Example of Validation Failure
+
+```typescript
+const config = {
+  // Incorrect implementation: returns a string instead of a number
+  calculator: (a, b) => "result",
+};
+
+const schema = Interface({
+  calculator: "fn((a: number, b: number) => number)",
+});
+
+const result = schema.parse(config);
+
+// This call will THROW an Error:
+// "[ReliantType] Return value validation failed... Expected number, got string"
+result.calculator(10, 20);
+```
+
+## TypeScript Integration
+
+The `fn` syntax is fully compatible with ReliantType's type inference system.
+
+- `fn((a: string) => number)` infers to `(a: string) => number`
+- `fn((...args: string[]) => void)` infers to `(...args: string[]) => void`
+- `fn((opt?: string) => boolean)` infers to `(opt?: string | undefined) => boolean`
+
+This ensures that your IDE provides correct autocompletion and type checking for implementation code.

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "reliant-type",
-  "version": "1.0.0",
-  "description": "ReliantType is a modern TypeScript validation library designed around familiar interface syntax and powerful conditional validation. Experience schema validation that feels natural to TypeScript developers while unlocking advanced runtime validation capabilities.",
+  "version": "2.1.3",
+  "description": "A modern TypeScript validation library designed around familiar interface syntax and powerful conditional validation. Experience schema validation that feels natural to TypeScript developers while unlocking advanced runtime validation capabilities.",
   "main": "dist/cjs/index.js",
   "module": "dist/esm/index.js",
   "types": "dist/schema.d.ts",
@@ -178,7 +178,7 @@
     "robust",
     "scalable"
   ],
-  "author": "Nehonix Team <rlt.support@nehonix.space> (https://nehonix.space)",
+  "author": "Nehonix Team <support@nehonix.space> (https://nehonix.space)",
   "license": "MIT License",
   "repository": {
     "type": "git",
@@ -203,7 +203,7 @@
     "jest": "^29.7.0",
     "prettier": "^3.0.3",
     "rimraf": "^6.0.1",
-    "rollup": "^3.29.5",
+    "rollup": "^3.29.2",
     "rollup-plugin-dts": "^6.0.2",
     "ts-jest": "^29.1.1",
     "typescript": "^5.8.3"

package/src/core/schema/extensions/components/AutoDocumentation/Docs.ts

@@ -70,7 +70,7 @@ export const Docs = {
      * //   name: string;
      * //   age?: number;
      * //   role: "user" | "admin" | "moderator";
-     * // }
+     * // } 
      * ```
      */
     typescript(schema: SchemaInterface, options: TSOptions = {}): string {