@utiliread/http 1.16.2 → 1.17.0

package/plugins/msgpack/package-lock.json

@@ -0,0 +1,134 @@
+{
+    "name": "@utiliread/http/msgpack",
+    "lockfileVersion": 2,
+    "requires": true,
+    "packages": {
+        "": {
+            "name": "@utiliread/http/msgpack",
+            "dependencies": {
+                "@msgpack/msgpack": "^2.7.2",
+                "@utiliread/http": "../../",
+                "@utiliread/msgpack": "^1.0.1"
+            }
+        },
+        "../..": {
+            "name": "@utiliread/http",
+            "version": "1.16.2",
+            "devDependencies": {
+                "@parcel/packager-ts": "^2.5.0",
+                "@parcel/transformer-typescript-types": "^2.5.0",
+                "@types/chai": "^4.2.16",
+                "@types/luxon": "^2.0.5",
+                "@types/mocha": "^9.0.0",
+                "@utiliread/json": "^1.0.2",
+                "@utiliread/jsonpatch": "^1.0.0",
+                "@utiliread/msgpack": "^1.0.1",
+                "chai": "^4.3.4",
+                "karma": "^6.3.8",
+                "karma-chai": "^0.1.0",
+                "karma-chrome-launcher": "^3.1.0",
+                "karma-mocha": "^2.0.1",
+                "karma-typescript": "^5.5.1",
+                "luxon": "^2.1.0",
+                "mocha": "^9.1.3",
+                "parcel": "^2.5.0",
+                "rimraf": "^3.0.2",
+                "typescript": "^4.2.4"
+            },
+            "peerDependencies": {
+                "@utiliread/json": "^1.0.2",
+                "@utiliread/jsonpatch": "^1.0.0",
+                "@utiliread/msgpack": "^1.0.1",
+                "luxon": "^2.1.0"
+            },
+            "peerDependenciesMeta": {
+                "@utiliread/json": {
+                    "optional": true
+                },
+                "@utiliread/jsonpatch": {
+                    "optional": true
+                },
+                "@utiliread/msgpack": {
+                    "optional": true
+                }
+            }
+        },
+        "node_modules/@msgpack/msgpack": {
+            "version": "2.7.2",
+            "resolved": "https://registry.npmjs.org/@msgpack/msgpack/-/msgpack-2.7.2.tgz",
+            "integrity": "sha512-rYEi46+gIzufyYUAoHDnRzkWGxajpD9vVXFQ3g1vbjrBm6P7MBmm+s/fqPa46sxa+8FOUdEuRQKaugo5a4JWpw==",
+            "engines": {
+                "node": ">= 10"
+            }
+        },
+        "node_modules/@utiliread/http": {
+            "resolved": "../..",
+            "link": true
+        },
+        "node_modules/@utiliread/msgpack": {
+            "version": "1.0.1",
+            "resolved": "https://registry.npmjs.org/@utiliread/msgpack/-/msgpack-1.0.1.tgz",
+            "integrity": "sha512-M5bG7drhwrp4YLZhL1Al+K2SkFw3rVhsCVJvi+yV2n5M8nD/qnLuMRu5ZvjYT5iNYKfo1MJWUXfSbq30a0GqLA==",
+            "dependencies": {
+                "@msgpack/msgpack": "^2.4.0"
+            },
+            "peerDependencies": {
+                "luxon": "^2.1.0"
+            }
+        },
+        "node_modules/luxon": {
+            "version": "2.4.0",
+            "resolved": "https://registry.npmjs.org/luxon/-/luxon-2.4.0.tgz",
+            "integrity": "sha512-w+NAwWOUL5hO0SgwOHsMBAmZ15SoknmQXhSO0hIbJCAmPKSsGeK8MlmhYh2w6Iib38IxN2M+/ooXWLbeis7GuA==",
+            "peer": true,
+            "engines": {
+                "node": ">=12"
+            }
+        }
+    },
+    "dependencies": {
+        "@msgpack/msgpack": {
+            "version": "2.7.2",
+            "resolved": "https://registry.npmjs.org/@msgpack/msgpack/-/msgpack-2.7.2.tgz",
+            "integrity": "sha512-rYEi46+gIzufyYUAoHDnRzkWGxajpD9vVXFQ3g1vbjrBm6P7MBmm+s/fqPa46sxa+8FOUdEuRQKaugo5a4JWpw=="
+        },
+        "@utiliread/http": {
+            "version": "file:../..",
+            "requires": {
+                "@parcel/packager-ts": "^2.5.0",
+                "@parcel/transformer-typescript-types": "^2.5.0",
+                "@types/chai": "^4.2.16",
+                "@types/luxon": "^2.0.5",
+                "@types/mocha": "^9.0.0",
+                "@utiliread/json": "^1.0.2",
+                "@utiliread/jsonpatch": "^1.0.0",
+                "@utiliread/msgpack": "^1.0.1",
+                "chai": "^4.3.4",
+                "karma": "^6.3.8",
+                "karma-chai": "^0.1.0",
+                "karma-chrome-launcher": "^3.1.0",
+                "karma-mocha": "^2.0.1",
+                "karma-typescript": "^5.5.1",
+                "luxon": "^2.1.0",
+                "mocha": "^9.1.3",
+                "parcel": "^2.5.0",
+                "rimraf": "^3.0.2",
+                "typescript": "^4.2.4"
+            }
+        },
+        "@utiliread/msgpack": {
+            "version": "1.0.1",
+            "resolved": "https://registry.npmjs.org/@utiliread/msgpack/-/msgpack-1.0.1.tgz",
+            "integrity": "sha512-M5bG7drhwrp4YLZhL1Al+K2SkFw3rVhsCVJvi+yV2n5M8nD/qnLuMRu5ZvjYT5iNYKfo1MJWUXfSbq30a0GqLA==",
+            "requires": {
+                "@msgpack/msgpack": "^2.4.0"
+            }
+        },
+        "luxon": {
+            "version": "2.4.0",
+            "resolved": "https://registry.npmjs.org/luxon/-/luxon-2.4.0.tgz",
+            "integrity": "sha512-w+NAwWOUL5hO0SgwOHsMBAmZ15SoknmQXhSO0hIbJCAmPKSsGeK8MlmhYh2w6Iib38IxN2M+/ooXWLbeis7GuA==",
+            "peer": true
+        }
+    }
+}

