typebad 1.0.0-alpha.0

package/dist/Type.d.ts

@@ -0,0 +1,53 @@
+export type InferType<T> = T extends Type<infer U> ? U : never;
+export type InferSchema<T extends TypeSchema> = Simplify<{
+    [K in keyof T as undefined extends InferType<T[K]> ? never : unknown extends InferType<T[K]> ? never : K]: InferType<T[K]>;
+} & {
+    [K in keyof T as undefined extends InferType<T[K]> ? unknown extends InferType<T[K]> ? never : K : never]?: InferType<T[K]>;
+}>;
+type Simplify<T> = {
+    [K in keyof T]: T[K];
+} & {};
+export type TypeSchema = Record<string, Type<any>>;
+type NormalizedValue<T> = T extends undefined ? Exclude<T, undefined> : T extends (infer U)[] ? NormalizedValue<U>[] : T extends Record<string, any> ? {
+    [K in keyof T]-?: NormalizedValue<T[K]>;
+} : T;
+export type NormalizedType<T extends Type<any>> = NormalizedValue<InferType<T>>;
+export interface ValidateOptions {
+    allowUnknownProperties: boolean;
+}
+export interface NormalizeOptions {
+    allowUnknownProperties: boolean;
+}
+export declare class Type<T> {
+    private matcher;
+    private validator;
+    private normalizer;
+    private onValidateCallback;
+    private onNormalizeCallback;
+    private allowMissingProperty;
+    onValidate(callback: (value: T) => void): Type<T>;
+    onNormalize(callback: (value: NormalizedValue<T>) => void): Type<T>;
+    private validate;
+    private normalize;
+    extend(matcher: (value: T) => boolean): Type<T>;
+    default(defaultValue: T | (() => T)): Type<T | undefined>;
+    optional(): Type<T | null | undefined>;
+    static match<T>(matcher: (value: T) => boolean): Type<T>;
+    static enum<const V extends readonly (string | number)[]>(values: V): Type<V[number]>;
+    static array<T extends Type<any>>(type: T): Type<InferType<T>[]>;
+    static schema<S extends TypeSchema>(schema: S): Type<InferSchema<S>>;
+    static lazy<T extends Type<any>>(callback: () => T): T;
+    static validate(type: Type<any>, value: any, options?: Partial<ValidateOptions>): void;
+    static normalize<T extends Type<any>>(type: T, value: any, options?: Partial<NormalizeOptions>): NormalizedType<T>;
+    private static getValueError;
+    private static getUnknownPropertyError;
+    private static getMissingPropertyError;
+    static readonly Null: Type<null>;
+    static readonly String: Type<string>;
+    static readonly Boolean: Type<boolean>;
+    static readonly Number: Type<number>;
+    static readonly Integer: Type<number>;
+    static readonly Float: Type<number>;
+    static readonly Date: Type<Date>;
+}
+export {};

package/dist/Type.js

