justus 0.0.1 → 0.0.5

package/{dist/index.d.ts → index.d.ts}

@@ -1,3 +1,5 @@
+/// <reference types="node" />
+
 /**
  * An interface defining whether a `Schema` should include additional
  * properties, and the `Validator` used to validate them.
@@ -31,17 +33,37 @@ export declare class AllOfValidator<A extends UnionArguments> extends Validator<
 export declare const allowAdditionalProperties: typeof _allowAdditionalProperties & AdditionalProperties<Validator<any>>;
 
 /** Internal definition of `allowAdditionalProperties(...)` */
-declare function _allowAdditionalProperties(): AdditionalProperties<Validator<any>>;
+export declare function _allowAdditionalProperties(): AdditionalProperties<Validator<any>>;
 
-declare function _allowAdditionalProperties(allow: true): AdditionalProperties<Validator<any>>;
+export declare function _allowAdditionalProperties(allow: true): AdditionalProperties<Validator<any>>;
 
-declare function _allowAdditionalProperties(allow: false): AdditionalProperties<false>;
+export declare function _allowAdditionalProperties(allow: false): AdditionalProperties<false>;
 
-declare function _allowAdditionalProperties<V extends Validation>(validation: V): AdditionalProperties<Validator<InferValidation<V>>>;
+export declare function _allowAdditionalProperties<V extends Validation>(validation: V): AdditionalProperties<Validator<InferValidation<V>>>;
 
 /** The `Validator` validating _anything_. */
 export declare const any: AnyValidator;
 
