z-schema 12.0.4 → 12.1.0

package/dist/utils/json.js

@@ -1,70 +0,0 @@
-import { DEFAULT_MAX_RECURSION_DEPTH } from './constants.js';
-import { isObject } from './what-is.js';
-export const areEqual = (json1, json2, options, _depth = 0) => {
-    const caseInsensitiveComparison = options?.caseInsensitiveComparison || false;
-    const maxDepth = options?.maxDepth ?? DEFAULT_MAX_RECURSION_DEPTH;
-    // http://json-schema.org/latest/json-schema-core.html#rfc.section.3.6
-    // Two JSON values are said to be equal if and only if:
-    // both are nulls; or
-    // both are booleans, and have the same value; or
-    // both are strings, and have the same value; or
-    // both are numbers, and have the same mathematical value; or
-    if (json1 === json2) {
-        return true;
-    }
-    if (caseInsensitiveComparison === true &&
-        typeof json1 === 'string' &&
-        typeof json2 === 'string' &&
-        json1.toUpperCase() === json2.toUpperCase()) {
-        return true;
-    }
-    if (_depth >= maxDepth) {
-        throw new Error(`Maximum recursion depth (${maxDepth}) exceeded in areEqual. ` +
-            'If your data is deeply nested and valid, increase the maxRecursionDepth option.');
-    }
-    let i, len;
-    // both are arrays, and:
-    if (Array.isArray(json1) && Array.isArray(json2)) {
-        // have the same number of items; and
-        if (json1.length !== json2.length) {
-            return false;
-        }
-        // items at the same index are equal according to this definition; or
-        len = json1.length;
-        for (i = 0; i < len; i++) {
-            if (!areEqual(json1[i], json2[i], options, _depth + 1)) {
-                return false;
-            }
-        }
-        return true;
-    }
-    // both are objects, and:
-    if (isObject(json1) && isObject(json2)) {
-        // have the same set of property names; and
-        const keys1 = sortedKeys(json1);
-        const keys2 = sortedKeys(json2);
-        if (!areEqual(keys1, keys2, options, _depth + 1)) {
-            return false;
-        }
-        // values for a same property name are equal according to this definition.
-        len = keys1.length;
-        for (i = 0; i < len; i++) {
-            if (!areEqual(json1[keys1[i]], json2[keys1[i]], options, _depth + 1)) {
-                return false;
-            }
-        }
-        return true;
-    }
-    return false;
-};
-export const decodeJSONPointer = (str) => {
-    // http://tools.ietf.org/html/draft-ietf-appsawg-json-pointer-07#section-3
-    return decodeURIComponent(str).replace(/~[0-1]/g, (x) => (x === '~1' ? '/' : '~'));
-};
-export const sortedKeys = (obj) => Object.keys(obj).sort();
-export const get = (obj, path) => {
-    if (typeof path === 'string') {
-        path = path.split('.');
-    }
-    return path.reduce((acc, key) => (acc && acc[key] !== undefined ? acc[key] : undefined), obj);
-};

package/dist/utils/properties.js

@@ -1,10 +0,0 @@
-export function copyProp(from, to, key, fn) {
-    if (Object.hasOwn(from, key)) {
-        Object.defineProperty(to, key, {
-            value: fn ? fn(from[key]) : from[key],
-            enumerable: true,
-            writable: true,
-            configurable: true,
-        });
-    }
-}

package/dist/utils/schema-regex.js

