z-schema 12.0.4 → 12.1.0

package/dist/validation/object.js

@@ -1,237 +0,0 @@
-import { difference } from '../utils/array.js';
-import { compileSchemaRegex } from '../utils/schema-regex.js';
-import { isObject } from '../utils/what-is.js';
-import { deferOrRunSync, shouldSkipValidate, supportsDependentKeywords } from './shared.js';
-// ---------------------------------------------------------------------------
-// maxProperties
-// ---------------------------------------------------------------------------
-export function maxPropertiesValidator(report, schema, json) {
-    // http://json-schema.org/latest/json-schema-validation.html#rfc.section.5.4.1.2
-    if (shouldSkipValidate(this.validateOptions, ['OBJECT_PROPERTIES_MAXIMUM'])) {
-        return;
-    }
-    if (!isObject(json)) {
-        return;
-    }
-    const keysCount = Object.keys(json).length;
-    if (keysCount > schema.maxProperties) {
-        report.addError('OBJECT_PROPERTIES_MAXIMUM', [keysCount, schema.maxProperties], undefined, schema, 'maxProperties');
-    }
-}
-// ---------------------------------------------------------------------------
-// minProperties
-// ---------------------------------------------------------------------------
-export function minPropertiesValidator(report, schema, json) {
-    // http://json-schema.org/latest/json-schema-validation.html#rfc.section.5.4.2.2
-    if (shouldSkipValidate(this.validateOptions, ['OBJECT_PROPERTIES_MINIMUM'])) {
-        return;
-    }
-    if (!isObject(json)) {
-        return;
-    }
-    const keysCount = Object.keys(json).length;
-    if (keysCount < schema.minProperties) {
-        report.addError('OBJECT_PROPERTIES_MINIMUM', [keysCount, schema.minProperties], undefined, schema, 'minProperties');
-    }
-}
-// ---------------------------------------------------------------------------
-// required
-// ---------------------------------------------------------------------------
-export function requiredValidator(report, schema, json) {
-    // http://json-schema.org/latest/json-schema-validation.html#rfc.section.5.4.3.2
-    if (shouldSkipValidate(this.validateOptions, ['OBJECT_MISSING_REQUIRED_PROPERTY'])) {
-        return;
-    }
-    if (!isObject(json)) {
-        return;
-    }
-    const idx = schema.required.length;
-    for (let i = 0; i < idx; i++) {
-        const requiredPropertyName = schema.required[i];
-        if (!Object.hasOwn(json, requiredPropertyName)) {
-            report.addError('OBJECT_MISSING_REQUIRED_PROPERTY', [requiredPropertyName], undefined, schema, 'required');
-        }
-    }
-}
-// ---------------------------------------------------------------------------
-// additionalProperties  (delegates to properties when standalone)
-// ---------------------------------------------------------------------------
-export function additionalPropertiesValidator(report, schema, json) {
-    // covered in properties and patternProperties
-    if (schema.properties === undefined && schema.patternProperties === undefined) {
-        return propertiesValidator.call(this, report, schema, json);
-    }
-}
-// ---------------------------------------------------------------------------
-// patternProperties  (delegates to properties when standalone)
-// ---------------------------------------------------------------------------
-export function patternPropertiesValidator(report, schema, json) {
-    // covered in properties
-    if (schema.properties === undefined) {
-        return propertiesValidator.call(this, report, schema, json);
-    }
-}
-// ---------------------------------------------------------------------------
-// properties
-// ---------------------------------------------------------------------------
-export function propertiesValidator(report, schema, json) {
-    // http://json-schema.org/latest/json-schema-validation.html#rfc.section.5.4.4.2
-    if (shouldSkipValidate(this.validateOptions, ['OBJECT_ADDITIONAL_PROPERTIES'])) {
-        return;
-    }
-    if (!isObject(json)) {
-        return;
-    }
-    const properties = schema.properties !== undefined ? schema.properties : {};
-    const patternProperties = schema.patternProperties !== undefined ? schema.patternProperties : {};
-    if (schema.additionalProperties === false) {
-        // The property set of the json to validate.
-        let s = Object.keys(json);
-        // The property set from "properties".
-        const p = Object.keys(properties);
-        // The property set from "patternProperties".
-        const pp = Object.keys(patternProperties);
-        // remove from "s" all elements of "p", if any;
-        s = difference(s, p);
-        // for each regex in "pp", remove all elements of "s" which this regex matches.
-        for (const ppKey of pp) {
-            const result = compileSchemaRegex(ppKey);
-            if (!result.ok) {
-                continue;
-            }
-            const regExp = result.value;
-            for (let idx2 = s.length - 1; idx2 >= 0; idx2--) {
-                if (regExp.test(s[idx2]) === true) {
-                    s.splice(idx2, 1);
-                }
-            }
-        }
-        // Validation of the json succeeds if, after these two steps, set "s" is empty.
-        if (s.length > 0) {
-            // assumeAdditional can be an array of allowed properties
-            if (Array.isArray(this.options.assumeAdditional)) {
-                for (const allowed of this.options.assumeAdditional) {
-                    const io = s.indexOf(allowed);
-                    if (io !== -1) {
-                        s.splice(io, 1);
-                    }
-                }
-            }
-            if (s.length > 0) {
-                for (const extra of s) {
-                    report.addError('OBJECT_ADDITIONAL_PROPERTIES', [extra], undefined, schema, 'properties');
-                }
-            }
-        }
-    }
-}
-// ---------------------------------------------------------------------------
-// dependencies
-// ---------------------------------------------------------------------------
-export function dependenciesValidator(report, schema, json) {
-    // http://json-schema.org/latest/json-schema-validation.html#rfc.section.5.4.5.2
-    if (shouldSkipValidate(this.validateOptions, ['OBJECT_DEPENDENCY_KEY'])) {
-        return;
-    }
-    if (!isObject(json)) {
-        return;
-    }
-    const keys = Object.keys(schema.dependencies);
-    for (const dependencyName of keys) {
-        // iterate all dependencies
-        if (Object.hasOwn(json, dependencyName)) {
-            const dependencyDefinition = schema.dependencies[dependencyName];
-            if (Array.isArray(dependencyDefinition)) {
-                // Array
-                // if dependency is an array, object needs to have all properties in this array
-                for (const requiredPropertyName of dependencyDefinition) {
-                    if (!Object.hasOwn(json, requiredPropertyName)) {
-                        report.addError('OBJECT_DEPENDENCY_KEY', [requiredPropertyName, dependencyName], undefined, schema, 'dependencies');
-                    }
-                }
-            }
-            else {
-                // if dependency is a schema, validate against this schema
-                this._jsonValidate(report, dependencyDefinition, json);
-            }
-        }
-    }
-}
-// ---------------------------------------------------------------------------
-// dependentSchemas
-// ---------------------------------------------------------------------------
-export function dependentSchemasValidator(report, schema, json) {
-    if (!supportsDependentKeywords(schema, this.options.version)) {
-        return;
-    }
-    if (!isObject(json) || !isObject(schema.dependentSchemas)) {
-        return;
-    }
-    const keys = Object.keys(schema.dependentSchemas);
-    for (const dependencyName of keys) {
-        if (Object.hasOwn(json, dependencyName)) {
-            const dependencySchema = schema.dependentSchemas[dependencyName];
-            this._jsonValidate(report, dependencySchema, json);
-        }
-    }
-}
-// ---------------------------------------------------------------------------
-// dependentRequired
-// ---------------------------------------------------------------------------
-export function dependentRequiredValidator(report, schema, json) {
-    if (!supportsDependentKeywords(schema, this.options.version)) {
-        return;
-    }
-    if (shouldSkipValidate(this.validateOptions, ['OBJECT_DEPENDENCY_KEY'])) {
-        return;
-    }
-    if (!isObject(json) || !isObject(schema.dependentRequired)) {
-        return;
-    }
-    const keys = Object.keys(schema.dependentRequired);
-    for (const dependencyName of keys) {
-        if (!Object.hasOwn(json, dependencyName)) {
-            continue;
-        }
-        const requiredProperties = schema.dependentRequired[dependencyName];
-        if (!Array.isArray(requiredProperties)) {
-            continue;
-        }
-        for (const requiredPropertyName of requiredProperties) {
-            if (!Object.hasOwn(json, requiredPropertyName)) {
-                report.addError('OBJECT_DEPENDENCY_KEY', [requiredPropertyName, dependencyName], undefined, schema, 'dependentRequired');
-            }
-        }
-    }
-}
-// ---------------------------------------------------------------------------
-// propertyNames
-// ---------------------------------------------------------------------------
-export function propertyNamesValidator(report, schema, json) {
-    if (shouldSkipValidate(this.validateOptions, ['PROPERTY_NAMES'])) {
-        return;
-    }
-    if (!isObject(json)) {
-        return;
-    }
-    const propertyNamesSchema = schema.propertyNames;
-    if (propertyNamesSchema === undefined) {
-        return;
-    }
-    const Report_ = report.constructor;
-    const keys = Object.keys(json);
-    const subReports = [];
-    for (const key of keys) {
-        const subReport = new Report_(report);
-        subReports.push(subReport);
-        this._jsonValidate(subReport, propertyNamesSchema, key);
-    }
-    const addPropertyNameErrors = () => {
-        for (let idx = 0; idx < keys.length; idx++) {
-            if (subReports[idx].errors.length > 0) {
-                report.addError('PROPERTY_NAMES', [keys[idx]], subReports[idx], schema, undefined);
-            }
-        }
-    };
-    deferOrRunSync(report, subReports, addPropertyNameErrors);
-}

