used hyperjump pact for better performance

Author: animeshsahoo1

src/error-handlers/anyOf.js

@@ -1,77 +1,69 @@
 import * as Instance from "@hyperjump/json-schema/instance/experimental";
+import * as JsonPointer from "@hyperjump/json-pointer";
+import * as Pact from "@hyperjump/pact";
 import { getErrors } from "../json-schema-errors.js";
 
 /**
  * @import { ErrorHandler, ErrorObject, NormalizedOutput } from "../index.d.ts"
  */
 
-/** @type (alternative: NormalizedOutput, propLocation: string) => boolean */
-const propertyPasses = (alternative, propLocation) => {
-  const propOutput = alternative[propLocation];
-  if (!propOutput || Object.keys(propOutput).length === 0) return false;
-  return Object.values(propOutput).every((keywordResults) =>
-    Object.values(keywordResults).every((v) => v === true)
-  );
-};
-
 /** @type ErrorHandler */
 const anyOfErrorHandler = async (normalizedErrors, instance, localization) => {
   /** @type ErrorObject[] */
   const errors = [];
 
-  for (const schemaLocation in normalizedErrors[
-    "https://json-schema.org/keyword/anyOf"
-  ]) {
-    const anyOf
-      = normalizedErrors["https://json-schema.org/keyword/anyOf"][schemaLocation];
+  for (const schemaLocation in normalizedErrors["https://json-schema.org/keyword/anyOf"]) {
+    const anyOf = normalizedErrors["https://json-schema.org/keyword/anyOf"][schemaLocation];
     if (typeof anyOf === "boolean") {
       continue;
     }
     const instanceLocation = Instance.uri(instance);
     let filtered = anyOf;
 
     if (Instance.typeOf(instance) === "object") {
-      const instanceProps = new Set(
-        [...Instance.keys(instance)].map(
-          (keyNode) => /** @type {string} */ (Instance.value(keyNode))
+      const instanceProps = Pact.collectSet(
+        Pact.map(
+          (keyNode) => /** @type {string} */ (Instance.value(keyNode)),
+          Instance.keys(instance)
         )
       );
       const prefix = `${instanceLocation}/`;
 
-      filtered = filtered.filter((alternative) => {
+      filtered = [];
+      for (const alternative of anyOf) {
+        const typeResults = alternative[instanceLocation]["https://json-schema.org/keyword/type"];
+        if (typeResults && !Object.values(typeResults).every((isValid) => isValid)) {
+          continue;
+        }
+
         const declaredProps = Object.keys(alternative)
           .filter((loc) => loc.startsWith(prefix))
-          .map((loc) => loc.slice(prefix.length));
+          .map((loc) => /** @type {string} */ (Pact.head(JsonPointer.pointerSegments(loc.slice(prefix.length - 1)))));
 
-        if (declaredProps.length === 0) return true;
-        return declaredProps.some((prop) => instanceProps.has(prop));
-      });
+        if (declaredProps.length > 0 && !declaredProps.some((prop) => instanceProps.has(prop))) {
+          continue;
+        }
 
-      filtered = filtered.filter((alternative) =>
-        [...instanceProps].some((prop) =>
-          propertyPasses(alternative, `${instanceLocation}/${prop}`)
-        )
-      );
+        if (!Pact.some((prop) => propertyPasses(alternative[JsonPointer.append(prop, instanceLocation)]), instanceProps)) {
+          continue;
+        }
 
-      if (filtered.length === 0) {
-        filtered = anyOf;
+        filtered.push(alternative);
       }
     } else {
-      filtered = filtered.filter((alternative) => {
-        const typeResults
-          = alternative[instanceLocation]?.[
-            "https://json-schema.org/keyword/type"
-          ];
-        return (
-          !typeResults || Object.values(typeResults).every((isValid) => isValid)
-        );
-      });
-
-      if (filtered.length === 0) {
-        filtered = anyOf;
+      filtered = [];
+      for (const alternative of anyOf) {
+        const typeResults = alternative[instanceLocation]["https://json-schema.org/keyword/type"];
+        if (!typeResults || Object.values(typeResults).every((isValid) => isValid)) {
+          filtered.push(alternative);
+        }
       }
     }
 
+    if (filtered.length === 0) {
+      filtered = anyOf;
+    }
+
     const alternatives = [];
     for (const alternative of filtered) {
       alternatives.push(await getErrors(alternative, instance, localization));
@@ -92,4 +84,12 @@ const anyOfErrorHandler = async (normalizedErrors, instance, localization) => {
   return errors;
 };
 
+/** @type (propOutput: NormalizedOutput[string] | undefined) => boolean */
+const propertyPasses = (propOutput) => {
+  if (!propOutput || Object.keys(propOutput).length === 0) return false;
+  return Object.values(propOutput).every((keywordResults) =>
+    Object.values(keywordResults).every((v) => v === true)
+  );
+};
+
 export default anyOfErrorHandler;

src/error-handlers/oneOf.js

@@ -1,29 +1,19 @@
 import * as Instance from "@hyperjump/json-schema/instance/experimental";
+import * as JsonPointer from "@hyperjump/json-pointer";
+import * as Pact from "@hyperjump/pact";
 import { getErrors } from "../json-schema-errors.js";
 
 /**
  * @import { ErrorHandler, ErrorObject, NormalizedOutput } from "../index.d.ts"
  */
 
-/** @type (alternative: NormalizedOutput, propLocation: string) => boolean */
-const propertyPasses = (alternative, propLocation) => {
-  const propOutput = alternative[propLocation];
-  if (!propOutput || Object.keys(propOutput).length === 0) return false;
-  return Object.values(propOutput).every((keywordResults) =>
-    Object.values(keywordResults).every((v) => v === true)
-  );
-};
-
 /** @type ErrorHandler */
 const oneOfErrorHandler = async (normalizedErrors, instance, localization) => {
   /** @type ErrorObject[] */
   const errors = [];
 
-  for (const schemaLocation in normalizedErrors[
-    "https://json-schema.org/keyword/oneOf"
-  ]) {
-    const oneOf
-      = normalizedErrors["https://json-schema.org/keyword/oneOf"][schemaLocation];
+  for (const schemaLocation in normalizedErrors["https://json-schema.org/keyword/oneOf"]) {
+    const oneOf = normalizedErrors["https://json-schema.org/keyword/oneOf"][schemaLocation];
     if (typeof oneOf === "boolean") {
       continue;
     }
@@ -35,11 +25,7 @@ const oneOfErrorHandler = async (normalizedErrors, instance, localization) => {
     const failingAlternatives = [];
 
     for (const alternative of oneOf) {
-      const alternativeErrors = await getErrors(
-        alternative,
-        instance,
-        localization
-      );
+      const alternativeErrors = await getErrors(alternative, instance, localization);
       if (alternativeErrors.length) {
         failingAlternatives.push(alternativeErrors);
       } else {
@@ -64,54 +50,52 @@ const oneOfErrorHandler = async (normalizedErrors, instance, localization) => {
     let filtered = oneOf;
 
     if (Instance.typeOf(instance) === "object") {
-      const instanceProps = new Set(
-        [...Instance.keys(instance)].map(
-          (keyNode) => /** @type {string} */ (Instance.value(keyNode))
+      const instanceProps = Pact.collectSet(
+        Pact.map(
+          (keyNode) => /** @type {string} */ (Instance.value(keyNode)),
+          Instance.keys(instance)
         )
       );
       const prefix = `${instanceLocation}/`;
 
-      filtered = filtered.filter((alternative) => {
+      filtered = [];
+      for (const alternative of oneOf) {
+        const typeResults = alternative[instanceLocation]["https://json-schema.org/keyword/type"];
+        if (typeResults && !Object.values(typeResults).every((isValid) => isValid)) {
+          continue;
+        }
+
         const declaredProps = Object.keys(alternative)
           .filter((loc) => loc.startsWith(prefix))
-          .map((loc) => loc.slice(prefix.length));
+          .map((loc) => /** @type {string} */ (Pact.head(JsonPointer.pointerSegments(loc.slice(prefix.length - 1)))));
 
-        if (declaredProps.length === 0) return true;
-        return declaredProps.some((prop) => instanceProps.has(prop));
-      });
+        if (declaredProps.length > 0 && !declaredProps.some((prop) => instanceProps.has(prop))) {
+          continue;
+        }
 
-      filtered = filtered.filter((alternative) =>
-        [...instanceProps].some((prop) =>
-          propertyPasses(alternative, `${instanceLocation}/${prop}`)
-        )
-      );
+        if (!Pact.some((prop) => propertyPasses(alternative[JsonPointer.append(prop, instanceLocation)]), instanceProps)) {
+          continue;
+        }
 
-      if (filtered.length === 0) {
-        filtered = oneOf;
+        filtered.push(alternative);
       }
     } else {
-      filtered = filtered.filter((alternative) => {
-        const typeResults
-          = alternative[instanceLocation]?.[
-            "https://json-schema.org/keyword/type"
-          ];
-        return (
-          !typeResults || Object.values(typeResults).every((isValid) => isValid)
-        );
-      });
-
-      if (filtered.length === 0) {
-        filtered = oneOf;
+      filtered = [];
+      for (const alternative of oneOf) {
+        const typeResults = alternative[instanceLocation]["https://json-schema.org/keyword/type"];
+        if (!typeResults || Object.values(typeResults).every((isValid) => isValid)) {
+          filtered.push(alternative);
+        }
       }
     }
 
+    if (filtered.length === 0) {
+      filtered = oneOf;
+    }
+
     const alternatives = [];
     for (const alternative of filtered) {
-      const alternativeErrors = await getErrors(
-        alternative,
-        instance,
-        localization
-      );
+      const alternativeErrors = await getErrors(alternative, instance, localization);
       if (alternativeErrors.length) {
         alternatives.push(alternativeErrors);
       }
@@ -136,4 +120,12 @@ const oneOfErrorHandler = async (normalizedErrors, instance, localization) => {
   return errors;
 };
 
+/** @type (propOutput: NormalizedOutput[string] | undefined) => boolean */
+const propertyPasses = (propOutput) => {
+  if (!propOutput || Object.keys(propOutput).length === 0) return false;
+  return Object.values(propOutput).every((keywordResults) =>
+    Object.values(keywordResults).every((v) => v === true)
+  );
+};
+
 export default oneOfErrorHandler;