elbe-ui 0.4.2 → 0.4.5

package/dist/{service/s_api.d.ts → api/api_worker.d.ts}

@@ -1,30 +1,23 @@
-export interface PostArgs {
+export interface GetArgs {
     path?: {
         [key: string]: string | number | boolean | undefined;
     };
     query?: {
         [key: string]: string | number | boolean | undefined;
     };
+}
+export interface PostArgs extends GetArgs {
     body?: any;
 }
 /**
  * ApiService is a simple wrapper around fetch that handles JSON serialization and error handling.
  * to use it, you must first call `ApiService.init(apiURL)` with the base URL of your API.
  */
-export declare class ApiService {
+export declare class ApiWorker {
     private apiURL;
-    private static _i;
-    static get i(): ApiService;
-    private constructor();
-    static init(apiURL: string): void;
+    constructor(apiURL: string);
     private _fetch;
-    get(path: string, args?: PostArgs): Promise<any>;
+    get(path: string, args?: GetArgs): Promise<any>;
     post(path: string, args: PostArgs): Promise<any>;
-    delete(path: string, args: PostArgs): Promise<any>;
-}
-export interface ApiError {
-    code: number;
-    message: string;
-    data?: any;
+    delete(path: string, args: GetArgs): Promise<any>;
 }
-export declare function ifApiError(e: any): ApiError | null;

package/dist/{service/s_api.js → api/api_worker.js}

@@ -7,28 +7,18 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
+import { httpErrorFromCode, rethrow } from "./error";
 const _noArgs = {};
 /**
  * ApiService is a simple wrapper around fetch that handles JSON serialization and error handling.
  * to use it, you must first call `ApiService.init(apiURL)` with the base URL of your API.
  */
-export class ApiService {
-    static get i() {
-        if (!ApiService._i)
-            throw "ApiService not initialized. Call ApiService.init(apiURL)";
-        return ApiService._i;
-    }
+export class ApiWorker {
     constructor(apiURL) {
         this.apiURL = apiURL;
     }
-    static init(apiURL) {
-        if (ApiService._i)
-            throw "ApiService already initialized";
-        ApiService._i = new ApiService(apiURL);
-    }
     _fetch(p_1, method_1, _a) {
         return __awaiter(this, arguments, void 0, function* (p, method, { path, query, body }) {
-            var _b;
             try {
                 p = path
                     ? p.replace(/:([a-zA-Z0-9_]+)/g, (m, p1) => {
@@ -61,14 +51,10 @@ export class ApiService {
                 catch (e) {
                     data = yield response.text();
                 }
-                throw {
-                    code: response.status,
-                    message: (_b = data.message) !== null && _b !== void 0 ? _b : "undefined error",
-                    data,
-                };
+                throw httpErrorFromCode(response.status);
             }
             catch (e) {
-                rethrow(e, 0, "unknown error");
+                rethrow(e);
             }
         });
     }
@@ -88,15 +74,4 @@ export class ApiService {
         });
     }
 }
-ApiService._i = null;
-function rethrow(e, code, message) {
-    // if e implements the apiError interface, rethrow it:
-    if (e && e.code !== null && e.message !== null)
-        throw e;
-    throw { code, message, data: e };
-}
-export function ifApiError(e) {
-    if (e && e.code !== null && e.message !== null)
-        return e;
-    return null;
-}
+const errors = {};

package/dist/api/error.d.ts

@@ -0,0 +1,24 @@
+import { Maybe } from "..";
+import { IconChild } from "../ui/components/button/icon_button";
+import { L10nInlinePlain } from "../ui/util/l10n/l10n";
+/**
+ * a generic error for providing reasonable error messages
+ * to both the user and the developer
+ */
+export type ElbeError = {
+    code: string | number;
+    message: string | L10nInlinePlain;
+    description?: Maybe<string | L10nInlinePlain>;
+    icon?: Maybe<IconChild>;
+    details?: Maybe<any>;
+    cause?: Maybe<ElbeError | any>;
+};
+export declare function isElbeError(e: any): e is ElbeError;
+export declare function maybeElbeError(e: any): ElbeError | null;
+export declare function toElbeError(e: any): ElbeError;
+export declare function httpErrorFromCode(code: number, e?: any): ElbeError;
+/**
+ * takes an object and throws it as an ElbeError.
+ * @param e the error to throw
+ */
+export declare function rethrow(e: any, base?: ElbeError): void;

package/dist/api/error.js

@@ -0,0 +1,29 @@
+import { errors } from "..";
+export function isElbeError(e) {
+    return (e &&
+        (typeof e.code === "string" || typeof e.code === "number") &&
+        (typeof e.message === "string" || typeof e.message === "object"));
+}
+export function maybeElbeError(e) {
+    if (isElbeError(e))
+        return e;
+    return null;
+}
+export function toElbeError(e) {
+    var _a;
+    return ((_a = maybeElbeError(e)) !== null && _a !== void 0 ? _a : Object.assign(Object.assign({}, errors.unknown), { details: e }));
+}
+export function httpErrorFromCode(code, e) {
+    var _a;
+    const err = (_a = Object.values(errors.http).find((e) => e.code.toString().split("_")[1] === code.toString())) !== null && _a !== void 0 ? _a : errors.unknown;
+    return Object.assign(Object.assign({}, err), { details: e });
+}
+/**
+ * takes an object and throws it as an ElbeError.
+ * @param e the error to throw
+ */
+export function rethrow(e, base = errors.unknown) {
+    if (isElbeError(e))
+        throw e;
+    throw Object.assign(Object.assign({}, base), { message: e instanceof Error ? e.message : base.message, details: e });
+}

package/dist/api/errors.d.ts

@@ -0,0 +1,100 @@
+import { ElbeError } from "..";
+export declare const errors: {
+    unknown: ElbeError;
+    http: {
+        badRequest: ElbeError;
+        unauthorized: ElbeError;
+        paymentRequired: ElbeError;
+        forbidden: ElbeError;
+        notFound: ElbeError;
+        methodNotAllowed: ElbeError;
+        notAcceptable: {
+            code: string;
+            message: {
+                de: string;
+                en: string;
+                es: string;
+                fr: string;
+                it: string;
+                pt: string;
+            };
+            description: {
+                de: string;
+                en: string;
+                es: string;
+                fr: string;
+                it: string;
+                pt: string;
+            };
+        };
+        proxyAuthenticationRequired: {
+            code: string;
+            message: {
+                de: string;
+                en: string;
+                es: string;
+                fr: string;
+                it: string;
+                pt: string;
+            };
+            description: {
+                de: string;
+                en: string;
+                es: string;
+                fr: string;
+                it: string;
+                pt: string;
+            };
+        };
+        requestTimeout: {
+            code: string;
+            message: {
+                de: string;
+                en: string;
+                es: string;
+                fr: string;
+                it: string;
+                pt: string;
+            };
+            description: {
+                de: string;
+                en: string;
+                es: string;
+                fr: string;
+                it: string;
+                pt: string;
+            };
+        };
+        conflict: ElbeError;
+        gone: ElbeError;
+        lengthRequired: ElbeError;
+        preconditionFailed: ElbeError;
+        contentTooLarge: ElbeError;
+        uriTooLong: ElbeError;
+        unsupportedMediaType: ElbeError;
+        rangeNotSatisfiable: ElbeError;
+        expectationFailed: ElbeError;
+        imATeapot: ElbeError;
+        misdirectedRequest: ElbeError;
+        unprocessableContent: ElbeError;
+        locked: ElbeError;
+        failedDependency: ElbeError;
+        tooEarly: ElbeError;
+        upgradeRequired: ElbeError;
+        preconditionRequired: ElbeError;
+        tooManyRequests: ElbeError;
+        requestHeaderFieldsTooLarge: ElbeError;
+        unavailableForLegalReasons: ElbeError;
+        internalServerError: ElbeError;
+        notImplemented: ElbeError;
+        badGateway: ElbeError;
+        serviceUnavailable: ElbeError;
+        gatewayTimeout: ElbeError;
+        httpVersionNotSupported: ElbeError;
+        variantAlsoNegotiates: ElbeError;
+        insufficientStorage: ElbeError;
+        loopDetected: ElbeError;
+        notExtended: ElbeError;
+        networkAuthenticationRequired: ElbeError;
+    };
+};