Add JSON utility functions

Author: jdesrosiers

package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hyperjump/browser",
-  "version": "2.0.0",
+  "version": "2.0.0-dev",
   "description": "A client for working with JSON Reference (`$ref`) documents",
   "keywords": [
     "$ref",
@@ -19,7 +19,7 @@
   "type": "module",
   "exports": {
     ".": "./src/hyperjump/index.js",
-    "./rejson": "./src/json/index.js",
+    "./json": "./src/json/index.js",
     "./jref": "./src/jref/index.js"
   },
   "bin": {

src/hyperjump/node-functions.test.js

@@ -42,11 +42,11 @@ describe("JSON Browser", () => {
     });
 
     test("true", () => {
-      expect(node && hyperjump.has("foo", node)).to.eql(true);
+      expect(hyperjump.has("foo", node)).to.eql(true);
     });
 
     test("false", () => {
-      expect(node && hyperjump.has("bar", node)).to.eql(false);
+      expect(hyperjump.has("bar", node)).to.eql(false);
     });
   });
 
@@ -63,7 +63,7 @@ describe("JSON Browser", () => {
     expect(hyperjump.length(subject)).to.eql(1);
   });
 
-  describe("object has property", () => {
+  describe("typeOf", () => {
     const hyperjump = new Hyperjump();
 
     beforeEach(() => {

src/json/jsonast-util.js

@@ -13,7 +13,8 @@ import { JsonLexer } from "./json-lexer.js";
  *   JsonObjectNode,
  *   JsonPropertyNameNode,
  *   JsonPropertyNode,
- *   JsonStringNode
+ *   JsonStringNode,
+ *   JsonType
  * } from "./jsonast.js"
  */
 
@@ -336,6 +337,72 @@ const unescapePointerSegment = (segment) => segment.toString().replace(/~1/g, "/
 /** @type (segment: string) => string */
 const escapePointerSegment = (segment) => segment.toString().replace(/~/g, "~0").replace(/\//g, "~1");
 
+/** @type (node: JsonNode) => unknown */
+export const jsonValue = (node) => {
+  switch (node.jsonType) {
+    case "object":
+    case "array":
+      // TODO: Handle structured values
+      throw Error("Can't get the value of a structured value.");
+    default:
+      return node.value;
+  }
+};
+
+/** @type (node: JsonNode) => JsonType */
+export const jsonTypeOf = (node) => {
+  return node.jsonType;
+};
+
+/** @type (key: string, node: JsonNode) => boolean */
+export const jsonObjectHas = (key, node) => {
+  if (node.jsonType === "object") {
+    for (const property of node.children) {
+      if (property.children[0].value === key) {
+        return true;
+      }
+    }
+  }
+
+  return false;
+};
+
+/** @type (node: JsonNode) => Generator<JsonNode, void, unknown> */
+export const jsonArrayIter = function* (node) {
+  if (node.jsonType === "array") {
+    for (const itemNode of node.children) {
+      yield itemNode;
+    }
+  }
+};
+
+/** @type (node: JsonNode) => Generator<string, undefined, string> */
+export const jsonObjectKeys = function* (node) {
+  if (node.jsonType === "object") {
+    for (const propertyNode of node.children) {
+      yield propertyNode.children[0].value;
+    }
+  }
+};
+
+/** @type (node: JsonNode) => Generator<JsonNode, void, unknown> */
+export const jsonObjectValues = function* (node) {
+  if (node.jsonType === "object") {
+    for (const propertyNode of node.children) {
+      yield propertyNode.children[1];
+    }
+  }
+};
+
+/** @type (node: JsonNode) => Generator<[string, JsonNode], void, unknown> */
+export const jsonObjectEntries = function* (node) {
+  if (node.jsonType === "object") {
+    for (const propertyNode of node.children) {
+      yield [propertyNode.children[0].value, propertyNode.children[1]];
+    }
+  }
+};
+
 export class JsonPointerError extends Error {
   /**
    * @param {string} [message]

src/json/jsonast-util.test.js

@@ -1,8 +1,13 @@
 import { readdir, readFile } from "node:fs/promises";
 import { resolve } from "node:path";
-import { describe, test, expect } from "vitest";
+import { describe, test, expect, beforeEach } from "vitest";
 import { VFileMessage } from "vfile-message";
-import { rejson, rejsonStringify } from "./index.js";
+import { fromJson, toJson, rejson, rejsonStringify } from "./index.js";
+import * as Json from "./index.js";
+
+/**
+ * @import { JsonNode } from "./index.js"
+ */
 
 
 describe("jsonast-util", async () => {
@@ -36,4 +41,119 @@ describe("jsonast-util", async () => {
       });
     }
   }
+
+  describe("object has property", () => {
+    /** @type JsonNode */
+    let subject;
+
+    beforeEach(() => {
+      subject = fromJson(`{
+        "foo": 42
+      }`);
+    });
+
+    test("true", () => {
+      expect(Json.jsonObjectHas("foo", subject)).to.eql(true);
+    });
+
+    test("false", () => {
+      expect(Json.jsonObjectHas("bar", subject)).to.eql(false);
+    });
+  });
+
+  describe("typeOf", () => {
+    test("null", () => {
+      const subject = fromJson(`null`);
+      expect(Json.jsonTypeOf(subject)).to.eql("null");
+    });
+
+    test("true", () => {
+      const subject = fromJson(`true`);
+      expect(Json.jsonTypeOf(subject)).to.eql("boolean");
+    });
+
+    test("false", () => {
+      const subject = fromJson(`false`);
+      expect(Json.jsonTypeOf(subject)).to.eql("boolean");
+    });
+
+    test("number", () => {
+      const subject = fromJson(`42`);
+      expect(Json.jsonTypeOf(subject)).to.eql("number");
+    });
+
+    test("string", () => {
+      const subject = fromJson(`"foo"`);
+      expect(Json.jsonTypeOf(subject)).to.eql("string");
+    });
+
+    test("array", () => {
+      const subject = fromJson(`["foo", 42]`);
+      expect(Json.jsonTypeOf(subject)).to.eql("array");
+    });
+
+    test("object", () => {
+      const subject = fromJson(`{ "foo": 42 }`);
+      expect(Json.jsonTypeOf(subject)).to.eql("object");
+    });
+  });
+
+  test("iter", () => {
+    const subject = fromJson(`[1, 2]`);
+
+    const generator = Json.jsonArrayIter(subject);
+
+    const first = generator.next();
+    expect(toJson(first.value)).to.equal(`1`);
+    const second = generator.next();
+    expect(toJson(second.value)).to.equal(`2`);
+    expect((generator.next()).done).to.equal(true);
+  });
+
+  test("keys", () => {
+    const subject = fromJson(`{
+      "a": 1,
+      "b": 2
+    }`);
+
+    const generator = Json.jsonObjectKeys(subject);
+
+    expect(generator.next().value).to.equal("a");
+    expect(generator.next().value).to.equal("b");
+    expect(generator.next().done).to.equal(true);
+  });
+
+  test("values", () => {
+    const subject = fromJson(`{
+      "a": 1,
+      "b": 2
+    }`);
+
+    const generator = Json.jsonObjectValues(subject);
+
+    const first = generator.next();
+    expect(toJson(first.value)).to.equal(`1`);
+    const second = generator.next();
+    expect(toJson(second.value)).to.equal(`2`);
+    expect((generator.next()).done).to.equal(true);
+  });
+
+  test("entries", () => {
+    const subject = fromJson(`{
+      "a": 1,
+      "b": 2
+    }`);
+
+    const generator = Json.jsonObjectEntries(subject);
+
+    const a = /** @type [string, JsonNode] */ ((generator.next()).value);
+    expect(a[0]).to.equal("a");
+    expect(toJson(a[1])).to.equal(`1`);
+
+    const b = /** @type [string, JsonNode] */ ((generator.next()).value);
+    expect(b[0]).to.equal("b");
+    expect(toJson(b[1])).to.equal(`2`);
+
+    expect(generator.next().done).to.equal(true);
+  });
 });