package/dist/validation/ref.js

@@ -1,70 +0,0 @@
-import { findId, getId } from '../json-schema.js';
-import { getRemotePath } from '../utils/uri.js';
-// ---------------------------------------------------------------------------
-// $dynamicRef helpers
-// ---------------------------------------------------------------------------
-export const getDynamicRefAnchorName = (dynamicRef) => {
-    const hashIdx = dynamicRef.indexOf('#');
-    if (hashIdx === -1) {
-        return undefined;
-    }
-    const fragment = dynamicRef.slice(hashIdx + 1);
-    if (!fragment || fragment[0] === '/') {
-        return undefined;
-    }
-    return fragment;
-};
-export const findDynamicAnchorInScope = (scopeSchema, anchorName) => {
-    const scopeId = getId(scopeSchema);
-    const scopeBaseUri = scopeId ? getRemotePath(scopeId) : undefined;
-    const found = findId(scopeSchema, anchorName, scopeBaseUri, scopeBaseUri);
-    if (found && found.$dynamicAnchor === anchorName) {
-        return found;
-    }
-    return undefined;
-};
-// ---------------------------------------------------------------------------
-// $recursiveRef resolution
-// ---------------------------------------------------------------------------
-/**
- * Resolves the effective target for a $recursiveRef, walking the recursive anchor stack.
- */
-export const resolveRecursiveRef = (schema, recursiveAnchorStack) => {
-    const resolved = schema.__$recursiveRefResolved;
-    if (!resolved) {
-        return undefined;
-    }
-    let target = resolved;
-    if (typeof target === 'object' && target.$recursiveAnchor === true) {
-        const dynamicTarget = recursiveAnchorStack[0];
-        if (dynamicTarget) {
-            target = dynamicTarget;
-        }
-    }
-    return target;
-};
-// ---------------------------------------------------------------------------
-// $dynamicRef resolution
-// ---------------------------------------------------------------------------
-/**
- * Resolves the effective target for a $dynamicRef, walking the dynamic scope stack.
- */
-export const resolveDynamicRef = (schema, dynamicScopeStack) => {
-    const resolved = schema.__$dynamicRefResolved;
-    if (typeof resolved === 'undefined' || !schema.$dynamicRef) {
-        return resolved;
-    }
-    let target = resolved;
-    const anchorName = getDynamicRefAnchorName(schema.$dynamicRef);
-    if (anchorName && typeof target === 'object' && target.$dynamicAnchor === anchorName) {
-        for (let scopeIdx = 0; scopeIdx < dynamicScopeStack.length; scopeIdx++) {
-            const scopeSchema = dynamicScopeStack[scopeIdx];
-            const scopedTarget = findDynamicAnchorInScope(scopeSchema, anchorName);
-            if (scopedTarget) {
-                target = scopedTarget;
-                break;
-            }
-        }
-    }
-    return target;
-};

