@inweb/client 25.2.2

package/src/Api/impl/Utils.ts

@@ -0,0 +1,367 @@
+///////////////////////////////////////////////////////////////////////////////
+// Copyright (C) 2002-2021, Open Design Alliance (the "Alliance").
+// All rights reserved.
+//
+// This software and its documentation and related materials are owned by
+// the Alliance. The software may only be incorporated into application
+// programs owned by members of the Alliance, subject to a signed
+// Membership Agreement and Supplemental Software License Agreement with the
+// Alliance. The structure and organization of this software are the valuable
+// trade secrets of the Alliance and its suppliers. The software is also
+// protected by copyright law and international treaty provisions. Application
+// programs incorporating this software must include the following statement
+// with their copyright notices:
+//
+//   This application incorporates Open Design Alliance software pursuant to a
+//   license agreement with Open Design Alliance.
+//   Open Design Alliance Copyright (C) 2002-2021 by Open Design Alliance.
+//   All rights reserved.
+//
+// By use of this software, its documentation or related materials, you
+// acknowledge and accept the above terms.
+///////////////////////////////////////////////////////////////////////////////
+
+import { FetchError } from "./FetchError";
+import { statusText } from "./http";
+
+export function json(request: any): any {
+  return request.then((response) => response.json());
+}
+
+export function text(request: any): any {
+  return request.then((response) => response.text());
+}
+
+export function arrayBuffer(request: any): any {
+  return request.then((response) => response.arrayBuffer());
+}
+
+function error400(text: string, _default = "400") {
+  try {
+    return JSON.parse(text).description;
+  } catch {
+    return _default;
+  }
+}
+
+function handleXMLHttpError(xhr: any): Promise<any> {
+  if (xhr.status === 0) {
+    return Promise.reject(new FetchError(0, "Network error"));
+  }
+  if (xhr.status < 200 || xhr.status > 299) {
+    switch (xhr.status) {
+      case 400: {
+        console.error(xhr.responseText);
+        return Promise.reject(new FetchError(400, error400(xhr.responseText)));
+      }
+      case 500: {
+        console.error(error400(xhr.responseText, xhr.responseText));
+        return Promise.reject(new FetchError(500));
+      }
+      default: {
+        return Promise.reject(new FetchError(xhr.status));
+      }
+    }
+  }
+  return Promise.resolve(xhr);
+}
+
+function handleFetchError(response: Response): Promise<Response> {
+  if (!response.ok) {
+    switch (response.status) {
+      case 400: {
+        return response.text().then((text) => {
+          console.error(text);
+          return Promise.reject(new FetchError(400, error400(text)));
+        });
+      }
+      case 500: {
+        return response.text().then((text) => {
+          console.error(error400(text, text));
+          return Promise.reject(new FetchError(500));
+        });
+      }
+      default:
+        return Promise.reject(new FetchError(response.status, statusText(response.status)));
+    }
+  }
+  return Promise.resolve(response);
+}
+
+export function $init(
+  method: "GET" | "POST" | "PUT" | "DELETE",
+  headers?: HeadersInit,
+  body?: ArrayBuffer | Blob | globalThis.File | FormData | object | string | null,
+  signal?: AbortSignal
+): RequestInit {
+  headers = { ...headers };
+  headers["Content-Type"] = "application/json";
+
+  if (method === "POST" || method === "PUT") {
+    if (body instanceof FormData) {
+      delete headers["Content-Type"];
+    } else if (body instanceof File || body instanceof Blob) {
+      const formData = new FormData();
+      formData.append("file", body);
+      return $init(method, headers, formData, signal);
+    } else if (body instanceof ArrayBuffer) {
+      const blob = new Blob([body]);
+      return $init(method, headers, blob, signal);
+    } else if (body && typeof body === "object") {
+      body = JSON.stringify(body);
+    } else if (typeof body === "string") {
+      headers["Content-Type"] = "text/plain";
+    }
+  }
+
+  const result = { method, headers } as RequestInit;
+
+  // body with type "object", converted to type "string" in the code above
+  if (
+    body &&
+    (body instanceof ArrayBuffer ||
+      body instanceof Blob ||
+      body instanceof globalThis.File ||
+      body instanceof FormData ||
+      typeof body === "string")
+  ) {
+    result.body = body;
+  }
+
+  if (signal) result.signal = signal;
+
+  return result;
+}
+
+export function $fetch(url: RequestInfo | URL, init?: RequestInit): Promise<Response> {
+  return fetch(url, init).then((response) => handleFetchError(response));
+}
+
+export function $get(url: RequestInfo | URL, headers?: HeadersInit, signal?: AbortSignal): Promise<Response> {
+  return $fetch(url, $init("GET", headers, null, signal));
+}
+
+export function $put(
+  url: RequestInfo | URL,
+  headers?: HeadersInit,
+  body?: ArrayBuffer | Blob | globalThis.File | FormData | object | string | null
+) {
+  return $fetch(url, $init("PUT", headers, body));
+}
+
+export function $post(
+  url: RequestInfo | URL,
+  headers?: HeadersInit,
+  body?: ArrayBuffer | Blob | globalThis.File | FormData | object | string | null
+) {
+  return $fetch(url, $init("POST", headers, body));
+}
+
+export function $delete(url: RequestInfo | URL, headers?: HeadersInit) {
+  return $fetch(url, $init("DELETE", headers));
+}
+
+export function streamProgress(stream: ReadableStream<Uint8Array>, onprogress: (progress: number) => void) {
+  const reader = stream.getReader();
+  let current = 0;
+
+  function calc(ev) {
+    if (!ev.done) {
+      reader.read().then(calc).catch(console.error);
+    }
+    if (ev.value) current += ev.value.length;
+    onprogress(current);
+  }
+
+  reader.read().then(calc).catch(console.error);
+
+  return stream;
+}
+
+export function downloadProgress(response: Response, onprogress?: (progress: number) => void): Response {
+  const contentLength = response.headers.get("Content-Length") ?? "";
+  const total = parseInt(contentLength, 10);
+  const tee = response.body.tee();
+  streamProgress(tee[0], (bytesCount: number) => onprogress && onprogress(bytesCount / total));
+  return new Response(tee[1]);
+}
+
+interface XMLHttpParams {
+  headers: HeadersInit;
+  method: "GET" | "POST" | "PUT" | "DELETE";
+  body?: XMLHttpRequestBodyInit | Document;
+  uploadProgress?: (progress: number) => void;
+  downloadProgress?: (progress: number) => void;
+}
+
+export function $XMLHttp(
+  url: string,
+  { headers, method, body, uploadProgress, downloadProgress }: XMLHttpParams
+): Promise<XMLHttpRequest> {
+  return new Promise((resolve, reject) => {
+    const xhr = new XMLHttpRequest();
+    xhr.open(method, url, true);
+    for (const key in headers) {
+      xhr.setRequestHeader(key, headers[key]);
+    }
+    function calcProgress(event) {
+      return event.lengthComputable ? event.loaded / event.total : 1;
+    }
+    xhr.upload.onprogress = (event) => uploadProgress && uploadProgress(calcProgress(event));
+    xhr.onprogress = (event) => downloadProgress && downloadProgress(calcProgress(event));
+    xhr.onloadend = (event) => handleXMLHttpError(event.target).then(resolve, reject);
+    xhr.send(body);
+  });
+}
+
+function delay(ms: number, signal: AbortSignal) {
+  return new Promise((resolve) => {
+    let timeoutId = 0;
+
+    const abortHandler = () => {
+      clearTimeout(timeoutId);
+      resolve(true);
+    };
+
+    timeoutId = window.setTimeout(() => {
+      signal.removeEventListener("abort", abortHandler);
+      resolve(false);
+    }, ms);
+
+    signal.addEventListener("abort", abortHandler, { once: true });
+  });
+}
+
+export async function waitFor(
+  func: (params: any) => Promise<boolean>,
+  params: {
+    timeout?: number;
+    interval?: number;
+    signal?: AbortSignal;
+    abortError?: DOMException;
+    timeoutError?: DOMException;
+    result?: any;
+  } = {}
+) {
+  const timeout = params.timeout ?? 600000;
+  const interval = params.interval ?? 3000;
+  const signal = params.signal ?? new AbortController().signal;
+  const abortError = params.abortError ?? new DOMException("Aborted", "AbortError");
+  const timeoutError = params.timeoutError ?? new DOMException("Timeout", "TimeoutError");
+
+  const end = performance.now() + timeout;
+  let count = timeout / interval;
+
+  do {
+    if (await func(params)) return Promise.resolve(params.result);
+    if ((await delay(interval, signal)) || signal.aborted) return Promise.reject(abortError);
+  } while (performance.now() < end && --count > 0);
+
+  return Promise.reject(timeoutError);
+}
+
+export async function downloadPartOfFile(
+  requestId: number,
+  records: any | null,
+  url: string,
+  defHeaders: HeadersInit,
+  onProgress?: (progress: number, downloaded: Uint8Array, requestId: number) => void,
+  signal?: AbortSignal
+): Promise<void> {
+  const headers = { ...defHeaders };
+  const isMultipleResourceParts = records && records.length;
+  if (records) {
+    const ranges: string[] = [];
+    if (isMultipleResourceParts) {
+      for (let i = 0; i < records.length; i++) {
+        const record = records[i];
+        ranges.push(`${record.begin}-${record.end}`);
+      }
+    } else {
+      for (let i = 0; i < records.size(); i++) {
+        const record = records.get(i);
+        ranges.push(`${record.begin}-${record.end}`);
+        record.delete();
+      }
+    }
+    headers["Range"] = "bytes=" + ranges.join(",");
+  }
+
+  const response = await $fetch(url, $init("GET", headers, null, signal));
+  const contentLength = response.headers.get("content-length") ?? "";
+  const total = parseInt(contentLength, 10);
+
+  const reader = response.body.getReader();
+
+  if (isMultipleResourceParts) {
+    let curRecordIndex = 0;
+    let curRecordPos = 0;
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      let totalLeft = value.byteLength;
+      let loadedPos = 0;
+      while (totalLeft > 0) {
+        const curRecord = records[curRecordIndex];
+        const recLeft = curRecord.size - curRecordPos;
+        if (totalLeft < recLeft) {
+          const buf = value.subarray(loadedPos, loadedPos + totalLeft);
+          if (typeof onProgress === "function") onProgress(loadedPos / total, buf, curRecord.reqId);
+          curRecordPos += totalLeft;
+          totalLeft = 0;
+        } else {
+          const buf = value.subarray(loadedPos, loadedPos + recLeft);
+          if (typeof onProgress === "function") onProgress(loadedPos / total, buf, curRecord.reqId);
+          curRecordIndex++;
+          curRecordPos = 0;
+          loadedPos += recLeft;
+          totalLeft -= recLeft;
+        }
+      }
+    }
+  } else {
+    let loaded = 0;
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      loaded += value.byteLength;
+      if (onProgress) onProgress(loaded / total, value, requestId);
+    }
+  }
+}
+
+export function parseArgs(args: string | object): object {
+  if (typeof args === "string") {
+    const firstArg = args.indexOf("--");
+    if (firstArg !== -1) args = args.slice(firstArg);
+    const argArray = args
+      .split("--")
+      .map((x) =>
+        x
+          .split("=")
+          .map((y) => y.split(" "))
+          .flat()
+      )
+      .filter((x) => x[0])
+      .map((x) => x.concat([""]));
+    return Object.fromEntries(argArray);
+  }
+  return args ?? {};
+}
+
+export function userFullName(firstName: string | any, lastName = "", userName = ""): string {
+  if (firstName && typeof firstName !== "string") {
+    return userFullName(firstName.firstName ?? firstName.name, firstName.lastName, firstName.userName);
+  }
+  return `${firstName ?? ""} ${lastName ?? ""}`.trim() || userName;
+}
+
+export function userInitials(fullName = ""): string {
+  const names = fullName.split(" ").filter((x) => x);
+  return names
+    .reduce((initials, name, index) => {
+      if (index === 0 || index === names.length - 1) initials += name.charAt(0);
+      return initials;
+    }, "")
+    .toUpperCase();
+}

