elbe-ui 0.2.26 → 0.2.34

package/dist/bit/bit.js

@@ -0,0 +1,83 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeBit = makeBit;
+exports.ProvideBit = ProvideBit;
+exports.useBit = useBit;
+const jsx_runtime_1 = require("preact/jsx-runtime");
+const signals_1 = require("@preact/signals");
+const preact_1 = require("preact");
+const hooks_1 = require("preact/hooks");
+const error_view_1 = require("../ui/components/error_view");
+const spinner_1 = require("../ui/components/spinner");
+function makeBit(name) {
+    const c = (0, preact_1.createContext)(null);
+    c.displayName = name;
+    return c;
+}
+function ProvideBit(context, parameters, worker, ctrl, children) {
+    const s = (0, signals_1.useSignal)({ loading: true });
+    const _set = (n) => {
+        try {
+            if (JSON.stringify(n) === JSON.stringify(s.peek()))
+                return;
+        }
+        catch (e) { }
+        s.value = n;
+    };
+    const emit = (data) => _set({ data });
+    const emitLoading = () => _set({ loading: true });
+    const emitError = (error) => {
+        console.warn(`BIT: ${context.displayName} emitted ERROR`, error);
+        return _set({ error });
+    };
+    function map(m) {
+        const st = s.value;
+        if (st.loading)
+            return m.onLoading();
+        if (st.error)
+            return m.onError(st.error);
+        return m.onData(st.data ?? null);
+    }
+    const c = ctrl(parameters, { emit, emitLoading, emitError, map, signal: s });
+    worker(parameters, { emit, emitLoading, emitError, map, signal: s }, c);
+    return ((0, jsx_runtime_1.jsx)(context.Provider, { value: { ctrl: c, state: s }, children: children }));
+}
+function useBit(context) {
+    try {
+        const { ctrl, state } = (0, hooks_1.useContext)(context);
+        const v = state.value;
+        function map(m) {
+            if (v.loading)
+                return (m.onLoading || (() => (0, jsx_runtime_1.jsx)(spinner_1.Spinner, {})))();
+            if (v.error)
+                return (m.onError ||
+                    ((e) => (0, jsx_runtime_1.jsx)(error_view_1.ErrorView, { error: e, retry: ctrl.reload ?? null })))(v.error);
+            return m.onData(v.data ?? null);
+        }
+        return {
+            signal: state,
+            ctrl,
+            map,
+            /**
+             * this is a quality of life function that allows
+             * you to chain the map function with the onData function
+             * @param f the builder function
+             * @returns the built component
+             */
+            onData: (f) => map({ onData: f }),
+        };
+    }
+    catch (e) {
+        const err = `BIT ERROR: NO ${context.displayName} PROVIDED`;
+        console.error(err, e);
+        return {
+            map: (_) => (0, jsx_runtime_1.jsx)("div", { children: err }),
+            ctrl: null,
+            signal: null,
+            onData: () => (0, jsx_runtime_1.jsx)("div", { children: err }),
+        };
+    }
+}
+function BitSpinner({ name }) {
+    return (0, jsx_runtime_1.jsx)(spinner_1.Spinner, {});
+}

package/dist/bit/ctrl_bit.js

@@ -0,0 +1,89 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StreamControl = exports.WorkerControl = void 0;
+exports.CtrlBit = CtrlBit;
+const hooks_1 = require("preact/hooks");
+const bit_1 = require("./bit");
+class BitControl {
+    p;
+    bit;
+    constructor(p, bit) {
+        this.bit = bit;
+        this.p = p;
+    }
+    act(fn) {
+        this.bit.map({
+            onData: async (d) => {
+                try {
+                    await fn(d);
+                }
+                catch (e) {
+                    if (e && e.code && e.message)
+                        console.error(`[BitERROR] act: ${e.code} (${e.message})`);
+                    else
+                        console.error("[BitERROR] act: ", e);
+                }
+            },
+        });
+    }
+    /**
+     * Clean up resources. This is called once
+     * the element is removed from the DOM.
+     */
+    dispose() { }
+}
+class WorkerControl extends BitControl {
+    reload = null;
+}
+exports.WorkerControl = WorkerControl;
+class StreamControl extends BitControl {
+    stream = null;
+    dispose() {
+        if (this.stream)
+            this.disposeStream(this.stream);
+    }
+}
+exports.StreamControl = StreamControl;
+function make(name) {
+    return (0, bit_1.makeBit)(name);
+}
+function use(b) {
+    return (0, bit_1.useBit)(b);
+}
+function CtrlBit(ctrl, name) {
+    const context = make((name || "Unknown") + "Bit");
+    function Provide({ children, ...p }) {
+        return (0, bit_1.ProvideBit)(context, p, async (p, b, c) => {
+            b.emitLoading();
+            try {
+                if (c instanceof WorkerControl) {
+                    if (c.reload)
+                        await c.reload();
+                }
+                if (c instanceof StreamControl) {
+                    c.stream = c.listen();
+                }
+            }
+            catch (e) {
+                b.emitError(e);
+            }
+        }, (p, b) => {
+            const c = ctrl(p, b);
+            // clean up on unmount
+            (0, hooks_1.useEffect)(() => () => c.dispose(), []);
+            if (c instanceof WorkerControl) {
+                c.reload = async () => {
+                    b.emitLoading();
+                    try {
+                        b.emit(await c.worker());
+                    }
+                    catch (e) {
+                        b.emitError(e);
+                    }
+                };
+            }
+            return c;
+        }, children);
+    }
+    return { Provide: Provide, use: () => use(context) };
+}