z-schema 7.0.0 → 7.0.5

package/README.md

@@ -1,11 +1,12 @@
-# z-schema validator
+# z-schema - a JSON Schema validator
 
-[![NPM](https://nodei.co/npm/z-schema.png?downloads=true&downloadRank=true)](https://nodei.co/npm/z-schema/)
+[![NPM](https://nodei.co/npm/z-schema.png?downloads=true&downloadRank=true)](https://www.npmjs.com/package/z-schema)
 
 [![coverage status](https://coveralls.io/repos/zaggino/z-schema/badge.svg)](https://coveralls.io/r/zaggino/z-schema)
 
 ## Topics
 
+- [What](#what)
 - [Usage](#usage)
 - [Features](#features)
 - [Options](#options)
@@ -13,6 +14,10 @@
 - [Contributing](#contributing)
 - [Contributors](#contributors)
 
+## What
+
+What is a JSON Schema? Find here: [https://json-schema.org/](https://json-schema.org/)
+
 ## Usage
 
 Validator will try to perform sync validation when possible for speed, but supports async callbacks when they are necessary.

package/cjs/index.d.ts

@@ -189,6 +189,8 @@ declare class ZSchema {
     private validateOptions;
     options: ZSchemaOptions;
     constructor(options?: ZSchemaOptions);
+    /** Used by SchemaCache to break circular dependency with SchemaCompilation */
+    _compileSchema(report: Report, schema: unknown): boolean;
     /**
      * @param schema - JSON object representing schema
      * @returns {boolean} true if schema is valid.

package/cjs/index.js

@@ -11972,257 +11972,6 @@ function requireLodash_isequal () {
 var lodash_isequalExports = requireLodash_isequal();
 var isequal = /*@__PURE__*/getDefaultExportFromCjs(lodash_isequalExports);
 
-function mergeReference(scope, ref) {
-    if (isAbsoluteUri(ref)) {
-        return ref;
-    }
-    let joinedScope = scope.join('');
-    const isScopeAbsolute = isAbsoluteUri(joinedScope);
-    const isScopeRelative = isRelativeUri(joinedScope);
-    const isRefRelative = isRelativeUri(ref);
-    let toRemove;
-    if (isScopeAbsolute && isRefRelative) {
-        toRemove = joinedScope.match(/\/[^/]*$/);
-        if (toRemove) {
-            joinedScope = joinedScope.slice(0, toRemove.index + 1);
-        }
-    }
-    else if (isScopeRelative && isRefRelative) {
-        joinedScope = '';
-    }
-    else {
-        toRemove = joinedScope.match(/[^#/]+$/);
-        if (toRemove) {
-            joinedScope = joinedScope.slice(0, toRemove.index);
-        }
-    }
-    let res = joinedScope + ref;
-    res = res.replace(/##/, '#');
-    return res;
-}
-function collectReferences(obj, results, scope, path) {
-    results = results || [];
-    scope = scope || [];
-    path = path || [];
-    if (typeof obj !== 'object' || obj === null) {
-        return results;
-    }
-    if (typeof obj.id === 'string') {
-        scope.push(obj.id);
-    }
-    if (typeof obj.$ref === 'string' && typeof obj.__$refResolved === 'undefined') {
-        results.push({
-            ref: mergeReference(scope, obj.$ref),
-            key: '$ref',
-            obj: obj,
-            path: path.slice(0),
-        });
-    }
-    if (typeof obj.$schema === 'string' && typeof obj.__$schemaResolved === 'undefined') {
-        results.push({
-            ref: mergeReference(scope, obj.$schema),
-            key: '$schema',
-            obj: obj,
-            path: path.slice(0),
-        });
-    }
-    let idx;
-    if (Array.isArray(obj)) {
-        idx = obj.length;
-        while (idx--) {
-            path.push(idx.toString());
-            collectReferences(obj[idx], results, scope, path);
-            path.pop();
-        }
-    }
-    else {
-        const keys = Object.keys(obj);
-        idx = keys.length;
-        while (idx--) {
-            // do not recurse through resolved references and other z-schema props
-            if (keys[idx].indexOf('__$') === 0) {
-                continue;
-            }
-            path.push(keys[idx]);
-            collectReferences(obj[keys[idx]], results, scope, path);
-            path.pop();
-        }
-    }
-    if (typeof obj.id === 'string') {
-        scope.pop();
-    }
-    return results;
-}
-const compileArrayOfSchemasLoop = function (mainReport, arr) {
-    let idx = arr.length, compiledCount = 0;
-    while (idx--) {
-        // try to compile each schema separately
-        const report = new Report(mainReport);
-        const isValid = compileSchema.call(this, report, arr[idx]);
-        if (isValid) {
-            compiledCount++;
-        }
-        // copy errors to report
-        mainReport.errors = mainReport.errors.concat(report.errors);
-    }
-    return compiledCount;
-};
-function findId$1(arr, id) {
-    let idx = arr.length;
-    while (idx--) {
-        if (arr[idx].id === id) {
-            return arr[idx];
-        }
-    }
-    return null;
-}
-const compileArrayOfSchemas = function (report, arr) {
-    let compiled = 0, lastLoopCompiled;
-    do {
-        // remove all UNRESOLVABLE_REFERENCE errors before compiling array again
-        let idx = report.errors.length;
-        while (idx--) {
-            if (report.errors[idx].code === 'UNRESOLVABLE_REFERENCE') {
-                report.errors.splice(idx, 1);
-            }
-        }
-        // remember how many were compiled in the last loop
-        lastLoopCompiled = compiled;
-        // count how many are compiled now
-        compiled = compileArrayOfSchemasLoop.call(this, report, arr);
-        // fix __$missingReferences if possible
-        idx = arr.length;
-        while (idx--) {
-            const sch = arr[idx];
-            if (sch.__$missingReferences) {
-                let idx2 = sch.__$missingReferences.length;
-                while (idx2--) {
-                    const refObj = sch.__$missingReferences[idx2];
-                    const response = findId$1(arr, refObj.ref);
-                    if (response) {
-                        // this might create circular references
-                        refObj.obj['__' + refObj.key + 'Resolved'] = response;
-                        // it's resolved now so delete it
-                        sch.__$missingReferences.splice(idx2, 1);
-                    }
-                }
-                if (sch.__$missingReferences.length === 0) {
-                    delete sch.__$missingReferences;
-                }
-            }
-        }
-        // keep repeating if not all compiled and at least one more was compiled in the last loop
-    } while (compiled !== arr.length && compiled !== lastLoopCompiled);
-    return report.isValid();
-};
-function compileSchema(report, schema) {
-    report.commonErrorMessage = 'SCHEMA_COMPILATION_FAILED';
-    // if schema is a string, assume it's a uri
-    if (typeof schema === 'string') {
-        const loadedSchema = getSchemaByUri.call(this, report, schema);
-        if (!loadedSchema) {
-            report.addError('SCHEMA_NOT_REACHABLE', [schema]);
-            return false;
-        }
-        schema = loadedSchema;
-    }
-    // if schema is an array, assume it's an array of schemas
-    if (Array.isArray(schema)) {
-        return compileArrayOfSchemas.call(this, report, schema);
-    }
-    // if we have an id than it should be cached already (if this instance has compiled it)
-    if (schema.__$compiled && schema.id && checkCacheForUri.call(this, schema.id) === false) {
-        schema.__$compiled = undefined;
-    }
-    // do not re-compile schemas
-    if (schema.__$compiled) {
-        return true;
-    }
-    if (schema.id && typeof schema.id === 'string') {
-        // add this to our schemaCache (before compilation in case we have references including id)
-        cacheSchemaByUri.call(this, schema.id, schema);
-    }
-    // this method can be called recursively, so we need to remember our root
-    let isRoot = false;
-    if (!report.rootSchema) {
-        report.rootSchema = schema;
-        isRoot = true;
-    }
-    // delete all __$missingReferences from previous compilation attempts
-    const isValidExceptReferences = report.isValid();
-    delete schema.__$missingReferences;
-    // collect all references that need to be resolved - $ref and $schema
-    const refs = collectReferences.call(this, schema);
-    let idx = refs.length;
-    while (idx--) {
-        // resolve all the collected references into __xxxResolved pointer
-        const refObj = refs[idx];
-        let response = getSchemaByUri.call(this, report, refObj.ref, schema);
-        // we can try to use custom schemaReader if available
-        if (!response) {
-            const schemaReader = this.getSchemaReader();
-            if (schemaReader) {
-                // it's supposed to return a valid schema
-                const s = schemaReader(refObj.ref);
-                if (s) {
-                    // it needs to have the id
-                    s.id = refObj.ref;
-                    // try to compile the schema
-                    const subreport = new Report(report);
-                    if (!compileSchema.call(this, subreport, s)) {
-                        // copy errors to report
-                        report.errors = report.errors.concat(subreport.errors);
-                    }
-                    else {
-                        response = getSchemaByUri.call(this, report, refObj.ref, schema);
-                    }
-                }
-            }
-        }
-        if (!response) {
-            const hasNotValid = report.hasError('REMOTE_NOT_VALID', [refObj.ref]);
-            const isAbsolute = isAbsoluteUri(refObj.ref);
-            let isDownloaded = false;
-            const ignoreUnresolvableRemotes = this.options.ignoreUnresolvableReferences === true;
-            if (isAbsolute) {
-                // we shouldn't add UNRESOLVABLE_REFERENCE for schemas we already have downloaded
-                // and set through setRemoteReference method
-                isDownloaded = checkCacheForUri.call(this, refObj.ref);
-            }
-            if (hasNotValid) ;
-            else if (ignoreUnresolvableRemotes && isAbsolute) ;
-            else if (isDownloaded) ;
-            else {
-                Array.prototype.push.apply(report.path, refObj.path);
-                report.addError('UNRESOLVABLE_REFERENCE', [refObj.ref]);
-                report.path = report.path.slice(0, -refObj.path.length);
-                // pusblish unresolved references out
-                if (isValidExceptReferences) {
-                    schema.__$missingReferences = schema.__$missingReferences || [];
-                    schema.__$missingReferences.push(refObj);
-                }
-            }
-        }
-        // this might create circular references
-        refObj.obj['__' + refObj.key + 'Resolved'] = response;
-    }
-    const isValid = report.isValid();
-    if (isValid) {
-        schema.__$compiled = true;
-    }
-    else {
-        if (schema.id && typeof schema.id === 'string') {
-            // remove this schema from schemaCache because it failed to compile
-            removeFromCacheByUri.call(this, schema.id);
-        }
-    }
-    // we don't need the root pointer anymore
-    if (isRoot) {
-        report.rootSchema = undefined;
-    }
-    return isValid;
-}
-
 const SchemaValidators = {
     $ref: function (report, schema) {
         // http://tools.ietf.org/html/draft-ietf-appsawg-json-pointer-07
@@ -12868,7 +12617,7 @@ function getQueryPath(uri) {
     // if (res && res[0] === "/") { res = res.slice(1); }
     return res;
 }
-function findId(schema, id) {
+function findId$1(schema, id) {
     // process only arrays and objects
     if (typeof schema !== 'object' || schema === null) {
         return;
@@ -12886,7 +12635,7 @@ function findId(schema, id) {
     if (Array.isArray(schema)) {
         idx = schema.length;
         while (idx--) {
-            result = findId(schema[idx], id);
+            result = findId$1(schema[idx], id);
             if (result) {
                 return result;
             }
@@ -12900,7 +12649,7 @@ function findId(schema, id) {
             if (k.indexOf('__$') === 0) {
                 continue;
             }
-            result = findId(schema[k], id);
+            result = findId$1(schema[k], id);
             if (result) {
                 return result;
             }
@@ -12980,7 +12729,7 @@ function getSchemaByUri(report, uri, root) {
             }
             else {
                 remoteReport = new Report(report);
-                if (compileSchema.call(this, remoteReport, result)) {
+                if (this._compileSchema(remoteReport, result)) {
                     const savedOptions = this.options;
                     try {
                         // If custom validationOptions were provided to setRemoteReference(),
@@ -13009,7 +12758,7 @@ function getSchemaByUri(report, uri, root) {
             const key = decodeJSONPointer(parts[idx]);
             if (idx === 0) {
                 // it's an id
-                result = findId(result, key);
+                result = findId$1(result, key);
             }
             else {
                 // it's a path behind id
@@ -13020,6 +12769,257 @@ function getSchemaByUri(report, uri, root) {
     return result;
 }
 
+function mergeReference(scope, ref) {
+    if (isAbsoluteUri(ref)) {
+        return ref;
+    }
+    let joinedScope = scope.join('');
+    const isScopeAbsolute = isAbsoluteUri(joinedScope);
+    const isScopeRelative = isRelativeUri(joinedScope);
+    const isRefRelative = isRelativeUri(ref);
+    let toRemove;
+    if (isScopeAbsolute && isRefRelative) {
+        toRemove = joinedScope.match(/\/[^/]*$/);
+        if (toRemove) {
+            joinedScope = joinedScope.slice(0, toRemove.index + 1);
+        }
+    }
+    else if (isScopeRelative && isRefRelative) {
+        joinedScope = '';
+    }
+    else {
+        toRemove = joinedScope.match(/[^#/]+$/);
+        if (toRemove) {
+            joinedScope = joinedScope.slice(0, toRemove.index);
+        }
+    }
+    let res = joinedScope + ref;
+    res = res.replace(/##/, '#');
+    return res;
+}
+function collectReferences(obj, results, scope, path) {
+    results = results || [];
+    scope = scope || [];
+    path = path || [];
+    if (typeof obj !== 'object' || obj === null) {
+        return results;
+    }
+    if (typeof obj.id === 'string') {
+        scope.push(obj.id);
+    }
+    if (typeof obj.$ref === 'string' && typeof obj.__$refResolved === 'undefined') {
+        results.push({
+            ref: mergeReference(scope, obj.$ref),
+            key: '$ref',
+            obj: obj,
+            path: path.slice(0),
+        });
+    }
+    if (typeof obj.$schema === 'string' && typeof obj.__$schemaResolved === 'undefined') {
+        results.push({
+            ref: mergeReference(scope, obj.$schema),
+            key: '$schema',
+            obj: obj,
+            path: path.slice(0),
+        });
+    }
+    let idx;
+    if (Array.isArray(obj)) {
+        idx = obj.length;
+        while (idx--) {
+            path.push(idx.toString());
+            collectReferences(obj[idx], results, scope, path);
+            path.pop();
+        }
+    }
+    else {
+        const keys = Object.keys(obj);
+        idx = keys.length;
+        while (idx--) {
+            // do not recurse through resolved references and other z-schema props
+            if (keys[idx].indexOf('__$') === 0) {
+                continue;
+            }
+            path.push(keys[idx]);
+            collectReferences(obj[keys[idx]], results, scope, path);
+            path.pop();
+        }
+    }
+    if (typeof obj.id === 'string') {
+        scope.pop();
+    }
+    return results;
+}
+const compileArrayOfSchemasLoop = function (mainReport, arr) {
+    let idx = arr.length, compiledCount = 0;
+    while (idx--) {
+        // try to compile each schema separately
+        const report = new Report(mainReport);
+        const isValid = compileSchema.call(this, report, arr[idx]);
+        if (isValid) {
+            compiledCount++;
+        }
+        // copy errors to report
+        mainReport.errors = mainReport.errors.concat(report.errors);
+    }
+    return compiledCount;
+};
+function findId(arr, id) {
+    let idx = arr.length;
+    while (idx--) {
+        if (arr[idx].id === id) {
+            return arr[idx];
+        }
+    }
+    return null;
+}
+const compileArrayOfSchemas = function (report, arr) {
+    let compiled = 0, lastLoopCompiled;
+    do {
+        // remove all UNRESOLVABLE_REFERENCE errors before compiling array again
+        let idx = report.errors.length;
+        while (idx--) {
+            if (report.errors[idx].code === 'UNRESOLVABLE_REFERENCE') {
+                report.errors.splice(idx, 1);
+            }
+        }
+        // remember how many were compiled in the last loop
+        lastLoopCompiled = compiled;
+        // count how many are compiled now
+        compiled = compileArrayOfSchemasLoop.call(this, report, arr);
+        // fix __$missingReferences if possible
+        idx = arr.length;
+        while (idx--) {
+            const sch = arr[idx];
+            if (sch.__$missingReferences) {
+                let idx2 = sch.__$missingReferences.length;
+                while (idx2--) {
+                    const refObj = sch.__$missingReferences[idx2];
+                    const response = findId(arr, refObj.ref);
+                    if (response) {
+                        // this might create circular references
+                        refObj.obj['__' + refObj.key + 'Resolved'] = response;
+                        // it's resolved now so delete it
+                        sch.__$missingReferences.splice(idx2, 1);
+                    }
+                }
+                if (sch.__$missingReferences.length === 0) {
+                    delete sch.__$missingReferences;
+                }
+            }
+        }
+        // keep repeating if not all compiled and at least one more was compiled in the last loop
+    } while (compiled !== arr.length && compiled !== lastLoopCompiled);
+    return report.isValid();
+};
+function compileSchema(report, schema) {
+    report.commonErrorMessage = 'SCHEMA_COMPILATION_FAILED';
+    // if schema is a string, assume it's a uri
+    if (typeof schema === 'string') {
+        const loadedSchema = getSchemaByUri.call(this, report, schema);
+        if (!loadedSchema) {
+            report.addError('SCHEMA_NOT_REACHABLE', [schema]);
+            return false;
+        }
+        schema = loadedSchema;
+    }
+    // if schema is an array, assume it's an array of schemas
+    if (Array.isArray(schema)) {
+        return compileArrayOfSchemas.call(this, report, schema);
+    }
+    // if we have an id than it should be cached already (if this instance has compiled it)
+    if (schema.__$compiled && schema.id && checkCacheForUri.call(this, schema.id) === false) {
+        schema.__$compiled = undefined;
+    }
+    // do not re-compile schemas
+    if (schema.__$compiled) {
+        return true;
+    }
+    if (schema.id && typeof schema.id === 'string') {
+        // add this to our schemaCache (before compilation in case we have references including id)
+        cacheSchemaByUri.call(this, schema.id, schema);
+    }
+    // this method can be called recursively, so we need to remember our root
+    let isRoot = false;
+    if (!report.rootSchema) {
+        report.rootSchema = schema;
+        isRoot = true;
+    }
+    // delete all __$missingReferences from previous compilation attempts
+    const isValidExceptReferences = report.isValid();
+    delete schema.__$missingReferences;
+    // collect all references that need to be resolved - $ref and $schema
+    const refs = collectReferences.call(this, schema);
+    let idx = refs.length;
+    while (idx--) {
+        // resolve all the collected references into __xxxResolved pointer
+        const refObj = refs[idx];
+        let response = getSchemaByUri.call(this, report, refObj.ref, schema);
+        // we can try to use custom schemaReader if available
+        if (!response) {
+            const schemaReader = this.getSchemaReader();
+            if (schemaReader) {
+                // it's supposed to return a valid schema
+                const s = schemaReader(refObj.ref);
+                if (s) {
+                    // it needs to have the id
+                    s.id = refObj.ref;
+                    // try to compile the schema
+                    const subreport = new Report(report);
+                    if (!compileSchema.call(this, subreport, s)) {
+                        // copy errors to report
+                        report.errors = report.errors.concat(subreport.errors);
+                    }
+                    else {
+                        response = getSchemaByUri.call(this, report, refObj.ref, schema);
+                    }
+                }
+            }
+        }
+        if (!response) {
+            const hasNotValid = report.hasError('REMOTE_NOT_VALID', [refObj.ref]);
+            const isAbsolute = isAbsoluteUri(refObj.ref);
+            let isDownloaded = false;
+            const ignoreUnresolvableRemotes = this.options.ignoreUnresolvableReferences === true;
+            if (isAbsolute) {
+                // we shouldn't add UNRESOLVABLE_REFERENCE for schemas we already have downloaded
+                // and set through setRemoteReference method
+                isDownloaded = checkCacheForUri.call(this, refObj.ref);
+            }
+            if (hasNotValid) ;
+            else if (ignoreUnresolvableRemotes && isAbsolute) ;
+            else if (isDownloaded) ;
+            else {
+                Array.prototype.push.apply(report.path, refObj.path);
+                report.addError('UNRESOLVABLE_REFERENCE', [refObj.ref]);
+                report.path = report.path.slice(0, -refObj.path.length);
+                // pusblish unresolved references out
+                if (isValidExceptReferences) {
+                    schema.__$missingReferences = schema.__$missingReferences || [];
+                    schema.__$missingReferences.push(refObj);
+                }
+            }
+        }
+        // this might create circular references
+        refObj.obj['__' + refObj.key + 'Resolved'] = response;
+    }
+    const isValid = report.isValid();
+    if (isValid) {
+        schema.__$compiled = true;
+    }
+    else {
+        if (schema.id && typeof schema.id === 'string') {
+            // remove this schema from schemaCache because it failed to compile
+            removeFromCacheByUri.call(this, schema.id);
+        }
+    }
+    // we don't need the root pointer anymore
+    if (isRoot) {
+        report.rootSchema = undefined;
+    }
+    return isValid;
+}
+
 var id$1 = "http://json-schema.org/draft-04/schema#";
 var $schema$1 = "http://json-schema.org/draft-04/schema#";
 var description = "Core schema meta-schema";
@@ -13561,6 +13561,10 @@ class ZSchema {
         this.setRemoteReference('http://json-schema.org/draft-04/schema', Draft4Schema, metaschemaOptions);
         this.setRemoteReference('http://json-schema.org/draft-04/hyper-schema', Draft4HyperSchema, metaschemaOptions);
     }
+    /** Used by SchemaCache to break circular dependency with SchemaCompilation */
+    _compileSchema(report, schema) {
+        return compileSchema.call(this, report, schema);
+    }
     /**
      * @param schema - JSON object representing schema
      * @returns {boolean} true if schema is valid.

package/dist/SchemaCache.js

@@ -1,6 +1,5 @@
 import isequal from 'lodash.isequal';
 import { Report } from './Report.js';
-import { compileSchema } from './SchemaCompilation.js';
 import * as SchemaValidation from './SchemaValidation.js';
 import * as Utils from './Utils.js';
 function decodeJSONPointer(str) {
@@ -132,7 +131,7 @@ export function getSchemaByUri(report, uri, root) {
             }
             else {
                 remoteReport = new Report(report);
-                if (compileSchema.call(this, remoteReport, result)) {
+                if (this._compileSchema(remoteReport, result)) {
                     const savedOptions = this.options;
                     try {
                         // If custom validationOptions were provided to setRemoteReference(),

package/dist/ZSchema.js

@@ -143,6 +143,10 @@ export class ZSchema {
         this.setRemoteReference('http://json-schema.org/draft-04/schema', Draft4Schema, metaschemaOptions);
         this.setRemoteReference('http://json-schema.org/draft-04/hyper-schema', Draft4HyperSchema, metaschemaOptions);
     }
+    /** Used by SchemaCache to break circular dependency with SchemaCompilation */
+    _compileSchema(report, schema) {
+        return SchemaCompilation.compileSchema.call(this, report, schema);
+    }
     /**
      * @param schema - JSON object representing schema
      * @returns {boolean} true if schema is valid.

package/dist/types/ZSchema.d.ts

@@ -60,6 +60,8 @@ export declare class ZSchema {
     private validateOptions;
     options: ZSchemaOptions;
     constructor(options?: ZSchemaOptions);
+    /** Used by SchemaCache to break circular dependency with SchemaCompilation */
+    _compileSchema(report: Report, schema: unknown): boolean;
     /**
      * @param schema - JSON object representing schema
      * @returns {boolean} true if schema is valid.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "z-schema",
-  "version": "7.0.0",
+  "version": "7.0.5",
   "engines": {
     "node": ">=22.0.0"
   },
@@ -67,7 +67,8 @@
     "test": "vitest run",
     "test:browsers": "vitest run --project browsers --silent=true",
     "test:node": "vitest run --project node --silent=true",
-    "test:sample": "npx vitest run --silent=false --hideSkippedTests --project node -t \"invalid definition\""
+    "test:sample": "npx vitest run --silent=false --hideSkippedTests --project node -t \"invalid definition\"",
+    "release:commit": "node -e \"const v=process.argv[1]; if(!v) throw new Error('Usage: npm run release:empty-commit -- <version>'); require('child_process').execSync(`git commit --allow-empty -m \\\"chore: release ${v}\\\" -m \\\"Release-As: ${v}\\\"`, {stdio:'inherit'});\" --"
   },
   "dependencies": {
     "lodash.get": "^4.4.2",

package/src/SchemaCache.ts

@@ -1,6 +1,5 @@
 import isequal from 'lodash.isequal';
 import { Report } from './Report.js';
-import { compileSchema } from './SchemaCompilation.js';
 import * as SchemaValidation from './SchemaValidation.js';
 import * as Utils from './Utils.js';
 
@@ -146,7 +145,7 @@ export function getSchemaByUri(report, uri, root) {
         remoteReport = anscestorReport;
       } else {
         remoteReport = new Report(report);
-        if (compileSchema.call(this, remoteReport, result)) {
+        if (this._compileSchema(remoteReport, result)) {
           const savedOptions = this.options;
           try {
             // If custom validationOptions were provided to setRemoteReference(),