package/plugins/msgpack/package.json

@@ -0,0 +1,12 @@
+{
+  "name": "@utiliread/http/msgpack",
+  "source": "./src/index.ts",
+  "main": "../../dist/msgpack.js",
+  "module": "../../dist/msgpack.mjs",
+  "types": "../../dist/msgpack.d.ts",
+  "dependencies": {
+    "@msgpack/msgpack": "^2.7.2",
+    "@utiliread/http": "../../",
+    "@utiliread/msgpack": "^1.0.1"
+  }
+}

package/{src/msgpack.ts → plugins/msgpack/src/index.ts}

@@ -1,64 +1,60 @@
-import { deserialize } from "@utiliread/msgpack";
-import { HttpBuilder } from "./http-builder";
-import { decodeArrayStream, decodeAsync } from "@msgpack/msgpack";
-import { getMapper, Mapper, Type } from "./mapping";
-import { HttpResponse } from "./http-response";
-
-type TypeOrMapper<T> = Type<T> | Mapper<T>;
-
-declare module "./http-builder" {
-  interface HttpBuilder {
-    expectMessagePack<T>(
-      typeOrMapper?: TypeOrMapper<T>
-    ): HttpBuilderOfT<T>;
-    expectMessagePackArray<T>(
-      typeOrMapper?: TypeOrMapper<T>
-    ): HttpBuilderOfT<T[]>;
-    streamMessagePackArray<T>(
-      typeOrMapper?: TypeOrMapper<T>
-    ): HttpBuilderOfT<AsyncGenerator<T, void, unknown>>;
-  }
-}
-
-HttpBuilder.prototype.expectMessagePack = function <T>(
-  this: HttpBuilder,
-  typeOrMapper?: TypeOrMapper<T>
-) {
-  this.message.headers.set("Accept", "application/x-msgpack");
-  return this.useHandler(async (response) => {
-    const itemFactory = getMapper(deserialize, typeOrMapper);
-    const decoded = await decodeAsync(response.rawResponse.body!);
-    return itemFactory(decoded);
-  });
-};
-
-HttpBuilder.prototype.expectMessagePackArray = function <T>(
-  this: HttpBuilder,
-  typeOrMapper?: TypeOrMapper<T>
-) {
-  this.message.headers.set("Accept", "application/x-msgpack");
-  return this.useHandler(async (response) => {
-    const items: T[] = [];
-    const itemFactory = getMapper(deserialize, typeOrMapper);
-    for await (const item of decodeArrayStream(response.rawResponse.body!)) {
-      items.push(itemFactory(item));
-    }
-    return items;
-  });
-};
-
-HttpBuilder.prototype.streamMessagePackArray = function <T>(
-  this: HttpBuilder,
-  typeOrMapper?: TypeOrMapper<T>
-) {
-  this.message.headers.set("Accept", "application/x-msgpack");
-
-  async function* handler(response: HttpResponse) {
-    const itemFactory = getMapper(deserialize, typeOrMapper);
-    for await (const item of decodeArrayStream(response.rawResponse.body!)) {
-      yield itemFactory(item);
-    }
-  }
-
-  return this.useHandler((response) => Promise.resolve(handler(response)));
-};
+import { deserialize } from "@utiliread/msgpack";
+import { HttpBuilder, HttpBuilderOfT, HttpResponse, TypeOrMapper } from "@utiliread/http";
+import { decodeArrayStream, decodeAsync } from "@msgpack/msgpack";
+import { getMapper } from "../../../src/mapping";
+
+// https://www.typescriptlang.org/docs/handbook/declaration-merging.html#module-augmentation
+declare module "@utiliread/http" {
+  interface HttpBuilder {
+    expectMessagePack<T>(typeOrMapper?: TypeOrMapper<T>): HttpBuilderOfT<T>;
+    expectMessagePackArray<T>(
+      typeOrMapper?: TypeOrMapper<T>
+    ): HttpBuilderOfT<T[]>;
+    streamMessagePackArray<T>(
+      typeOrMapper?: TypeOrMapper<T>
+    ): HttpBuilderOfT<AsyncGenerator<T, void, unknown>>;
+  }
+}
+
+HttpBuilder.prototype.expectMessagePack = function <T>(
+  this: HttpBuilder,
+  typeOrMapper?: TypeOrMapper<T>
+) {
+  this.message.headers.set("Accept", "application/x-msgpack");
+  return this.useHandler(async (response) => {
+    const itemFactory = getMapper(deserialize, typeOrMapper);
+    const decoded = await decodeAsync(response.rawResponse.body!);
+    return itemFactory(decoded);
+  });
+};
+
+HttpBuilder.prototype.expectMessagePackArray = function <T>(
+  this: HttpBuilder,
+  typeOrMapper?: TypeOrMapper<T>
+) {
+  this.message.headers.set("Accept", "application/x-msgpack");
+  return this.useHandler(async (response) => {
+    const items: T[] = [];
+    const itemFactory = getMapper(deserialize, typeOrMapper);
+    for await (const item of decodeArrayStream(response.rawResponse.body!)) {
+      items.push(itemFactory(item));
+    }
+    return items;
+  });
+};
+
+HttpBuilder.prototype.streamMessagePackArray = function <T>(
+  this: HttpBuilder,
+  typeOrMapper?: TypeOrMapper<T>
+) {
+  this.message.headers.set("Accept", "application/x-msgpack");
+
+  async function* handler(response: HttpResponse) {
+    const itemFactory = getMapper(deserialize, typeOrMapper);
+    for await (const item of decodeArrayStream(response.rawResponse.body!)) {
+      yield itemFactory(item);
+    }
+  }
+
+  return this.useHandler((response) => Promise.resolve(handler(response)));
+};