+/** Basic validator for `Array` instances. */
+export declare class AnyArrayValidator<T = any> extends Validator<T[]> {
+    validate(value: unknown, options: ValidationOptions): T[];
+}
+
+/** A `Validator` validating any `number`. */
+export declare class AnyNumberValidator extends Validator<number> {
+    validate(value: unknown): number;
+}
+
+/** A `Validator` validating any `object`. */
+export declare class AnyObjectValidator extends Validator<Record<string, any>> {
+    validate(value: unknown): Record<string, any>;
+}
+
+/** A `Validator` validating any `string`. */
+export declare class AnyStringValidator extends Validator<string> {
+    validate(value: unknown): string;
+}
+
 /** A `Validator` validating _anything_. */
 export declare class AnyValidator extends Validator<any> {
     validate(value: unknown): any;
@@ -50,12 +72,12 @@ export declare class AnyValidator extends Validator<any> {
 /** Validate `Array`s. */
 export declare const array: typeof _array & Iterable<TupleRestParameter<any[]>>;
 
-declare function _array(): Validator<any[]>;
+export declare function _array(): Validator<any[]>;
 
-declare function _array<V extends Validation>(constraints: ArrayConstraints<V>): ArrayValidator<InferValidation<V>>;
+export declare function _array<V extends Validation>(constraints: ArrayConstraints<V>): ArrayValidator<InferValidation<V>>;
 
 /** Constraints to validate an `Array` with. */
-declare interface ArrayConstraints<V extends Validation> {
+export declare interface ArrayConstraints<V extends Validation> {
     /** The _maximum_ number of elements a valid `Array`: `value.length <= maxItems` */
     maxItems?: number;
     /** The _minimum_ number of elements a valid `Array`: `value.length >= minItems` */
@@ -69,9 +91,7 @@ declare interface ArrayConstraints<V extends Validation> {
 /** Validate `Array`s containing only the specified elements. */
 export declare function arrayOf<V extends Validation>(validation: V): ArrayValidator<InferValidation<V>>;
 
-/**
- * A validator for `Array` instances.
- */
+/** A validator for `Array` instances with constraints. */
 export declare class ArrayValidator<T> extends Validator<T[]> {
     readonly maxItems: number;
     readonly minItems: number;
@@ -100,6 +120,25 @@ export declare class BooleanValidator extends Validator<boolean> {
     validate(value: unknown): boolean;
 }
 
+/** Constraints to validate a `number` with extra branding information. */
+export declare interface BrandedNumberConstraints<B extends string> extends NumberConstraints {
+    /** The _brand_ of the string (will generate a `__brand_${B}` type property */
+    brand: B;
+}
+
+/** Constraints to validate a `string` with extra branding information. */
+export declare interface BrandedStringConstraints<B extends string> extends StringConstraints {
+    /** The _brand_ of the string (will generate a `__brand_${B}` type property */
+    brand: B;
+}
+
+/** Utility type to infer primitive branding according to a string */
+export declare type Branding<S extends string> = {
+    [key in keyof {
+        __brand: never;
+    } as `__brand_${S}`]: never;
+};
+
 /**
  * Mark a `Schema` property as both _optional_ and _read only_.
  */
@@ -108,7 +147,7 @@ export declare interface CombinedModifier<V extends Validator = Validator> exten
     readonly: true;
 }
 
-declare type CombineModifiers<M1 extends Modifier, M2 extends Modifier> = M1 extends ReadonlyModifier ? M2 extends ReadonlyModifier<infer V> ? ReadonlyModifier<V> : M2 extends OptionalModifier<infer V> ? CombinedModifier<V> : never : M1 extends OptionalModifier ? M2 extends ReadonlyModifier<infer V> ? CombinedModifier<V> : M2 extends OptionalModifier<infer V> ? OptionalModifier<V> : never : never;
+export declare type CombineModifiers<M1 extends Modifier, M2 extends Modifier> = M1 extends ReadonlyModifier ? M2 extends ReadonlyModifier<infer V> ? ReadonlyModifier<V> : M2 extends OptionalModifier<infer V> ? CombinedModifier<V> : never : M1 extends OptionalModifier ? M2 extends ReadonlyModifier<infer V> ? CombinedModifier<V> : M2 extends OptionalModifier<infer V> ? OptionalModifier<V> : never : never;
 
 /** Validate _constants_. */
 export declare function constant<T extends string | number | boolean | null>(constant: T): Validator<T>;
@@ -123,12 +162,12 @@ export declare class ConstantValidator<T extends string | number | boolean | nul
 /** Validate dates and convert them to `Date` instances. */
 export declare const date: typeof _date & Iterable<TupleRestParameter<Date>>;
 
-declare function _date(): DateValidator;
+export declare function _date(): DateValidator;
 
-declare function _date(constraints: DateConstraints): DateValidator;
+export declare function _date(constraints: DateConstraints): DateValidator;
 
 /** Constraints to validate a `Date` with. */
-declare interface DateConstraints {
+export declare interface DateConstraints {
     /** The format for dates, an _ISO date_ (RFC 3339) or a numeric timestamp */
     format?: 'iso' | 'timestamp';
     /** The earliest value a date can have */
@@ -153,32 +192,32 @@ export declare class DateValidator extends Validator<Date> {
  */
 export declare function getValidator(validation?: Validation): Validator;
 
-declare type InferAllOfValidationType<A extends UnionArguments> = A extends readonly [infer First, ...infer Rest] ? First extends Validation ? Rest extends UnionArguments ? InferValidation<First> & InferOneOfValidationType<Rest> : InferValidation<First> : never : never;
+export declare type InferAllOfValidationType<A extends UnionArguments> = A extends readonly [infer First, ...infer Rest] ? First extends Validation ? Rest extends UnionArguments ? InferValidation<First> & InferOneOfValidationType<Rest> : InferValidation<First> : never : never;
 
 /** Infer the type of  _read only_ **and** _optional_ `Schema` properties  */
-declare type InferCombinedModifiers<S extends Schema> = {
+export declare type InferCombinedModifiers<S extends Schema> = {
     readonly [key in keyof S as key extends string ? S[key] extends CombinedModifier ? key : never : never]?: S[key] extends CombinedModifier<infer V> ? InferValidation<V> : never;
 };
 
 /** Ensure that we properly type `never` properties */
-declare type InferNever<S extends Schema> = {
+export declare type InferNever<S extends Schema> = {
     [key in keyof S as key extends string ? S[key] extends typeof never ? key : never : never]: never;
 };
 
-declare type InferOneOfValidationType<A extends UnionArguments> = A extends readonly [infer First, ...infer Rest] ? First extends Validation ? Rest extends UnionArguments ? InferValidation<First> | InferOneOfValidationType<Rest> : InferValidation<First> : never : never;
+export declare type InferOneOfValidationType<A extends UnionArguments> = A extends readonly [infer First, ...infer Rest] ? First extends Validation ? Rest extends UnionArguments ? InferValidation<First> | InferOneOfValidationType<Rest> : InferValidation<First> : never : never;
 
 /** Infer the type of _optional_ `Schema` properties  */
-declare type InferOptionalModifiers<S extends Schema> = {
+export declare type InferOptionalModifiers<S extends Schema> = {
     [key in keyof S as key extends string ? S[key] extends ReadonlyModifier<Validator> ? never : S[key] extends OptionalModifier<Validator> ? key : never : never]?: S[key] extends OptionalModifier<infer V> ? InferValidation<V> : never;
 };
 
 /** Infer the type of _read only_ `Schema` properties  */
-declare type InferReadonlyModifiers<S extends Schema> = {
+export declare type InferReadonlyModifiers<S extends Schema> = {
     readonly [key in keyof S as key extends string ? S[key] extends OptionalModifier<Validator> ? never : S[key] extends ReadonlyModifier<Validator> ? key : never : never]: S[key] extends ReadonlyModifier<infer V> ? InferValidation<V> : never;
 };
 
 /** Infer the type of keys associated with `Validation`s */
-declare type InferRequired<S extends Schema> = {
+export declare type InferRequired<S extends Schema> = {
     [key in keyof S as key extends string ? S[key] extends Validation ? key : never : never]: S[key] extends Validation ? InferValidation<S[key]> : never;
 };
 
@@ -215,7 +254,7 @@ export declare type InferValidation<V> = V extends Validation ? V extends {
 } ? A0 extends [] ? R0 : A1 extends [] ? R1 : A2 extends [] ? R2 : A3 extends [] ? R3 : A4 extends [] ? R4 : A5 extends [] ? R5 : A6 extends [] ? R6 : A7 extends [] ? R7 : A8 extends [] ? R8 : A9 extends [] ? R9 : never : V extends Validator<infer T> ? T : V extends Tuple ? InferTuple<V> : V extends Schema ? InferSchema<V> : V extends boolean ? V : V extends number ? V : V extends string ? V : V extends null ? V : never : never;
 
 /** Infer the type validated by a `Validation` or `TupleRestParameter` */
-declare type InferValidationOrTupleRest<T> = T extends TupleRestParameter<infer X> ? X : T extends Validation ? InferValidation<T> : never;
+export declare type InferValidationOrTupleRest<T> = T extends TupleRestParameter<infer X> ? X : T extends Validation ? InferValidation<T> : never;
 
 /** Type guard for `Modifier` instances */
 export declare function isModifier(what: any): what is Modifier<any>;
@@ -238,12 +277,16 @@ export declare const never: unique symbol;
 /** Validate `number`s. */
 export declare const number: typeof _number & Iterable<TupleRestParameter<number>>;
 
-declare function _number(): Validator<number>;
+export declare function _number(): Validator<number>;
+
+export declare function _number(constraints?: NumberConstraints): NumberValidator<number>;
+
+export declare function _number<N extends number>(constraints?: NumberConstraints): NumberValidator<N>;
 
-declare function _number<N extends number = number>(constraints?: NumberConstraints): NumberValidator<N>;
+export declare function _number<B extends string>(constraints: BrandedNumberConstraints<B>): NumberValidator<number & Branding<B>>;
 
 /** Constraints to validate a `number` with. */
-declare interface NumberConstraints {
+export declare interface NumberConstraints {
     /** The value for which a `number` must be multiple of for it to be valid */
     multipleOf?: number;
     /** The _inclusive_ maximum value for a valid `number`: `value <= maximum` */
@@ -258,7 +301,7 @@ declare interface NumberConstraints {
     allowNaN?: boolean;
 }
 
-/** A `Validator` validating `number`s. */
+/** A `Validator` validating `number`s with constaints. */
 export declare class NumberValidator<N extends number = number> extends Validator<N> {
     #private;
     readonly allowNaN: boolean;
@@ -267,22 +310,31 @@ export declare class NumberValidator<N extends number = number> extends Validato
     readonly maximum: number;
     readonly minimum: number;
     readonly multipleOf?: number;
+    readonly brand?: string;
     constructor(constraints?: NumberConstraints);
     validate(value: unknown): N;
-    static readonly PRECISION = 1000000;
 }
 
 /** Validate `object`s. */
 export declare const object: typeof _object & Iterable<TupleRestParameter<Record<string, any>>>;
 
-declare function _object(): Validator<Record<string, any>>;
+export declare function _object(): Validator<Record<string, any>>;
 
-declare function _object<S extends Schema>(schema: S): S;
+export declare function _object<S extends Schema>(schema: S): S & {
+    [Symbol.iterator](): Generator<TupleRestParameter<InferSchema<S>>>;
+};
 
-/** A `Validator` validating `object`s according to a `Schema` */
+export declare type ObjectProperty = {
+    validator: Validator;
+    readonly?: true;
+    optional?: true;
+};
+
+/** A `Validator` validating `object`s according to a `Schema`. */
 export declare class ObjectValidator<S extends Schema> extends Validator<InferSchema<S>> {
-    #private;
     readonly schema: Readonly<S>;
+    properties: Map<string, ObjectProperty | undefined>;
+    additionalProperties?: Validator;
     constructor(schema: S);
     validate(value: unknown, options: ValidationOptions): InferSchema<S>;
 }
@@ -351,12 +403,16 @@ export declare const schemaValidator: unique symbol;
 /** Validate `string`s. */
 export declare const string: typeof _string & Iterable<TupleRestParameter<string>>;
 
-declare function _string(): Validator<string>;
+export declare function _string(): Validator<string>;
+
+export declare function _string(constraints?: StringConstraints): StringValidator<string>;
+
+export declare function _string<S extends string>(constraints?: StringConstraints): StringValidator<S>;
 
-declare function _string<S extends string = string>(constraints?: StringConstraints): StringValidator<S>;
+export declare function _string<B extends string>(constraints: BrandedStringConstraints<B>): StringValidator<string & Branding<B>>;
 
 /** Constraints to validate a `string` with. */
-declare interface StringConstraints {
+export declare interface StringConstraints {
     /** The _maximum_ length of a valid `string`: `value.length <= maxLength` */
     maxLength?: number;
     /** The _minimum_ length of a valid `string`: `value.length >= minLength` */
@@ -365,15 +421,22 @@ declare interface StringConstraints {
     pattern?: RegExp;
 }
 
-/** A `Validator` validating `string`s. */
+/** A `Validator` validating `string`s with constraints. */
 export declare class StringValidator<S extends string = string> extends Validator<S> {
     readonly maxLength: number;
     readonly minLength: number;
     readonly pattern?: RegExp;
+    readonly brand?: string;
     constructor(constraints?: StringConstraints);
     validate(value: unknown): S;
 }
 
+/**
+ * Validate a _value_ using the specified `Validation`, automatically stripping
+ * additional properties (but not forbidden ones).
+ */
+export declare function strip<V extends Validation>(validation: V, value: any, options?: ValidateOptions): InferValidation<V>;
+
 /**
  * A `Tuple` is defined to be an array of `Validation` or `TupleRest`
  */
@@ -382,6 +445,11 @@ export declare type Tuple = readonly (Validation | TupleRestParameter)[];
 /** Validate _tuples_. */
 export declare function tuple<T extends Tuple>(tuple: T): Validator<InferTuple<T>>;
 
+export declare interface TupleMember {
+    single: boolean;
+    validator: Validator;
+}
+
 /**
  * The `TupleRestParameter` defines a tuple member that can occur several
  * times while validating an array.
@@ -401,15 +469,78 @@ export declare type TupleRestParameter<T = any> = {
 
 /** A `Validator` for _tuples_. */
 export declare class TupleValidator<T extends Tuple> extends Validator<InferTuple<T>> {
-    #private;
+    readonly members: readonly TupleMember[];
     readonly tuple: T;
     constructor(tuple: T);
     validate(value: unknown, options: ValidationOptions): InferTuple<T>;
 }
 
-declare type UnionArguments = readonly [Validation, ...Validation[]];
+export declare type UnionArguments = readonly [Validation, ...Validation[]];
+
+/** Validate URLs and convert them to `URL` instances. */
+export declare const url: typeof _url & Iterable<TupleRestParameter<URL>>;
+
+export declare function _url(): URLValidator;
+
+export declare function _url(constraints: URLConstraints): URLValidator;
+
+/** Constraints to validate a `URL` with. */
+export declare interface URLConstraints {
+    /** Constraint to validate the `href` component of the `URL`. */
+    href?: string | Validator<string>;
+    /** Constraint to validate the `origin` component of the `URL`. */
+    origin?: string | Validator<string>;
+    /** Constraint to validate the `protocol` component of the `URL`. */
+    protocol?: string | Validator<string>;
+    /** Constraint to validate the `username` component of the `URL`. */
+    username?: string | Validator<string>;
+    /** Constraint to validate the `password` component of the `URL`. */
+    password?: string | Validator<string>;
+    /** Constraint to validate the `host` (`hostname:port`) component of the `URL`. */
+    host?: string | Validator<string>;
+    /** Constraint to validate the `hostname` component of the `URL`. */
+    hostname?: string | Validator<string>;
+    /** Constraint to validate the `port` component of the `URL`. */
+    port?: string | Validator<string>;
+    /** Constraint to validate the `pathname` component of the `URL`. */
+    pathname?: string | Validator<string>;
+    /** Constraint to validate the `search` component of the `URL` as a string. */
+    search?: string | Validator<string>;
+    /** Constraint to validate the `hash` component of the `URL`. */
+    hash?: string | Validator<string>;
+    /**
+     * Schema used to validate the `searchParams` component of the `URL`.
+     *
+     * The `searchParams` will be normalized in a `Record<string, string>`, where
+     * only the _first_ value associated with a search parameter will be checked.
+     */
+    searchParams?: Schema;
+}
+
+/** A `Validator` validating URLs and converting them to `URL` instances. */
+export declare class URLValidator extends Validator<URL> {
+    readonly href?: Validator<string>;
+    readonly origin?: Validator<string>;
+    readonly protocol?: Validator<string>;
+    readonly username?: Validator<string>;
+    readonly password?: Validator<string>;
+    readonly host?: Validator<string>;
+    readonly hostname?: Validator<string>;
+    readonly port?: Validator<string>;
+    readonly pathname?: Validator<string>;
+    readonly search?: Validator<string>;
+    readonly hash?: Validator<string>;
+    readonly searchParams?: ObjectValidator<Schema>;
+    constructor(constraints?: URLConstraints);
+    validate(value: unknown): URL;
+}
 
-/** Validate a _value_ using the specified `Validation` */
+/**
+ * Validate a _value_ using the specified `Validation`.
+ *
+ * By default additional and forbidden properties will _not_ be stripped and
+ * reported as an error.
+ */
 export declare function validate<V extends Validation>(validation: V, value: any, options?: ValidateOptions): InferValidation<V>;
 
 /** Options for `validate` */
@@ -465,7 +596,7 @@ export declare class ValidationErrorBuilder {
      * @param key - The key in an object, or index in an array where the
      *              vaildation error was encountered
      */
-    record(error: any, key?: string | number): this;
+    record(error: any, ...key: (string | number)[]): this;
     /**
      * Assert there are no validation errors and return the specified value, or
      * throw a `ValidationError` combining all errors
@@ -475,7 +606,7 @@ export declare class ValidationErrorBuilder {
     assert<T>(value: T): T;
 }
 
-declare type ValidationErrors = {
+export declare type ValidationErrors = {
     path: (string | number)[];
     message: string;
 }[];

package/package.json

@@ -1,12 +1,22 @@
 {
   "name": "justus",
-  "version": "0.0.1",
+  "version": "0.0.5",
   "description": "A JavaScript validation library, with types!",
-  "main": "dist/index.cjs",
-  "types": "dist/index.d.ts",
-  "module": "dist/index.mjs",
+  "main": "./dist/index.js",
+  "module": "./dist/index.mjs",
+  "exports": {
+    ".": {
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.js"
+    },
+    "./dts-generator": {
+      "import": "./dist/dts-generator.mjs",
+      "require": "./dist/dts-generator.js"
+    }
+  },
+  "types": "./index.d.ts",
   "scripts": {
-    "build": "build.sh",
+    "build": "./build.sh",
     "dev": "nodemon -e ts -x build.sh -w src -w test -w test-d",
     "lint": "eslint src test test-d",
     "prepare": "patch -N -p0 -i .nyc.patch || true"
@@ -14,20 +24,21 @@
   "author": "Juit Developers <developers@juit.com>",
   "license": "MIT",
   "devDependencies": {
-    "@microsoft/api-extractor": "^7.18.19",
-    "@types/chai": "^4.2.22",
-    "@types/mocha": "^9.0.0",
-    "@typescript-eslint/eslint-plugin": "^5.5.0",
-    "@typescript-eslint/parser": "^5.5.0",
-    "chai": "^4.3.4",
-    "esbuild": "^0.14.1",
-    "eslint": "^8.3.0",
+    "@microsoft/api-extractor": "^7.19.5",
+    "@types/chai": "^4.3.0",
+    "@types/mocha": "^9.1.0",
+    "@types/node": "~16.11.26",
+    "@typescript-eslint/eslint-plugin": "^5.15.0",
+    "@typescript-eslint/parser": "^5.15.0",
+    "chai": "^4.3.6",
+    "esbuild": "^0.14.27",
+    "eslint": "^8.11.0",
     "eslint-config-google": "^0.14.0",
-    "mocha": "^9.1.3",
+    "mocha": "^9.2.2",
     "nodemon": "^2.0.15",
     "nyc": "^15.1.0",
-    "tsd": "^0.19.0",
-    "typescript": "^4.5.2"
+    "tsd": "^0.19.1",
+    "typescript": "^4.6.2"
   },
   "directories": {
     "test": "test"