elbe-ui 0.2.26 → 0.2.34

package/dist/service/s_api.js

@@ -0,0 +1,89 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ApiService = void 0;
+exports.ifApiError = ifApiError;
+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.
+ */
+class ApiService {
+    apiURL;
+    static _i = null;
+    static get i() {
+        if (!ApiService._i)
+            throw "ApiService not initialized. Call ApiService.init(apiURL)";
+        return ApiService._i;
+    }
+    constructor(apiURL) {
+        this.apiURL = apiURL;
+    }
+    static init(apiURL) {
+        if (ApiService._i)
+            throw "ApiService already initialized";
+        ApiService._i = new ApiService(apiURL);
+    }
+    async _fetch(p, method, { path, query, body }) {
+        try {
+            p = path
+                ? p.replace(/:([a-zA-Z0-9_]+)/g, (m, p1) => {
+                    const v = path[p1];
+                    if (v === undefined)
+                        throw { code: 400, message: `missing parameter ${p1}` };
+                    return v?.toString() ?? "";
+                })
+                : p;
+            const queryStr = query != null ? "?" + new URLSearchParams(query).toString() : "";
+            const response = await fetch(this.apiURL + p + queryStr, {
+                method,
+                credentials: "include",
+                headers: { "Content-Type": "application/json" },
+                body: body ? JSON.stringify(body) : undefined,
+            });
+            if (response.ok) {
+                try {
+                    return await response.json();
+                }
+                catch (e) {
+                    return null;
+                }
+            }
+            let data = null;
+            try {
+                data = await response.clone().json();
+            }
+            catch (e) {
+                data = await response.text();
+            }
+            throw {
+                code: response.status,
+                message: data.message ?? "undefined error",
+                data,
+            };
+        }
+        catch (e) {
+            rethrow(e, 0, "unknown error");
+        }
+    }
+    async get(path, args) {
+        return this._fetch(path, "GET", args || _noArgs);
+    }
+    async post(path, args) {
+        return this._fetch(path, "POST", args || _noArgs);
+    }
+    async delete(path, args) {
+        return this._fetch(path, "DELETE", args || _noArgs);
+    }
+}
+exports.ApiService = ApiService;
+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 };
+}
+function ifApiError(e) {
+    if (e && e.code !== null && e.message !== null)
+        return e;
+    return null;
+}

package/dist/ui/components/badge.d.ts

@@ -1,20 +1,20 @@
 import React from "preact/compat";
-import type { ElbeColorStyles } from "../color_theme";
+import type { ElbeColorKinds } from "../theme/colors";
 import type { ElbeChild, ElbeChildren } from "../util/util";
-import type { ElbeProps } from "./box";
+import type { ElbeProps } from "./base/box";
 export type BadgeProps = {
     count?: number;
-    message?: string;
+    label?: string;
     child?: ElbeChild;
     hidden?: boolean;
     children?: ElbeChildren;
 } & ElbeProps;
 export declare function TestBadge(p: BadgeProps): Badge;
 export declare class Badge extends React.Component<BadgeProps & {
-    colorStyle: ElbeColorStyles;
+    kind: ElbeColorKinds;
 }> {
     constructor(props: BadgeProps & {
-        colorStyle: ElbeColorStyles;
+        kind: ElbeColorKinds;
     });
     static accent(p: BadgeProps): React.JSX.Element;
     static error(p: BadgeProps): React.JSX.Element;

package/dist/ui/components/badge.js

@@ -0,0 +1,53 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Badge = void 0;
+exports.TestBadge = TestBadge;
+const jsx_runtime_1 = require("preact/jsx-runtime");
+const compat_1 = __importDefault(require("preact/compat"));
+function TestBadge(p) {
+    return new Badge({ ...p, kind: "accent" });
+}
+class Badge extends compat_1.default.Component {
+    constructor(props) {
+        super(props);
+    }
+    static accent(p) {
+        return (0, jsx_runtime_1.jsx)(Badge, { ...p, kind: "accent" });
+    }
+    static error(p) {
+        return (0, jsx_runtime_1.jsx)(Badge, { ...p, kind: "error" });
+    }
+    static warning(p) {
+        return (0, jsx_runtime_1.jsx)(Badge, { ...p, kind: "warning" });
+    }
+    static success(p) {
+        return (0, jsx_runtime_1.jsx)(Badge, { ...p, kind: "success" });
+    }
+    static info(p) {
+        return (0, jsx_runtime_1.jsx)(Badge, { ...p, kind: "info" });
+    }
+    render() {
+        return ((0, jsx_runtime_1.jsxs)("div", { style: {
+                position: "relative",
+                display: "inline-block",
+            }, children: [this.props.child, this.props.children, (0, jsx_runtime_1.jsx)("div", { class: `b ${this.props.kind} major ${this.props.class ?? ""}`, style: {
+                        position: "absolute",
+                        top: "-0.25rem",
+                        right: "-0.25rem",
+                        minWidth: "1.5rem",
+                        minHeight: "1.5rem",
+                        padding: "0rem .4rem",
+                        borderRadius: "3rem",
+                        fontWeight: "bold",
+                        display: "flex",
+                        justifyContent: "center",
+                        alignItems: "center",
+                        visibility: this.props.hidden ? "hidden" : "visible",
+                        ...this.props.style,
+                    }, children: this.props.label ?? this.props.count })] }));
+    }
+}
+exports.Badge = Badge;