More type refactoring. Maybe this one will work

Author: jdesrosiers

src/hyperjump/embedded.test.js

@@ -6,7 +6,7 @@ import { fromJref } from "../jref/index.js";
 import { toJson } from "../json/jsonast-util.js";
 
 /**
- * @import { JrefJrefNode } from "../jref/jref-ast.js"
+ * @import { JrefNode } from "../jref/jref-ast.js"
  */
 
 
@@ -20,7 +20,7 @@ describe("JSON Browser", () => {
       /**
        * @typedef {{
        *   type: "embedded-document";
-       *   children: JrefJrefNode[];
+       *   children: JrefNode[];
        *   uri: string;
        *   fragmentKind: "json-pointer";
        *   embedded?: Record<string, EmbeddedDocumentNode>;

src/hyperjump/hyperjump.d.ts

@@ -1,5 +1,4 @@
-import type { JsonNode } from "../json/jsonast.d.ts";
-import type { JrefJrefNode } from "../jref/jref-ast.d.ts";
+import type { JrefNode } from "../jref/jref-ast.js";
 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, jsonValue } from "../json/jsonast-util.js";
@@ -11,7 +10,9 @@ export type GetOptions = {
   referencedFrom?: string;
 };
 
-export class Hyperjump<T extends JrefNode<{}> = JrefJrefNode> {
+type UnionIncludes<T, U> = U extends T ? T : never;
+
+export class Hyperjump<T extends UnionIncludes<U, JrefNode> = JrefNode> {
   constructor(config?: HyperjumpConfig);
 
   /**
@@ -29,7 +30,7 @@ export class Hyperjump<T extends JrefNode<{}> = JrefJrefNode> {
    * @throws {@link RetrievalError}
    * @throws {@link json.JsonPointerError}
    */
-  get: (uri: string, options?: GetOptions) => Promise<JsonNode<T>>;
+  get: (uri: string, options?: GetOptions) => Promise<T>;
 
   /**
    * Add support for a
@@ -71,7 +72,7 @@ export class Hyperjump<T extends JrefNode<{}> = JrefJrefNode> {
    * {@link hyperjump.JsonMediaTypePlugin | `JSON`} media types are enabled by
    * default.
    */
-  addMediaTypePlugin: <A extends DocumentNode<T>>(plugin: MediaTypePlugin<A>) => void;
+  addMediaTypePlugin: <A extends DocumentNode>(plugin: MediaTypePlugin<A>) => void;
 
   /**
    * This is mostly useful for disabling a scheme that's enabled by default.
@@ -93,27 +94,27 @@ export class Hyperjump<T extends JrefNode<{}> = JrefJrefNode> {
    * This is like indexing into an object or array. It will follow any
    * references it encounters so it always returns a JSON compatible value.
    */
-  step: (key: string, node: JsonNode<T>) => Promise<JsonNode<T>>;
+  step: (key: string, node: T) => Promise<T>;
 
   /**
    * Iterate over an array node. It will follow any references it encounters so
    * it always yields JSON compatible values.
    */
-  iter: (node: JsonNode<T>) => AsyncGenerator<JsonNode<T>, void, unknown>;
+  iter: (node: T) => AsyncGenerator<T, void, unknown>;
 
   keys: typeof jsonObjectKeys;
 
   /**
    * Iterate over the values of an object. It will follow any references it
    * encounters so it always yields JSON compatible values.
    */
-  values: (node: JsonNode<T>) => AsyncGenerator<JsonNode<T>, void, unknown>;
+  values: (node: T) => AsyncGenerator<T, void, unknown>;
 
   /**
    * Iterate over key/value pairs of an object. It will follow any references it
    * encounters so it always yields JSON compatible values.
    */
-  entries: (node: JsonNode<T>) => AsyncGenerator<[string, JsonNode<T>], void, unknown>;
+  entries: (node: T) => AsyncGenerator<[string, T], void, unknown>;
 }
 
 export class RetrievalError extends Error {

src/hyperjump/hyperjump.js

@@ -9,8 +9,7 @@ import { jsonObjectHas, jsonObjectKeys, jsonValue, pointerGet, pointerStep } fro
 import { mimeMatch } from "./utilities.js";
 
 /**
- * @import { JrefJrefNode, JrefNode } from "../jref/jref-ast.js"
- * @import { JsonNode } from "../json/jsonast.js"
+ * @import { JrefNode } from "../jref/jref-ast.js"
  * @import { UriSchemePlugin } from "./uri-schemes/uri-scheme-plugin.js"
  * @import { DocumentNode, MediaTypePlugin } from "./media-types/media-type-plugin.js"
  * @import * as API from "./hyperjump.d.ts"
@@ -21,20 +20,19 @@ import { mimeMatch } from "./utilities.js";
 // TODO: Support filters
 
 /**
- * @template {JrefNode<unknown>} [T=JrefJrefNode]
- * @implements API.Hyperjump<T>
+ * @implements API.Hyperjump<JrefNode>
  */
 export class Hyperjump {
   // TODO: Add config to enable schemes and media types
   #config;
 
-  /** @type Record<string, DocumentNode<T>> */
+  /** @type Record<string, DocumentNode> */
   #cache;
 
   /** @type Record<string, UriSchemePlugin> */
   #uriSchemePlugins;
 
-  /** @type Record<string, MediaTypePlugin<DocumentNode<T>>> */
+  /** @type Record<string, MediaTypePlugin<DocumentNode>> */
   #mediaTypePlugins;
 
   /** @type API.GetOptions */
@@ -62,7 +60,7 @@ export class Hyperjump {
     this.addMediaTypePlugin(new JsonMediaTypePlugin());
   }
 
-  /** @type API.Hyperjump<T>["get"] */
+  /** @type API.Hyperjump<JrefNode>["get"] */
   async get(uri, options = this.#defaultGetOptions) {
     uri = resolveIri(uri, contextUri());
     const id = toAbsoluteIri(uri);
@@ -95,28 +93,28 @@ export class Hyperjump {
     return await this.#followReferences(node);
   }
 
-  /** @type (node: JrefNode<T>) => Promise<JsonNode<T>> */
+  /** @type (node: JrefNode) => Promise<JrefNode> */
   async #followReferences(node) {
-    if (node.jrefType === "reference") {
+    if (node.type === "reference") {
       return this.get(node.href, { referencedFrom: toAbsoluteIri(node.location) });
     } else {
-      return /** @type JsonNode<T> */ (node);
+      return node;
     }
   }
 
-  /** @type API.Hyperjump<T>["addUriSchemePlugin"] */
+  /** @type API.Hyperjump<JrefNode>["addUriSchemePlugin"] */
   addUriSchemePlugin(plugin) {
     for (const scheme of plugin.schemes) {
       this.#uriSchemePlugins[scheme] = plugin;
     }
   }
 
-  /** @type API.Hyperjump<T>["removeUriSchemePlugin"] */
+  /** @type API.Hyperjump<JrefNode>["removeUriSchemePlugin"] */
   removeUriSchemePlugin(scheme) {
     delete this.#uriSchemePlugins[scheme];
   }
 
-  /** @type API.Hyperjump<T>["retrieve"] */
+  /** @type API.Hyperjump<JrefNode>["retrieve"] */
   async retrieve(uri, options) {
     const { scheme } = parseIri(uri);
 
@@ -127,7 +125,7 @@ export class Hyperjump {
     return this.#uriSchemePlugins[scheme].retrieve(uri, options);
   }
 
-  /** @type API.Hyperjump<T>["acceptableMediaTypes"] */
+  /** @type API.Hyperjump<JrefNode>["acceptableMediaTypes"] */
   acceptableMediaTypes() {
     let accept = "";
 
@@ -151,7 +149,7 @@ export class Hyperjump {
     return accept;
   }
 
-  /** @type API.Hyperjump<T>["getMediaType"] */
+  /** @type API.Hyperjump<JrefNode>["getMediaType"] */
   getMediaType(uri) {
     for (const contentType in this.#mediaTypePlugins) {
       for (const extension of this.#mediaTypePlugins[contentType].extensions) {
@@ -166,22 +164,22 @@ export class Hyperjump {
     throw new UnknownMediaTypeError(`The media type of the file at '${uri}' could not be determined. Use the 'addMediaTypePlugin' function to add support for this media type.`);
   }
 
-  /** @type API.Hyperjump<T>["addMediaTypePlugin"] */
+  /** @type API.Hyperjump<JrefNode>["addMediaTypePlugin"] */
   addMediaTypePlugin(plugin) {
     this.#mediaTypePlugins[plugin.mediaType] = plugin;
   }
 
-  /** @type API.Hyperjump<T>["removeMediaTypePlugin"] */
+  /** @type API.Hyperjump<JrefNode>["removeMediaTypePlugin"] */
   removeMediaTypePlugin(contentType) {
     delete this.#mediaTypePlugins[contentType];
   }
 
-  /** @type API.Hyperjump<T>["setMediaTypeQuality"] */
+  /** @type API.Hyperjump<JrefNode>["setMediaTypeQuality"] */
   setMediaTypeQuality(contentType, quality) {
     this.#mediaTypePlugins[contentType].quality = quality;
   }
 
-  /** @type (response: Response) => Promise<DocumentNode<T>> */
+  /** @type (response: Response) => Promise<DocumentNode> */
   #parseResponse(response) {
     const contentTypeText = response.headers.get("content-type");
     if (contentTypeText === null) {
@@ -201,12 +199,12 @@ export class Hyperjump {
   value = jsonValue;
   has = jsonObjectHas;
 
-  /** @type API.Hyperjump<T>["step"] */
+  /** @type API.Hyperjump<JrefNode>["step"] */
   async step(key, node) {
     return await this.#followReferences(pointerStep(key, node));
   }
 
-  /** @type API.Hyperjump<T>["iter"] */
+  /** @type API.Hyperjump<JrefNode>["iter"] */
   async* iter(node) {
     if (node.jsonType === "array") {
       for (const itemNode of node.children) {
@@ -217,7 +215,7 @@ export class Hyperjump {
 
   keys = jsonObjectKeys;
 
-  /** @type API.Hyperjump<T>["values"] */
+  /** @type API.Hyperjump<JrefNode>["values"] */
   async* values(node) {
     if (node.jsonType === "object") {
       for (const propertyNode of node.children) {
@@ -226,7 +224,7 @@ export class Hyperjump {
     }
   }
 
-  /** @type API.Hyperjump<T>["entries"] */
+  /** @type API.Hyperjump<JrefNode>["entries"] */
   async* entries(node) {
     if (node.jsonType === "object") {
       for (const propertyNode of node.children) {

src/hyperjump/media-types/media-type-plugin.d.ts

@@ -1,14 +1,16 @@
-export type DocumentNode<A> = {
+import type { JrefNode } from "../../jref/jref-ast.js";
+
+export type DocumentNode = {
   type: string;
-  children: A[];
+  children: JrefNode[];
   uri?: string;
-  embedded?: Record<string, DocumentNode<A>>;
+  embedded?: Record<string, DocumentNode>;
   anchors?: Record<string, string>;
   fragmentKind?: string;
 };
 
 // eslint-disable-next-line @typescript-eslint/consistent-type-definitions
-export interface MediaTypePlugin<T extends DocumentNode<unknown>> {
+export interface MediaTypePlugin<T extends DocumentNode> {
   mediaType: string;
   /**
    * Extensions start with `.` (Example: `.jref`).

src/hyperjump/node-functions.test.js

@@ -3,8 +3,7 @@ import { MockAgent, setGlobalDispatcher } from "undici";
 import { Hyperjump } from "./index.js";
 
 /**
- * @import { JsonNode } from "../json/index.js"
- * @import { JrefJrefNode } from "../jref/index.js"
+ * @import { JrefNode } from "../jref/index.js"
  */
 
 
@@ -26,7 +25,7 @@ describe("JSON Browser", () => {
   describe("object has property", () => {
     const hyperjump = new Hyperjump();
 
-    /** @type JsonNode<JrefJrefNode> */
+    /** @type JrefNode */
     let node;
 
     beforeEach(async () => {

src/jref/jref-ast.d.ts

@@ -1,20 +1,16 @@
 import type { Data } from "unist";
 import type { JsonNode } from "../json/jsonast.d.ts";
 
-export type JrefNode<A> = JsonNode<A & (
-  {
-    jrefType: "json";
-  } | {
-    jrefType: "reference";
-    href: string;
-  }
-)>;
-
-export type JrefJrefNode = JrefNode<{ type: "jref" }>;
+export type JrefNode = JsonNode<{
+  type: "json";
+} | {
+  type: "reference";
+  href: string;
+}>;
 
 export type JrefDocumentNode = {
   type: "jref-document";
-  children: JrefNode<{}>[];
+  children: JrefNode[];
   uri: string;
   fragmentKind: "json-pointer";
   data?: Data;

src/jref/jref-parse.d.ts

@@ -1,10 +1,10 @@
 import { Plugin } from "unified";
-import { JrefDocumentNode, JrefJrefNode } from "./jref-ast.d.ts";
+import { JrefDocumentNode, JrefNode } from "./jref-ast.d.ts";
 import { Reviver } from "./jref-util.js";
 
 
 export type JrefParseOptions = {
-  reviver?: Reviver<JrefJrefNode, JrefJrefNode>;
+  reviver?: Reviver<JrefNode | undefined>;
 };
 
 /**

src/jref/jref-util.d.ts

@@ -1,35 +1,9 @@
-import type {
-  JsonArrayNode,
-  JsonBooleanNode,
-  JsonNullNode,
-  JsonNumberNode,
-  JsonObjectNode,
-  JsonStringNode
-} from "../json/jsonast.js";
 import type { JrefNode } from "./jref-ast.d.ts";
 
-export type ParsedJrefNode<A> = {
-  type: "jref";
-} & (
-  {
-    jrefType: "json";
-  } | {
-    jrefType: "reference";
-    href: string;
-  }
-) & (
-  JsonObjectNode<JrefNode<A>>
-  | JsonArrayNode<JrefNode<A>>
-  | JsonStringNode
-  | JsonNumberNode
-  | JsonBooleanNode
-  | JsonNullNode
-);
-
-export type Reviver<A, R extends JrefNode<A> | undefined> = (node: ParsedJrefNode<A>, key?: string) => R;
+export type Reviver<A extends JrefNode | undefined> = (node: JrefNode, key?: string) => A;
 
 /**
  * Parse a JRef string into a JRef AST. Includes a reviver option similar to
  * {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/JSON/parse | JSON.parse}.
  */
-export const fromJref: <A = { type: "jref" }, R = JrefNode<A>>(json: string, uri: string, reviver?: Reviver<A, R>) => R;
+export const fromJref: <A extends JrefNode | undefined = JrefNode>(json: string, uri: string, reviver?: Reviver<A>) => A;