boubiyeah

validation.ts

var __assign = (this && this.__assign) || function () {

    __assign = Object.assign || function(t) {

        for (var s, i = 1, n = arguments.length; i < n; i++) {

            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))

    return __assign.apply(this, arguments);

Object.defineProperty(exports, "__esModule", { value: true });

exports.undefined = exports.null = exports.errorDebugString = exports.isoDate = exports.recursion = exports.optional = exports.union = exports.intersection = exports.literal = exports.dictionary = exports.keyof = exports.object = exports.tuple = exports.array = exports.boolean = exports.number = exports.string = exports.is = exports.snakeCaseTransformation = exports.getContext = exports.typeFailure = exports.failure = exports.success = exports.isOk = exports.Err = exports.Ok = void 0;

        return this.flatMap(function (v) { return Ok(fn(v)); });

        return this.flatMap(function (v) { return fn(v) ? Ok(v) : Err("filter error: " + pretty(v) + "\""); });

        return this.transform(function (r) { return isOk(r) ? fn(r.value) : r; });

        return Object.assign({}, validatorMethods, {

            validate: function (v, config, c) {

                if (config === void 0) { config = defaultConfig; }

                if (c === void 0) { c = rootContext; }

                var validated = validator.validate(v, config, c);

                var transformed = fn(validated);

                    return success(transformed.value);

                var error = transformed.errors;

                if (typeof error === 'string')

                    return failure(c, error);

    return { type: 'error', errors: errors };

    return Err([{ context: context, message: message }]);

function typeFailure(value, context, expectedType) {

    var message = "Expected " + expectedType + ", got " + valueType;

    return (parent ? parent + " / " + name : name);

var upperThenLower = /([A-Z]+)([A-Z][a-z])/g;

var lowerThenUpper = /([a-z\\\\d])([A-Z])/g;

exports.snakeCaseTransformation = function (key) {

        .replace(upperThenLower, '$1_$2')

        .replace(lowerThenUpper, '$1_$2')

    return isOk(validator.validate(value));

    var Self = __assign(__assign({}, validatorMethods), { validate: function (v, config, c) {

    var Self = __assign({ validate: function (v, config, c) {

            if (config === void 0) { config = defaultConfig; }

            if (c === void 0) { c = rootContext; }

            return Result.validate(v, config, c);

exports.isoDate = exports.string.flatMap(function (str) {

        ? Err("Expected ISO date, got: " + pretty(str))

    return JSON.stringify(value, undefined, 2);

    return errors.map(function (e) { return "At [" + e.context + "] " + e.message; }).join('\n');

exports.errorDebugString = errorDebugString;

        return this.flatMap(v => Ok(fn(v)));

        return this.flatMap(v => fn(v) ? Ok(v) : Err(`filter error: ${pretty(v)}"`));

        return this.transform(r => isOk(r) ? fn(r.value) : r);

            validate(v, config = defaultConfig, c = rootContext) {

                const validated = validator.validate(v, config, c);

                const transformed = fn(validated);

                const error = transformed.errors;

export function failure(context, message) {

export function typeFailure(value, context, expectedType) {

    const message = `Expected ${expectedType}, got ${valueType}`;

export function getContext(name, parent) {

    return (parent ? `${parent} / ${name}` : name);

const upperThenLower = /([A-Z]+)([A-Z][a-z])/g;

const lowerThenUpper = /([a-z\\\\d])([A-Z])/g;

export const snakeCaseTransformation = (key) => key

const nullValidator = Object.assign({ validate: (v, _config = defaultConfig, c = rootContext) => v === null ? success(v) : typeFailure(v, c, 'null') }, validatorMethods);

const undefinedValidator = Object.assign({ validate: (v, _config = defaultConfig, c = rootContext) => v === void 0 ? success(v) : typeFailure(v, c, 'undefined') }, validatorMethods);

export const string = Object.assign({ validate: (v, _config = defaultConfig, c = rootContext) => typeof v === 'string' ? success(v) : typeFailure(v, c, 'string') }, validatorMethods);

export const number = Object.assign({ validate: (v, _config = defaultConfig, c = rootContext) => typeof v === 'number' ? success(v) : typeFailure(v, c, 'number') }, validatorMethods);

export const boolean = Object.assign({ validate: (v, _config = defaultConfig, c = rootContext) => typeof v === 'boolean' ? success(v) : typeFailure(v, c, 'boolean') }, validatorMethods);

    return Object.assign({ validate(v, config = defaultConfig, c = rootContext) {

                return typeFailure(v, c, 'array');

            for (let i = 0; i < v.length; i++) {

                const validation = validator.validate(item, config, getContext(String(i), c));

                    validatedArray.push(validation.value);

                    pushAll(errors, validation.errors);

            return errors.length ? Err(errors) : Ok(validatedArray);

    const Self = Object.assign(Object.assign({}, validatorMethods), { validate: (v, config = defaultConfig, c = rootContext) => Result.validate(v, config, c) });

    const Self = Object.assign({ validate: (v, config = defaultConfig, c = rootContext) => Result.validate(v, config, c) }, validatorMethods);

export const isoDate = string.flatMap(str => {

        ? Err(`Expected ISO date, got: ${pretty(str)}`)

export function errorDebugString(errors) {

    return errors.map(e => `At [${e.context}] ${e.message}`).join('\n');

export { nullValidator as null, undefinedValidator as undefined };

  "description": "Validation for TypeScript",

    "build": "npm run build-es && npm run build-commonjs",

    "build-es": "tsc validation.ts --outDir es --strict --noUnusedParameters --declaration --lib dom,es5,es6 --module es6 --target es6 --moduleResolution node",

    "build-commonjs": "tsc validation.ts --outDir commonjs --strict --noUnusedParameters --declaration --lib dom,es5,es6 --target es5",

    "pretest": "npm run build && tsc test/mocha.d.ts test/global.d.ts test/expect.d.ts test/test.ts --strict",

    "test": "mocha --recursive && node test/testCompilationErrors.js",

    "locale-test": "cross-env LANG=tr_TR npm run test"

  "homepage": "https://github.com/AlexGalays/validation.ts"

		@@ -347,7 +347,7 @@ "use strict";
		function recursion(definition) {
		var Self = __assign(__assign({}, validatorMethods), { validate: function (v, config, c) {
		var Self = __assign({ validate: function (v, config, c) {
		if (config === void 0) { config = defaultConfig; }
		if (c === void 0) { c = rootContext; }
		return Result.validate(v, config, c);
		} });
		} }, validatorMethods);
		var Result = definition(Self);
		@@ -354,0 +354,0 @@ return Result;

		@@ -252,3 +252,3 @@ //--------------------------------------
		export function recursion(definition) {
		const Self = Object.assign(Object.assign({}, validatorMethods), { validate: (v, config = defaultConfig, c = rootContext) => Result.validate(v, config, c) });
		const Self = Object.assign({ validate: (v, config = defaultConfig, c = rootContext) => Result.validate(v, config, c) }, validatorMethods);
		const Result = definition(Self);
		@@ -255,0 +255,0 @@ return Result;

		{
		"name": "validation.ts",
		"version": "0.0.28",
		"version": "0.0.29",
		"sideEffects": false,
		"description": "Validation for TypeScript",
		@@ -5,0 +6,0 @@ "license": "MIT",

Fixed alerts

Improved metrics

Worsened metrics