package/dist/validation/shared.js

@@ -1,136 +0,0 @@
-import { isObject } from '../utils/what-is.js';
-// ---------------------------------------------------------------------------
-// Draft / vocabulary helpers
-// ---------------------------------------------------------------------------
-export const shouldSkipValidate = function (options, errors) {
-    return (options &&
-        Array.isArray(options.includeErrors) &&
-        options.includeErrors.length > 0 &&
-        !errors.some(function (err) {
-            return options.includeErrors.includes(err);
-        }));
-};
-export const supportsDependentKeywords = (schema, version) => {
-    if (typeof schema.$schema === 'string') {
-        return !/draft-04|draft-06|draft-07/.test(schema.$schema);
-    }
-    return !(version === 'draft-04' || version === 'draft-06' || version === 'draft-07');
-};
-// ---------------------------------------------------------------------------
-// Vocabulary constants
-// ---------------------------------------------------------------------------
-const VOCAB_VALIDATION_2019_09 = 'https://json-schema.org/draft/2019-09/vocab/validation';
-const VOCAB_VALIDATION_2020_12 = 'https://json-schema.org/draft/2020-12/vocab/validation';
-const VOCAB_FORMAT_2019_09 = 'https://json-schema.org/draft/2019-09/vocab/format';
-const VOCAB_FORMAT_ASSERTION_2020_12 = 'https://json-schema.org/draft/2020-12/vocab/format-assertion';
-export const VALIDATION_VOCAB_KEYWORDS = new Set([
-    'type',
-    'multipleOf',
-    'maximum',
-    'exclusiveMaximum',
-    'minimum',
-    'exclusiveMinimum',
-    'maxLength',
-    'minLength',
-    'pattern',
-    'maxItems',
-    'minItems',
-    'uniqueItems',
-    'maxContains',
-    'minContains',
-    'maxProperties',
-    'minProperties',
-    'required',
-    'dependentRequired',
-    'enum',
-    'const',
-    'contentEncoding',
-    'contentMediaType',
-]);
-export const isValidationVocabularyEnabled = (schema, report, version) => {
-    if (version !== 'draft2019-09' && version !== 'draft2020-12') {
-        return true;
-    }
-    const currentSchemaMeta = schema.__$schemaResolved;
-    const rootSchemaMeta = report.rootSchema && typeof report.rootSchema !== 'boolean' ? report.rootSchema.__$schemaResolved : undefined;
-    const metaSchema = (currentSchemaMeta || rootSchemaMeta);
-    if (!metaSchema || typeof metaSchema !== 'object' || !isObject(metaSchema.$vocabulary)) {
-        return true;
-    }
-    const vocabulary = metaSchema.$vocabulary;
-    const has2019 = Object.hasOwn(vocabulary, VOCAB_VALIDATION_2019_09);
-    const has2020 = Object.hasOwn(vocabulary, VOCAB_VALIDATION_2020_12);
-    if (has2019 || has2020) {
-        return vocabulary[VOCAB_VALIDATION_2019_09] === true || vocabulary[VOCAB_VALIDATION_2020_12] === true;
-    }
-    return false;
-};
-/**
- * Checks whether the format-assertion vocabulary is enabled in the meta-schema.
- * For draft 2019-09: checks if the format vocabulary is set to true.
- * For draft 2020-12: checks if the format-assertion vocabulary is present and true.
- * Returns true for older drafts (format was always an assertion).
- */
-export const isFormatAssertionVocabEnabled = (schema, report, version) => {
-    if (version !== 'draft2019-09' && version !== 'draft2020-12') {
-        return true; // older drafts always assert format
-    }
-    const currentSchemaMeta = schema.__$schemaResolved;
-    const rootSchemaMeta = report.rootSchema && typeof report.rootSchema !== 'boolean' ? report.rootSchema.__$schemaResolved : undefined;
-    const metaSchema = (currentSchemaMeta || rootSchemaMeta);
-    if (!metaSchema || typeof metaSchema !== 'object' || !isObject(metaSchema.$vocabulary)) {
-        return false; // no vocabulary info, default to annotation-only for modern drafts
-    }
-    const vocabulary = metaSchema.$vocabulary;
-    // For draft 2020-12, only the format-assertion vocabulary enables format as assertion
-    if (Object.hasOwn(vocabulary, VOCAB_FORMAT_ASSERTION_2020_12)) {
-        return vocabulary[VOCAB_FORMAT_ASSERTION_2020_12] === true;
-    }
-    // For draft 2019-09, check if the format vocabulary is enabled (true)
-    if (Object.hasOwn(vocabulary, VOCAB_FORMAT_2019_09)) {
-        return vocabulary[VOCAB_FORMAT_2019_09] === true;
-    }
-    return false; // default to annotation-only for modern drafts
-};
-// ---------------------------------------------------------------------------
-// Validation result caching
-// ---------------------------------------------------------------------------
-export function cacheValidationResult(report, schema, json, passed) {
-    let schemaMap = report.__validationResultCache.get(schema);
-    if (!schemaMap) {
-        schemaMap = new Map();
-        report.__validationResultCache.set(schema, schemaMap);
-    }
-    schemaMap.set(json, passed);
-}
-export function getCachedValidationResult(report, schema, json) {
-    return report.__validationResultCache.get(schema)?.get(json);
-}
-// ---------------------------------------------------------------------------
-// Async task aggregation
-// ---------------------------------------------------------------------------
-/**
- * Shared async-task aggregation pattern.
- *
- * 1. Collects async tasks from `subReports` into `report`.
- * 2. If new async tasks were added, defers `decisionFn` via `report.addAsyncTask`
- *    with proper path save/restore so error paths are correct.
- * 3. Otherwise, runs `decisionFn` synchronously.
- */
-export function deferOrRunSync(report, subReports, decisionFn) {
-    const asyncTasksBefore = report.asyncTasks.length;
-    for (const subReport of subReports) {
-        report.asyncTasks.push(...subReport.asyncTasks);
-    }
-    const hasAsyncTasks = report.asyncTasks.length > asyncTasksBefore;
-    if (hasAsyncTasks) {
-        report.addAsyncTaskWithPath((callback) => {
-            setTimeout(() => callback(null), 0);
-        }, [], () => {
-            decisionFn();
-        });
-    }
-    else {
-        decisionFn();
-    }
-}