@@ -1,52 +0,0 @@
-// Shared regex compilation helper for JSON Schema patterns
-// Returns { ok: true, value: RegExp } or { ok: false, error: { pattern, message } }
-import { MAX_SCHEMA_REGEX_LENGTH } from './constants.js';
-export function compileSchemaRegex(pattern) {
-    if (pattern.length > MAX_SCHEMA_REGEX_LENGTH) {
-        return {
-            ok: false,
-            error: {
-                pattern,
-                message: `Pattern length ${pattern.length} exceeds maximum allowed length of ${MAX_SCHEMA_REGEX_LENGTH}`,
-            },
-        };
-    }
-    const unicodePropertyEscape = /\\[pP]{/;
-    const nonBmpCharacter = /[\u{10000}-\u{10FFFF}]/u;
-    const surrogatePairEscape = /\\uD[89AB][0-9A-Fa-f]{2}\\uD[CDEF][0-9A-Fa-f]{2}/;
-    const needsUnicode = unicodePropertyEscape.test(pattern) || nonBmpCharacter.test(pattern) || surrogatePairEscape.test(pattern);
-    // Try compiling without 'u' flag if not needed
-    if (needsUnicode) {
-        // Try compiling with 'u' flag only
-        try {
-            // lgtm[js/regex-injection] JSON Schema `pattern` is intentionally regex syntax and constrained by MAX_SCHEMA_REGEX_LENGTH.
-            const re = new RegExp(pattern, 'u');
-            return { ok: true, value: re };
-        }
-        catch (e) {
-            return {
-                ok: false,
-                error: {
-                    pattern,
-                    message: e && e.message ? e.message : 'Invalid regular expression',
-                },
-            };
-        }
-    }
-    else {
-        try {
-            // lgtm[js/regex-injection] JSON Schema `pattern` is intentionally regex syntax and constrained by MAX_SCHEMA_REGEX_LENGTH.
-            const re = new RegExp(pattern);
-            return { ok: true, value: re };
-        }
-        catch (e) {
-            return {
-                ok: false,
-                error: {
-                    pattern,
-                    message: e && e.message ? e.message : 'Invalid regular expression',
-                },
-            };
-        }
-    }
-}

package/dist/utils/symbols.js

@@ -1,2 +0,0 @@
-export const jsonSymbol = Symbol.for('z-schema/json');
-export const schemaSymbol = Symbol.for('z-schema/schema');

package/dist/utils/time.js

@@ -1,50 +0,0 @@
-export const toUtcTime = (hour, minute, offsetSign, offsetHour, offsetMinute) => {
-    const localTotalMinutes = hour * 60 + minute;
-    const offsetTotalMinutes = offsetHour * 60 + offsetMinute;
-    const utcTotalMinutes = offsetSign === '+' ? localTotalMinutes - offsetTotalMinutes : localTotalMinutes + offsetTotalMinutes;
-    const normalizedUtcTotalMinutes = ((utcTotalMinutes % 1440) + 1440) % 1440;
-    return {
-        hour: Math.floor(normalizedUtcTotalMinutes / 60),
-        minute: normalizedUtcTotalMinutes % 60,
-    };
-};
-const RFC3339_TIME_REGEX = /^([0-9]{2}):([0-9]{2}):([0-9]{2})(\.[0-9]+)?(z|([+-][0-9]{2}:[0-9]{2}))$/i;
-export const parseRfc3339Time = (time) => {
-    const matches = RFC3339_TIME_REGEX.exec(time);
-    if (matches === null) {
-        return null;
-    }
-    const hour = parseInt(matches[1], 10);
-    const minute = parseInt(matches[2], 10);
-    const second = parseInt(matches[3], 10);
-    if (hour > 23 || minute > 59 || second > 60) {
-        return null;
-    }
-    let utcHour = hour;
-    let utcMinute = minute;
-    if (matches[5].toLowerCase() !== 'z') {
-        const offsetMatches = /^([+-])([0-9]{2}):([0-9]{2})$/.exec(matches[5]);
-        if (offsetMatches === null) {
-            return null;
-        }
-        const offsetSign = offsetMatches[1];
-        const offsetHour = parseInt(offsetMatches[2], 10);
-        const offsetMinute = parseInt(offsetMatches[3], 10);
-        if (offsetHour > 23 || offsetMinute > 59) {
-            return null;
-        }
-        const utc = toUtcTime(hour, minute, offsetSign, offsetHour, offsetMinute);
-        utcHour = utc.hour;
-        utcMinute = utc.minute;
-    }
-    if (second === 60 && (utcHour !== 23 || utcMinute !== 59)) {
-        return null;
-    }
-    return {
-        hour,
-        minute,
-        second,
-        utcHour,
-        utcMinute,
-    };
-};

package/dist/utils/unicode.js

@@ -1,12 +0,0 @@
-/**
- * Returns the number of Unicode code points in the string.
- * Uses the built-in string iterator which correctly handles surrogate pairs.
- */
-export function unicodeLength(str) {
-    let count = 0;
-    for (const _cp of str) {
-        void _cp;
-        count++;
-    }
-    return count;
-}

package/dist/utils/uri.js

@@ -1,15 +0,0 @@
-export const getQueryPath = (uri) => {
-    const io = uri.indexOf('#');
-    const res = io === -1 ? undefined : uri.slice(io + 1);
-    // WARN: do not slice slash, #/ means take root and go down from it
-    // if (res && res[0] === "/") { res = res.slice(1); }
-    return res;
-};
-export const getRemotePath = (uri) => {
-    const io = uri.indexOf('#');
-    return io === -1 ? uri : uri.slice(0, io);
-};
-export const isAbsoluteUri = (uri) => /^[a-zA-Z][a-zA-Z\d+.-]*:/.test(uri);
-export const isRelativeUri = (uri) => 
-// relative URIs that end with a hash sign, issue #56
-/.+#/.test(uri);

package/dist/utils/what-is.js

@@ -1,32 +0,0 @@
-export const whatIs = (what) => {
-    if (typeof what === 'object') {
-        if (what === null) {
-            return 'null';
-        }
-        if (Array.isArray(what)) {
-            return 'array';
-        }
-        return 'object'; // typeof what === 'object' && what === Object(what) && !Array.isArray(what);
-    }
-    if (typeof what === 'number') {
-        if (Number.isFinite(what)) {
-            if (what % 1 === 0) {
-                return 'integer';
-            }
-            else {
-                return 'number';
-            }
-        }
-        if (Number.isNaN(what)) {
-            return 'not-a-number';
-        }
-        return 'unknown-number';
-    }
-    return typeof what; // undefined, boolean, string, function
-};
-export function isObject(value) {
-    return typeof value === 'object' && value !== null && !Array.isArray(value);
-}
-export function isInteger(value) {
-    return typeof value === 'number' && Number.isFinite(value) && value % 1 === 0;
-}

package/dist/validation/array.js

@@ -1,127 +0,0 @@
-import { isUniqueArray } from '../utils/array.js';
-import { cacheValidationResult, deferOrRunSync, shouldSkipValidate } from './shared.js';
-// ---------------------------------------------------------------------------
-// additionalItems
-// ---------------------------------------------------------------------------
-export function additionalItemsValidator(report, schema, json) {
-    // http://json-schema.org/latest/json-schema-validation.html#rfc.section.5.3.1.2
-    if (shouldSkipValidate(this.validateOptions, ['ARRAY_ADDITIONAL_ITEMS'])) {
-        return;
-    }
-    if (!Array.isArray(json)) {
-        return;
-    }
-    // if the value of "additionalItems" is boolean value false and the value of "items" is an array,
-    // the json is valid if its size is less than, or equal to, the size of "items".
-    if (schema.additionalItems === false && Array.isArray(schema.items)) {
-        if (json.length > schema.items.length) {
-            report.addError('ARRAY_ADDITIONAL_ITEMS', undefined, undefined, schema, 'additionalItems');
-        }
-    }
-}
-// ---------------------------------------------------------------------------
-// items  (no-op — covered in additionalItems / recurseArray)
-// ---------------------------------------------------------------------------
-export function itemsValidator() {
-    /*report: Report, schema: JsonSchemaInternal, json: unknown*/
-    // covered in additionalItems
-}
-// ---------------------------------------------------------------------------
-// prefixItems  (no-op — handled in recurseArray)
-// ---------------------------------------------------------------------------
-export function prefixItemsValidator() {
-    // handled in recurseArray
-}
-// ---------------------------------------------------------------------------
-// maxItems
-// ---------------------------------------------------------------------------
-export function maxItemsValidator(report, schema, json) {
-    // http://json-schema.org/latest/json-schema-validation.html#rfc.section.5.3.2.2
-    if (shouldSkipValidate(this.validateOptions, ['ARRAY_LENGTH_LONG'])) {
-        return;
-    }
-    if (!Array.isArray(json)) {
-        return;
-    }
-    if (json.length > schema.maxItems) {
-        report.addError('ARRAY_LENGTH_LONG', [json.length, schema.maxItems], undefined, schema, 'maxItems');
-    }
-}
-// ---------------------------------------------------------------------------
-// minItems
-// ---------------------------------------------------------------------------
-export function minItemsValidator(report, schema, json) {
-    // http://json-schema.org/latest/json-schema-validation.html#rfc.section.5.3.3.2
-    if (shouldSkipValidate(this.validateOptions, ['ARRAY_LENGTH_SHORT'])) {
-        return;
-    }
-    if (!Array.isArray(json)) {
-        return;
-    }
-    if (json.length < schema.minItems) {
-        report.addError('ARRAY_LENGTH_SHORT', [json.length, schema.minItems], undefined, schema, 'minItems');
-    }
-}
-// ---------------------------------------------------------------------------
-// uniqueItems
-// ---------------------------------------------------------------------------
-export function uniqueItemsValidator(report, schema, json) {
-    // http://json-schema.org/latest/json-schema-validation.html#rfc.section.5.3.4.2
-    if (shouldSkipValidate(this.validateOptions, ['ARRAY_UNIQUE'])) {
-        return;
-    }
-    if (!Array.isArray(json)) {
-        return;
-    }
-    if (schema.uniqueItems === true) {
-        const matches = [];
-        if (isUniqueArray(json, matches, this.options.maxRecursionDepth) === false) {
-            report.addError('ARRAY_UNIQUE', matches, undefined, schema, 'uniqueItems');
-        }
-    }
-}
-// ---------------------------------------------------------------------------
-// contains
-// ---------------------------------------------------------------------------
-export function containsValidator(report, schema, json) {
-    if (shouldSkipValidate(this.validateOptions, ['CONTAINS'])) {
-        return;
-    }
-    if (!Array.isArray(json)) {
-        return;
-    }
-    const containsSchema = schema.contains;
-    if (containsSchema === undefined) {
-        return;
-    }
-    const Report_ = report.constructor;
-    const subReports = [];
-    for (let idx = 0; idx < json.length; idx++) {
-        const subReport = new Report_(report);
-        subReports.push(subReport);
-        this._jsonValidate(subReport, containsSchema, json[idx]);
-        cacheValidationResult(report, containsSchema, json[idx], subReport.errors.length === 0);
-    }
-    const addContainsErrorIfNeeded = () => {
-        let matchingItems = 0;
-        for (const subReport of subReports) {
-            if (subReport.errors.length === 0) {
-                matchingItems += 1;
-            }
-        }
-        const supportsContainsBounds = this.options.version === 'draft2019-09' || this.options.version === 'draft2020-12';
-        const minContains = supportsContainsBounds && typeof schema.minContains === 'number' ? (schema.minContains ?? 1) : 1;
-        const maxContains = supportsContainsBounds && typeof schema.maxContains === 'number' ? schema.maxContains : undefined;
-        const hasEnoughMatches = matchingItems >= minContains;
-        const notTooManyMatches = maxContains === undefined || matchingItems <= maxContains;
-        if (!hasEnoughMatches || !notTooManyMatches) {
-            report.addError('CONTAINS', undefined, subReports, schema, undefined);
-        }
-    };
-    deferOrRunSync(report, subReports, addContainsErrorIfNeeded);
-}
-// ---------------------------------------------------------------------------
-// maxContains / minContains  (no-op — handled inside contains)
-// ---------------------------------------------------------------------------
-export function maxContainsValidator() { }
-export function minContainsValidator() { }

package/dist/validation/combinators.js

@@ -1,106 +0,0 @@
-import { Report } from '../report.js';
-import { cacheValidationResult, deferOrRunSync } from './shared.js';
-// ---------------------------------------------------------------------------
-// allOf
-// ---------------------------------------------------------------------------
-export function allOfValidator(report, schema, json) {
-    // http://json-schema.org/latest/json-schema-validation.html#rfc.section.5.5.3.2
-    for (let i = 0; i < schema.allOf.length; i++) {
-        const validateResult = this._jsonValidate(report, schema.allOf[i], json);
-        if (this.options.breakOnFirstError && validateResult === false) {
-            break;
-        }
-    }
-}
-// ---------------------------------------------------------------------------
-// anyOf
-// ---------------------------------------------------------------------------
-export function anyOfValidator(report, schema, json) {
-    // http://json-schema.org/latest/json-schema-validation.html#rfc.section.5.5.4.2
-    const subReports = [];
-    for (let i = 0; i < schema.anyOf.length; i++) {
-        const subReport = new Report(report);
-        subReports.push(subReport);
-        this._jsonValidate(subReport, schema.anyOf[i], json);
-        cacheValidationResult(report, schema.anyOf[i], json, subReport.errors.length === 0);
-    }
-    // Aggregate async tasks and decide when ready
-    deferOrRunSync(report, subReports, () => {
-        let passed = false;
-        for (const subReport of subReports) {
-            if (subReport.errors.length === 0) {
-                passed = true;
-                break;
-            }
-        }
-        if (passed === false) {
-            report.addError('ANY_OF_MISSING', undefined, subReports, schema, 'anyOf');
-        }
-    });
-}
-// ---------------------------------------------------------------------------
-// oneOf
-// ---------------------------------------------------------------------------
-export function oneOfValidator(report, schema, json) {
-    // http://json-schema.org/latest/json-schema-validation.html#rfc.section.5.5.5.2
-    const subReports = [];
-    for (let i = 0; i < schema.oneOf.length; i++) {
-        const subReport = new Report(report);
-        subReports.push(subReport);
-        this._jsonValidate(subReport, schema.oneOf[i], json);
-        cacheValidationResult(report, schema.oneOf[i], json, subReport.errors.length === 0);
-    }
-    // Aggregate async tasks and decide when ready
-    deferOrRunSync(report, subReports, () => {
-        let passes = 0;
-        for (const subReport of subReports) {
-            if (subReport.errors.length === 0) {
-                passes++;
-            }
-        }
-        if (passes === 0) {
-            report.addError('ONE_OF_MISSING', undefined, subReports, schema, 'oneOf');
-        }
-        else if (passes > 1) {
-            report.addError('ONE_OF_MULTIPLE', undefined, undefined, schema, 'oneOf');
-        }
-    });
-}
-// ---------------------------------------------------------------------------
-// not
-// ---------------------------------------------------------------------------
-export function notValidator(report, schema, json) {
-    // http://json-schema.org/latest/json-schema-validation.html#rfc.section.5.5.6.2
-    const subReport = new Report(report);
-    if (this._jsonValidate(subReport, schema.not, json) === true) {
-        report.addError('NOT_PASSED', undefined, undefined, schema, 'not');
-    }
-}
-// ---------------------------------------------------------------------------
-// if / then / else
-// ---------------------------------------------------------------------------
-export function ifValidator(report, schema, json) {
-    if (this.options.version === 'draft-04' || this.options.version === 'draft-06') {
-        return;
-    }
-    const conditionSchema = schema.if;
-    const thenSchema = schema.then;
-    const elseSchema = schema.else;
-    if (conditionSchema === undefined || (thenSchema === undefined && elseSchema === undefined)) {
-        return;
-    }
-    const conditionReport = new Report(report);
-    this._jsonValidate(conditionReport, conditionSchema, json);
-    cacheValidationResult(report, conditionSchema, json, conditionReport.errors.length === 0);
-    const branchSchema = conditionReport.errors.length === 0 ? thenSchema : elseSchema;
-    if (branchSchema === undefined) {
-        return;
-    }
-    this._jsonValidate(report, branchSchema, json);
-}
-export function thenValidator() {
-    // handled by if
-}
-export function elseValidator() {
-    // handled by if
-}

package/dist/validation/numeric.js

@@ -1,97 +0,0 @@
-import { shouldSkipValidate } from './shared.js';
-// ---------------------------------------------------------------------------
-// multipleOf
-// ---------------------------------------------------------------------------
-export function multipleOfValidator(report, schema, json) {
-    // http://json-schema.org/latest/json-schema-validation.html#rfc.section.5.1.1.2
-    if (shouldSkipValidate(this.validateOptions, ['MULTIPLE_OF'])) {
-        return;
-    }
-    if (typeof json !== 'number') {
-        return;
-    }
-    const result = json / schema.multipleOf;
-    if (!Number.isFinite(result) || Math.abs(result - Math.round(result)) >= 1e-10) {
-        report.addError('MULTIPLE_OF', [json, schema.multipleOf], undefined, schema, 'multipleOf');
-    }
-}
-// ---------------------------------------------------------------------------
-// maximum
-// ---------------------------------------------------------------------------
-export function maximumValidator(report, schema, json) {
-    // http://json-schema.org/latest/json-schema-validation.html#rfc.section.5.1.2.2
-    if (shouldSkipValidate(this.validateOptions, ['MAXIMUM', 'MAXIMUM_EXCLUSIVE'])) {
-        return;
-    }
-    if (typeof json !== 'number') {
-        return;
-    }
-    if (schema.exclusiveMaximum !== true) {
-        if (json > schema.maximum) {
-            report.addError('MAXIMUM', [json, schema.maximum], undefined, schema, 'maximum');
-        }
-    }
-    else {
-        if (json >= schema.maximum) {
-            report.addError('MAXIMUM_EXCLUSIVE', [json, schema.maximum], undefined, schema, 'maximum');
-        }
-    }
-}
-// ---------------------------------------------------------------------------
-// exclusiveMaximum
-// ---------------------------------------------------------------------------
-export function exclusiveMaximumValidator(report, schema, json) {
-    // In draft-06+, exclusiveMaximum is a standalone number
-    if (typeof schema.exclusiveMaximum === 'number') {
-        if (shouldSkipValidate(this.validateOptions, ['MAXIMUM_EXCLUSIVE'])) {
-            return;
-        }
-        if (typeof json !== 'number') {
-            return;
-        }
-        if (json >= schema.exclusiveMaximum) {
-            report.addError('MAXIMUM_EXCLUSIVE', [json, schema.exclusiveMaximum], undefined, schema, 'exclusiveMaximum');
-        }
-    }
-    // In draft-04, exclusiveMaximum is a boolean handled inside the `maximum` validator
-}
-// ---------------------------------------------------------------------------
-// minimum
-// ---------------------------------------------------------------------------
-export function minimumValidator(report, schema, json) {
-    // http://json-schema.org/latest/json-schema-validation.html#rfc.section.5.1.3.2
-    if (shouldSkipValidate(this.validateOptions, ['MINIMUM', 'MINIMUM_EXCLUSIVE'])) {
-        return;
-    }
-    if (typeof json !== 'number') {
-        return;
-    }
-    if (schema.exclusiveMinimum !== true) {
-        if (json < schema.minimum) {
-            report.addError('MINIMUM', [json, schema.minimum], undefined, schema, 'minimum');
-        }
-    }
-    else {
-        if (json <= schema.minimum) {
-            report.addError('MINIMUM_EXCLUSIVE', [json, schema.minimum], undefined, schema, 'minimum');
-        }
-    }
-}
-// ---------------------------------------------------------------------------
-// exclusiveMinimum
-// ---------------------------------------------------------------------------
-export function exclusiveMinimumValidator(report, schema, json) {
-    // In draft-06+, exclusiveMinimum is a standalone number
-    if (typeof schema.exclusiveMinimum === 'number') {
-        if (shouldSkipValidate(this.validateOptions, ['MINIMUM_EXCLUSIVE'])) {
-            return;
-        }
-        if (typeof json !== 'number') {
-            return;
-        }
-        if (json <= schema.exclusiveMinimum) {
-            report.addError('MINIMUM_EXCLUSIVE', [json, schema.exclusiveMinimum], undefined, schema, 'exclusiveMinimum');
-        }
-    }
-    // In draft-04, exclusiveMinimum is a boolean handled inside the `minimum` validator
-}