package/plugins/msgpack/tsconfig.json

@@ -0,0 +1,3 @@
+{
+  "extends": "../../tsconfig.json"
+}

package/src/http-builder.ts

@@ -2,7 +2,7 @@ import { Fetch } from './http';
 import { HttpResponse, HttpResponseOfT } from './http-response';
 import { TimeoutError } from './timeout-error';
 import { EventAggregator } from './event-aggregator';
-import { Http } from '.';
+import { Http } from './http';
 
 export class HttpBuilder {
     private _ensureSuccessStatusCode = true;

package/src/http.ts

@@ -1,122 +1,138 @@
-import { EventAggregator } from './event-aggregator';
-import { HttpBuilder, HttpMethod, Message } from './http-builder';
-import { HttpResponse, HttpResponseOfT } from './http-response';
-import { QueryString } from './query-string';
+import { EventAggregator } from "./event-aggregator";
+import type { Subscription } from "./event-aggregator";
+import { HttpBuilder, HttpMethod, Message } from "./http-builder";
+import { HttpResponse, HttpResponseOfT } from "./http-response";
+import { QueryString } from "./query-string";
 
-export type Fetch = (input: RequestInfo, init?: RequestInit) => Promise<Response>;
+export type Fetch = (
+  input: RequestInfo,
+  init?: RequestInit
+) => Promise<Response>;
 
 export class Http {
-    static defaults: HttpOptions = {
-        fetch: self.fetch ? self.fetch.bind(self) : undefined,
-    }
-    private static instance?: Http;
-    options: HttpOptions;
-    /** @internal */
-    _onSend = new EventAggregator<[Message]>();
-    /** @internal */
-    _onSent = new EventAggregator<[HttpResponse, Message]>();
-    /** @internal */
-    _onReceived = new EventAggregator<[HttpResponseOfT<any>, Message, any]>();
-
-    constructor(options?: Partial<HttpOptions>) {
-        this.options = Object.assign({}, Http.defaults, options); // Later sources' properties overwrite earlier ones.
-    }
-
-    static request(method: HttpMethod, url: string, params?: any) {
-        return this.getInstance().request(method, url, params);
-    }
-
-    static head(url: string, params?: any) {
-        return this.getInstance().head(url, params);
-    }
-
-    static post(url: string, params?: any) {
-        return this.getInstance().post(url, params);
-    }
-
-    static get(url: string, params?: any) {
-        return this.getInstance().get(url, params);
-    }
-
-    static put(url: string, params?: any) {
-        return this.getInstance().put(url, params);
-    }
-
-    static patch(url: string, params?: any) {
-        return this.getInstance().patch(url, params);
-    }
-
-    static delete(url: string, params?: any) {
-        return this.getInstance().delete(url, params);
-    }
-
-    private static getInstance() {
-        if (!this.instance) {
-            this.instance = new Http();
-            // The singleton instance should always use the static options
-            this.instance.options = Http.defaults;
-        }
-        return this.instance;
-    }
-
-    request(method: HttpMethod, url: string, params?: any) {
-        const message = {
-            method,
-            url: url + QueryString.serialize(params),
-            headers: new Headers(),
-            properties: {},
-        };
-        const fetch = this.options.fetch;
-        if (!fetch) {
-            throw Error('fetch() is not properly configured');
-        }
-        const builder = new HttpBuilder(message, {
-            fetch,
-            timeout: this.options.timeout,
-            baseUrl: this.options.baseUrl,
-        }, this);
-        return builder;
-    }
-
-    head(url: string, params?: any) {
-        return this.request('HEAD', url, params);
-    }
-
-    post(url: string, params?: any) {
-        return this.request('POST', url, params);
-    }
-
-    get(url: string, params?: any) {
-        return this.request('GET', url, params);
-    }
-
-    put(url: string, params?: any) {
-        return this.request('PUT', url, params);
-    }
-
-    patch(url: string, params?: any) {
-        return this.request('PATCH', url, params);
-    }
-
-    delete(url: string, params?: any) {
-        return this.request('DELETE', url, params);
-    }
-
-    onSend(callback: (request: Message) => void | Promise<void>) {
-        return this._onSend.subscribe(callback);
-    }
-
-    onSent(callback: (response: HttpResponse, request: Message) => void | Promise<void>) {
-        return this._onSent.subscribe(callback);
-    }
-
-    onReceived(callback: (response: HttpResponseOfT<any>, request: Message, value: any) => void | Promise<void>) {
-        return this._onReceived.subscribe(callback);
-    }
+  static defaults: HttpOptions = {
+    fetch: self.fetch ? self.fetch.bind(self) : undefined,
+  };
+  private static instance?: Http;
+  options: HttpOptions;
+  /** @internal */
+  _onSend = new EventAggregator<[Message]>();
+  /** @internal */
+  _onSent = new EventAggregator<[HttpResponse, Message]>();
+  /** @internal */
+  _onReceived = new EventAggregator<[HttpResponseOfT<any>, Message, any]>();
+
+  constructor(options?: Partial<HttpOptions>) {
+    this.options = Object.assign({}, Http.defaults, options); // Later sources' properties overwrite earlier ones.
+  }
+
+  static request(method: HttpMethod, url: string, params?: any) {
+    return this.getInstance().request(method, url, params);
+  }
+
+  static head(url: string, params?: any) {
+    return this.getInstance().head(url, params);
+  }
+
+  static post(url: string, params?: any) {
+    return this.getInstance().post(url, params);
+  }
+
+  static get(url: string, params?: any) {
+    return this.getInstance().get(url, params);
+  }
+
+  static put(url: string, params?: any) {
+    return this.getInstance().put(url, params);
+  }
+
+  static patch(url: string, params?: any) {
+    return this.getInstance().patch(url, params);
+  }
+
+  static delete(url: string, params?: any) {
+    return this.getInstance().delete(url, params);
+  }
+
+  private static getInstance() {
+    if (!this.instance) {
+      this.instance = new Http();
+      // The singleton instance should always use the static options
+      this.instance.options = Http.defaults;
+    }
+    return this.instance;
+  }
+
+  request(method: HttpMethod, url: string, params?: any) {
+    const message = {
+      method,
+      url: url + QueryString.serialize(params),
+      headers: new Headers(),
+      properties: {},
+    };
+    const fetch = this.options.fetch;
+    if (!fetch) {
+      throw Error("fetch() is not properly configured");
+    }
+    const builder = new HttpBuilder(
+      message,
+      {
+        fetch,
+        timeout: this.options.timeout,
+        baseUrl: this.options.baseUrl,
+      },
+      this
+    );
+    return builder;
+  }
+
+  head(url: string, params?: any) {
+    return this.request("HEAD", url, params);
+  }
+
+  post(url: string, params?: any) {
+    return this.request("POST", url, params);
+  }
+
+  get(url: string, params?: any) {
+    return this.request("GET", url, params);
+  }
+
+  put(url: string, params?: any) {
+    return this.request("PUT", url, params);
+  }
+
+  patch(url: string, params?: any) {
+    return this.request("PATCH", url, params);
+  }
+
+  delete(url: string, params?: any) {
+    return this.request("DELETE", url, params);
+  }
+
+  onSend(callback: (request: Message) => void | Promise<void>): Subscription {
+    return this._onSend.subscribe(callback);
+  }
+
+  onSent(
+    callback: (response: HttpResponse, request: Message) => void | Promise<void>
+  ): Subscription {
+    return this._onSent.subscribe(callback);
+  }
+
+  onReceived(
+    callback: (
+      response: HttpResponseOfT<any>,
+      request: Message,
+      value: any
+    ) => void | Promise<void>
+  ): Subscription {
+    return this._onReceived.subscribe(callback);
+  }
 }
 
 export interface HttpOptions {
-    fetch?: Fetch,
-    timeout?: number,
-    baseUrl?: string,
-}
+  fetch?: Fetch;
+  timeout?: number;
+  baseUrl?: string;
+}