@@ -0,0 +1,214 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Type = void 0;
+class Type {
+    constructor() {
+        this.matcher = () => true;
+        this.validator = () => true;
+        this.normalizer = (value) => value;
+        this.onValidateCallback = null;
+        this.onNormalizeCallback = null;
+        this.allowMissingProperty = false;
+    }
+    onValidate(callback) {
+        this.onValidateCallback = callback;
+        return this;
+    }
+    onNormalize(callback) {
+        this.onNormalizeCallback = callback;
+        return this;
+    }
+    validate(value, propertyName, options) {
+        if (!this.matcher(value) || !this.validator(value, propertyName, options)) {
+            throw new Error(Type.getValueError(propertyName));
+        }
+        this.onValidateCallback?.(value);
+    }
+    normalize(value, propertyName, options) {
+        if (!this.matcher(value)) {
+            throw new Error(Type.getValueError(propertyName));
+        }
+        const normalizedValue = this.normalizer(value, propertyName, options) ?? null;
+        this.onNormalizeCallback?.(normalizedValue);
+        return normalizedValue;
+    }
+    extend(matcher) {
+        const type = new Type();
+        type.matcher = (value) => {
+            return this.matcher(value) && matcher(value);
+        };
+        type.validator = this.validator;
+        type.normalizer = this.normalizer;
+        type.allowMissingProperty = this.allowMissingProperty;
+        return type;
+    }
+    default(defaultValue) {
+        const type = new Type();
+        type.matcher = (value) => {
+            return value === undefined || this.matcher(value);
+        };
+        type.validator = (value, propertyName, options) => {
+            if (value === undefined) {
+                return true;
+            }
+            return this.validator(value, propertyName, options);
+        };
+        type.normalizer = (value, propertyName, options) => {
+            if (value === undefined) {
+                const tmpValue = typeof defaultValue === "function"
+                    ? defaultValue()
+                    : defaultValue;
+                return this.normalizer(tmpValue, propertyName, options);
+            }
+            return this.normalizer(value, propertyName, options);
+        };
+        type.allowMissingProperty = true;
+        return type;
+    }
+    optional() {
+        const type = new Type();
+        type.matcher = (value) => {
+            return value === null || value === undefined || this.matcher(value);
+        };
+        type.validator = (value, propertyName, options) => {
+            if (value === null || value === undefined) {
+                return true;
+            }
+            return this.validator(value, propertyName, options);
+        };
+        type.normalizer = (value, propertyName, options) => {
+            if (value === null || value === undefined) {
+                return null;
+            }
+            return this.normalizer(value, propertyName, options);
+        };
+        type.allowMissingProperty = true;
+        return type;
+    }
+    static match(matcher) {
+        const type = new Type();
+        type.matcher = matcher;
+        return type;
+    }
+    static enum(values) {
+        const type = new Type();
+        type.matcher = (value) => {
+            return values.includes(value);
+        };
+        return type;
+    }
+    static array(type) {
+        const arrayType = new Type();
+        arrayType.matcher = (value) => {
+            return Array.isArray(value);
+        };
+        arrayType.validator = (value, propertyName, options) => {
+            value.forEach((tmpValue, i) => {
+                const tmpPropertyName = `${propertyName ?? ""}[${i}]`;
+                type.validate(tmpValue, tmpPropertyName, options);
+            });
+            return true;
+        };
+        arrayType.normalizer = (value, propertyName, options) => {
+            return value.map((tmpValue, i) => {
+                const tmpPropertyName = `${propertyName ?? ""}[${i}]`;
+                return type.normalize(tmpValue, tmpPropertyName, options);
+            });
+        };
+        return arrayType;
+    }
+    static schema(schema) {
+        const type = new Type();
+        type.matcher = (value) => {
+            return (value !== null && !Array.isArray(value) && typeof value === "object");
+        };
+        type.validator = (value, propertyName, options) => {
+            if (!options.allowUnknownProperties) {
+                for (const key in value) {
+                    const tmpPropertyName = propertyName !== null ? `${propertyName}.${key}` : key;
+                    if (!(key in schema)) {
+                        throw new Error(this.getUnknownPropertyError(tmpPropertyName));
+                    }
+                }
+            }
+            for (const key in schema) {
+                const tmpPropertyName = propertyName !== null ? `${propertyName}.${key}` : key;
+                const tmpType = schema[key];
+                const tmpValue = value[key];
+                if (!(key in value) && !tmpType.allowMissingProperty) {
+                    throw new Error(this.getMissingPropertyError(tmpPropertyName));
+                }
+                tmpType.validate(tmpValue, tmpPropertyName, options);
+            }
+            return true;
+        };
+        type.normalizer = (value, propertyName, options) => {
+            const objectValue = {};
+            if (!options.allowUnknownProperties) {
+                for (const key in value) {
+                    const tmpPropertyName = propertyName !== null ? `${propertyName}.${key}` : key;
+                    if (!(key in schema)) {
+                        throw new Error(this.getUnknownPropertyError(tmpPropertyName));
+                    }
+                }
+            }
+            for (const key in schema) {
+                const tmpPropertyName = propertyName !== null ? `${propertyName}.${key}` : key;
+                const tmpType = schema[key];
+                const tmpValue = value[key];
+                if (!(key in value) && !tmpType.allowMissingProperty) {
+                    throw new Error(this.getMissingPropertyError(tmpPropertyName));
+                }
+                objectValue[key] = tmpType.normalize(tmpValue, tmpPropertyName, options);
+            }
+            return objectValue;
+        };
+        return type;
+    }
+    static lazy(callback) {
+        const type = new Type();
+        type.matcher = (value) => {
+            const tmpType = callback();
+            return tmpType.matcher(value);
+        };
+        type.validator = (value, propertyName, options) => {
+            const tmpType = callback();
+            return tmpType.validator(value, propertyName, options);
+        };
+        type.normalizer = (value, propertyName, options) => {
+            const tmpType = callback();
+            return tmpType.normalizer(value, propertyName, options);
+        };
+        return type;
+    }
+    static validate(type, value, options = {}) {
+        const tmpOptions = {
+            allowUnknownProperties: options.allowUnknownProperties ?? false,
+        };
+        type.validate(value, null, tmpOptions);
+    }
+    static normalize(type, value, options = {}) {
+        const tmpOptions = {
+            allowUnknownProperties: options.allowUnknownProperties ?? false,
+        };
+        return type.normalize(value, null, tmpOptions);
+    }
+    static getValueError(propertyName) {
+        return ("Invalid value" +
+            (propertyName !== null ? ` for "${propertyName}".` : "."));
+    }
+    static getUnknownPropertyError(propertyName) {
+        return `Unknown property "${propertyName}".`;
+    }
+    static getMissingPropertyError(propertyName) {
+        return `Missing property "${propertyName}".`;
+    }
+}
+exports.Type = Type;
+Type.Null = Type.match((value) => value === null);
+Type.String = Type.match((value) => typeof value === "string");
+Type.Boolean = Type.match((value) => typeof value === "boolean");
+Type.Number = Type.match((value) => typeof value === "number");
+Type.Integer = Type.match((value) => typeof value === "number" && Number.isInteger(value));
+Type.Float = Type.match((value) => typeof value === "number" && !Number.isInteger(value));
+Type.Date = Type.match((value) => value instanceof Date && !isNaN(value.getTime()));

package/dist/index.d.ts

@@ -0,0 +1 @@
+export * from "./Type";

package/dist/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./Type"), exports);

package/package.json

@@ -0,0 +1,20 @@
+{
+  "name": "typebad",
+  "version": "1.0.0-alpha.0",
+  "description": "Efficient type validator for complex structures.",
+  "main": "dist/index.js",
+  "scripts": {
+    "clean": "rm -rf dist",
+    "build": "npm run clean && tsc",
+    "prepare": "npm run build"
+  },
+  "keywords": [
+    "type",
+    "validation",
+    "json"
+  ],
+  "license": "MIT",
+  "devDependencies": {
+    "typescript": "^5.9.3"
+  }
+}