Drop jsonTypeOf and Hyperjump.typeOf

Author: jdesrosiers

src/hyperjump/hyperjump.d.ts

@@ -2,7 +2,7 @@ import type { JsonCompatible } from "../json/jsonast.d.ts";
 import type { JrefNode } from "../jref/jref-ast.d.ts";
 import type { UriSchemePlugin } from "./uri-schemes/uri-scheme-plugin.d.ts";
 import type { DocumentNode, MediaTypePlugin } from "./media-types/media-type-plugin.d.ts";
-import type { jsonObjectHas, jsonObjectKeys, jsonTypeOf, jsonValue } from "../json/jsonast-util.js";
+import type { jsonObjectHas, jsonObjectKeys, jsonValue } from "../json/jsonast-util.js";
 
 
 export type HyperjumpConfig = object;
@@ -87,7 +87,6 @@ export class Hyperjump<T extends JrefNode = JrefNode> {
   setMediaTypeQuality: (contentType: string, quality: number) => void;
 
   value: typeof jsonValue;
-  typeOf: typeof jsonTypeOf;
   has: typeof jsonObjectHas;
 
   /**

src/hyperjump/hyperjump.js

@@ -6,7 +6,7 @@ import { FileUriSchemePlugin } from "./uri-schemes/file-scheme-plugin.js";
 import { JsonMediaTypePlugin } from "./media-types/json-media-type-plugin.js";
 import { JrefMediaTypePlugin } from "./media-types/jref-media-type-plugin.js";
 import { pointerGet, pointerStep } from "../jref/jref-util.js";
-import { jsonObjectHas, jsonObjectKeys, jsonTypeOf, jsonValue } from "../json/jsonast-util.js";
+import { jsonObjectHas, jsonObjectKeys, jsonValue } from "../json/jsonast-util.js";
 import { mimeMatch } from "./utilities.js";
 
 /**
@@ -201,7 +201,6 @@ export class Hyperjump {
   }
 
   value = jsonValue;
-  typeOf = jsonTypeOf;
   has = jsonObjectHas;
 
   /** @type API.Hyperjump<T>["step"] */

src/hyperjump/node-functions.test.js

@@ -71,68 +71,41 @@ describe("JSON Browser", () => {
 
     test("null", async () => {
       const node = await hyperjump.get(`${testDomain}/foo#/null`);
-      if (hyperjump.typeOf(node, "null")) {
-        /** @type null */
-        const subject = hyperjump.value(node);
-        expect(subject).to.equal(null);
-      } else {
-        expect.fail();
-      }
+      const subject = hyperjump.value(node);
+      expect(subject).to.equal(null);
     });
 
     test("true", async () => {
       const node = await hyperjump.get(`${testDomain}/foo#/true`);
-      if (hyperjump.typeOf(node, "boolean")) {
-        /** @type boolean */
-        const subject = hyperjump.value(node);
-        expect(subject).to.equal(true);
-      } else {
-        expect.fail();
-      }
+      const subject = hyperjump.value(node);
+      expect(subject).to.equal(true);
     });
 
     test("false", async () => {
       const node = await hyperjump.get(`${testDomain}/foo#/false`);
-      if (hyperjump.typeOf(node, "boolean")) {
-        /** @type boolean */
-        const subject = hyperjump.value(node);
-        expect(subject).to.equal(false);
-      } else {
-        expect.fail();
-      }
+      const subject = hyperjump.value(node);
+      expect(subject).to.equal(false);
     });
 
     test("number", async () => {
       const node = await hyperjump.get(`${testDomain}/foo#/number`);
-      if (hyperjump.typeOf(node, "number")) {
-        /** @type number */
-        const subject = hyperjump.value(node);
-        expect(subject).to.equal(42);
-      } else {
-        expect.fail();
-      }
+      const subject = hyperjump.value(node);
+      expect(subject).to.equal(42);
     });
 
     test("string", async () => {
       const node = await hyperjump.get(`${testDomain}/foo#/string`);
-      if (hyperjump.typeOf(node, "string")) {
-        /** @type string */
-        const subject = hyperjump.value(node);
-        expect(subject).to.equal("foo");
-      } else {
-        expect.fail();
-      }
+      const subject = hyperjump.value(node);
+      expect(subject).to.equal("foo");
     });
 
     test("array", async () => {
       const node = await hyperjump.get(`${testDomain}/foo#/array`);
-      expect(hyperjump.typeOf(node, "array")).to.equal(true);
       expect(() => hyperjump.value(node)).to.throw();
     });
 
     test("object", async () => {
       const node = await hyperjump.get(`${testDomain}/foo#/object`);
-      expect(hyperjump.typeOf(node, "object")).to.equal(true);
       expect(() => hyperjump.value(node)).to.throw();
     });
   });

src/json/jsonast-util.d.ts

@@ -7,8 +7,7 @@ import {
   JsonNullNode,
   JsonNumberNode,
   JsonObjectNode,
-  JsonStringNode,
-  JsonType
+  JsonStringNode
 } from "./jsonast.d.ts";
 
 export type Reviver<A = JsonNode> = (node: JsonCompatible<NonNullable<A>>, key?: string) => A;
@@ -57,16 +56,6 @@ export const jsonValue: (
   (<A>(node: JsonCompatible<A>) => Json)
 );
 
-export const jsonTypeOf: (
-  (<A>(node: JsonCompatible<A>, type: "null") => node is JsonNullNode) &
-  (<A>(node: JsonCompatible<A>, type: "boolean") => node is JsonBooleanNode) &
-  (<A>(node: JsonCompatible<A>, type: "number") => node is JsonNumberNode) &
-  (<A>(node: JsonCompatible<A>, type: "string") => node is JsonStringNode) &
-  (<A>(node: JsonCompatible<A>, type: "array") => node is JsonArrayNode<A>) &
-  (<A>(node: JsonCompatible<A>, type: "object") => node is JsonObjectNode<A>) &
-  (<A>(node: JsonCompatible<A>, type: JsonType) => boolean)
-);
-
 export const jsonObjectHas: <A>(key: string, node: JsonCompatible<A>) => boolean;
 
 export const jsonArrayIter: <A>(node: JsonCompatible<A>) => Generator<A, void, unknown>;

src/json/jsonast-util.js

@@ -387,11 +387,6 @@ export const jsonValue = /** @type API.jsonValue */ ((node) => {
   }
 });
 