package/src/index.ts

@@ -1,18 +1,20 @@
 export { Http } from "./http";
-export {
+export type {
   Page,
   PaginationResult,
   InfinitePage,
   InfinitePaginationResult,
 } from "./pagination";
-export { ProblemDetails } from "./problem-details";
+export type { ProblemDetails } from "./problem-details";
 export { QueryString } from "./query-string";
 export { HttpResponse, HttpResponseOfT } from "./http-response";
-export { HttpBuilder, HttpBuilderOfT, Message } from "./http-builder";
+export { HttpBuilder, HttpBuilderOfT } from "./http-builder";
+export type { Message } from "./http-builder";
 export { HttpError } from "./http-error";
 export { TimeoutError } from "./timeout-error";
 export { events } from "./events";
 export * from "./helpers";
-export { Fetch } from "./http";
-export { Subscription } from "./event-aggregator";
-export { statusCodes } from "./status-codes";
+export type { Fetch } from "./http";
+export type { Subscription } from "./event-aggregator";
+export { statusCodes } from "./status-codes";
+export type { TypeOrMapper } from "./mapping";

package/src/mapping.ts

@@ -1,6 +1,7 @@
 type DeserializeFn<T> = (source: any, type: Type<T>) => T | null | undefined;
 export type Type<T> = { new(): T };
 export type Mapper<T> = ((source: any) => T);
+export type TypeOrMapper<T> = Type<T> | Mapper<T>;
 
 export function getNullableMapper<T>(deserialize: DeserializeFn<T>, typeOrMap: Type<T> | Mapper<T> | undefined): Mapper<T | null> {
     if (!typeOrMap) {

package/tsconfig.json

@@ -1,18 +1,9 @@
 {
-    "compilerOptions": {
-        "target": "es5",
-        "module": "esnext",
-        "moduleResolution": "node",
-        "declaration": true,
-        "sourceMap": true,
-        "strict": true,
-        "rootDir": "src",
-        "outDir": "dist/esm",
-        "lib": [ "es2017", "dom" ],
-        "stripInternal": true,
-    },
-    "exclude": [
-        "./*.d.ts",
-        "dist"
-    ]
-}
+  "compilerOptions": {
+    "target": "ES2018",
+    "strict": true,
+    "stripInternal": true,
+    "lib": ["ES2018", "DOM"]
+  },
+  "exclude": ["dist/*", "*.d.ts"]
+}