inu-light 1.0.0

package/README.md

@@ -0,0 +1,105 @@
+# inu-light
+
+A lightweight, zero-dependency schema validation library for TypeScript and JavaScript.
+
+## Design philosophy
+
+inu-light focuses on predictable schemas and strict typing, avoiding magic behavior and unnecessary runtime dependencies.
+
+## Features
+
+- **Zero Dependencies**: Minimum footprint for your project.
+- **Type Safe**: Automatically infers TypeScript types from your schemas without using explicit any.
+- **ESM Native**: Built for modern environments.
+- **Lightweight**: Focused on core validation primitives.
+
+### Complex Types & Modifiers
+
+- `inu.object(shape)`: Validates an object based on the provided shape.
+- `inu.array(schema)`: Validates an array of elements matching the schema.
+- `inu.union([schema1, schema2])`: Validates that the input matches at least one of the provided schemas.
+- `inu.literal(value)`: Validates an exact value (string, number, or boolean).
+- `.optional()`: Modifier to allow `undefined`.
+- `.nullable()`: Modifier to allow `null`.
+
+## Installation
+
+```
+npm install inu-light
+```
+
+## Usage
+
+### Basic Example
+
+Define a schema and validate data against it. The `parse` method returns a result object containing either the validated data or an error message.
+
+```typescript
+import { inu } from 'inu-light';
+
+const userSchema = inu.object({
+  name: inu.string(),
+  age: inu.number(),
+  isActive: inu.boolean(),
+});
+
+const result = userSchema.parse({
+  name: 'John Doe',
+  age: 30,
+  isActive: true,
+});
+
+if (result.success) {
+  console.log(result.value); // Type-safe data
+} else {
+  console.error(result.error);
+}
+```
+
+### Type Inference
+
+You can extract the TypeScript type directly from a schema using `ShapeToType`.
+
+```typescript
+import { inu, ShapeToType } from 'inu-light';
+
+const schema = inu.object({
+  id: inu.number(),
+});
+
+type User = ShapeToType<typeof schema>;
+```
+
+## API Reference
+
+### Primitives
+
+- `inu.string()`: Validates that the input is a string.
+- `inu.number()`: Validates that the input is a number.
+- `inu.boolean()`: Validates that the input is a boolean.
+
+### Complex Types
+
+- `inu.object(shape)`: Validates an object based on the provided shape.
+
+## Development
+
+### Build
+
+To compile the library from source:
+
+```
+npm run build
+```
+
+### Testing
+
+To run local tests during development:
+
+```
+npx tsx test-local.ts
+```
+
+## License
+
+MIT

package/dist/core/array.d.ts

@@ -0,0 +1,7 @@
+import { Schema, ParseResult } from '../types/schema.js';
+export declare class InuArray<T> extends Schema<T[]> {
+    private itemSchema;
+    constructor(itemSchema: Schema<T>);
+    parse(value: unknown): ParseResult<T[]>;
+}
+export declare function array<T>(input: Schema<T> | [Schema<T>]): Schema<T[]>;

package/dist/core/array.js

@@ -0,0 +1,36 @@
+import { Schema } from '../types/schema.js';
+import { isArray } from '../utils/guards.js';
+export class InuArray extends Schema {
+    constructor(itemSchema) {
+        super();
+        this.itemSchema = itemSchema;
+    }
+    parse(value) {
+        if (!isArray(value)) {
+            return { success: false, error: 'Array Expected' };
+        }
+        const validatedArray = [];
+        for (let i = 0; i < value.length; i++) {
+            const result = this.itemSchema.parse(value[i]);
+            if (result.success === false) {
+                return {
+                    success: false,
+                    error: `Invalid item at index ${i}: ${result.error}`,
+                };
+            }
+            validatedArray.push(result.value);
+        }
+        return { success: true, value: validatedArray };
+    }
+}
+export function array(input) {
+    if (Array.isArray(input)) {
+        if (input.length !== 1) {
+            throw new Error(`[InuError] inu.array([...]) must contain exactly one schema. 
+         - For multiple types in any order, use inu.union().
+         - For a fixed sequence, use inu.tuple().`);
+        }
+        return new InuArray(input[0]);
+    }
+    return new InuArray(input);
+}

package/dist/core/boolean.d.ts

