Remove build step

Author: jdesrosiers

bin/postpack.js

@@ -29,11 +29,8 @@
   "scripts": {
     "lint": "eslint src",
     "test": "vitest --watch=false",
-    "coverage": "vitest run --coverage",
     "type-check": "tsc --noEmit",
-    "docs": "typedoc",
-    "prepack": "tsc --project tsconfig.build.json",
-    "postpack": "node ./bin/postpack.js"
+    "docs": "typedoc --excludeExternals"
   },
   "devDependencies": {
     "@stylistic/eslint-plugin": "*",

package.json

@@ -0,0 +1,136 @@
+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 { jsonObjectHas, jsonObjectKeys, jsonTypeOf, jsonValue } from "../json/jsonast-util.js";
+
+
+export type HyperjumpConfig = object;
+
+export type GetOptions = {
+  referencedFrom?: string;
+};
+
+export class Hyperjump {
+  constructor(config?: HyperjumpConfig);
+
+  /**
+   * Retrieve a document located at the given URI. URIs can be relative if a
+   * base URI can be determined. On the server-side, the base URI is the CWD. In
+   * browser, the base URI is the URI of the page.
+   *
+   * @see Use {@link Hyperjump.addUriSchemePlugin} to add support for additional
+   * URI schemes.
+   * @see Support for {@link JrefMediaTypePlugin | JRef} and
+   * {@link JsonMediaTypePlugin | JSON} is built in. Use
+   * {@link Hyperjump.addMediaTypePlugin} to add support for additional media
+   * types.
+   *
+   * @throws {@link RetrievalError}
+   * @throws {@link json.JsonPointerError}
+   */
+  get: (uri: string, options?: GetOptions) => Promise<JsonCompatible<JrefNode>>;
+
+  /**
+   * Add support for a
+   * {@link https://www.rfc-editor.org/rfc/rfc3986#section-3.1 | URI scheme}.
+   * Support for the {@link HttpUriSchemePlugin | `http(s):`} and
+   * {@link FileUriSchemePlugin | `file:`} URI schemes are enabled by default.
+   */
+  addUriSchemePlugin: (plugin: UriSchemePlugin) => void;
+
+  /**
+   * This is mostly useful for disabling a scheme that's enabled by default.
+   */
+  removeUriSchemePlugin: (scheme: string) => void;
+
+  /**
+   * Unless you're using it in a {@link UriSchemePlugin.retrieve} method, this
+   * is not the method you're looking for. It's used internally to fetch a
+   * resource before processing it based on its media type. You might use it for
+   * implementing {@link hyperjump.UriSchemePlugin}s for URI schemes that don't
+   * have locating semantics (such as `urn:`) and instead map to another URI
+   * where the resource can be retrieved from. See the example in the README.
+   */
+  retrieve: (uri: string, options: GetOptions) => Promise<Response>;
+
+  /**
+   * Constructs an `Accept` header based on the registered media types.
+   */
+  acceptableMediaTypes: () => string;
+
+  /**
+   * Returns the media type of the resource based on its URI. This is usually
+   * based on the extension and configured by {@link hyperjump.MediaTypePlugin}s.
+   */
+  getMediaType: (uri: string) => string;
+
+  /**
+   * Add support for a media tpe. Support for the
+   * {@link hyperjump.JrefMediaTypePlugin | `JRef`} and
+   * {@link hyperjump.JsonMediaTypePlugin | `JSON`} media types are enabled by
+   * default.
+   */
+  addMediaTypePlugin: <T extends DocumentNode>(plugin: MediaTypePlugin<T>) => void;
+
+  /**
+   * This is mostly useful for disabling a scheme that's enabled by default.
+   */
+  removeMediaTypePlugin: (contentType: string) => void;
+
+  /**
+   * Set the
+   * {@link https://developer.mozilla.org/en-US/docs/Glossary/Quality_values | quality}
+   * that will be used in the Accept header of requests to indicate to servers
+   * which media types are preferred over others.
+   */
+  setMediaTypeQuality: (contentType: string, quality: number) => void;
+
+  value: typeof jsonValue;
+  typeOf: typeof jsonTypeOf;
+  has: typeof jsonObjectHas;
+
+  /**
+   * 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: JsonCompatible<JrefNode>) => Promise<JsonCompatible<JrefNode>>;
+
+  /**
+   * Iterate over an array node. It will follow any references it encounters so
+   * it always yields JSON compatible values.
+   */
+  iter: (node: JsonCompatible<JrefNode>) => AsyncGenerator<JsonCompatible<JrefNode>, 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: JsonCompatible<JrefNode>) => AsyncGenerator<JsonCompatible<JrefNode>, 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: JsonCompatible<JrefNode>) => AsyncGenerator<[string, JsonCompatible<JrefNode>], void, unknown>;
+}
+
+export class RetrievalError extends Error {
+  constructor(message: string, options: { cause: unknown });
+}
+
+export class UnsupportedUriSchemeError extends Error {
+  constructor(scheme: string, message?: string);
+}
+
+export class UnsupportedMediaTypeError extends Error {
+  mediaType: string;
+
+  constructor(mediaType: string, message?: string);
+}
+
+export class UnknownMediaTypeError extends Error {
+  constructor(message?: string);
+}