package/src/Api/impl/http.ts

@@ -0,0 +1,92 @@
+///////////////////////////////////////////////////////////////////////////////
+// Copyright (C) 2002-2021, Open Design Alliance (the "Alliance").
+// All rights reserved.
+//
+// This software and its documentation and related materials are owned by
+// the Alliance. The software may only be incorporated into application
+// programs owned by members of the Alliance, subject to a signed
+// Membership Agreement and Supplemental Software License Agreement with the
+// Alliance. The structure and organization of this software are the valuable
+// trade secrets of the Alliance and its suppliers. The software is also
+// protected by copyright law and international treaty provisions. Application
+// programs incorporating this software must include the following statement
+// with their copyright notices:
+//
+//   This application incorporates Open Design Alliance software pursuant to a
+//   license agreement with Open Design Alliance.
+//   Open Design Alliance Copyright (C) 2002-2021 by Open Design Alliance.
+//   All rights reserved.
+//
+// By use of this software, its documentation or related materials, you
+// acknowledge and accept the above terms.
+///////////////////////////////////////////////////////////////////////////////
+
+export const STATUS_CODES = {
+  100: "Continue",
+  101: "Switching Protocols",
+  102: "Processing",
+  103: "Early Hints",
+  200: "OK",
+  201: "Created",
+  202: "Accepted",
+  203: "Non-Authoritative Information",
+  204: "No Content",
+  205: "Reset Content",
+  206: "Partial Content",
+  207: "Multi-Status",
+  208: "Already Reported",
+  226: "IM Used",
+  300: "Multiple Choices",
+  301: "Moved Permanently",
+  302: "Found",
+  303: "See Other",
+  304: "Not Modified",
+  305: "Use Proxy",
+  307: "Temporary Redirect",
+  308: "Permanent Redirect",
+  400: "Bad Request",
+  401: "Unauthorized",
+  402: "Payment Required",
+  403: "Forbidden",
+  404: "Not Found",
+  405: "Method Not Allowed",
+  406: "Not Acceptable",
+  407: "Proxy Authentication Required",
+  408: "Request Time-out",
+  409: "Conflict",
+  410: "Gone",
+  411: "Length Required",
+  412: "Precondition Failed",
+  413: "Payload Too Large",
+  414: "URI Too Long",
+  415: "Unsupported Media Type",
+  416: "Range Not Satisfiable",
+  417: "Expectation Failed",
+  418: "I'm a teapot",
+  421: "Misdirected Request",
+  422: "Unprocessable Entity",
+  423: "Locked",
+  424: "Failed Dependency",
+  425: "Too Early",
+  426: "Upgrade Required",
+  428: "Precondition Required",
+  429: "Too Many Requests",
+  431: "Header Fields Too Large",
+  451: "Unavailable For Legal Reasons",
+  500: "Internal Server Error",
+  501: "Not Implemented",
+  502: "Bad Gateway",
+  503: "Service Unavailable",
+  504: "Gateway Timeout",
+  505: "HTTP Version Not Supported",
+  506: "Variant Also Negotiates",
+  507: "Insufficient Storage",
+  508: "Loop Detected",
+  509: "Bandwidth Limit Exceeded",
+  510: "Not Extended",
+  511: "Network Authentication Required",
+};
+
+export function statusText(status: number): string {
+  return STATUS_CODES[status] || `Error ${status}`;
+}