@jetio/validator 1.0.0

package/dist/index.js

@@ -0,0 +1,28 @@
+"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 });
+exports.JetValidator = void 0;
+var jet_validator_1 = require("./jet-validator");
+Object.defineProperty(exports, "JetValidator", { enumerable: true, get: function () { return jet_validator_1.JetValidator; } });
+__exportStar(require("./resolver"), exports);
+__exportStar(require("./formats"), exports);
+__exportStar(require("./compileSchema"), exports);
+__exportStar(require("./types/format"), exports);
+__exportStar(require("./types/keywords"), exports);
+__exportStar(require("./types/schema"), exports);
+__exportStar(require("./types/validation"), exports);
+__exportStar(require("./utilities"), exports);
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;AAAA,iDAA+C;AAAtC,6GAAA,YAAY,OAAA;AACrB,6CAA2B;AAC3B,4CAA0B;AAC1B,kDAAgC;AAChC,iDAA+B;AAC/B,mDAAiC;AACjC,iDAA+B;AAC/B,qDAAmC;AACnC,8CAA4B"}

package/dist/jet-validator.d.ts

@@ -0,0 +1,88 @@
+import { SchemaDefinition } from "./types/schema";
+import { ErrorAttachedValidatorFn, ValidationResult, ValidatorOptions } from "./types/validation";
+import { CodeKeywordDefinition, CompileKeywordDefinition, KeywordDefinition, MacroKeywordDefinition, ValidateKeywordDefinition } from "./types/keywords";
+import { FormatDefinition } from "./types/format";
+export declare class JetValidator {
+    private schemas;
+    private metaSchemas;
+    private customKeywords;
+    private formatValidators;
+    private hasMacros;
+    private compilationCache;
+    options: Required<ValidatorOptions>;
+    private counter;
+    private aliases;
+    constructor(options?: ValidatorOptions);
+    addFormat(key: string, validator: FormatDefinition, options?: {
+        override?: boolean;
+    }): void;
+    removeFormat(key: string): void;
+    getFormat(format: string): FormatDefinition | undefined;
+    testFormat(value: string, format: string): boolean | Promise<boolean>;
+    isFormatRegistered(key: string): boolean;
+    getRegisteredFormats(): string[];
+    validateFormat(value: string, format: string): any;
+    getAllFormats(): Record<string, FormatDefinition>;
+    addKeyword(definition: MacroKeywordDefinition | CompileKeywordDefinition | ValidateKeywordDefinition | CodeKeywordDefinition): this;
+    removeKeyword(keyword: string): this;
+    hasMacroKeywords(): boolean;
+    getKeyword(keyword: string): MacroKeywordDefinition | CompileKeywordDefinition | ValidateKeywordDefinition | CodeKeywordDefinition | undefined;
+    private validateKeywordDefinition;
+    isKeywordAdded(key: string): boolean;
+    getAddedKeywords(): string[];
+    clearKeywords(): void;
+    getAllKeywords(): Map<string, KeywordDefinition>;
+    addSchema(schema: SchemaDefinition, id?: string): void;
+    getSchema(key: string): SchemaDefinition | undefined;
+    getCompiledSchema(key: string, config?: ValidatorOptions): Function;
+    getCompiledSchemaAsync(key: string, config?: ValidatorOptions): Promise<Function>;
+    isSchemaAdded(key: string): boolean;
+    getAddedSchemas(): string[];
+    removeSchema(pattern?: string | RegExp | object): void;
+    clearSchemas(): void;
+    getAllSchemas(): Record<string, SchemaDefinition>;
+    validate(schema: object | boolean | string, data: any, config?: ValidatorOptions): ValidationResult;
+    validateAsync(schema: object | boolean | string, data: any, config?: ValidatorOptions): Promise<ValidationResult>;
+    getMetaSchema($schema?: string, options?: ValidatorOptions): {
+        metaSchema: object | undefined;
+        metaSchemaId: string;
+    };
+    validateSchemaSync(schema: SchemaDefinition, options?: ValidatorOptions): {
+        valid: boolean;
+        errors: any;
+    };
+    validateSchemaAsync(schema: SchemaDefinition, options?: ValidatorOptions): Promise<{
+        valid: boolean;
+        errors: any;
+    }>;
+    addMetaSchema(schema: SchemaDefinition, key?: string): this;
+    clearRegistries(): void;
+    private compileResolved;
+    compile(fschema: object | boolean, config?: ValidatorOptions): ErrorAttachedValidatorFn;
+    compileAsync(fschema: SchemaDefinition | boolean, config?: ValidatorOptions): Promise<ErrorAttachedValidatorFn>;
+    logErrors(errors: any, indent?: number): void;
+    getFieldFromPath(dataPath: string): string;
+    getFullFieldPath(dataPath: string): string;
+    getFieldErrors(errors: any[]): Record<string, string[]>;
+    errorsText(errors: any[], options?: {
+        separator?: string;
+        dataVar?: string;
+    }): string;
+    generateStandalone(schema: object, sconfig?: ValidatorOptions): {
+        code: string;
+        functionName: string;
+        formatSetup?: string;
+        imports: string[];
+    };
+    private inlineUsedFormats;
+    private resolveFormats;
+    private inlineAllConfiguredFormats;
+    private resolve$DataFormat;
+    private createFormatObject;
+    private getSafeFormatName;
+    private formatNeedsExternalDeps;
+    private inlineFormatWithDeps;
+    private serializeFormatFunction;
+    private isSelfContained;
+    private generateFormatSetup;
+}