@opra/client 1.0.0-alpha.21 → 1.0.0-alpha.23

package/browser/index.mjs

@@ -0,0 +1,576 @@
+/****************************************
+* All rights reserved Panates® 2022-2024
+* http://www.panates.com
+*****************************************/
+
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+
+// ../../build/client/esm/index.js
+import { Buffer as Buffer2 } from "buffer";
+
+// ../../build/client/esm/constants.js
+var kClient = Symbol.for("kClient");
+var kBackend = Symbol.for("kBackend");
+var kContext = Symbol.for("kContext");
+
+// ../../build/client/esm/core/backend.js
+var _Backend = class _Backend {
+  constructor(options) {
+    this.document = options == null ? void 0 : options.document;
+  }
+};
+__name(_Backend, "Backend");
+var Backend = _Backend;
+
+// ../../build/client/esm/core/client-error.js
+var _ClientError = class _ClientError extends Error {
+  constructor(init, cause) {
+    super(init.message);
+    this.cause = cause;
+    this.issues = init.issues || [];
+    this.status = init.status;
+    if (cause) {
+      this.cause = cause;
+      if (cause.stack)
+        this.stack = cause.stack;
+    }
+  }
+};
+__name(_ClientError, "ClientError");
+var ClientError = _ClientError;
+
+// ../../build/client/esm/http/enums/http-observable-type.enum.js
+var HttpObserveType;
+(function(HttpObserveType2) {
+  HttpObserveType2["ResponseHeader"] = "response-header";
+  HttpObserveType2["Response"] = "response";
+  HttpObserveType2["Body"] = "body";
+  HttpObserveType2["Events"] = "events";
+})(HttpObserveType || (HttpObserveType = {}));
+
+// ../../build/client/esm/http/fetch-backend.js
+import typeIs from "@browsery/type-is";
+import { isBlob, isFormData } from "@opra/common";
+import { Observable } from "rxjs";
+import { isReadableStreamLike } from "rxjs/internal/util/isReadableStreamLike";
+
+// ../../build/client/esm/http/http-backend.js
+var _HttpBackend = class _HttpBackend extends Backend {
+  constructor(serviceUrl, options) {
+    super(options);
+    const u = new URL(serviceUrl);
+    this.serviceUrl = u.toString().split("?")[0].split("#")[0];
+    if (!this.serviceUrl.endsWith("/"))
+      this.serviceUrl += "/";
+  }
+};
+__name(_HttpBackend, "HttpBackend");
+var HttpBackend = _HttpBackend;
+
+// ../../build/client/esm/http/http-response.js
+var _HttpResponse = class _HttpResponse {
+  constructor(init) {
+    this.hasBody = false;
+    this.headers = (init == null ? void 0 : init.headers) instanceof Headers ? init == null ? void 0 : init.headers : new Headers(init == null ? void 0 : init.headers);
+    this.status = (init == null ? void 0 : init.status) || 200;
+    this.statusText = (init == null ? void 0 : init.statusText) || "OK";
+    this.url = (init == null ? void 0 : init.url) || null;
+    this.ok = this.status >= 200 && this.status < 300;
+    this.body = init == null ? void 0 : init.body;
+    this.hasBody = (init == null ? void 0 : init.body) != null || !!(init == null ? void 0 : init.hasBody);
+    this.contentType = (this.headers.get("content-type") || "").split(";")[0];
+  }
+  clone(update) {
+    return new _HttpResponse({ ...this, ...update });
+  }
+};
+__name(_HttpResponse, "HttpResponse");
+var HttpResponse = _HttpResponse;
+
+// ../../build/client/esm/http/interfaces/http-event.js
+var HttpEventType;
+(function(HttpEventType2) {
+  HttpEventType2["Sent"] = "Sent";
+  HttpEventType2["UploadProgress"] = "UploadProgress";
+  HttpEventType2["ResponseHeader"] = "ResponseHeader";
+  HttpEventType2["DownloadProgress"] = "DownloadProgress";
+  HttpEventType2["Response"] = "Response";
+  HttpEventType2["User"] = "User";
+})(HttpEventType || (HttpEventType = {}));
+
+// ../../build/client/esm/http/fetch-backend.js
+var _FetchBackend = class _FetchBackend extends HttpBackend {
+  constructor(serviceUrl, options) {
+    var _a, _b, _c, _d, _e, _f;
+    super(serviceUrl, options);
+    this.interceptors = Array.from(/* @__PURE__ */ new Set([...(options == null ? void 0 : options.interceptors) || []]));
+    this.defaults = {
+      ...options == null ? void 0 : options.defaults,
+      headers: ((_a = options == null ? void 0 : options.defaults) == null ? void 0 : _a.headers) instanceof Headers ? (_b = options == null ? void 0 : options.defaults) == null ? void 0 : _b.headers : new Headers((_c = options == null ? void 0 : options.defaults) == null ? void 0 : _c.headers),
+      params: ((_d = options == null ? void 0 : options.defaults) == null ? void 0 : _d.params) instanceof URLSearchParams ? (_e = options == null ? void 0 : options.defaults) == null ? void 0 : _e.params : new URLSearchParams((_f = options == null ? void 0 : options.defaults) == null ? void 0 : _f.params)
+    };
+  }
+  handle(init) {
+    return new Observable((subscriber) => {
+      (async () => {
+        let request = this.prepareRequest(init);
+        if (request.body && init.reportProgress) {
+          const stream = request.body;
+          const contentLength = request.headers.get("content-length") || "0";
+          const total = parseInt(contentLength, 10) || 0;
+          let loaded = 0;
+          const progressTrackingStream = new TransformStream({
+            transform(chunk, controller) {
+              controller.enqueue(chunk);
+              loaded += chunk.byteLength;
+              subscriber.next({
+                type: HttpEventType.UploadProgress,
+                request,
+                total,
+                loaded
+              });
+            }
+          });
+          request = new Request(request.url, {
+            cache: request.cache,
+            credentials: request.credentials,
+            headers: request.headers,
+            integrity: request.integrity,
+            keepalive: request.keepalive,
+            method: request.method,
+            mode: request.mode,
+            redirect: request.redirect,
+            referrer: request.referrer,
+            referrerPolicy: request.referrerPolicy,
+            signal: request.signal,
+            body: stream.pipeThrough(progressTrackingStream),
+            window: init.window,
+            ...{
+              // undici library requires
+              duplex: "half"
+            }
+          });
+        }
+        const fetchPromise = this.send(request);
+        subscriber.next({
+          request,
+          type: HttpEventType.Sent
+        });
+        const fetchResponse = await fetchPromise;
+        const headersResponse = this.createResponse({
+          url: fetchResponse.url,
+          headers: fetchResponse.headers,
+          status: fetchResponse.status,
+          statusText: fetchResponse.statusText,
+          hasBody: !!fetchResponse.body
+        });
+        subscriber.next({
+          request,
+          type: HttpEventType.ResponseHeader,
+          response: headersResponse
+        });
+        let body;
+        if (fetchResponse.body) {
+          if (init.reportProgress) {
+            const fetchBody = fetchResponse.body;
+            const contentLength = fetchResponse.headers.get("content-length") || "0";
+            const total = parseInt(contentLength, 10) || 0;
+            let loaded = 0;
+            const res = new Response(new ReadableStream({
+              async start(controller) {
+                const reader = fetchBody.getReader();
+                for (; ; ) {
+                  const { done, value } = await reader.read();
+                  if (done)
+                    break;
+                  loaded += value.byteLength;
+                  controller.enqueue(value);
+                  subscriber.next({
+                    type: HttpEventType.DownloadProgress,
+                    request,
+                    total,
+                    loaded
+                  });
+                }
+                controller.close();
+              }
+            }));
+            body = await this.parseBody(res);
+          } else {
+            body = await this.parseBody(fetchResponse);
+          }
+        }
+        const response = this.createResponse({
+          url: fetchResponse.url,
+          headers: fetchResponse.headers,
+          status: fetchResponse.status,
+          statusText: fetchResponse.statusText,
+          body
+        });
+        subscriber.next({
+          request,
+          type: HttpEventType.Response,
+          response
+        });
+        subscriber.complete();
+      })().catch((error) => subscriber.error(error));
+    });
+  }
+  send(request) {
+    return fetch(request);
+  }
+  prepareRequest(init) {
+    const headers = init.headers || new Headers();
+    const requestInit = {
+      ...init,
+      headers
+    };
+    this.defaults.headers.forEach((val, key) => {
+      if (!headers.has(key))
+        headers.set(key, val);
+    });
+    const url = new URL(requestInit.url, this.serviceUrl);
+    if (this.defaults.params.size) {
+      this.defaults.params.forEach((val, key) => {
+        if (!url.searchParams.has(key))
+          url.searchParams.set(key, val);
+      });
+      requestInit.url = url.toString();
+    }
+    const body = requestInit.body;
+    if (body) {
+      let contentType = "";
+      if (typeof body === "string" || typeof body === "number" || typeof body === "boolean") {
+        contentType = 'text/plain; charset="UTF-8"';
+        requestInit.body = new Blob([String(body)], { type: contentType });
+        headers.set("Content-Length", String(requestInit.body.size));
+        delete requestInit.duplex;
+      } else if (isReadableStreamLike(body)) {
+        contentType = "application/octet-stream";
+        requestInit.duplex = "half";
+      } else if (Buffer.isBuffer(body)) {
+        contentType = "application/octet-stream";
+        headers.set("Content-Length", String(body.length));
+        delete requestInit.duplex;
+      } else if (isBlob(body)) {
+        contentType = body.type || "application/octet-stream";
+        headers.set("Content-Length", String(body.size));
+        delete requestInit.duplex;
+      } else if (isFormData(body)) {
+        delete requestInit.duplex;
+      } else {
+        contentType = 'application/json;charset="UTF-8"';
+        requestInit.body = new Blob([JSON.stringify(body)], { type: contentType });
+        headers.set("Content-Length", String(requestInit.body.size));
+        delete requestInit.duplex;
+      }
+      if (contentType && !headers.has("Content-Type"))
+        headers.set("Content-Type", contentType);
+    }
+    return new Request(url.toString(), requestInit);
+  }
+  createResponse(init) {
+    return new HttpResponse(init);
+  }
+  async parseBody(fetchResponse) {
+    let body;
+    const contentType = fetchResponse.headers.get("Content-Type") || "";
+    if (typeIs.is(contentType, ["json", "application/*+json"])) {
+      body = await fetchResponse.json();
+      if (typeof body === "string")
+        body = JSON.parse(body);
+    } else if (typeIs.is(contentType, ["text"]))
+      body = await fetchResponse.text();
+    else if (typeIs.is(contentType, ["multipart"]))
+      body = await fetchResponse.formData();
+    else {
+      const buf = await fetchResponse.arrayBuffer();
+      if (buf.byteLength)
+        body = buf;
+    }
+    return body;
+  }
+};
+__name(_FetchBackend, "FetchBackend");
+var FetchBackend = _FetchBackend;
+
+// ../../build/client/esm/http/http-client-base.js
+import { ApiDocumentFactory } from "@opra/common";
+
+// ../../build/client/esm/http/http-request-observable.js
+import typeIs2 from "@browsery/type-is";
+import { MimeTypes } from "@opra/common";
+import { lastValueFrom, Observable as Observable2 } from "rxjs";
+
+// ../../build/client/esm/http/http-interceptor-handler.js
+var _HttpInterceptorHandler = class _HttpInterceptorHandler {
+  constructor(interceptors, finalHandler) {
+    this.chain = interceptors.reduceRight((chainTailFn, interceptor) => (initialRequest, handler) => interceptor.intercept(initialRequest, {
+      handle: /* @__PURE__ */ __name((downstreamRequest) => chainTailFn(downstreamRequest, handler), "handle")
+    }), chainEnd);
+    this.finalHandler = finalHandler;
+  }
+  handle(initialRequest) {
+    return this.chain(initialRequest, (req) => this.finalHandler.handle(req));
+  }
+};
+__name(_HttpInterceptorHandler, "HttpInterceptorHandler");
+var HttpInterceptorHandler = _HttpInterceptorHandler;
+function chainEnd(req, handler) {
+  return handler(req);
+}
+__name(chainEnd, "chainEnd");
+
+// ../../build/client/esm/http/http-request-observable.js
+var _HttpRequestObservable = class _HttpRequestObservable extends Observable2 {
+  constructor(backend, init) {
+    super((subscriber) => {
+      const observe = this[kContext].observe;
+      new HttpInterceptorHandler(backend.interceptors || [], this[kBackend]).handle(this[kContext]).subscribe({
+        next(event) {
+          if (observe === HttpObserveType.Events) {
+            subscriber.next(event);
+            return;
+          }
+          if (observe === HttpObserveType.ResponseHeader && event.type === HttpEventType.ResponseHeader) {
+            subscriber.next(event.response);
+            subscriber.complete();
+            return;
+          }
+          if (event.type === HttpEventType.Response) {
+            const { response } = event;
+            if (observe === HttpObserveType.Response) {
+              subscriber.next(response);
+              subscriber.complete();
+              return;
+            }
+            const isOpraResponse = typeIs2.is(event.response.contentType || "", [MimeTypes.opra_response_json]);
+            if (response.status >= 400 && response.status < 600) {
+              subscriber.error(new ClientError({
+                message: response.status + " " + response.statusText,
+                status: response.status,
+                issues: isOpraResponse ? response.body.errors : void 0
+              }));
+              subscriber.complete();
+              return;
+            }
+            subscriber.next(event.response.body);
+            subscriber.complete();
+          }
+        },
+        error(error) {
+          subscriber.error(error);
+        },
+        complete() {
+          subscriber.complete();
+        }
+      });
+    });
+    Object.defineProperty(this, kBackend, {
+      enumerable: false,
+      value: backend
+    });
+    Object.defineProperty(this, kContext, {
+      enumerable: false,
+      value: {
+        ...init,
+        observe: HttpObserveType.Body,
+        headers: new Headers(init == null ? void 0 : init.headers)
+      }
+    });
+  }
+  clone() {
+    return new _HttpRequestObservable(this[kBackend], this[kContext]);
+  }
+  options(options) {
+    Object.assign(this[kContext], options);
+    return this;
+  }
+  header(arg0, value) {
+    const target = this[kContext].headers;
+    if (typeof arg0 === "object") {
+      const h = arg0 instanceof Headers ? arg0 : new Headers(arg0);
+      h.forEach((v, k) => {
+        if (k.toLowerCase() === "set-cookie") {
+          target.append(k, v);
+        } else
+          target.set(k, v);
+      });
+      return this;
+    }
+    if (value == null || value === "")
+      target.delete(arg0);
+    else
+      target.append(arg0, String(value));
+    return this;
+  }
+  param(arg0, value) {
+    if (value && typeof value === "object") {
+      value = JSON.stringify(value);
+    }
+    const target = this[kContext].url.searchParams;
+    if (typeof arg0 === "object") {
+      if (typeof arg0.forEach === "function") {
+        arg0.forEach((v, k) => target.set(String(k), String(v)));
+      } else {
+        Object.entries(arg0).forEach((entry) => target.set(String(entry[0]), String(entry[1])));
+      }
+      return this;
+    }
+    if (value == null)
+      target.delete(arg0);
+    else
+      target.set(arg0, String(value));
+    return this;
+  }
+  observe(observe) {
+    if (observe === this[kContext].observe)
+      return this;
+    const cloned = this.clone();
+    cloned[kContext].observe = observe || HttpObserveType.Body;
+    return cloned;
+  }
+  getBody() {
+    return lastValueFrom(this.observe(HttpObserveType.Body));
+  }
+  getResponse() {
+    return lastValueFrom(this.observe(HttpObserveType.Response));
+  }
+};
+__name(_HttpRequestObservable, "HttpRequestObservable");
+var HttpRequestObservable = _HttpRequestObservable;
+
+// ../../build/client/esm/http/http-client-base.js
+var SPLIT_BACKSLASH_PATTERN = /^(\/*)(.+)/;
+var _HttpClientBase = class _HttpClientBase {
+  constructor(backend) {
+    Object.defineProperty(this, kBackend, {
+      enumerable: false,
+      value: backend
+    });
+  }
+  get serviceUrl() {
+    return this[kBackend].serviceUrl;
+  }
+  async fetchDocument(options) {
+    const documentMap = {};
+    const getDocument = /* @__PURE__ */ __name(async (documentId) => {
+      const req = this.request("$schema", {
+        headers: new Headers({ accept: "application/json" })
+      });
+      if (documentId)
+        req.param("id", documentId);
+      const body2 = await req.getBody().catch((e) => {
+        e.message = "Error fetching api schema from url (" + this.serviceUrl + ").\n" + e.message;
+        throw e;
+      });
+      if (body2.references) {
+        const oldReferences = body2.references;
+        body2.references = {};
+        for (const [ns, obj] of Object.entries(oldReferences)) {
+          if (documentMap[obj.id] === null)
+            throw new Error("Circular reference detected");
+          documentMap[obj.id] = null;
+          const x = await getDocument(obj.id);
+          body2.references[ns] = documentMap[obj.id] = x;
+        }
+      }
+      return body2;
+    }, "getDocument");
+    const body = await getDocument(options == null ? void 0 : options.documentId);
+    return await ApiDocumentFactory.createDocument(body).catch((e) => {
+      e.message = "Error loading api document.\n" + e.message;
+      throw e;
+    });
+  }
+  request(path, options) {
+    var _a;
+    path = ((_a = SPLIT_BACKSLASH_PATTERN.exec(path)) == null ? void 0 : _a[2]) || "";
+    const observable = new HttpRequestObservable(this[kBackend], {
+      ...options,
+      method: (options == null ? void 0 : options.method) || "GET",
+      url: new URL(path, this.serviceUrl)
+    });
+    if (options == null ? void 0 : options.params)
+      observable.param(options.params);
+    return observable;
+  }
+  delete(path, options) {
+    return this.request(path, {
+      ...options,
+      method: "DELETE"
+    });
+  }
+  get(path, options) {
+    return this.request(path, {
+      ...options,
+      method: "GET"
+    });
+  }
+  patch(path, requestBody, options) {
+    return this.request(path, {
+      ...options,
+      method: "PATCH",
+      body: requestBody
+    });
+  }
+  post(path, requestBody, options) {
+    return this.request(path, {
+      ...options,
+      method: "POST",
+      body: requestBody
+    });
+  }
+  put(path, requestBody, options) {
+    return this.request(path, {
+      ...options,
+      method: "PUT",
+      body: requestBody
+    });
+  }
+};
+__name(_HttpClientBase, "HttpClientBase");
+var HttpClientBase = _HttpClientBase;
+
+// ../../build/client/esm/http/http-client.js
+var _OpraHttpClient = class _OpraHttpClient extends HttpClientBase {
+  constructor(serviceUrl, options) {
+    super(new FetchBackend(serviceUrl, options));
+  }
+  get defaults() {
+    return this[kBackend].defaults;
+  }
+};
+__name(_OpraHttpClient, "OpraHttpClient");
+var OpraHttpClient = _OpraHttpClient;
+
+// ../../build/client/esm/http/http-utils.js
+function urlPath(strings, ...values) {
+  let str = "";
+  let i;
+  for (i = 0; i < strings.length; i++) {
+    str += strings[0] + encodeURIComponent(values[i]);
+  }
+  return str;
+}
+__name(urlPath, "urlPath");
+
+// ../../build/client/esm/index.js
+globalThis.Buffer = Buffer2;
+export {
+  Backend,
+  ClientError,
+  FetchBackend,
+  HttpBackend,
+  HttpClientBase,
+  HttpEventType,
+  HttpObserveType,
+  HttpRequestObservable,
+  HttpResponse,
+  OpraHttpClient,
+  kBackend,
+  kClient,
+  kContext,
+  urlPath
+};