@@ -0,0 +1,6 @@
+import { Schema, ParseResult } from '../types/schema.js';
+export declare class InuBoolean extends Schema<boolean> {
+    constructor();
+    parse(value: unknown): ParseResult<boolean>;
+}
+export declare function boolean(): Schema<boolean>;

package/dist/core/boolean.js

@@ -0,0 +1,24 @@
+import { Schema } from '../types/schema.js';
+import { isBoolean } from '../utils/guards.js';
+export class InuBoolean extends Schema {
+    constructor() {
+        super();
+    }
+    parse(value) {
+        if (isBoolean(value)) {
+            return {
+                success: true,
+                value: value,
+            };
+        }
+        else {
+            return {
+                success: false,
+                error: 'Boolean Expected',
+            };
+        }
+    }
+}
+export function boolean() {
+    return new InuBoolean();
+}

package/dist/core/literal.d.ts

@@ -0,0 +1,7 @@
+import { Schema, ParseResult } from '../types/schema.js';
+export declare class InuLiteral<T> extends Schema<T> {
+    private readonly expectedValue;
+    constructor(expectedValue: T);
+    parse(value: unknown): ParseResult<T>;
+}
+export declare function literal<T>(value: T): Schema<T>;

package/dist/core/literal.js

@@ -0,0 +1,22 @@
+import { Schema } from '../types/schema.js';
+export class InuLiteral extends Schema {
+    constructor(expectedValue) {
+        super();
+        this.expectedValue = expectedValue;
+    }
+    parse(value) {
+        if (value === this.expectedValue) {
+            return {
+                success: true,
+                value: value,
+            };
+        }
+        return {
+            success: false,
+            error: `Expected literal ${JSON.stringify(this.expectedValue)}, but got ${JSON.stringify(value)}`,
+        };
+    }
+}
+export function literal(value) {
+    return new InuLiteral(value);
+}

package/dist/core/number.d.ts

@@ -0,0 +1,5 @@
+import { Schema, ParseResult } from '../types/schema.js';
+export declare class InuNumber extends Schema<number> {
+    parse(value: unknown): ParseResult<number>;
+}
+export declare function number(): Schema<number>;

package/dist/core/number.js

@@ -0,0 +1,18 @@
+import { Schema } from '../types/schema.js';
+export class InuNumber extends Schema {
+    parse(value) {
+        if (typeof value === 'number' && !isNaN(value)) {
+            return {
+                success: true,
+                value,
+            };
+        }
+        return {
+            success: false,
+            error: 'Number Expected',
+        };
+    }
+}
+export function number() {
+    return new InuNumber();
+}

package/dist/core/object.d.ts

@@ -0,0 +1,14 @@
+import { Schema, ParseResult, NestedShape } from '../types/schema.js';
+type IsOptional<T> = undefined extends T ? true : false;
+export type ShapeToType<S> = S extends Schema<infer T> ? T : {
+    [K in keyof S as IsOptional<S[K] extends Schema<infer T> ? T : never> extends true ? never : K]: S[K] extends Schema<infer T> ? T : S[K] extends Record<string, unknown> ? ShapeToType<S[K]> : never;
+} & {
+    [K in keyof S as IsOptional<S[K] extends Schema<infer T> ? T : never> extends true ? K : never]?: S[K] extends Schema<infer T> ? T : S[K] extends Record<string, unknown> ? ShapeToType<S[K]> : never;
+};
+export declare class InuObject<S extends NestedShape> extends Schema<ShapeToType<S>> {
+    private shape;
+    constructor(shape: S);
+    parse(value: unknown): ParseResult<ShapeToType<S>>;
+}
+export declare function object<S extends NestedShape>(shape: S): Schema<ShapeToType<S>>;
+export {};

package/dist/core/object.js