src/hyperjump/hyperjump.d.ts

@@ -14,21 +14,11 @@ import { mimeMatch } from "./utilities.js";
  * @import { JsonCompatible } from "../json/jsonast.js"
  * @import { UriSchemePlugin } from "./uri-schemes/uri-scheme-plugin.js"
  * @import { DocumentNode, MediaTypePlugin } from "./media-types/media-type-plugin.js"
- * @import { JsonPointerError } from "../json/jsonast-util.js"
+ * @import * as API from "./hyperjump.d.ts";
  */
 
 
-/**
- * @typedef {{}} HyperjumpConfig
- */
-
 // TODO: Support fetch options in get
-/**
- * @typedef {{
- *   referencedFrom?: string;
- * }} GetOptions
- */
-
 // TODO: Support filters
 
 export class Hyperjump {
@@ -44,11 +34,11 @@ export class Hyperjump {
   /** @type Record<string, MediaTypePlugin<DocumentNode>> */
   #mediaTypePlugins;
 
-  /** @type GetOptions */
+  /** @type API.GetOptions */
   #defaultGetOptions;
 
   /**
-   * @param {HyperjumpConfig} [config]
+   * @param {API.HyperjumpConfig} [config]
    */
   constructor(config = {}) {
     this.#config = config;
@@ -69,22 +59,7 @@ export class Hyperjump {
     this.addMediaTypePlugin(new JsonMediaTypePlugin());
   }
 
-  /**
-   * Retrieve a document located at the given URI. URIs can be relative if a
-   * base URI can be determined. On the server-side, the base URI is the CWD. In
-   * browser, the base URI is the URI of the page.
-   *
-   * @see Use {@link Hyperjump.addUriSchemePlugin} to add support for additional
-   * URI schemes.
-   * @see Support for {@link JrefMediaTypePlugin | JRef} and
-   * {@link JsonMediaTypePlugin | JSON} is built in. Use
-   * {@link Hyperjump.addMediaTypePlugin} to add support for additional media
-   * types.
-   *
-   * @type (uri: string, options?: GetOptions) => Promise<JsonCompatible<JrefNode>>
-   * @throws &nbsp;{@link RetrievalError}
-   * @throws &nbsp;{@link JsonPointerError}
-   */
+  /** @type API.Hyperjump["get"] */
   async get(uri, options = this.#defaultGetOptions) {
     uri = resolveIri(uri, contextUri());
     const id = toAbsoluteIri(uri);
@@ -127,39 +102,19 @@ export class Hyperjump {
     }
   }
 
-  /**
-   * Add support for a
-   * {@link https://www.rfc-editor.org/rfc/rfc3986#section-3.1 | URI scheme}.
-   * Support for the {@link HttpUriSchemePlugin | `http(s):`} and
-   * {@link FileUriSchemePlugin | `file:`} URI schemes are enabled by default.
-   *
-   * @type (plugin: UriSchemePlugin) => void
-   */
+  /** @type API.Hyperjump["addUriSchemePlugin"] */
   addUriSchemePlugin(plugin) {
     for (const scheme of plugin.schemes) {
       this.#uriSchemePlugins[scheme] = plugin;
     }
   }
 
-  /**
-   * This is mostly useful for disabling a scheme that's enabled by default.
-   *
-   * @type (scheme: string) => void
-   */
+  /** @type API.Hyperjump["removeUriSchemePlugin"] */
   removeUriSchemePlugin(scheme) {
     delete this.#uriSchemePlugins[scheme];
   }
 
-  /**
-   * Unless you're using it in a {@link UriSchemePlugin.retrieve} method, this
-   * is not the method you're looking for. It's used internally to fetch a
-   * resource before processing it based on its media type. You might use it for
-   * implementing {@link UriSchemePlugin}s for URI schemes that don't have
-   * locating semantics (such as `urn:`) and instead map to another URI where
-   * the resource can be retrieved from. See the example in the README.
-   *
-   * @type (uri: string, options: GetOptions) => Promise<Response>
-   */
+  /** @type API.Hyperjump["retrieve"] */
   async retrieve(uri, options) {
     const { scheme } = parseIri(uri);
 
@@ -170,11 +125,7 @@ export class Hyperjump {
     return this.#uriSchemePlugins[scheme].retrieve(uri, options);
   }
 
-  /**
-   * Constructs an `Accept` header based on the registered media types.
-   *
-   * @type () => string
-   */
+  /** @type API.Hyperjump["acceptableMediaTypes"] */
   acceptableMediaTypes() {
     let accept = "";
 
@@ -198,12 +149,7 @@ export class Hyperjump {
     return accept;
   }
 
-  /**
-   * Returns the media type of the resource based on its URI. This is usually
-   * based on the extension and configured by {@link MediaTypePlugin}s.
-   *
-   * @type (uri: string) => string
-   */
+  /** @type API.Hyperjump["getMediaType"] */
   getMediaType(uri) {
     for (const contentType in this.#mediaTypePlugins) {
       for (const extension of this.#mediaTypePlugins[contentType].extensions) {
@@ -218,34 +164,17 @@ 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.`);
   }
 
-  /**
-   * Add support for a media tpe. Support for the
-   * {@link JrefMediaTypePlugin | `JRef`} and
-   * {@link JsonMediaTypePlugin | `JSON`} media types are enabled by default.
-   *
-   * @type <T extends DocumentNode>(plugin: MediaTypePlugin<T>) => void
-   */
+  /** @type API.Hyperjump["addMediaTypePlugin"] */
   addMediaTypePlugin(plugin) {
     this.#mediaTypePlugins[plugin.mediaType] = plugin;
   }
 
-  /**
-   * This is mostly useful for disabling a scheme that's enabled by default.
-   *
-   * @type (contentType: string) => void
-   */
+  /** @type API.Hyperjump["removeMediaTypePlugin"] */
   removeMediaTypePlugin(contentType) {
     delete this.#mediaTypePlugins[contentType];
   }
 
-  /**
-   * Set the
-   * {@link https://developer.mozilla.org/en-US/docs/Glossary/Quality_values | quality}
-   * that will be used in the Accept header of requests to indicate to servers
-   * which media types are preferred over others.
-   *
-   * @type (contentType: string, quality: number) => void
-   */
+  /** @type API.Hyperjump["setMediaTypeQuality"] */
   setMediaTypeQuality(contentType, quality) {
     this.#mediaTypePlugins[contentType].quality = quality;
   }
@@ -271,22 +200,12 @@ export class Hyperjump {
   typeOf = jsonTypeOf;
   has = jsonObjectHas;
 
-  /**
-   * This is like indexing into an object or array. It will follow any
-   * references it encounters so it always returns a JSON compatible value.
-   *
-   * @type (key: string, node: JsonCompatible<JrefNode>) => Promise<JsonCompatible<JrefNode>>
-   */
+  /** @type API.Hyperjump["step"] */
   async step(key, node) {
     return await this.#followReferences(pointerStep(key, node));
   }
 
-  /**
-   * Iterate over an array node. It will follow any references it encounters so
-   * it always yields JSON compatible values.
-   *
-   * @type (node: JsonCompatible<JrefNode>) => AsyncGenerator<JsonCompatible<JrefNode>, void, unknown>
-   */
+  /** @type API.Hyperjump["iter"] */
   async* iter(node) {
     if (node.jsonType === "array") {
       for (const itemNode of node.children) {
@@ -297,12 +216,7 @@ export class Hyperjump {
 
   keys = jsonObjectKeys;
 
-  /**
-   * Iterate over the values of an object. It will follow any references it
-   * encounters so it always yields JSON compatible values.
-   *
-   * @type (node: JsonCompatible<JrefNode>) => AsyncGenerator<JsonCompatible<JrefNode>, void, unknown>
-   */
+  /** @type API.Hyperjump["values"] */
   async* values(node) {
     if (node.jsonType === "object") {
       for (const propertyNode of node.children) {
@@ -311,12 +225,7 @@ export class Hyperjump {
     }
   }
 
-  /**
-   * Iterate over key/value pairs of an object. It will follow any references it
-   * encounters so it always yields JSON compatible values.
-   *
-   * @type (node: JsonCompatible<JrefNode>) => AsyncGenerator<[string, JsonCompatible<JrefNode>], void, unknown>
-   */
+  /** @type API.Hyperjump["entries"] */
   async* entries(node) {
     if (node.jsonType === "object") {
       for (const propertyNode of node.children) {

src/hyperjump/hyperjump.js

@@ -3,7 +3,9 @@
  */
 
 export * from "./hyperjump.js";
+export * from "./uri-schemes/uri-scheme-plugin.js"; // eslint-disable-line import/export
 export * from "./uri-schemes/file-scheme-plugin.js";
 export * from "./uri-schemes/http-scheme-plugin.js";
+export * from "./media-types/media-type-plugin.js"; // eslint-disable-line import/export
 export * from "./media-types/json-media-type-plugin.js";
 export * from "./media-types/jref-media-type-plugin.js";