elbe-ui 0.2.30 → 0.2.37

package/dist/bit/bit.d.ts

@@ -0,0 +1,34 @@
+import { Signal } from "@preact/signals";
+import { type PreactContext } from "preact";
+export interface BitUseInterface<C, T> {
+    signal: Signal<BitState<T>>;
+    ctrl: C;
+    map: <D>(m: TriMap<T, D>) => D | preact.JSX.Element;
+    onData: (f: (d: T) => any) => any;
+}
+interface BitData<C, T> {
+    ctrl: C;
+    state: Signal<BitState<T>>;
+}
+export interface BitState<T> {
+    loading?: boolean;
+    error?: any;
+    data?: T;
+}
+export type BitContext<T, C> = PreactContext<BitData<T, C> | null>;
+export interface TriMap<T, D> {
+    onLoading?: () => D;
+    onError?: (e: string) => D;
+    onData?: (value: T) => D;
+}
+export interface TWParams<T> {
+    emit: (t: T) => void;
+    emitLoading: () => void;
+    emitError: (e: any) => void;
+    map: <D>(m: TriMap<T, D>) => D;
+    signal: Signal<BitState<T>>;
+}
+export declare function makeBit<C, T>(name: string): BitContext<C, T>;
+export declare function ProvideBit<I, C, T>(context: BitContext<C, T>, parameters: I, worker: (p: I, d: TWParams<T>, ctrl: C) => void, ctrl: (p: I, d: TWParams<T>) => C, children: any): import("preact").JSX.Element;
+export declare function useBit<C, T>(context: BitContext<C, T>): BitUseInterface<C, T>;
+export {};

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.d.ts

@@ -0,0 +1,30 @@
+import type { JSX } from "preact/jsx-runtime";
+import type { BitUseInterface, TWParams } from "./bit";
+declare abstract class BitControl<I, DT> {
+    p: I;
+    bit: TWParams<DT>;
+    constructor(p: I, bit: TWParams<DT>);
+    act(fn: (b: DT) => Promise<void>): void;
+    /**
+     * Clean up resources. This is called once
+     * the element is removed from the DOM.
+     */
+    dispose(): void;
+}
+export declare abstract class WorkerControl<I, DT> extends BitControl<I, DT> {
+    reload: (() => Promise<void>) | null;
+    abstract worker(): Promise<DT>;
+}
+export declare abstract class StreamControl<I, DT, Stream> extends BitControl<I, DT> {
+    protected stream: Stream | null;
+    abstract listen(): Stream;
+    dispose(): void;
+    abstract disposeStream(stream: Stream): void;
+}
+export declare function CtrlBit<I, DT, C extends BitControl<I, DT>>(ctrl: (p: I, d: TWParams<DT>) => C, name?: string): {
+    Provide: (props: I & {
+        children: React.ReactNode;
+    }) => JSX.Element;
+    use: () => BitUseInterface<C, DT>;
+};
+export {};

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) };
+}