@hyperjump/json-schema 1.4.6 → 1.5.0

package/README.md

@@ -254,7 +254,7 @@ import { addSchema } from "@hyperjump/json-schema/draft-2020-12";
 import { bundle } from "@hyperjump/json-schema/bundle";
 
 addSchema({
-  "$id": "https://example.com/main"
+  "$id": "https://example.com/main",
   "$schema": "https://json-schema.org/draft/2020-12/schema",
 
   "type": "object",
@@ -280,8 +280,8 @@ const bundledSchema = await bundle("https://example.com/main"); // {
 //   },
 //
 //   "$defs": {
-//     "https://example.com/main": {
-//       "$id": "https://example.com/main",
+//     "https://example.com/string": {
+//       "$id": "https://example.com/string",
 //       "type": "string"
 //     }
 //   }
@@ -564,15 +564,18 @@ set of functions for working with SchemaDocuments.
 * **Schema.step**: (key: string, doc: SchemaDocument) => Promise<SchemaDocument>
 
     Similar to `schema[key]`, but returns an SchemaDocument.
-* **Schema.entries**: (doc: SchemaDocument) => Promise<[[string, SchemaDocument]]>
+* **Schema.iter**: (doc: SchemaDocument) => AsyncGenerator<SchemaDocument>
 
-    Similar to `Object.entries`, but returns SchemaDocuments for values.
-* **Schema.keys**: (doc: SchemaDocument) => [string]
+    Iterate over the items in the array that the SchemaDocument represents
+* **Schema.entries**: (doc: SchemaDocument) => AsyncGenerator<[string, SchemaDocument]>
 
-    Similar to `Object.keys`.
-* **Schema.map**: (fn: (item: Promise<SchemaDocument>, index: integer) => T, doc: SchemaDocument) => Promise<[T]>
+    Similar to `Object.entries`, but yields SchemaDocuments for values.
+* **Schema.values**: (doc: SchemaDocument) => AsyncGenerator<SchemaDocument>
+
+    Similar to `Object.values`, but yields SchemaDocuments for values.
+* **Schema.keys**: (doc: SchemaDocument) => Generator<string>
 
-    A `map` function for an SchemaDocument whose value is an array.
+    Similar to `Object.keys`.
 * **Schema.length**: (doc: SchemaDocument) => number
 
     Similar to `Array.prototype.length`.
@@ -622,24 +625,18 @@ set of functions for working with InstanceDocuments.
 * **Instance.step**: (key: string, doc: InstanceDocument) => InstanceDocument
 
     Similar to `schema[key]`, but returns a InstanceDocument.
-* **Instance.entries**: (doc: InstanceDocument) => [string, InstanceDocument]
-
-    Similar to `Object.entries`, but returns IDocs for values.
-* **Instance.keys**: (doc: InstanceDocument) => [string]
+* **Instance.iter**: (doc: InstanceDocument) => Generator<InstanceDocument>
 
-    Similar to `Object.keys`.
-* **Instance.map**: (fn: (item: InstanceDocument, index: integer) => T, doc: InstanceDocument) => [T]
-
-    A `map` function for an InstanceDocument whose value is an array.
-* **Instance.reduce**: (fn: (accumulator: T, item: InstanceDocument, index: integer) => T, initial: T, doc: InstanceDocument) => T
+    Iterate over the items in the array that the SchemaDocument represents.
+* **Instance.entries**: (doc: InstanceDocument) => Generator<[string, InstanceDocument]>
 
-    A `reduce` function for an InstanceDocument whose value is an array.
-* **Instance.every**: (fn: (doc: InstanceDocument, index: integer) => boolean, doc: InstanceDocument) => boolean
+    Similar to `Object.entries`, but yields InstanceDocuments for values.
+* **Instance.values**: (doc: InstanceDocument) => Generator<InstanceDocument>
 
-    An `every` function for an InstanceDocument whose value is an array.
-* **Instance.some**: (fn: (doc: InstanceDocument, index: integer) => boolean, doc: InstanceDocument) => boolean
+    Similar to `Object.values`, but yields InstanceDocuments for values.
+* **Instance.keys**: (doc: InstanceDocument) => Generator<string>
 
-    A `some` function for an InstanceDocument whose value is an array.
+    Similar to `Object.keys`.
 * **Instance.length**: (doc: InstanceDocument) => number
 
     Similar to `Array.prototype.length`.
@@ -708,10 +705,9 @@ const unknowns = AnnotatedInstance.annotation(instance, "unknown", dialectId); /
 const types = AnnotatedInstance.annotation(instance, "type", dialectId); // => []
 
 // Get the title of each of the properties in the object
-AnnotatedInstance.entries(instance)
-  .map(([propertyName, propertyInstance]) => {
-    return { propertyName, titles: Instance.annotation(propertyInstance, "title", dialectId) }; // => (Example) { propertyName: "givenName", titles: ["Given Name", "Name"] });
-  });
+for (const [propertyName, propertyInstance] of AnnotatedInstance.entries(instance)) {
+  console.log(propertyName, Instance.annotation(propertyInstance, "title", dialectId));
+}
 
 // List all locations in the instance that are deprecated
 for (const deprecated of AnnotatedInstance.annotatedWith(instance, "deprecated", dialectId)) {

package/draft-04/additionalItems.js

@@ -1,3 +1,4 @@
+import { pipe, drop, every } from "@hyperjump/pact";
 import * as Instance from "../lib/instance.js";
 import * as Schema from "../lib/schema.js";
 import Validation from "../lib/keywords/validation.js";
@@ -19,7 +20,11 @@ const interpret = ([numberOfItems, additionalItems], instance, ast, dynamicAncho
     return true;
   }
 
-  return Instance.every((item, ndx) => ndx < numberOfItems || Validation.interpret(additionalItems, item, ast, dynamicAnchors), instance, quiet);
+  return pipe(
+    Instance.iter(instance),
+    drop(numberOfItems),
+    every((item) => Validation.interpret(additionalItems, item, ast, dynamicAnchors, quiet))
+  );
 };
 
 const collectEvaluatedItems = (keywordValue, instance, ast, dynamicAnchors) => {

package/draft-04/dependencies.js

@@ -1,18 +1,19 @@
+import { pipe, asyncMap, asyncCollectArray } from "@hyperjump/pact";
 import * as Instance from "../lib/instance.js";
 import * as Schema from "../lib/schema.js";
 import Validation from "../lib/keywords/validation.js";
-import * as Pact from "@hyperjump/pact";
 
 
 const id = "https://json-schema.org/keyword/draft-04/dependencies";
 
-const compile = (schema, ast) => Pact.pipeline([
-  Schema.entries,
-  Pact.map(async ([key, dependency]) => {
-    return [key, Schema.typeOf(dependency, "array") ? Schema.value(dependency) : await Validation.compile(dependency, ast)];
-  }),
-  Pact.all
-], schema);
+const compile = (schema, ast) => pipe(
+  Schema.entries(schema),
+  asyncMap(async ([key, dependency]) => [
+    key,
+    Schema.typeOf(dependency, "array") ? Schema.value(dependency) : await Validation.compile(dependency, ast)
+  ]),
+  asyncCollectArray
+);
 
 const interpret = (dependencies, instance, ast, dynamicAnchors, quiet) => {
   const value = Instance.value(instance);

package/draft-04/items.js

@@ -1,3 +1,4 @@
+import { pipe, asyncMap, asyncCollectArray, every, zip, take, range, collectSet } from "@hyperjump/pact";
 import * as Instance from "../lib/instance.js";
 import * as Schema from "../lib/schema.js";
 import Validation from "../lib/keywords/validation.js";
@@ -5,10 +6,13 @@ import Validation from "../lib/keywords/validation.js";
 
 const id = "https://json-schema.org/keyword/draft-04/items";
 
-const compile = async (schema, ast) => {
+const compile = (schema, ast) => {
   if (Schema.typeOf(schema, "array")) {
-    const tupleItems = await Schema.map((itemSchema) => Validation.compile(itemSchema, ast), schema);
-    return Promise.all(tupleItems);
+    return pipe(
+      Schema.iter(schema),
+      asyncMap((itemSchema) => Validation.compile(itemSchema, ast)),
+      asyncCollectArray
+    );
   } else {
     return Validation.compile(schema, ast);
   }
@@ -20,16 +24,20 @@ const interpret = (items, instance, ast, dynamicAnchors, quiet) => {
   }
 
   if (typeof items === "string") {
-    return Instance.every((itemValue) => Validation.interpret(items, itemValue, ast, dynamicAnchors), instance, quiet);
+    return every((itemValue) => Validation.interpret(items, itemValue, ast, dynamicAnchors, quiet), Instance.iter(instance));
   } else {
-    return Instance.every((item, ndx) => !(ndx in items) || Validation.interpret(items[ndx], item, ast, dynamicAnchors), instance, quiet);
+    return pipe(
+      zip(items, Instance.iter(instance)),
+      take(Instance.length(instance)),
+      every(([prefixItem, item]) => Validation.interpret(prefixItem, item, ast, dynamicAnchors, quiet))
+    );
   }
 };
 
 const collectEvaluatedItems = (items, instance, ast, dynamicAnchors) => {
   return interpret(items, instance, ast, dynamicAnchors) && (typeof items === "string"
-    ? new Set(Instance.map((item, itemIndex) => itemIndex, instance))
-    : new Set(items.map((item, itemIndex) => itemIndex)));
+    ? collectSet(range(0, Instance.length(instance)))
+    : collectSet(range(0, items.length)));
 };
 
 export default { id, compile, interpret, collectEvaluatedItems };

package/draft-06/contains.js

@@ -1,3 +1,4 @@
+import { some } from "@hyperjump/pact";
 import * as Instance from "../lib/instance.js";
 import Validation from "../lib/keywords/validation.js";
 
@@ -7,7 +8,7 @@ const id = "https://json-schema.org/keyword/draft-06/contains";
 const compile = (schema, ast) => Validation.compile(schema, ast);
 
 const interpret = (contains, instance, ast, dynamicAnchors, quiet) => {
-  return !Instance.typeOf(instance, "array") || Instance.some((item) => Validation.interpret(contains, item, ast, dynamicAnchors), instance, quiet);
+  return !Instance.typeOf(instance, "array") || some((item) => Validation.interpret(contains, item, ast, dynamicAnchors, quiet), Instance.iter(instance));
 };
 
 export default { id, compile, interpret };

package/draft-2019-09/contains.js

@@ -1,3 +1,4 @@
+import { pipe, filter, reduce, zip, range, map, collectSet } from "@hyperjump/pact";
 import * as Instance from "../lib/instance.js";
 import * as Schema from "../lib/schema.js";
 import { getKeywordName } from "../lib/keywords.js";
@@ -21,20 +22,23 @@ const compile = async (schema, ast, parentSchema) => {
 };
 
 const interpret = ({ contains, minContains, maxContains }, instance, ast, dynamicAnchors, quiet) => {
-  if (!Instance.typeOf(instance, "array")) {
-    return true;
-  }
-
-  const matches = Instance.reduce((matches, item) => {
-    return Validation.interpret(contains, item, ast, dynamicAnchors, quiet) ? matches + 1 : matches;
-  }, 0, instance);
+  const matches = !Instance.typeOf(instance, "array") || pipe(
+    Instance.iter(instance),
+    filter((item) => Validation.interpret(contains, item, ast, dynamicAnchors, quiet)),
+    reduce((matches) => matches + 1, 0)
+  );
   return matches >= minContains && matches <= maxContains;
 };
 
 const collectEvaluatedItems = (keywordValue, instance, ast, dynamicAnchors) => {
-  return interpret(keywordValue, instance, ast, dynamicAnchors) && Instance.reduce((matchedIndexes, item, itemIndex) => {
-    return Validation.interpret(keywordValue.contains, item, ast, dynamicAnchors) ? matchedIndexes.add(itemIndex) : matchedIndexes;
-  }, new Set(), instance);
+  return interpret(keywordValue, instance, ast, dynamicAnchors, true)
+    && Instance.typeOf(instance, "array")
+    && pipe(
+      zip(Instance.iter(instance), range(0)),
+      filter(([item]) => Validation.interpret(keywordValue.contains, item, ast, dynamicAnchors, true)),
+      map(([, itemIndex]) => itemIndex),
+      collectSet
+    );
 };
 
 export default { id, compile, interpret, collectEvaluatedItems };

package/lib/instance.d.ts

@@ -26,40 +26,10 @@ export const typeOf: (
   (doc: JsonDocument) => (type: JsonType) => boolean
 );
 export const step: (key: string, doc: JsonDocument<JsonObject | Json[]>) => JsonDocument<typeof doc.value>;
-export const entries: (doc: JsonDocument<JsonObject>) => [string, JsonDocument][];
-export const keys: (doc: JsonDocument<JsonObject>) => string[];
-export const map: (
-  <A>(fn: MapFn<A>, doc: JsonDocument<Json[]>) => A[]
-) & (
-  <A>(fn: MapFn<A>) => (doc: JsonDocument<Json[]>) => A[]
-);
-export const forEach: (
-  (fn: ForEachFn, doc: JsonDocument<Json[]>) => void
-) & (
-  (fn: ForEachFn) => (doc: JsonDocument<Json[]>) => void
-);
-export const filter: (
-  (fn: FilterFn, doc: JsonDocument<Json[]>) => JsonDocument[]
-) & (
-  (fn: FilterFn) => (doc: JsonDocument<Json[]>) => JsonDocument[]
-);
-export const reduce: (
-  <A>(fn: ReduceFn<A>, acc: A, doc: JsonDocument<Json[]>) => A
-) & (
-  <A>(fn: ReduceFn<A>) => (acc: A, doc: JsonDocument<Json[]>) => A
-) & (
-  <A>(fn: ReduceFn<A>) => (acc: A) => (doc: JsonDocument<Json[]>) => A
-);
-export const every: (
-  (fn: FilterFn, doc: JsonDocument<Json[]>) => boolean
-) & (
-  (fn: FilterFn) => (doc: JsonDocument<Json[]>) => boolean
-);
-export const some: (
-  (fn: FilterFn, doc: JsonDocument<Json[]>) => boolean
-) & (
-  (fn: FilterFn) => (doc: JsonDocument<Json[]>) => boolean
-);
+export const iter: (doc: JsonDocument<JsonObject>) => Generator<JsonDocument>;
+export const keys: (doc: JsonDocument<JsonObject>) => Generator<string>;
+export const values: (doc: JsonDocument<JsonObject>) => Generator<JsonDocument>;
+export const entries: (doc: JsonDocument<JsonObject>) => Generator<[string, JsonDocument]>;
 export const length: (doc: JsonDocument<Json[] | string>) => number;
 
 type MapFn<A> = (element: JsonDocument, index: number) => A;

package/lib/instance.js

@@ -32,28 +32,28 @@ export const step = (key, doc) => ({
   value: value(doc)[key]
 });
 
-export const entries = (doc) => Object.keys(value(doc))
-  .map((key) => [key, step(key, doc)]);
-
-export const keys = (doc) => Object.keys(value(doc));
-
-export const map = curry((fn, doc) => value(doc)
-  .map((item, ndx, array, thisArg) => fn(step(ndx, doc), ndx, array, thisArg)));
-
-export const forEach = curry((fn, doc) => value(doc)
-  .forEach((item, ndx, array, thisArg) => fn(step(ndx, doc), ndx, array, thisArg)));
-
-export const filter = curry((fn, doc) => value(doc)
-  .map((item, ndx, array, thisArg) => step(ndx, doc, array, thisArg))
-  .filter((item, ndx, array, thisArg) => fn(item, ndx, array, thisArg)));
+export const iter = function* (doc) {
+  for (let index = 0; index < value(doc).length; index++) {
+    yield step(index, doc);
+  }
+};
 
-export const reduce = curry((fn, acc, doc) => value(doc)
-  .reduce((acc, item, ndx) => fn(acc, step(ndx, doc), ndx), acc));
+export const keys = function* (doc) {
+  for (const key in value(doc)) {
+    yield key;
+  }
+};
 
-export const every = curry((fn, doc) => value(doc)
-  .every((item, ndx, array, thisArg) => fn(step(ndx, doc), ndx, array, thisArg)));
+export const values = function* (doc) {
+  for (const key in value(doc)) {
+    yield step(key, doc);
+  }
+};
 
-export const some = curry((fn, doc) => value(doc)
-  .some((item, ndx, array, thisArg) => fn(step(ndx, doc), ndx, array, thisArg)));
+export const entries = function* (doc) {
+  for (const key in value(doc)) {
+    yield [key, step(key, doc)];
+  }
+};
 
 export const length = (doc) => value(doc).length;

package/lib/keywords/additionalProperties.js

@@ -1,3 +1,4 @@
+import { filter, every, pipe } from "@hyperjump/pact";
 import * as Schema from "../schema.js";
 import * as Instance from "../instance.js";
 import { getKeywordName } from "../keywords.js";
@@ -38,9 +39,11 @@ const interpret = ([isDefinedProperty, additionalProperties], instance, ast, dyn
     return true;
   }
 
-  return Instance.entries(instance)
-    .filter(([propertyName]) => !isDefinedProperty.test(propertyName))
-    .every(([, property]) => Validation.interpret(additionalProperties, property, ast, dynamicAnchors, quiet));
+  return pipe(
+    Instance.entries(instance),
+    filter(([propertyName]) => !isDefinedProperty.test(propertyName)),
+    every(([, property]) => Validation.interpret(additionalProperties, property, ast, dynamicAnchors, quiet))
+  );
 };
 
 const collectEvaluatedProperties = ([isDefinedProperty, additionalProperties], instance, ast, dynamicAnchors) => {

package/lib/keywords/allOf.js

@@ -1,14 +1,15 @@
-import * as Pact from "@hyperjump/pact";
+import { pipe, asyncMap, asyncCollectArray } from "@hyperjump/pact";
 import * as Schema from "../schema.js";
 import Validation from "./validation.js";
 
 
 const id = "https://json-schema.org/keyword/allOf";
 
-const compile = (schema, ast) => Pact.pipeline([
-  Schema.map(async (itemSchema) => Validation.compile(await itemSchema, ast)),
-  Pact.all
-], schema);
+const compile = (schema, ast) => pipe(
+  Schema.iter(schema),
+  asyncMap((itemSchema) => Validation.compile(itemSchema, ast)),
+  asyncCollectArray
+);
 
 const interpret = (allOf, instance, ast, dynamicAnchors, quiet) => {
   return allOf.every((schemaUrl) => Validation.interpret(schemaUrl, instance, ast, dynamicAnchors, quiet));

package/lib/keywords/anyOf.js

@@ -1,14 +1,15 @@
-import * as Pact from "@hyperjump/pact";
+import { pipe, asyncMap, asyncCollectArray } from "@hyperjump/pact";
 import * as Schema from "../schema.js";
 import Validation from "./validation.js";
 
 
 const id = "https://json-schema.org/keyword/anyOf";
 
-const compile = (schema, ast) => Pact.pipeline([
-  Schema.map(async (itemSchema) => Validation.compile(await itemSchema, ast)),
-  Pact.all
-], schema);
+const compile = (schema, ast) => pipe(
+  Schema.iter(schema),
+  asyncMap((itemSchema) => Validation.compile(itemSchema, ast)),
+  asyncCollectArray
+);
 
 const interpret = (anyOf, instance, ast, dynamicAnchors, quiet) => {
   const matches = anyOf.filter((schemaUrl) => Validation.interpret(schemaUrl, instance, ast, dynamicAnchors, quiet));

package/lib/keywords/contains.js

@@ -1,3 +1,4 @@
+import { pipe, map, filter, reduce, collectSet, zip, range } from "@hyperjump/pact";
 import * as Schema from "../schema.js";
 import * as Instance from "../instance.js";
 import { getKeywordName } from "../keywords.js";
@@ -21,33 +22,43 @@ const compile = async (schema, ast, parentSchema) => {
 };
 
 const interpret = ({ contains, minContains, maxContains }, instance, ast, dynamicAnchors, quiet) => {
-  if (!Instance.typeOf(instance, "array") && !Instance.typeOf(instance, "object")) {
+  let iterator;
+  if (Instance.typeOf(instance, "array")) {
+    iterator = Instance.iter(instance);
+  } else if (Instance.typeOf(instance, "object")) {
+    iterator = Instance.values(instance);
+  } else {
     return true;
   }
 
-  const matches = Instance.entries(instance).reduce((matches, [, item]) => {
-    return Validation.interpret(contains, item, ast, dynamicAnchors, quiet) ? matches + 1 : matches;
-  }, 0);
+  const matches = pipe(
+    iterator,
+    filter((item) => Validation.interpret(contains, item, ast, dynamicAnchors, quiet)),
+    reduce((matches) => matches + 1, 0)
+  );
   return matches >= minContains && matches <= maxContains;
 };
 
 const collectEvaluatedProperties = (keywordValue, instance, ast, dynamicAnchors) => {
   return interpret(keywordValue, instance, ast, dynamicAnchors, true)
     && Instance.typeOf(instance, "object")
-    && Instance.entries(instance).reduce((matchedPropertyNames, [propertyName, item]) => {
-      if (Validation.interpret(keywordValue.contains, item, ast, dynamicAnchors, true)) {
-        matchedPropertyNames.add(propertyName);
-      }
-      return matchedPropertyNames;
-    }, new Set(), instance);
+    && pipe(
+      Instance.entries(instance),
+      filter(([, item]) => Validation.interpret(keywordValue.contains, item, ast, dynamicAnchors, true)),
+      map(([propertyName]) => propertyName),
+      collectSet
+    );
 };
 
 const collectEvaluatedItems = (keywordValue, instance, ast, dynamicAnchors) => {
   return interpret(keywordValue, instance, ast, dynamicAnchors, true)
     && Instance.typeOf(instance, "array")
-    && Instance.reduce((matchedIndexes, item, itemIndex) => {
-      return Validation.interpret(keywordValue.contains, item, ast, dynamicAnchors, true) ? matchedIndexes.add(itemIndex) : matchedIndexes;
-    }, new Set(), instance);
+    && pipe(
+      zip(Instance.iter(instance), range(0)),
+      filter(([item]) => Validation.interpret(keywordValue.contains, item, ast, dynamicAnchors, true)),
+      map(([, itemIndex]) => itemIndex),
+      collectSet
+    );
 };
 
 export default { id, compile, interpret, collectEvaluatedItems, collectEvaluatedProperties };

package/lib/keywords/definitions.js

@@ -1,17 +1,15 @@
-import * as Pact from "@hyperjump/pact";
+import { pipe, asyncMap, asyncCollectArray } from "@hyperjump/pact";
 import * as Schema from "../schema.js";
 import Validation from "./validation.js";
 
 
 const id = "https://json-schema.org/keyword/definitions";
 
-const compile = async (schema, ast) => {
-  await Pact.pipeline([
-    Schema.entries,
-    Pact.map(([, definitionSchema]) => Validation.compile(definitionSchema, ast)),
-    Pact.all
-  ], schema);
-};
+const compile = (schema, ast) => pipe(
+  Schema.values(schema),
+  asyncMap((definitionSchema) => Validation.compile(definitionSchema, ast)),
+  asyncCollectArray
+);
 
 const interpret = () => true;
 

package/lib/keywords/dependentRequired.js

@@ -1,15 +1,15 @@
-import * as Pact from "@hyperjump/pact";
+import { pipe, asyncMap, asyncCollectArray } from "@hyperjump/pact";
 import * as Schema from "../schema.js";
 import * as Instance from "../instance.js";
 
 
 const id = "https://json-schema.org/keyword/dependentRequired";
 
-const compile = (schema) => Pact.pipeline([
-  Schema.entries,
-  Pact.map(([key, dependentRequired]) => [key, Schema.value(dependentRequired)]),
-  Pact.all
-], schema);
+const compile = (schema) => pipe(
+  Schema.entries(schema),
+  asyncMap(([key, dependentRequired]) => [key, Schema.value(dependentRequired)]),
+  asyncCollectArray
+);
 
 const interpret = (dependentRequired, instance) => {
   const value = Instance.value(instance);

package/lib/keywords/dependentSchemas.js

@@ -1,4 +1,4 @@
-import * as Pact from "@hyperjump/pact";
+import { pipe, asyncMap, asyncCollectArray } from "@hyperjump/pact";
 import * as Schema from "../schema.js";
 import * as Instance from "../instance.js";
 import Validation from "./validation.js";
@@ -6,11 +6,11 @@ import Validation from "./validation.js";
 
 const id = "https://json-schema.org/keyword/dependentSchemas";
 
-const compile = (schema, ast) => Pact.pipeline([
-  Schema.entries,
-  Pact.map(async ([key, dependentSchema]) => [key, await Validation.compile(dependentSchema, ast)]),
-  Pact.all
-], schema);
+const compile = (schema, ast) => pipe(
+  Schema.entries(schema),
+  asyncMap(async ([key, dependentSchema]) => [key, await Validation.compile(dependentSchema, ast)]),
+  asyncCollectArray
+);
 
 const interpret = (dependentSchemas, instance, ast, dynamicAnchors, quiet) => {
   const value = Instance.value(instance);

package/lib/keywords/items.js

@@ -1,3 +1,4 @@
+import { pipe, drop, every } from "@hyperjump/pact";
 import * as Schema from "../schema.js";
 import * as Instance from "../instance.js";
 import { getKeywordName } from "../keywords.js";
@@ -19,7 +20,11 @@ const interpret = ([numberOfPrefixItems, items], instance, ast, dynamicAnchors,
     return true;
   }
 
-  return Instance.every((item, ndx) => ndx < numberOfPrefixItems || Validation.interpret(items, item, ast, dynamicAnchors, quiet), instance);
+  return pipe(
+    Instance.iter(instance),
+    drop(numberOfPrefixItems),
+    every((item) => Validation.interpret(items, item, ast, dynamicAnchors, quiet))
+  );
 };
 
 const collectEvaluatedItems = (keywordValue, instance, ast, dynamicAnchors) => {

package/lib/keywords/maxProperties.js

@@ -5,6 +5,8 @@ import * as Instance from "../instance.js";
 const id = "https://json-schema.org/keyword/maxProperties";
 
 const compile = (schema) => Schema.value(schema);
-const interpret = (maxProperties, instance) => !Instance.typeOf(instance, "object") || Instance.keys(instance).length <= maxProperties;
+const interpret = (maxProperties, instance) => {
+  return !Instance.typeOf(instance, "object") || [...Instance.keys(instance)].length <= maxProperties;
+};
 
 export default { id, compile, interpret };

package/lib/keywords/minProperties.js

@@ -5,6 +5,8 @@ import * as Instance from "../instance.js";
 const id = "https://json-schema.org/keyword/minProperties";
 
 const compile = (schema) => Schema.value(schema);
-const interpret = (minProperties, instance) => !Instance.typeOf(instance, "object") || Instance.keys(instance).length >= minProperties;
+const interpret = (minProperties, instance) => {
+  return !Instance.typeOf(instance, "object") || [...Instance.keys(instance)].length >= minProperties;
+};
 
 export default { id, compile, interpret };

package/lib/keywords/oneOf.js

@@ -1,13 +1,15 @@
+import { pipe, asyncMap, asyncCollectArray } from "@hyperjump/pact";
 import * as Schema from "../schema.js";
 import Validation from "./validation.js";
 
 
 const id = "https://json-schema.org/keyword/oneOf";
 
-const compile = async (schema, ast) => {
-  const oneOf = await Schema.map((itemSchema) => Validation.compile(itemSchema, ast), schema);
-  return Promise.all(oneOf);
-};
+const compile = (schema, ast) => pipe(
+  Schema.iter(schema),
+  asyncMap((itemSchema) => Validation.compile(itemSchema, ast)),
+  asyncCollectArray
+);
 
 const interpret = (oneOf, instance, ast, dynamicAnchors, quiet) => {
   let validCount = 0;

package/lib/keywords/patternProperties.js

@@ -1,4 +1,4 @@
-import * as Pact from "@hyperjump/pact";
+import { pipe, asyncMap, asyncCollectArray, filter, every } from "@hyperjump/pact";
 import * as Schema from "../schema.js";
 import * as Instance from "../instance.js";
 import Validation from "./validation.js";
@@ -6,17 +6,22 @@ import Validation from "./validation.js";
 
 const id = "https://json-schema.org/keyword/patternProperties";
 
-const compile = (schema, ast) => Pact.pipeline([
-  Schema.entries,
-  Pact.map(async ([pattern, propertySchema]) => [new RegExp(pattern, "u"), await Validation.compile(propertySchema, ast)]),
-  Pact.all
-], schema);
+const compile = (schema, ast) => pipe(
+  Schema.entries(schema),
+  asyncMap(async ([pattern, propertySchema]) => [
+    new RegExp(pattern, "u"),
+    await Validation.compile(propertySchema, ast)
+  ]),
+  asyncCollectArray
+);
 
 const interpret = (patternProperties, instance, ast, dynamicAnchors, quiet) => {
   return !Instance.typeOf(instance, "object") || patternProperties.every(([pattern, schemaUrl]) => {
-    return Instance.entries(instance)
-      .filter(([propertyName]) => pattern.test(propertyName))
-      .every(([, propertyValue]) => Validation.interpret(schemaUrl, propertyValue, ast, dynamicAnchors, quiet));
+    return pipe(
+      Instance.entries(instance),
+      filter(([propertyName]) => pattern.test(propertyName)),
+      every(([, propertyValue]) => Validation.interpret(schemaUrl, propertyValue, ast, dynamicAnchors, quiet))
+    );
   });
 };
 

package/lib/keywords/prefixItems.js

@@ -1,4 +1,4 @@
-import * as Pact from "@hyperjump/pact";
+import { pipe, asyncMap, asyncCollectArray, every, zip, take } from "@hyperjump/pact";
 import * as Instance from "../instance.js";
 import * as Schema from "../schema.js";
 import Validation from "./validation.js";
@@ -6,19 +6,22 @@ import Validation from "./validation.js";
 
 const id = "https://json-schema.org/keyword/prefixItems";
 
-const compile = (schema, ast) => {
-  return Pact.pipeline([
-    Schema.map((itemSchema) => Validation.compile(itemSchema, ast)),
-    Pact.all
-  ], schema);
-};
+const compile = (schema, ast) => pipe(
+  Schema.iter(schema),
+  asyncMap((itemSchema) => Validation.compile(itemSchema, ast)),
+  asyncCollectArray
+);
 
-const interpret = (items, instance, ast, dynamicAnchors, quiet) => {
+const interpret = (prefixItems, instance, ast, dynamicAnchors, quiet) => {
   if (!Instance.typeOf(instance, "array")) {
     return true;
   }
 
-  return Instance.every((item, ndx) => !(ndx in items) || Validation.interpret(items[ndx], item, ast, dynamicAnchors, quiet), instance);
+  return pipe(
+    zip(prefixItems, Instance.iter(instance)),
+    take(Instance.length(instance)),
+    every(([prefixItem, item]) => Validation.interpret(prefixItem, item, ast, dynamicAnchors, quiet))
+  );
 };
 
 const collectEvaluatedItems = (items, instance, ast, dynamicAnchors) => {

package/lib/keywords/properties.js

@@ -1,4 +1,4 @@
-import * as Pact from "@hyperjump/pact";
+import { pipe, asyncMap, asyncCollectObject, filter, every } from "@hyperjump/pact";
 import * as Schema from "../schema.js";
 import * as Instance from "../instance.js";
 import Validation from "./validation.js";
@@ -6,18 +6,18 @@ import Validation from "./validation.js";
 
 const id = "https://json-schema.org/keyword/properties";
 
-const compile = (schema, ast) => Pact.pipeline([
-  Schema.entries,
-  Pact.reduce(async (acc, [propertyName, propertySchema]) => {
-    acc[propertyName] = await Validation.compile(propertySchema, ast);
-    return acc;
-  }, Object.create(null))
-], schema);
+const compile = (schema, ast) => pipe(
+  Schema.entries(schema),
+  asyncMap(async ([propertyName, propertySchema]) => [propertyName, await Validation.compile(propertySchema, ast)]),
+  asyncCollectObject
+);
 
 const interpret = (properties, instance, ast, dynamicAnchors, quiet) => {
-  return !Instance.typeOf(instance, "object") || Instance.entries(instance)
-    .filter(([propertyName]) => propertyName in properties)
-    .every(([propertyName, schemaUrl]) => Validation.interpret(properties[propertyName], schemaUrl, ast, dynamicAnchors, quiet));
+  return !Instance.typeOf(instance, "object") || pipe(
+    Instance.entries(instance),
+    filter(([propertyName]) => propertyName in properties),
+    every(([propertyName, property]) => Validation.interpret(properties[propertyName], property, ast, dynamicAnchors, quiet))
+  );
 };
 
 const collectEvaluatedProperties = (properties, instance, ast, dynamicAnchors) => {

package/lib/keywords/propertyDependencies.js

@@ -1,4 +1,4 @@
-import * as Pact from "@hyperjump/pact";
+import { pipe, asyncMap, asyncCollectObject } from "@hyperjump/pact";
 import * as Schema from "../schema.js";
 import * as Instance from "../instance.js";
 import Validation from "./validation.js";
@@ -8,19 +8,17 @@ const id = "https://json-schema.org/keyword/propertyDependencies";
 const experimental = true;
 
 const compile = (schema, ast) => {
-  return Pact.pipeline([
-    Schema.entries,
-    Pact.reduce(async (propertyDependencies, [propertyName, valueMappings]) => {
-      propertyDependencies[propertyName] = await Pact.pipeline([
-        Schema.entries,
-        Pact.reduce(async (valueMappings, [propertyValue, conditionalSchema]) => {
-          valueMappings[propertyValue] = await Validation.compile(conditionalSchema, ast);
-          return valueMappings;
-        }, {})
-      ], valueMappings);
-      return propertyDependencies;
-    }, {})
-  ], schema);
+  return pipe(
+    Schema.entries(schema),
+    asyncMap(async ([propertyName, valueMappings]) => {
+      return [propertyName, await pipe(
+        Schema.entries(valueMappings),
+        asyncMap(async ([propertyValue, conditionalSchema]) => [propertyValue, await Validation.compile(conditionalSchema, ast)]),
+        asyncCollectObject
+      )];
+    }),
+    asyncCollectObject
+  );
 };
 
 const interpret = (propertyDependencies, instance, ast, dynamicAnchors, quiet) => {

package/lib/keywords/propertyNames.js

@@ -1,3 +1,4 @@
+import { every } from "@hyperjump/pact";
 import * as Instance from "../instance.js";
 import Validation from "./validation.js";
 
@@ -7,8 +8,9 @@ const id = "https://json-schema.org/keyword/propertyNames";
 const compile = (schema, ast) => Validation.compile(schema, ast);
 
 const interpret = (propertyNames, instance, ast, dynamicAnchors) => {
-  return !Instance.typeOf(instance, "object") || Instance.keys(instance)
-    .every((key) => Validation.interpret(propertyNames, Instance.cons(key), ast, dynamicAnchors, true));
+  return !Instance.typeOf(instance, "object") || every((key) => {
+    return Validation.interpret(propertyNames, Instance.cons(key), ast, dynamicAnchors, true);
+  }, Instance.keys(instance));
 };
 
 export default { id, compile, interpret };

package/lib/keywords/unevaluatedItems.js

@@ -1,3 +1,4 @@
+import { pipe, filter, every, zip, range } from "@hyperjump/pact";
 import * as Schema from "../schema.js";
 import * as Instance from "../instance.js";
 import Validation from "./validation.js";
@@ -15,9 +16,11 @@ const interpret = ([schemaUrl, unevaluatedItems], instance, ast, dynamicAnchors,
   }
 
   const itemIndexes = Validation.collectEvaluatedItems(schemaUrl, instance, ast, dynamicAnchors, true);
-  return itemIndexes === false || Instance.every((item, itemIndex) => {
-    return itemIndexes.has(itemIndex) || Validation.interpret(unevaluatedItems, Instance.step(itemIndex, instance), ast, dynamicAnchors, quiet);
-  }, instance);
+  return itemIndexes === false || pipe(
+    zip(Instance.iter(instance), range(0)),
+    filter(([, index]) => !itemIndexes.has(index)),
+    every(([item]) => Validation.interpret(unevaluatedItems, item, ast, dynamicAnchors, quiet))
+  );
 };
 
 const collectEvaluatedItems = (keywordValue, instance, ast, dynamicAnchors) => {

package/lib/keywords/unevaluatedProperties.js

@@ -1,3 +1,4 @@
+import { pipe, filter, every } from "@hyperjump/pact";
 import * as Schema from "../schema.js";
 import * as Instance from "../instance.js";
 import Validation from "./validation.js";
@@ -16,9 +17,11 @@ const interpret = ([schemaUrl, unevaluatedProperties], instance, ast, dynamicAnc
 
   const evaluatedPropertyNames = Validation.collectEvaluatedProperties(schemaUrl, instance, ast, dynamicAnchors, true);
 
-  return !evaluatedPropertyNames || Instance.entries(instance)
-    .filter(([propertyName]) => !evaluatedPropertyNames.has(propertyName))
-    .every(([, property]) => Validation.interpret(unevaluatedProperties, property, ast, dynamicAnchors, quiet));
+  return !evaluatedPropertyNames || pipe(
+    Instance.entries(instance),
+    filter(([propertyName]) => !evaluatedPropertyNames.has(propertyName)),
+    every(([, property]) => Validation.interpret(unevaluatedProperties, property, ast, dynamicAnchors, quiet))
+  );
 };
 
 const collectEvaluatedProperties = ([schemaUrl, unevaluatedProperties], instance, ast, dynamicAnchors) => {

package/lib/keywords/uniqueItems.js

@@ -12,7 +12,7 @@ const interpret = (uniqueItems, instance) => {
     return true;
   }
 
-  const normalizedItems = Instance.map((item) => jsonStringify(Instance.value(item)), instance);
+  const normalizedItems = Instance.value(instance).map(jsonStringify);
   return new Set(normalizedItems).size === normalizedItems.length;
 };
 

package/lib/keywords/validation.js

@@ -1,4 +1,4 @@
-import * as Pact from "@hyperjump/pact";
+import { pipe, asyncMap, asyncCollectArray } from "@hyperjump/pact";
 import { publishAsync, publish } from "../pubsub.js";
 import { isExperimentalKeywordEnabled } from "../configuration.js";
 import * as Instance from "../instance.js";
@@ -30,9 +30,9 @@ const compile = async (schema, ast) => {
       throw Error(`No schema found at '${url}'`);
     }
 
-    ast[url] = typeof schemaValue === "boolean" ? schemaValue : await Pact.pipeline([
-      Schema.entries,
-      Pact.map(async ([keyword, keywordSchema]) => {
+    ast[url] = typeof schemaValue === "boolean" ? schemaValue : await pipe(
+      Schema.entries(schema),
+      asyncMap(async ([keyword, keywordSchema]) => {
         const keywordId = getKeywordId(schema.dialectId, keyword);
         if (!keywordId) {
           throw Error(`Encountered unknown keyword '${keyword}' at ${url}`);
@@ -49,8 +49,8 @@ const compile = async (schema, ast) => {
         const keywordAst = await keywordHandler.compile(keywordSchema, ast, schema);
         return [keywordId, Schema.uri(keywordSchema), keywordAst];
       }),
-      Pact.all
-    ], schema);
+      asyncCollectArray
+    );
   }
 
   return url;

package/lib/schema.d.ts

@@ -25,18 +25,14 @@ export const typeOf: (
 );
 export const has: (key: string, doc: SchemaDocument) => boolean;
 export const step: (key: string, doc: SchemaDocument) => Promise<SchemaDocument>;
-export const keys: (doc: SchemaDocument) => string[];
-export const entries: (doc: SchemaDocument) => Promise<SchemaEntry[]>;
-export const map: (
-  <A>(fn: MapFn<Promise<A> | A>, doc: SchemaDocument) => Promise<A[]>
-) & (
-  <A>(fn: MapFn<Promise<A> | A>) => (doc: SchemaDocument) => Promise<A[]>
-);
+export const iter: (doc: SchemaDocument) => AsyncGenerator<SchemaDocument>;
+export const keys: (doc: SchemaDocument) => Generator<string>;
+export const values: (doc: SchemaDocument) => AsyncGenerator<string>;
+export const entries: (doc: SchemaDocument) => AsyncGenerator<[string, SchemaDocument]>;
 export const length: (doc: SchemaDocument) => number;
 export const toSchema: (doc: SchemaDocument, options: ToSchemaOptions) => SchemaObject;
 
 type MapFn<A> = (element: SchemaDocument, index: number) => A;
-export type SchemaEntry = [string, SchemaDocument];
 
 export type ToSchemaOptions = {
   parentId?: string;

package/lib/schema.js

@@ -220,20 +220,29 @@ export const step = (key, doc) => {
   });
 };
 
-export const keys = (doc) => Object.keys(value(doc));
-
-export const entries = (doc) => Pact.pipeline([
-  value,
-  Object.keys,
-  Pact.map(async (key) => [key, await step(key, doc)]),
-  Pact.all
-], doc);
-
-export const map = curry((fn, doc) => Pact.pipeline([
-  value,
-  Pact.map(async (item, ndx) => fn(await step(ndx, doc), ndx)),
-  Pact.all
-], doc));
+export const iter = async function* (doc) {
+  for (let index = 0; index < value(doc).length; index++) {
+    yield step(index, doc);
+  }
+};
+
+export const keys = function* (doc) {
+  for (const key in value(doc)) {
+    yield key;
+  }
+};
+
+export const values = async function* (doc) {
+  for (const key in value(doc)) {
+    yield step(key, doc);
+  }
+};
+
+export const entries = async function* (doc) {
+  for (const key in value(doc)) {
+    yield [key, await step(key, doc)];
+  }
+};
 
 export const length = (doc) => value(doc).length;
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hyperjump/json-schema",
-  "version": "1.4.6",
+  "version": "1.5.0",
   "description": "A JSON Schema validator with support for custom keywords, vocabularies, and dialects",
   "type": "module",
   "main": "./stable/index.js",
@@ -64,7 +64,7 @@
   },
   "dependencies": {
     "@hyperjump/json-pointer": "^1.0.0",
-    "@hyperjump/pact": "^0.2.4",
+    "@hyperjump/pact": "^1.0.0",
     "@hyperjump/uri": "^1.2.0",
     "content-type": "^1.0.4",
     "fastest-stable-stringify": "^2.0.2",