package/package.json

@@ -1,57 +1,45 @@
 {
   "name": "@opra/client",
-  "version": "1.0.0-alpha.21",
+  "version": "1.0.0-alpha.23",
   "description": "Opra Client package",
   "author": "Panates",
   "license": "MIT",
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/panates/opra.git",
-    "directory": "packages/client"
-  },
-  "scripts": {
-    "compile": "tsc",
-    "prebuild": "npm run check && npm run lint && npm run clean",
-    "build": "npm run build:cjs && npm run build:esm && npm run build:browser",
-    "build:cjs": "tsc -b tsconfig-build-cjs.json",
-    "build:esm": "tsc -b tsconfig-build-esm.json",
-    "build:browser": "node esbuild.mjs",
-    "postbuild": "cp README.md package.json ../../LICENSE ../../build/client && cp ../../package.cjs.json ../../build/client/cjs/package.json",
-    "lint": "eslint . --max-warnings=0",
-    "lint:fix": "eslint . --max-warnings=0 --fix",
-    "format": "prettier . --write --log-level=warn",
-    "check": "madge --circular src/**",
-    "test": "jest --passWithNoTests",
-    "cover": "jest --passWithNoTests --collect-coverage",
-    "clean": "npm run clean:src && npm run clean:test && npm run clean:dist && npm run clean:cover",
-    "clean:src": "ts-cleanup -s src --all",
-    "clean:test": "ts-cleanup -s test --all",
-    "clean:dist": "rimraf ../../build/client",
-    "clean:cover": "rimraf ../../coverage/client"
-  },
   "type": "module",
   "module": "./esm/index.js",
   "main": "./cjs/index.js",