package/dist/validation/string.js

@@ -1,170 +0,0 @@
-import { getFormatValidators } from '../format-validators.js';
-import { decodeBase64, isValidBase64 } from '../utils/base64.js';
-import { compileSchemaRegex } from '../utils/schema-regex.js';
-import { unicodeLength } from '../utils/unicode.js';
-import { whatIs } from '../utils/what-is.js';
-import { isFormatAssertionVocabEnabled, shouldSkipValidate } from './shared.js';
-// ---------------------------------------------------------------------------
-// minLength
-// ---------------------------------------------------------------------------
-export function minLengthValidator(report, schema, json) {
-    // http://json-schema.org/latest/json-schema-validation.html#rfc.section.5.2.2.2
-    if (shouldSkipValidate(this.validateOptions, ['MIN_LENGTH'])) {
-        return;
-    }
-    if (typeof json !== 'string') {
-        return;
-    }
-    if (unicodeLength(json) < schema.minLength) {
-        report.addError('MIN_LENGTH', [json.length, schema.minLength], undefined, schema, 'minLength');
-    }
-}
-// ---------------------------------------------------------------------------
-// maxLength
-// ---------------------------------------------------------------------------
-export function maxLengthValidator(report, schema, json) {
-    // http://json-schema.org/latest/json-schema-validation.html#rfc.section.5.2.1.2
-    if (shouldSkipValidate(this.validateOptions, ['MAX_LENGTH'])) {
-        return;
-    }
-    if (typeof json !== 'string') {
-        return;
-    }
-    if (unicodeLength(json) > schema.maxLength) {
-        report.addError('MAX_LENGTH', [json.length, schema.maxLength], undefined, schema, 'maxLength');
-    }
-}
-// ---------------------------------------------------------------------------
-// pattern
-// ---------------------------------------------------------------------------
-export function patternValidator(report, schema, json) {
-    // http://json-schema.org/latest/json-schema-validation.html#rfc.section.5.2.3.2
-    if (shouldSkipValidate(this.validateOptions, ['PATTERN'])) {
-        return;
-    }
-    if (typeof json !== 'string') {
-        return;
-    }
-    const result = compileSchemaRegex(schema.pattern);
-    if (!result.ok) {
-        // Should not happen: schema should have been validated already
-        report.addError('PATTERN', [schema.pattern, json, result.error.message], undefined, schema, 'pattern');
-        return;
-    }
-    if (!result.value.test(json)) {
-        report.addError('PATTERN', [schema.pattern, json], undefined, schema, 'pattern');
-    }
-}
-// ---------------------------------------------------------------------------
-// format
-// ---------------------------------------------------------------------------
-export function formatValidator(report, schema, json) {
-    // http://json-schema.org/latest/json-schema-validation.html#rfc.section.7.2
-    if (this.options.formatAssertions === false) {
-        return;
-    }
-    // When formatAssertions is explicitly true, respect the meta-schema vocabulary:
-    // for draft 2019-09/2020-12, format is annotation-only unless the format-assertion
-    // vocabulary is enabled in the meta-schema.
-    if (this.options.formatAssertions === true) {
-        if (!isFormatAssertionVocabEnabled(schema, report, this.options.version)) {
-            return;
-        }
-    }
-    const isModernDraft = this.options.version === 'draft2019-09' || this.options.version === 'draft2020-12';
-    const formatValidators = getFormatValidators(this.options);
-    const formatValidatorFn = formatValidators[schema.format];
-    if (typeof formatValidatorFn === 'function') {
-        if (shouldSkipValidate(this.validateOptions, ['INVALID_FORMAT'])) {
-            return;
-        }
-        if (report.hasError('INVALID_TYPE', [schema.type, whatIs(json)])) {
-            return;
-        }
-        if (formatValidatorFn.length === 2) {
-            // callback-based async
-            report.addAsyncTaskWithPath(formatValidatorFn, [json], function (result) {
-                if (result !== true) {
-                    report.addError('INVALID_FORMAT', [schema.format, JSON.stringify(json)], undefined, schema, 'format');
-                }
-            });
-        }
-        else {
-            const result = formatValidatorFn.call(this, json);
-            if (result instanceof Promise) {
-                // Promise-based async
-                const promiseResult = result;
-                report.addAsyncTaskWithPath(async (callback) => {
-                    try {
-                        const resolved = await promiseResult;
-                        callback(resolved);
-                    }
-                    catch (_error) {
-                        callback(false);
-                    }
-                }, [], function (resolvedResult) {
-                    if (resolvedResult !== true) {
-                        report.addError('INVALID_FORMAT', [schema.format, JSON.stringify(json)], undefined, schema, 'format');
-                    }
-                });
-            }
-            else {
-                // sync
-                if (result !== true) {
-                    report.addError('INVALID_FORMAT', [schema.format, JSON.stringify(json)], undefined, schema, 'format');
-                }
-            }
-        }
-    }
-    else if (this.options.ignoreUnknownFormats !== true && !isModernDraft) {
-        report.addError('UNKNOWN_FORMAT', [schema.format], undefined, schema, 'format');
-    }
-}
-// ---------------------------------------------------------------------------
-// contentEncoding
-// ---------------------------------------------------------------------------
-export function contentEncodingValidator(report, schema, json) {
-    if (this.options.version !== 'draft-07') {
-        return;
-    }
-    if (typeof json !== 'string') {
-        return;
-    }
-    const contentEncoding = schema.contentEncoding;
-    if (contentEncoding !== 'base64') {
-        return;
-    }
-    if (!isValidBase64(json)) {
-        report.addError('INVALID_FORMAT', ['contentEncoding:base64', JSON.stringify(json)], undefined, schema, 'contentEncoding');
-    }
-}
-// ---------------------------------------------------------------------------
-// contentMediaType
-// ---------------------------------------------------------------------------
-export function contentMediaTypeValidator(report, schema, json) {
-    if (this.options.version !== 'draft-07') {
-        return;
-    }
-    if (typeof json !== 'string') {
-        return;
-    }
-    const contentMediaType = schema.contentMediaType;
-    if (contentMediaType !== 'application/json') {
-        return;
-    }
-    let payload = json;
-    if (schema.contentEncoding === 'base64') {
-        const decoded = decodeBase64(json);
-        if (decoded === undefined) {
-            report.addError('INVALID_FORMAT', ['contentEncoding:base64', JSON.stringify(json)], undefined, schema, 'contentEncoding');
-            return;
-        }
-        payload = decoded;
-    }
-    try {
-        JSON.parse(payload);
-    }
-    catch {
-        report.addError('INVALID_FORMAT', ['contentMediaType:application/json', JSON.stringify(json)], undefined, schema, 'contentMediaType');
-    }
-}