@@ -0,0 +1,54 @@
+import { Schema } from '../types/schema.js';
+import { isRecord, isSchema } from '../utils/guards.js';
+export class InuObject extends Schema {
+    constructor(shape) {
+        super();
+        this.shape = shape;
+    }
+    parse(value) {
+        if (!isRecord(value)) {
+            return { success: false, error: 'Object Expected' };
+        }
+        const parsedFields = [];
+        for (const key in this.shape) {
+            const field = this.shape[key];
+            if (isSchema(field)) {
+                const parsed = field.parse(value[key]);
+                if (!parsed.success) {
+                    parsedFields.push({ key, success: false, error: parsed.error });
+                    continue;
+                }
+                parsedFields.push({ key, success: true, value: parsed.value });
+            }
+            else {
+                const nestedResult = new InuObject(field).parse(value[key]);
+                if (!nestedResult.success) {
+                    parsedFields.push({
+                        key,
+                        success: false,
+                        error: nestedResult.error,
+                    });
+                    continue;
+                }
+                parsedFields.push({ key, success: true, value: nestedResult.value });
+            }
+        }
+        const failed = parsedFields.find((f) => f.success === false);
+        if (failed && !failed?.success) {
+            return {
+                success: false,
+                error: `Invalid field "${failed.key}": ${failed.error}`,
+            };
+        }
+        const finalObject = parsedFields.reduce((acc, field) => {
+            if (field.success) {
+                acc[field.key] = field.value;
+            }
+            return acc;
+        }, {});
+        return { success: true, value: finalObject };
+    }
+}
+export function object(shape) {
+    return new InuObject(shape);
+}

package/dist/core/string.d.ts

@@ -0,0 +1,6 @@
+import { Schema, ParseResult } from '../types/schema.js';
+export declare class InuString extends Schema<string> {
+    constructor();
+    parse(value: unknown): ParseResult<string>;
+}
+export declare const string: () => Schema<string>;

package/dist/core/string.js

@@ -0,0 +1,16 @@
+import { Schema } from '../types/schema.js';
+import { isString } from '../utils/guards.js';
+export class InuString extends Schema {
+    constructor() {
+        super();
+    }
+    parse(value) {
+        if (isString(value)) {
+            return { success: true, value };
+        }
+        return { success: false, error: 'String Expected' };
+    }
+}
+export const string = () => {
+    return new InuString();
+};

package/dist/core/tuple.d.ts

@@ -0,0 +1,11 @@
+import { Schema, ParseResult } from '../types/schema.js';
+export declare class InuTuple<T extends unknown[]> extends Schema<T> {
+    private schemas;
+    constructor(schemas: {
+        [K in keyof T]: Schema<T[K]>;
+    });
+    parse(value: unknown): ParseResult<T>;
+}
+export declare function tuple<T extends unknown[]>(schemas: {
+    [K in keyof T]: Schema<T[K]>;
+}): Schema<T>;

package/dist/core/tuple.js

@@ -0,0 +1,37 @@
+import { Schema } from '../types/schema.js';
+import { isArray } from '../utils/guards.js';
+export class InuTuple extends Schema {
+    constructor(schemas) {
+        super();
+        this.schemas = schemas;
+    }
+    parse(value) {
+        if (!isArray(value)) {
+            return {
+                success: false,
+                error: 'Expected an array for tuple validation',
+            };
+        }
+        if (value.length !== this.schemas.length) {
+            return {
+                success: false,
+                error: `Tuple length mismatch: expected ${this.schemas.length} items, but got ${value.length}`,
+            };
+        }
+        const validatedTuple = [];
+        for (let i = 0; i < this.schemas.length; i++) {
+            const result = this.schemas[i].parse(value[i]);
+            if (!result.success) {
+                return {
+                    success: false,
+                    error: `Invalid tuple item at index ${i}: ${result.error}`,
+                };
+            }
+            validatedTuple[i] = result.value;
+        }
+        return { success: true, value: validatedTuple };
+    }
+}
+export function tuple(schemas) {
+    return new InuTuple(schemas);
+}

package/dist/core/union.d.ts

@@ -0,0 +1,9 @@
+import { Schema, ParseResult } from '../types/schema.js';
+export declare class InuUnion<T> extends Schema<T> {
+    private schemas;
+    constructor(schemas: Schema<T>[]);
+    parse(value: unknown): ParseResult<T>;
+}
+export declare function union<T extends unknown[]>(schemas: [...{
+    [K in keyof T]: Schema<T[K]>;
+}]): Schema<T[number]>;

package/dist/core/union.js

@@ -0,0 +1,25 @@
+import { Schema } from '../types/schema.js';
+export class InuUnion extends Schema {
+    constructor(schemas) {
+        super();
+        this.schemas = schemas;
+    }
+    parse(value) {
+        const errors = [];
+        for (const schema of this.schemas) {
+            const result = schema.parse(value);
+            if (result.success) {
+                return result;
+            }
+            errors.push(result.error || 'Invalid input');
+        }
+        return {
+            success: false,
+            error: `Union error: Data does not match any of the allowed types. 
+Sub-errors: [${errors.join(' | ')}]`,
+        };
+    }
+}
+export function union(schemas) {
+    return new InuUnion(schemas);
+}