-// eslint-disable-next-line @stylistic/no-extra-parens
-export const jsonTypeOf = /** @type API.jsonTypeOf */ ((node, type) => {
-  return node.jsonType === type;
-});
-
 /** @type API.jsonObjectHas */
 export const jsonObjectHas = (key, node) => {
   if (node.jsonType === "object") {

src/json/jsonast-util.test.js

@@ -8,7 +8,6 @@ import {
   rejson,
   rejsonStringify,
   jsonObjectHas,
-  jsonTypeOf,
   jsonArrayIter,
   jsonObjectKeys,
   jsonObjectValues,
@@ -56,57 +55,35 @@ describe("jsonast-util", async () => {
   describe("type/value and type narrowing", () => {
     test("null", () => {
       const node = fromJson(`null`);
-      if (jsonTypeOf(node, "null")) {
-        /** @type null */
-        const subject = jsonValue(node);
-        expect(subject).to.equal(null);
-      } else {
-        expect.fail();
-      }
+      const subject = jsonValue(node);
+      expect(subject).to.equal(null);
     });
 
     test("boolean", () => {
       const node = fromJson(`true`);
-      if (jsonTypeOf(node, "boolean")) {
-        /** @type boolean */
-        const subject = jsonValue(node);
-        expect(subject).to.equal(true);
-      } else {
-        expect.fail();
-      }
+      const subject = jsonValue(node);
+      expect(subject).to.equal(true);
     });
 
     test("number", () => {
       const node = fromJson(`42`);
-      if (jsonTypeOf(node, "number")) {
-        /** @type number */
-        const subject = jsonValue(node);
-        expect(subject).to.equal(42);
-      } else {
-        expect.fail();
-      }
+      const subject = jsonValue(node);
+      expect(subject).to.equal(42);
     });
 
     test("string", () => {
       const node = fromJson(`"foo"`);
-      if (jsonTypeOf(node, "string")) {
-        /** @type string */
-        const subject = jsonValue(node);
-        expect(subject).to.equal("foo");
-      } else {
-        expect.fail();
-      }
+      const subject = jsonValue(node);
+      expect(subject).to.equal("foo");
     });
 
     test("array", () => {
       const node = fromJson(`["foo", 42]`);
-      expect(jsonTypeOf(node, "array")).to.equal(true);
       expect(() => jsonValue(node)).to.throw();
     });
 
     test("object", () => {
       const node = fromJson(`{ "foo": 42 }`);
-      expect(jsonTypeOf(node, "object")).to.equal(true);
       expect(() => jsonValue(node)).to.throw();
     });
   });