package/dist/validation/type.js

@@ -1,55 +0,0 @@
-import { areEqual } from '../utils/json.js';
-import { whatIs } from '../utils/what-is.js';
-import { shouldSkipValidate } from './shared.js';
-// ---------------------------------------------------------------------------
-// type
-// ---------------------------------------------------------------------------
-export function typeValidator(report, schema, json) {
-    // http://json-schema.org/latest/json-schema-validation.html#rfc.section.5.5.2.2
-    if (shouldSkipValidate(this.validateOptions, ['INVALID_TYPE'])) {
-        return;
-    }
-    const jsonType = whatIs(json);
-    if (typeof schema.type === 'string') {
-        if (jsonType !== schema.type && (jsonType !== 'integer' || schema.type !== 'number')) {
-            report.addError('INVALID_TYPE', [schema.type, jsonType], undefined, schema, 'type');
-        }
-    }
-    else {
-        if (!schema.type.includes(jsonType) && (jsonType !== 'integer' || !schema.type.includes('number'))) {
-            report.addError('INVALID_TYPE', [JSON.stringify(schema.type), jsonType], undefined, schema, 'type');
-        }
-    }
-}
-// ---------------------------------------------------------------------------
-// enum
-// ---------------------------------------------------------------------------
-export function enumValidator(report, schema, json) {
-    // http://json-schema.org/latest/json-schema-validation.html#rfc.section.5.5.1.2
-    if (shouldSkipValidate(this.validateOptions, ['ENUM_CASE_MISMATCH', 'ENUM_MISMATCH'])) {
-        return;
-    }
-    let match = false, caseInsensitiveMatch = false;
-    for (const enumVal of schema.enum) {
-        if (areEqual(json, enumVal, { maxDepth: this.options.maxRecursionDepth })) {
-            match = true;
-            break;
-        }
-        else if (areEqual(json, enumVal, { caseInsensitiveComparison: true, maxDepth: this.options.maxRecursionDepth })) {
-            caseInsensitiveMatch = true;
-        }
-    }
-    if (match === false) {
-        const error = caseInsensitiveMatch && this.options.enumCaseInsensitiveComparison ? 'ENUM_CASE_MISMATCH' : 'ENUM_MISMATCH';
-        report.addError(error, [JSON.stringify(json)], undefined, schema, 'enum');
-    }
-}
-// ---------------------------------------------------------------------------
-// const
-// ---------------------------------------------------------------------------
-export function constValidator(report, schema, json) {
-    const constValue = schema.const;
-    if (areEqual(json, constValue, { maxDepth: this.options.maxRecursionDepth }) === false) {
-        report.addError('CONST', [JSON.stringify(constValue)], undefined, schema, undefined);
-    }
-}