validno 0.1.9 → 0.1.10

package/dist/dev.js

@@ -0,0 +1,63 @@
+import { Schema } from "./Schema.js";
+const schema = new Schema({
+    wrongType: {
+        type: Number,
+        required: true,
+        title: 'Не по типу',
+        customMessage: (input) => {
+            return 'wrong type 1 msg ' + input.keyword;
+        }
+    },
+    missingKey: {
+        type: Date,
+        required: true,
+        title: 'Отсутствующий',
+        customMessage: (input) => {
+            return 'missing msg ' + input.keyword;
+        }
+    },
+    wrongRule1: {
+        type: String,
+        required: true,
+        title: 'Wrong Rule #1',
+        rules: {
+            is: 'xxx'
+        },
+        customMessage: (input) => {
+            return 'wrong rule #1 msg ' + input.keyword;
+        }
+    },
+    wrongRule2: {
+        type: String,
+        required: true,
+        title: 'Wrong Rule #2',
+        rules: {
+            lengthMin: 999
+        },
+        customMessage: (input) => {
+            return 'wrong rule #2 msg ' + input.keyword;
+        }
+    },
+    wrongRule3: {
+        type: String,
+        required: true,
+        title: 'Wrong Rule #3',
+        rules: {
+            lengthMax: 1
+        },
+        customMessage: (input) => {
+            const { keyword, value, key, title, reqs, schema, rules } = input;
+            if (keyword === 'lengthMax') {
+                return `Значение ${value} недопустимо для поля ${title}. Минимальная длина ${rules.lengthMax} символов`;
+            }
+            return 'Проверьте значение, кажется, что-то не в порядке';
+        }
+    },
+});
+const obj = {
+    wrongType: 'String',
+    wrongRule1: 'qwertyuiop',
+    wrongRule2: 'asdfghjkl',
+    wrongRule3: 'zxcvbnmasd'
+};
+console.log('finalResult', schema.validate(obj));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "validno",
-  "version": "0.1.9",
+  "version": "0.1.10",
   "description": "",
   "main": "dist/index.js",
   "scripts": {

package/src/Schema.ts

@@ -1,46 +0,0 @@
-import validate from "./validate.js"
-
-export type TSchemaItem = {
-    required: boolean,
-    type: any,
-    eachType?: any,
-    rules?: {},
-    title?: string,
-    customMessage?: Function
-}
-
-export type TSchemaInput = {
-    [key: string]: TSchemaItem | TSchemaInput
-}
-
-export const enum ESchemaFields {
-    Required = 'required',
-    Type = 'type',
-    EachType = 'eachType',
-    Rules = 'rules',
-    Title = 'title',
-    CustomMessage = 'customMessage'
-}
-
-export const defaultSchemaKeys = [
-    ESchemaFields.Required,
-    ESchemaFields.Type,
-    ESchemaFields.EachType,
-    ESchemaFields.Rules,
-    ESchemaFields.Title,
-    ESchemaFields.CustomMessage
-]
-
-export type TSchema = TSchemaInput
-
-export class Schema {
-    schema: TSchema
-
-    constructor(inputSchema: TSchema) {
-        this.schema = inputSchema
-    }
-
-    validate(data: any, keys?: string | string[]) {
-        return validate.call(this, this, data, keys)
-    }
-}

package/src/checkRules.ts

@@ -1,196 +0,0 @@
-import { ErrorKeywords } from "./constants/details.js";
-import { TSchema, TSchemaItem } from "./Schema.js";
-import _validations from "./utils/validations.js"
-
-export type TRule = {[key: string]: any}
-
-type TLengths = string | Array<any>
-
-export const rulesParams = {
-    lengthMin: {
-        allowedTypes: [String]
-    }
-}
-
-const ensureRuleHasCorrectType = (value: any, allowedTypes: any[]) => {
-    const isInAllowedList = allowedTypes.some(TYPE => {
-        const getType = (el: any) => Object.prototype.toString.call(el)
-        return getType(new TYPE()) == getType(value)
-    })
-
-    return isInAllowedList
-}
-
-const rulesFunctions: any = {
-    custom: (key: string, val: any, func: Function, extra: {schema: TSchema, input: {[key: string]: any}}) => {
-        return func(val, extra)
-    },
-    isEmail: (key: string, val: any) => {
-        return {
-            result: _validations.isEmail(val),
-            details: `Значение должно соответствовать формату name@email.ru`
-        }
-    },
-    is: (key: string, val: any, equalTo: any) => {
-        return {
-            result: _validations.is(val, equalTo),
-            details: `Значение должно быть "${equalTo}"`
-        }
-    },
-    isNot: (key: string, val: any, notEqualTo: any) => {
-        return {
-            result: _validations.isNot(val, notEqualTo),
-            details: `Значение "${notEqualTo}" недопустимо`
-        }
-    },
-    min: (key: string, val: number, min: number) => {
-        return {
-            result: _validations.isNumberGte(val, min),
-            details: "Значение не может быть меньше " + min
-        }
-    },
-    max: (key: string, val: number, max: number) => {
-        return {
-            result: _validations.isNumberLte(val, max),
-            details: "Значение не может быть больше " + max
-        }
-    },
-    minMax: (key: string, val: number, minMax: [min: number, max: number]) => {
-        const [min, max] = minMax
-        return {
-            result: _validations.isNumberGte(val, min) && _validations.isNumberLte(val, max),
-            details: `Значение должно быть в пределах ${min}-${max}`
-        }
-    },
-    length: (key: string, val: TLengths, length: number) => {
-        return {
-            result: _validations.lengthIs(val, length),
-            details: "Количество символов должно быть равным " + length
-        }
-    },
-    lengthNot: (key: string, val:  TLengths, lengthNot: number) => {
-        return {
-            result: _validations.lengthNot(val, lengthNot),
-            details: "Количество символов не должно быть равным " + lengthNot
-        }
-    },
-    lengthMinMax: (key: string, val:  TLengths, minMax: [min: number, max: number]) => {
-        const [min, max] = minMax
-
-        return {
-            result: _validations.lengthMin(val, min) && _validations.lengthMax(val, max),
-            details: `Длина должна быть от ${min} до ${max} символов`
-        }
-    },
-    lengthMin: (key: string, val:  TLengths, min: number) => {
-        ensureRuleHasCorrectType(val, rulesParams['lengthMin'].allowedTypes)
-
-        return {
-            result: _validations.lengthMin(val, min),
-            details: `Длина не может быть меньше ${min} символов`
-        }
-    },
-    lengthMax: (key: string, val:  TLengths, max: number) => {
-        return {
-            result: _validations.lengthMax(val, max),
-            details: `Длина не может быть больше ${max} символов`
-        }
-    },
-    regex: (key: string, val: any, regex: RegExp) => {
-        return {
-            result: _validations.regexTested(val, regex),
-            details: "Значение не соответствует допустимому формату"
-        }
-    },
-    enum: (key: string, value: any, allowedList: any[]) => {
-        const output = {
-            result: true,
-            details: ''
-        }
-
-        if (!Array.isArray(value)) {
-            const isCorrect = allowedList.includes(value)
-            output.result = isCorrect,
-            output.details = isCorrect ? '' : `Значение "${value}" недопустимо`
-        } else {
-            const incorrectValues: any[] = []
-            value.forEach((v: any) => !allowedList.includes(v) ? incorrectValues.push(v): {})
-            const isCorrect = incorrectValues.length === 0
-
-            output.result = isCorrect,
-            output.details = isCorrect ? '' : `Значения недопустимы: "${incorrectValues.join(', ')}"`
-        }
-
-        return output
-    }
-};
-
-type TRulesResult = {
-    ok: boolean,
-    details: string[]
-} 
-
-function checkRules (this: any, key: string, value: any, requirements: TSchemaItem, inputObj: any) {
-    const result: TRulesResult = {
-        ok: true,
-        details: []
-    };
-
-    // Значение отсутствует, но НЕ является обязательным
-    if (requirements.required !== true && value === undefined) return result
-
-    // Для этого ключа нет правил
-    if (!requirements || !requirements.rules || !Object.keys(requirements.rules).length) {
-        return result
-    }
-
-    const rules: TRule = requirements.rules
-    const title = requirements.title || key
-
-    const allResults = []
-    const allRulesKeys = Object.keys(rules)
-    
-    let i = 0;
-    while (i < allRulesKeys.length) {
-        const ruleName = allRulesKeys[i]
-
-        // Если правило, указанное для ключа, отсутствует в списке доступных
-        if (ruleName in rulesFunctions === false) {
-            i++
-            continue
-        }
-
-        const func = rulesFunctions[ruleName]
-        const args = rules[ruleName]
-
-        const result = func(key, value, args, {schema: this.schema, input: inputObj})
-        
-        if (requirements.customMessage && typeof requirements.customMessage === 'function') {
-            result.details = requirements.customMessage({
-                keyword: ruleName,
-                value: value,
-                key: key,
-                title: title,
-                reqs: requirements,
-                schema: this.schema,
-                rules: rules,
-            })
-        }
-
-        allResults.push(result)
-
-        i++;
-    }
-  
-    // If key has failed rules checks
-    const failedResults = allResults.filter(el => el.result === false)
-    
-    if (failedResults.length) {
-        result.ok = false
-        result.details = failedResults.map(el => el.details)
-    }
-
-    return result;
-  };
-
-  export default checkRules

package/src/checkType.ts

@@ -1,213 +0,0 @@
-import { ErrorKeywords } from "./constants/details.js";
-import { TSchemaInput, TSchemaItem } from "./Schema.js";
-import _validations from "./utils/validations.js";
-
-const getErrorDetails = (key: string, expectedType: any, receivedValue: any) => {
-    let receivedType = ''
-
-    if (typeof receivedValue === 'string') receivedType = 'String'
-    else if (typeof receivedValue === 'number') receivedType = 'Number'
-    else if (typeof receivedValue === 'boolean') receivedType = 'Noolean'
-    else if (receivedValue === null) receivedType = 'null'
-    else if (Array.isArray(receivedValue)) receivedType = 'Array'
-    else if (_validations.isDate(receivedValue)) receivedType = 'Date'
-    else if (_validations.isObject(receivedValue)) receivedType = 'Object'
-    else if (receivedValue === undefined) receivedType = 'undefined'
-    
-    return `Проверьте тип "${key}": ожидался ${expectedType?.name || expectedType}, получен ${receivedType || 'unknown'}`;
-};
-
-const checkTypeMultiple = (key: string, value: any, requirements: TSchemaItem | TSchemaInput, keyName = key) => {
-  const constructorNames = requirements.type.map((el:any) => String(el?.name || el))
-  
-  const result = {
-    key: keyName,
-    passed: false,
-    details: getErrorDetails(keyName, constructorNames.join('/'), value)
-  };
-
-  let i = 0;
-  while (i < requirements.type.length) {
-    const requirementsRe = { ...requirements, type: requirements.type[i]}
-    const check = checkType(key, value, requirementsRe)
-
-    if (check[0].passed === true) {
-      result.passed = true
-      result.details = 'OK'
-      return result
-    }
-
-    i++
-  }
-
-  return result
-}
-
-type TCheckTypeResult = {key: string, passed: boolean, details: string}
-
-const checkType = (key: string, value: any, requirements: TSchemaItem | TSchemaInput, keyName = key): TCheckTypeResult[] => {
-    const isNotNull = value !== null
-    const keyTitle = 'title' in requirements ? requirements.title : keyName
-    const hasCustomMessage = requirements.customMessage && typeof requirements.customMessage === 'function'
-    
-    if (value === undefined && requirements.required) {
-      return [{key: keyName, passed: false, details: `Значение "${keyName}" отсутствует`}]
-    }
-
-    let result: TCheckTypeResult[] = []
-
-    if (Array.isArray(requirements.type)) {
-      return [checkTypeMultiple(key, value, requirements)]
-    }
-
-    if (value === undefined && requirements.required !== true) {
-      result.push({
-        key: keyName,
-        passed: true,
-        details: 'OK'
-      })
-      return result
-    }
-
-    
-    const customErrDetails = hasCustomMessage ?
-      //@ts-ignore
-      requirements.customMessage({
-        keyword: ErrorKeywords.Type,
-        value: value,
-        key: keyName,
-        title: keyTitle,
-        reqs: requirements,
-        schema: null
-      }) :
-      null;
-
-    const baseErrDetails = getErrorDetails(keyName, requirements.type, value)
-  
-    const getDetails = (isOK: boolean) => isOK ? 'OK' : customErrDetails || baseErrDetails
-
-    switch (requirements.type) {
-      case 'any':
-        result.push({
-          key: keyName,
-          passed: true,
-          details: 'OK'
-        })
-        break;
-      case Number:
-        const isNumber = isNotNull && value.constructor === Number 
-
-        result.push({
-          key: keyName,
-          passed: isNumber,
-          details: getDetails(isNumber)
-        })
-
-        break;
-      case String:
-        const isString = isNotNull && value.constructor === String
-
-        result.push({
-          key: keyName,
-          passed: isString,
-          details: getDetails(isString)
-        })
-        break;
-      case Date:
-        const isDate = isNotNull && value.constructor === Date
-        const isValid = isDate && !isNaN(value.getTime())
-        const errorMsg = isValid ? getDetails(isDate) : 'Дата невалидна'
-
-        result.push({
-          key: keyName,
-          passed: isDate && isValid,
-          details: isDate && isValid ? 'OK' : errorMsg
-        })
-        break;
-      case Boolean:
-        const isBoolean = isNotNull && value.constructor === Boolean
-
-        result.push({
-          key: keyName,
-          passed: isBoolean,
-          details: isBoolean ? 'OK' : getDetails(isBoolean)
-        })
-        break;
-      case Array:
-        const isArray = isNotNull && value.constructor === Array
-
-        if (!isArray) {
-          result.push({
-              key: keyName,
-              passed: false,
-              details: getDetails(isArray)
-          });
-          
-          break;
-      }
-
-        let isEachChecked = { passed: true, details: ""}
-        
-        if ('eachType' in requirements) {
-          isEachChecked.passed = value.every((el: any) => {
-            const checkResult = checkType('each of ' + key, el, {type: requirements.eachType, required: true})
-            
-            if (!checkResult[0].passed) {
-              isEachChecked.details = checkResult[0].details
-              isEachChecked.passed = false
-            }
-
-            return true
-          })
-        }
-
-        const isOk = isArray && isEachChecked.passed
-
-        result.push({
-          key: keyName,
-          passed: isOk,
-          details: isOk ? 'OK' : !isEachChecked.passed ? isEachChecked.details : getDetails(isOk)
-        })
-
-        break;
-      case Object:
-        const isObject = _validations.isObject(value) && value.constructor === Object
-
-        result.push({
-          key: keyName,
-          passed: isObject,
-          details: isObject ? 'OK' : getDetails(isObject)
-        })
-
-        break;
-      case RegExp:
-        const isRegex = _validations.isRegex(value)
-        result.push({
-          key: keyName,
-          passed: isRegex,
-          details: isRegex ? 'OK' : getDetails(isRegex)
-        })
-
-        break;
-      case null:
-        const isNull = value === null
-
-        result.push({
-          key: keyName,
-          passed: isNull,
-          details: isNull ? 'OK' : getDetails(isNull)
-        })
-
-        break;
-      default:
-        result.push({
-          key: keyName,
-          passed: false,
-          details: `Тип '${keyName}' не определен`
-        })
-    }
-  
-    return result;
-};
-
-  export default checkType

package/src/constants/details.ts

@@ -1,5 +0,0 @@
-export enum ErrorKeywords {
-    Missing = 'missing',
-    Type = 'type',
-    Rule = 'rule'
-} 

package/src/index.ts

@@ -1,3 +0,0 @@
-import { Schema } from "./Schema.js";
-
-export default Schema

package/src/tsconfig.json

@@ -1,103 +0,0 @@
-{
-  "compilerOptions": {
-    /* Visit https://aka.ms/tsconfig to read more about this file */
-
-    /* Projects */
-    // "incremental": true,                              /* Save .tsbuildinfo files to allow for incremental compilation of projects. */
-    // "composite": true,                                /* Enable constraints that allow a TypeScript project to be used with project references. */
-    // "tsBuildInfoFile": "./.tsbuildinfo",              /* Specify the path to .tsbuildinfo incremental compilation file. */
-    // "disableSourceOfProjectReferenceRedirect": true,  /* Disable preferring source files instead of declaration files when referencing composite projects. */
-    // "disableSolutionSearching": true,                 /* Opt a project out of multi-project reference checking when editing. */
-    // "disableReferencedProjectLoad": true,             /* Reduce the number of projects loaded automatically by TypeScript. */
-
-    /* Language and Environment */
-    "target": "ES2017",                                  /* Set the JavaScript language version for emitted JavaScript and include compatible library declarations. */
-    // "lib": [],                                        /* Specify a set of bundled library declaration files that describe the target runtime environment. */
-    // "jsx": "preserve",                                /* Specify what JSX code is generated. */
-    // "experimentalDecorators": true,                   /* Enable experimental support for TC39 stage 2 draft decorators. */
-    // "emitDecoratorMetadata": true,                    /* Emit design-type metadata for decorated declarations in source files. */
-    // "jsxFactory": "",                                 /* Specify the JSX factory function used when targeting React JSX emit, e.g. 'React.createElement' or 'h'. */
-    // "jsxFragmentFactory": "",                         /* Specify the JSX Fragment reference used for fragments when targeting React JSX emit e.g. 'React.Fragment' or 'Fragment'. */
-    // "jsxImportSource": "",                            /* Specify module specifier used to import the JSX factory functions when using 'jsx: react-jsx*'. */
-    // "reactNamespace": "",                             /* Specify the object invoked for 'createElement'. This only applies when targeting 'react' JSX emit. */
-    // "noLib": true,                                    /* Disable including any library files, including the default lib.d.ts. */
-    // "useDefineForClassFields": true,                  /* Emit ECMAScript-standard-compliant class fields. */
-    // "moduleDetection": "auto",                        /* Control what method is used to detect module-format JS files. */
-
-    /* Modules */
-    "module": "ES2022",                                /* Specify what module code is generated. */
-    // "rootDir": "./",                                  /* Specify the root folder within your source files. */
-     "moduleResolution": "node",                       /* Specify how TypeScript looks up a file from a given module specifier. */
-    // "baseUrl": "./",                                  /* Specify the base directory to resolve non-relative module names. */
-    // "paths": {},                                      /* Specify a set of entries that re-map imports to additional lookup locations. */
-    // "rootDirs": [],                                   /* Allow multiple folders to be treated as one when resolving modules. */
-    // "typeRoots": [],                                  /* Specify multiple folders that act like './node_modules/@types'. */
-    // "types": [],                                      /* Specify type package names to be included without being referenced in a source file. */
-    // "allowUmdGlobalAccess": true,                     /* Allow accessing UMD globals from modules. */
-    // "moduleSuffixes": [],                             /* List of file name suffixes to search when resolving a module. */
-    // "resolveJsonModule": true,                        /* Enable importing .json files. */
-    // "noResolve": true,                                /* Disallow 'import's, 'require's or '<reference>'s from expanding the number of files TypeScript should add to a project. */
-
-    /* JavaScript Support */
-    "allowJs": true,                                  /* Allow JavaScript files to be a part of your program. Use the 'checkJS' option to get errors from these files. */
-    // "checkJs": true,                                  /* Enable error reporting in type-checked JavaScript files. */
-    // "maxNodeModuleJsDepth": 1,                        /* Specify the maximum folder depth used for checking JavaScript files from 'node_modules'. Only applicable with 'allowJs'. */
-
-    /* Emit */
-    // "declaration": true,                              /* Generate .d.ts files from TypeScript and JavaScript files in your project. */
-    // "declarationMap": true,                           /* Create sourcemaps for d.ts files. */
-    // "emitDeclarationOnly": true,                      /* Only output d.ts files and not JavaScript files. */
-    "sourceMap": false,                                /* Create source map files for emitted JavaScript files. */
-    // "outFile": "./",                                  /* Specify a file that bundles all outputs into one JavaScript file. If 'declaration' is true, also designates a file that bundles all .d.ts output. */
-    "outDir": "../dist/",                                   /* Specify an output folder for all emitted files. */
-    "removeComments": true,                           /* Disable emitting comments. */
-    // "noEmit": true,                                   /* Disable emitting files from a compilation. */
-    // "importHelpers": true,                            /* Allow importing helper functions from tslib once per project, instead of including them per-file. */
-    // "importsNotUsedAsValues": "remove",               /* Specify emit/checking behavior for imports that are only used for types. */
-    // "downlevelIteration": true,                       /* Emit more compliant, but verbose and less performant JavaScript for iteration. */
-    // "sourceRoot": "",                                 /* Specify the root path for debuggers to find the reference source code. */
-    // "mapRoot": "",                                    /* Specify the location where debugger should locate map files instead of generated locations. */
-    // "inlineSourceMap": true,                          /* Include sourcemap files inside the emitted JavaScript. */
-    // "inlineSources": true,                            /* Include source code in the sourcemaps inside the emitted JavaScript. */
-    // "emitBOM": true,                                  /* Emit a UTF-8 Byte Order Mark (BOM) in the beginning of output files. */
-    // "newLine": "crlf",                                /* Set the newline character for emitting files. */
-    // "stripInternal": true,                            /* Disable emitting declarations that have '@internal' in their JSDoc comments. */
-    // "noEmitHelpers": true,                            /* Disable generating custom helper functions like '__extends' in compiled output. */
-    // "noEmitOnError": true,                            /* Disable emitting files if any type checking errors are reported. */
-    // "preserveConstEnums": true,                       /* Disable erasing 'const enum' declarations in generated code. */
-    // "declarationDir": "./",                           /* Specify the output directory for generated declaration files. */
-    // "preserveValueImports": true,                     /* Preserve unused imported values in the JavaScript output that would otherwise be removed. */
-
-    /* Interop Constraints */
-    // "isolatedModules": true,                          /* Ensure that each file can be safely transpiled without relying on other imports. */
-    // "allowSyntheticDefaultImports": true,             /* Allow 'import x from y' when a module doesn't have a default export. */
-    "esModuleInterop": true,                             /* Emit additional JavaScript to ease support for importing CommonJS modules. This enables 'allowSyntheticDefaultImports' for type compatibility. */
-    // "preserveSymlinks": true,                         /* Disable resolving symlinks to their realpath. This correlates to the same flag in node. */
-    "forceConsistentCasingInFileNames": true,            /* Ensure that casing is correct in imports. */
-
-    /* Type Checking */
-    "strict": true,                                      /* Enable all strict type-checking options. */
-    // "noImplicitAny": true,                            /* Enable error reporting for expressions and declarations with an implied 'any' type. */
-    // "strictNullChecks": true,                         /* When type checking, take into account 'null' and 'undefined'. */
-    // "strictFunctionTypes": true,                      /* When assigning functions, check to ensure parameters and the return values are subtype-compatible. */
-    // "strictBindCallApply": true,                      /* Check that the arguments for 'bind', 'call', and 'apply' methods match the original function. */
-    // "strictPropertyInitialization": true,             /* Check for class properties that are declared but not set in the constructor. */
-    // "noImplicitThis": true,                           /* Enable error reporting when 'this' is given the type 'any'. */
-    // "useUnknownInCatchVariables": true,               /* Default catch clause variables as 'unknown' instead of 'any'. */
-    // "alwaysStrict": true,                             /* Ensure 'use strict' is always emitted. */
-    // "noUnusedLocals": true,                           /* Enable error reporting when local variables aren't read. */
-    // "noUnusedParameters": true,                       /* Raise an error when a function parameter isn't read. */
-    // "exactOptionalPropertyTypes": true,               /* Interpret optional property types as written, rather than adding 'undefined'. */
-    // "noImplicitReturns": true,                        /* Enable error reporting for codepaths that do not explicitly return in a function. */
-    // "noFallthroughCasesInSwitch": true,               /* Enable error reporting for fallthrough cases in switch statements. */
-    // "noUncheckedIndexedAccess": true,                 /* Add 'undefined' to a type when accessed using an index. */
-    // "noImplicitOverride": true,                       /* Ensure overriding members in derived classes are marked with an override modifier. */
-    // "noPropertyAccessFromIndexSignature": true,       /* Enforces using indexed accessors for keys declared using an indexed type. */
-    // "allowUnusedLabels": true,                        /* Disable error reporting for unused labels. */
-    // "allowUnreachableCode": true,                     /* Disable error reporting for unreachable code. */
-
-    /* Completeness */
-    // "skipDefaultLibCheck": true,                      /* Skip type checking .d.ts files that are included with TypeScript. */
-    "skipLibCheck": true                                 /* Skip type checking all .d.ts files. */
-  }
-}

package/src/utils/errors.ts

@@ -1,6 +0,0 @@
-const _errors: {[key: string]: Function} = {}
-
-_errors.getMissingError = (key: string) => `Ключ '${key}' отсутствует`
-
-export default _errors
-