package/dist/index.d.ts

@@ -0,0 +1,19 @@
+import { number } from './core/number.js';
+import { boolean } from './core/boolean.js';
+import { object } from './core/object.js';
+import { array } from './core/array.js';
+import { tuple } from './core/tuple.js';
+import { union } from './core/union.js';
+import { literal } from './core/literal.js';
+export declare const inu: {
+    string: () => import("./types/schema.js").Schema<string>;
+    number: typeof number;
+    boolean: typeof boolean;
+    object: typeof object;
+    array: typeof array;
+    tuple: typeof tuple;
+    union: typeof union;
+    literal: typeof literal;
+};
+export type { Schema, ParseResult } from './types/schema.js';
+export type { ShapeToType } from './core/object.js';

package/dist/index.js

@@ -0,0 +1,18 @@
+import { string } from './core/string.js';
+import { number } from './core/number.js';
+import { boolean } from './core/boolean.js';
+import { object } from './core/object.js';
+import { array } from './core/array.js';
+import { tuple } from './core/tuple.js';
+import { union } from './core/union.js';
+import { literal } from './core/literal.js';
+export const inu = {
+    string,
+    number,
+    boolean,
+    object,
+    array,
+    tuple,
+    union,
+    literal,
+};

package/dist/types/schema.d.ts

@@ -0,0 +1,15 @@
+export type ParseResult<T> = {
+    success: true;
+    value: T;
+} | {
+    success: false;
+    error: string;
+};
+export declare abstract class Schema<T> {
+    abstract parse(value: unknown): ParseResult<T>;
+    optional(): Schema<T | undefined>;
+    nullable(): Schema<T | null>;
+}
+export type NestedShape = {
+    [k: string]: Schema<unknown> | NestedShape;
+};

package/dist/types/schema.js

@@ -0,0 +1,37 @@
+export class Schema {
+    optional() {
+        if (this instanceof InuOptional) {
+            return this;
+        }
+        return new InuOptional(this);
+    }
+    nullable() {
+        if (this instanceof InuNullable)
+            return this;
+        return new InuNullable(this);
+    }
+}
+class InuOptional extends Schema {
+    constructor(innerSchema) {
+        super();
+        this.innerSchema = innerSchema;
+    }
+    parse(value) {
+        if (value === undefined) {
+            return { success: true, value: undefined };
+        }
+        return this.innerSchema.parse(value);
+    }
+}
+class InuNullable extends Schema {
+    constructor(innerSchema) {
+        super();
+        this.innerSchema = innerSchema;
+    }
+    parse(value) {
+        if (value === null) {
+            return { success: true, value: null };
+        }
+        return this.innerSchema.parse(value);
+    }
+}

package/dist/utils/guards.d.ts

@@ -0,0 +1,7 @@
+import { Schema } from '../types/schema.js';
+export declare function isSchema(value: unknown): value is Schema<unknown>;
+export declare function isRecord(value: unknown): value is Record<string, unknown>;
+export declare function isString(value: unknown): value is string;
+export declare function isNumber(value: unknown): value is number;
+export declare function isBoolean(value: unknown): value is boolean;
+export declare function isArray(value: unknown): value is unknown[];

package/dist/utils/guards.js

@@ -0,0 +1,21 @@
+export function isSchema(value) {
+    return (typeof value === 'object' &&
+        value !== null &&
+        'parse' in value &&
+        typeof value.parse === 'function');
+}
+export function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+export function isString(value) {
+    return typeof value === 'string';
+}
+export function isNumber(value) {
+    return typeof value === 'number' && !isNaN(value);
+}
+export function isBoolean(value) {
+    return typeof value === 'boolean';
+}
+export function isArray(value) {
+    return Array.isArray(value);
+}

package/package.json

@@ -0,0 +1,24 @@
+{
+  "name": "inu-light",
+  "version": "1.0.0",
+  "description": "A ultra-lightweight TypeScript validation library with zero dependencies.",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "type": "module",
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "prepublishOnly": "npm run build"
+  },
+  "keywords": [
+    "validation",
+    "typescript",
+    "schema",
+    "lightweight",
+    "zod-like"
+  ],
+  "author": "Seu Nome",
+  "license": "MIT"
+}