-  "browser": "./browser.js",
   "types": "./types/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./esm/index.js",
+      "browser": "./cjs/index.js",
+      "require": "./cjs/index.js",
+      "types": "./types/index.d.ts"
+    },
+    "./esm": {
+      "browser": "./browser/index.mjs",
+      "types": "./types/index.d.ts",
+      "default": "./browser/index.mjs"
+    },
+    "./cjs": {
+      "browser": "./browser/index.cjs",
+      "types": "./types/index.d.ts",
+      "default": "./cjs/index.js"
+    },
+    "./browser": {
+      "import": "./browser/index.mjs",
+      "types": "./types/index.d.ts",
+      "default": "./browser/index.cjs"
+    },
+    "./browser-cjs-min": "./browser/cjs.min.cjs",
+    "./browser-esm-min": "./browser/esm.min.mjs"
+  },
   "dependencies": {
-    "@browsery/fs": "^0.4.0",
-    "@browsery/highland": "^2.13.5",
-    "@browsery/http-parser": "^0.5.8",
-    "@browsery/i18next": "^23.11.5",
-    "@browsery/stream": "^4.3.0",
-    "@browsery/type-is": "^1.6.18-r2",
-    "@browsery/util": "^0.12.5",
-    "@opra/common": "^1.0.0-alpha.21",
+    "@opra/common": "^1.0.0-alpha.23",
     "accepts": "^1.3.8",
-    "buffer": "^6.0.3",
     "cookie": "^0.6.0",
-    "crypto-browserify": "^3.12.0",
     "encodeurl": "^2.0.0",
-    "events": "^3.3.0",
     "fast-tokenizer": "^1.3.0",
     "lodash.omit": "^4.5.0",
-    "path-browserify": "^1.0.1",
     "process": "^0.11.10",
     "putil-isplainobject": "^1.1.5",
     "putil-merge": "^3.12.1",
@@ -64,13 +52,30 @@
     "uid": "^2.0.1"
   },
   "devDependencies": {
+    "@browsery/fs": "^0.4.0",
+    "@browsery/highland": "^2.13.5",
+    "@browsery/http-parser": "^0.5.8",
+    "@browsery/i18next": "^23.11.5",
+    "@browsery/stream": "^4.3.0",
+    "@browsery/type-is": "^1.6.18-r2",
+    "@browsery/util": "^0.12.5",
+    "buffer": "^6.0.3",
+    "events": "^3.3.0",
+    "path-browserify": "^1.0.1",
+    "crypto-browserify": "^3.12.0",
     "body-parser": "^1.20.2",
     "express": "^4.19.2"
   },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/panates/opra.git",
+    "directory": "packages/client"
+  },
   "sideEffects": false,
   "files": [
     "cjs/",
     "esm/",
+    "browser/",
     "types/",
     "browser.js",
     "LICENSE",
@@ -85,4 +90,4 @@
     "request",
     "fetch"
   ]
-}
+}