elbe-ui 0.4.5 → 0.4.8

package/dist/bit/_bit_provider.d.ts

@@ -0,0 +1,6 @@
+import { Context } from "preact";
+import { BitParams, BitUseInterface } from "..";
+import { _BitCtrlMaker, _BitProvider } from "./_bit_utils";
+export declare function _makeBitProvider<D, P, I>(context: Context<BitUseInterface<D, I>>, bitP: BitParams<D, P, I> & {
+    control: _BitCtrlMaker<D, P, I>;
+}): _BitProvider<P>;

package/dist/bit/_bit_provider.js

@@ -0,0 +1,110 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { jsx as _jsx } from "preact/jsx-runtime";
+import { useEffect, useMemo, useState } from "preact/hooks";
+import { Column, ErrorView, Spinner, } from "..";
+import { _isFn } from "./_bit_utils";
+function _LoadView({}) {
+    return (_jsx(Column, { cross: "center", children: _jsx(Spinner, {}) }));
+}
+export function _makeBitProvider(context, bitP) {
+    function _BitProvider(p) {
+        const [state, setState] = useState({
+            v: { type: "loading" },
+            history: [],
+        });
+        // ========== DEFINE BASIC CTRLS ==========
+        function _make() {
+            const _partCtrl = {
+                setData: (d) => {
+                    // if it's the same data, don't update
+                    if (state.v.type === "data" && state.v.value === d)
+                        return;
+                    setState({
+                        history: bitP.useHistory ? [...state.history, d] : [],
+                        v: { type: "data", value: d },
+                    });
+                },
+                setLoading: () => setState(Object.assign(Object.assign({}, state), { v: { type: "loading" } })),
+                setError: (e) => setState(Object.assign(Object.assign({}, state), { v: { type: "error", value: e } })),
+                canGoBack: !!(bitP.useHistory && state.history.length > 1),
+                back: () => {
+                    if (!bitP.useHistory)
+                        return false;
+                    if (state.history.length < 2)
+                        return false;
+                    const newHistory = state.history.slice(0, -1);
+                    const newData = newHistory[newHistory.length - 1];
+                    setState({
+                        history: newHistory,
+                        v: { type: "data", value: newData },
+                    });
+                    return true;
+                },
+                state: state.v.type,
+                isData: state.v.type === "data",
+                isLoading: state.v.type === "loading",
+                isError: state.v.type === "error",
+                data: state.v.type === "data" ? state.v.value : undefined,
+                error: state.v.type === "error" ? state.v.value : undefined,
+            };
+            // ========== DEFINE QoL FUNCTIONS ==========
+            function _worker(fn, silent) {
+                return __awaiter(this, void 0, void 0, function* () {
+                    if (!silent)
+                        _partCtrl.setLoading();
+                    try {
+                        const newData = yield fn();
+                        _partCtrl.setData(newData);
+                    }
+                    catch (e) {
+                        _partCtrl.setError(e);
+                    }
+                });
+            }
+            const _reload = () => _worker(() => bitP.worker(p));
+            function act(fn, silent) {
+                return __awaiter(this, void 0, void 0, function* () {
+                    const data = _partCtrl.data;
+                    if (data === undefined)
+                        return;
+                    _worker(() => fn(data), silent);
+                });
+            }
+            function map(onData, onError, onLoading) {
+                var _a, _b, _c;
+                if (state.v.type === "data") {
+                    return _isFn(onData)
+                        ? onData(state.v.value)
+                        : (_a = onData) !== null && _a !== void 0 ? _a : null;
+                }
+                if (state.v.type === "error") {
+                    return _isFn(onError)
+                        ? onError(state.v.value)
+                        : (_b = onError) !== null && _b !== void 0 ? _b : null;
+                }
+                return _isFn(onLoading) ? onLoading() : (_c = onLoading) !== null && _c !== void 0 ? _c : null;
+            }
+            function mapUI(onData, onError, onLoading) {
+                return map((d) => onData(d), (e) => (onError !== null && onError !== void 0 ? onError : ((e) => _jsx(ErrorView, { error: e, retry: _reload })))(e), () => onLoading !== null && onLoading !== void 0 ? onLoading : (() => _jsx(_LoadView, {}))());
+            }
+            const baseCtrl = Object.assign(Object.assign({}, _partCtrl), { act,
+                map,
+                mapUI });
+            const userCtrl = bitP.control(Object.assign(Object.assign({}, baseCtrl), { parameters: p }));
+            return Object.assign(Object.assign(Object.assign({}, baseCtrl), userCtrl), { reload: _reload });
+        }
+        const ctrl = useMemo(() => _make(), [state]);
+        useEffect(() => ctrl.reload(), []);
+        // ========== DEFINE THE JSX ELEMENT ==========
+        return _jsx(context.Provider, { value: ctrl, children: p.children });
+    }
+    return _BitProvider;
+}

package/dist/bit/_bit_utils.d.ts

@@ -0,0 +1,102 @@
+import { JSX } from "preact/jsx-runtime";
+import { BitStates, BitUseInterface, ElbeChild, ElbeChildren, Maybe, PromiseOr } from "..";
+export interface _BitData<D> {
+    state: any;
+}
+export type _BitState<D> = {
+    type: "loading";
+} | {
+    type: "error";
+    value: any;
+} | {
+    type: "data";
+    value: D;
+};
+export type BitTriMap<T, D> = {
+    onLoading?: () => D;
+    onError?: (e: any) => D;
+    onData?: (value: T) => D;
+};
+export interface _BitGetInterface<D> {
+    /**
+     * the current state of the bit. Is one of the following:
+     * - `data`: if valid data is present
+     * - `error`: if an error occurred
+     * - `loading`: if the bit is loading
+     */
+    state: BitStates;
+    /**
+     * QoL function to check if the current state is `data`
+     */
+    isData: boolean;
+    /**
+     * QoL function to check if the current state is `loading`
+     */
+    isLoading: boolean;
+    /**
+     * QoL function to check if the current state is `error`
+     */
+    isError: boolean;
+    /**
+     * the current data of the bit. If the state is not `data`, it will be `undefined`.
+     */
+    data: D | undefined;
+    /**
+     * the current error of the bit. If the state is not `error`, it will be `undefined`.
+     */
+    error: any | undefined;
+    /**
+     * return a value based on the current state.
+     * You can pass a function or a value. If you don't pass a parameter, it will return `null`.
+     * @param onData the value (or function) to return when the state is "data"
+     * @param onError the value (or function) to return when the state is "error"
+     * @param onLoading the value (or function) to return when the state is "loading"
+     * @returns the (nullable) T based on the current state
+     */
+    map: <T>(onData: ((d: D) => T) | T, onError?: ((e: any) => T) | T, onLoading?: (() => T) | T) => T | null;
+    /**
+     * a wrapper around `map` that returns a JSX element.
+     * If you don't pass a parameter, a default UI element will be rendered
+     * @param onData the value (or function) to return when the state is "data"
+     * @param onError the value (or function) to return when the state is "error"
+     * @param onLoading the value (or function) to return when the state is "loading"
+     * @returns a JSX element
+     */
+    mapUI: (onData: (d: D) => ElbeChild, onError?: (e: any) => ElbeChild, onLoading?: () => ElbeChild) => ElbeChild;
+    /**
+     * return to the previous `data` state. If there is no previous state, it will return `false`.
+     * make sure you enable `useHistory` in the `createBit` function. You can check if a history exists with `canGoBack`.
+     * @returns
+     */
+    back: () => boolean;
+    /**
+     * returns true if a previous `data` state exists.
+     */
+    canGoBack: boolean;
+}
+export interface _BitCtrlInput<D, P> extends _BitGetInterface<D> {
+    setData: (d: D) => void;
+    setLoading: () => void;
+    setError: (e: any) => void;
+    /**
+     * makes it easier to change the data state. It gets called when data is present.
+     * It will publish the data that `fn` returns as a new state.
+     * If an error occurs, it will set the state to `error` with the error.
+     * @param fn the function to call. It will be called with the current data.
+     * @param silent if true, it will not change the state to `loading` before calling `fn`.
+     */
+    act: (fn: (data: D) => PromiseOr<D>, silent?: boolean) => void;
+    /**
+     * the parameters passed to the provider.
+     */
+    parameters: P;
+}
+export type _BitCtrlMaker<D, P, I> = (d: _BitCtrlInput<D, P>) => I;
+export type _BitProvider<P> = (p: {
+    children?: Maybe<ElbeChildren>;
+} & P) => JSX.Element;
+export interface _BitInterface<D, P, I> {
+    Provider: _BitProvider<P>;
+    use: () => BitUseInterface<D, I>;
+}
+export declare function _isFn<T>(f: any): f is (d: T) => any;

package/dist/bit/_bit_utils.js

@@ -0,0 +1,3 @@
+export function _isFn(f) {
+    return typeof f === "function";
+}

package/dist/bit/bit.d.ts

@@ -1,37 +1,20 @@
-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: <D>(f: (d: T) => any, { onLoading, onError, }?: {
-        onLoading?: () => any;
-        onError?: (e: string) => 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> {
+import { PreactContext } from "preact";
+import { Maybe, PromiseOr } from "..";
+import { _BitCtrlMaker, _BitData, _BitGetInterface, _BitInterface } from "./_bit_utils";
+export type BitStates = "loading" | "error" | "data";
+export type BitContext<D> = PreactContext<_BitData<D> | null>;
+export type BitTriMap<T, D> = {
     onLoading?: () => D;
-    onError?: (e: string) => D;
+    onError?: (e: any) => 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 {};
+};
+export type BitUseInterface<D, I> = _BitGetInterface<D> & I & {
+    reload: () => void;
+};
+export type BitParams<D, P, I> = {
+    control?: _BitCtrlMaker<D, P, I>;
+    debugLabel?: Maybe<string>;
+    worker: (params: P) => PromiseOr<D>;
+    useHistory?: boolean;
+};
+export declare function createBit<D, P extends Object, I>({ control, ...p }: BitParams<D, P, I>): _BitInterface<D, P, I>;

package/dist/bit/bit.js

@@ -1,79 +1,30 @@
-import { jsx as _jsx } from "preact/jsx-runtime";
-import { useSignal } from "@preact/signals";
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
 import { createContext } from "preact";
 import { useContext } from "preact/hooks";
-import { ErrorView } from "../ui/components/error_view";
-import { Column } from "../ui/components/layout/flex";
-import { Spinner } from "../ui/components/spinner";
-export function makeBit(name) {
-    const c = createContext(null);
-    c.displayName = name;
-    return c;
-}
-export function ProvideBit(context, parameters, worker, ctrl, children) {
-    const s = 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) {
-        var _a;
-        const st = s.value;
-        if (st.loading)
-            return m.onLoading();
-        if (st.error)
-            return m.onError(st.error);
-        return m.onData((_a = st.data) !== null && _a !== void 0 ? _a : null);
-    }
-    const c = ctrl(parameters, { emit, emitLoading, emitError, map, signal: s });
-    worker(parameters, { emit, emitLoading, emitError, map, signal: s }, c);
-    return (_jsx(context.Provider, { value: { ctrl: c, state: s }, children: children }));
-}
-export function useBit(context) {
-    try {
-        const { ctrl, state } = useContext(context);
-        const v = state.value;
-        function map(m) {
-            var _a;
-            if (v.loading)
-                return (m.onLoading ||
-                    (() => (_jsx(Column, { cross: "center", children: _jsx(Spinner, {}) }))))();
-            if (v.error)
-                return (m.onError ||
-                    ((e) => { var _a; return _jsx(ErrorView, { error: e, retry: (_a = ctrl.reload) !== null && _a !== void 0 ? _a : null }); }))(v.error);
-            return m.onData((_a = v.data) !== null && _a !== void 0 ? _a : 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, { onLoading, onError, } = {}) => map({ onData: f, onLoading: onLoading, onError: onError }),
-        };
-    }
-    catch (e) {
-        const err = `BIT ERROR: NO ${context.displayName} PROVIDED`;
-        console.error(err, e);
+import { _makeBitProvider } from "./_bit_provider";
+export function createBit(_a) {
+    var { control = () => ({}) } = _a, p = __rest(_a, ["control"]);
+    const context = createContext(null);
+    {
         return {
-            map: (_) => _jsx("div", { children: err }),
-            ctrl: null,
-            signal: null,
-            onData: () => _jsx("div", { children: err }),
+            Provider: _makeBitProvider(context, Object.assign(Object.assign({}, p), { control })),
+            use: () => {
+                const ctx = useContext(context);
+                if (!ctx) {
+                    throw new Error(`BIT ERROR: NO ${p.debugLabel} PROVIDED`);
+                }
+                return ctx;
+            },
         };
     }
 }

package/dist/bit/old/old_bit.d.ts

@@ -0,0 +1,37 @@
+import { Signal } from "@preact/signals";
+import { type PreactContext } from "preact";
+export interface OldBitUseInterface<C, T> {
+    signal: Signal<OldBitState<T>>;
+    ctrl: C;
+    map: <D>(m: OldTriMap<T, D>) => D | preact.JSX.Element;
+    onData: <D>(f: (d: T) => any, { onLoading, onError, }?: {
+        onLoading?: () => any;
+        onError?: (e: string) => any;
+    }) => any;
+}
+interface OldBitData<C, T> {
+    ctrl: C;
+    state: Signal<OldBitState<T>>;
+}
+export interface OldBitState<T> {
+    loading?: boolean;
+    error?: any;
+    data?: T;
+}
+export type OldBitContext<T, C> = PreactContext<OldBitData<T, C> | null>;
+export interface OldTriMap<T, D> {
+    onLoading?: () => D;
+    onError?: (e: string) => D;
+    onData?: (value: T) => D;
+}
+export interface OldTWParams<T> {
+    emit: (t: T) => void;
+    emitLoading: () => void;
+    emitError: (e: any) => void;
+    map: <D>(m: OldTriMap<T, D>) => D;
+    signal: Signal<OldBitState<T>>;
+}
+export declare function makeOldBit<C, T>(name: string): OldBitContext<C, T>;
+export declare function ProvideOldBit<I, C, T>(context: OldBitContext<C, T>, parameters: I, worker: (p: I, d: OldTWParams<T>, ctrl: C) => void, ctrl: (p: I, d: OldTWParams<T>) => C, children: any): import("preact").JSX.Element;
+export declare function useOldBit<C, T>(context: OldBitContext<C, T>): OldBitUseInterface<C, T>;
+export {};

package/dist/bit/old/old_bit.js

@@ -0,0 +1,79 @@
+import { jsx as _jsx } from "preact/jsx-runtime";
+import { useSignal } from "@preact/signals";
+import { createContext } from "preact";
+import { useContext } from "preact/hooks";
+import { ErrorView } from "../../ui/components/error_view";
+import { Column } from "../../ui/components/layout/flex";
+import { Spinner } from "../../ui/components/spinner";
+export function makeOldBit(name) {
+    const c = createContext(null);
+    c.displayName = name;
+    return c;
+}
+export function ProvideOldBit(context, parameters, worker, ctrl, children) {
+    const s = 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) {
+        var _a;
+        const st = s.value;
+        if (st.loading)
+            return m.onLoading();
+        if (st.error)
+            return m.onError(st.error);
+        return m.onData((_a = st.data) !== null && _a !== void 0 ? _a : null);
+    }
+    const c = ctrl(parameters, { emit, emitLoading, emitError, map, signal: s });
+    worker(parameters, { emit, emitLoading, emitError, map, signal: s }, c);
+    return (_jsx(context.Provider, { value: { ctrl: c, state: s }, children: children }));
+}
+export function useOldBit(context) {
+    try {
+        const { ctrl, state } = useContext(context);
+        const v = state.value;
+        function map(m) {
+            var _a;
+            if (v.loading)
+                return (m.onLoading ||
+                    (() => (_jsx(Column, { cross: "center", children: _jsx(Spinner, {}) }))))();
+            if (v.error)
+                return (m.onError ||
+                    ((e) => { var _a; return _jsx(ErrorView, { error: e, retry: (_a = ctrl.reload) !== null && _a !== void 0 ? _a : null }); }))(v.error);
+            return m.onData((_a = v.data) !== null && _a !== void 0 ? _a : 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, { onLoading, onError, } = {}) => map({ onData: f, onLoading: onLoading, onError: onError }),
+        };
+    }
+    catch (e) {
+        const err = `BIT ERROR: NO ${context.displayName} PROVIDED`;
+        console.error(err, e);
+        return {
+            map: (_) => _jsx("div", { children: err }),
+            ctrl: null,
+            signal: null,
+            onData: () => _jsx("div", { children: err }),
+        };
+    }
+}

package/dist/bit/{ctrl_bit.d.ts → old/old_ctrl_bit.d.ts}

@@ -1,9 +1,9 @@
 import type { JSX } from "preact/jsx-runtime";
-import type { BitUseInterface, TWParams } from "./bit";
-declare abstract class BitControl<I, DT> {
+import { OldBitUseInterface, OldTWParams } from "./old_bit";
+declare abstract class OldBitControl<I, DT> {
     p: I;
-    bit: TWParams<DT>;
-    constructor(p: I, bit: TWParams<DT>);
+    bit: OldTWParams<DT>;
+    constructor(p: I, bit: OldTWParams<DT>);
     act(fn: (b: DT) => Promise<void>): void;
     /**
      * Clean up resources. This is called once
@@ -11,20 +11,20 @@ declare abstract class BitControl<I, DT> {
      */
     dispose(): void;
 }
-export declare abstract class WorkerControl<I, DT> extends BitControl<I, DT> {
+export declare abstract class WorkerControl<I, DT> extends OldBitControl<I, DT> {
     reload: (() => Promise<void>) | null;
     abstract worker(): Promise<DT>;
 }
-export declare abstract class StreamControl<I, DT, Stream> extends BitControl<I, DT> {
+export declare abstract class StreamControl<I, DT, Stream> extends OldBitControl<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): {
+export declare function CtrlBit<I, DT, C extends OldBitControl<I, DT>>(ctrl: (p: I, d: OldTWParams<DT>) => C, name?: string): {
     Provide: (props: I & {
         children: React.ReactNode;
     }) => JSX.Element;
-    use: () => BitUseInterface<C, DT>;
+    use: () => OldBitUseInterface<C, DT>;
 };
 export {};

package/dist/bit/{ctrl_bit.js → old/old_ctrl_bit.js}

@@ -19,8 +19,8 @@ var __rest = (this && this.__rest) || function (s, e) {
     return t;
 };
 import { useEffect } from "preact/hooks";
-import { makeBit as mb, ProvideBit, useBit } from "./bit";
-class BitControl {
+import { makeOldBit, ProvideOldBit, useOldBit, } from "./old_bit";
+class OldBitControl {
     constructor(p, bit) {
         this.bit = bit;
         this.p = p;
@@ -46,13 +46,13 @@ class BitControl {
      */
     dispose() { }
 }
-export class WorkerControl extends BitControl {
+export class WorkerControl extends OldBitControl {
     constructor() {
         super(...arguments);
         this.reload = null;
     }
 }
-export class StreamControl extends BitControl {
+export class StreamControl extends OldBitControl {
     constructor() {
         super(...arguments);
         this.stream = null;
@@ -63,16 +63,16 @@ export class StreamControl extends BitControl {
     }
 }
 function make(name) {
-    return mb(name);
+    return makeOldBit(name);
 }
 function use(b) {
-    return useBit(b);
+    return useOldBit(b);
 }
 export function CtrlBit(ctrl, name) {
     const context = make((name || "Unknown") + "Bit");
     function Provide(_a) {
         var { children } = _a, p = __rest(_a, ["children"]);
-        return ProvideBit(context, p, (p, b, c) => __awaiter(this, void 0, void 0, function* () {
+        return ProvideOldBit(context, p, (p, b, c) => __awaiter(this, void 0, void 0, function* () {
             b.emitLoading();
             try {
                 if (c instanceof WorkerControl) {

package/dist/index.d.ts

@@ -3,7 +3,8 @@ export * from "./api/api_worker";
 export * from "./api/error";
 export * from "./api/errors";
 export * from "./bit/bit";
-export * from "./bit/ctrl_bit";
+export * from "./bit/old/old_bit";
+export * from "./bit/old/old_ctrl_bit";
 export * from "./ui/util/confirm_dialog";
 export * from "./ui/util/ctx_toolbar";
 export * from "./ui/util/l10n/l10n";

package/dist/index.js

@@ -6,7 +6,8 @@ export * from "./api/api_worker";
 export * from "./api/error";
 export * from "./api/errors";
 export * from "./bit/bit";
-export * from "./bit/ctrl_bit";
+export * from "./bit/old/old_bit";
+export * from "./bit/old/old_ctrl_bit";
 export * from "./ui/util/confirm_dialog";
 export * from "./ui/util/ctx_toolbar";
 export * from "./ui/util/l10n/l10n";

package/dist/ui/components/layout/app_base.js

@@ -14,15 +14,13 @@ export function AppBase(p) {
     const [state, setState] = useState({
         menuSelected: (_c = (_a = p.initial) !== null && _a !== void 0 ? _a : (_b = p.menu[0]) === null || _b === void 0 ? void 0 : _b.id) !== null && _c !== void 0 ? _c : null,
         menuOpen: false,
-        icons: {
-            logo: p.logo,
-            logoDark: p.logoDark,
-            endLogo: p.endLogo,
-            endLogoDark: p.endLogoDark,
-        },
-        globalActions: (_d = p.globalActions) !== null && _d !== void 0 ? _d : [],
     });
-    return (_jsx(AppBaseContext.Provider, { value: Object.assign(Object.assign({}, state), { setMenuOpen: (b) => setState(Object.assign(Object.assign({}, state), { menuOpen: b })), setMenuSelected: (s) => setState(Object.assign(Object.assign({}, state), { menuSelected: s })) }), children: _jsxs(Box, { scheme: "primary", style: {
+    return (_jsx(AppBaseContext.Provider, { value: Object.assign(Object.assign({}, state), { icons: {
+                logo: p.logo,
+                logoDark: p.logoDark,
+                endLogo: p.endLogo,
+                endLogoDark: p.endLogoDark,
+            }, globalActions: (_d = p.globalActions) !== null && _d !== void 0 ? _d : [], setMenuOpen: (b) => setState(Object.assign(Object.assign({}, state), { menuOpen: b })), setMenuSelected: (s) => setState(Object.assign(Object.assign({}, state), { menuSelected: s })) }), children: _jsxs(Box, { scheme: "primary", style: {
                 display: "flex",
                 width: "100%",
                 minHeight: "100vh",

package/dist/ui/util/l10n/l10n.js

@@ -8,7 +8,7 @@ import { _bestMatch, _L10nContext, _useL10n, } from "./_l10n_util";
  * @returns an object with the L10n component and the useL10n hook.
  */
 export function makeL10n(fallback, supported) {
-    if (Object.keys(supported).length === 0) {
+    if (Object.keys(fallback).length === 0) {
         throw new Error("L10nBase: No fallback locales provided");
     }
     const fallbackLocale = Object.keys(fallback)[0];

package/dist/ui/util/util.d.ts

@@ -1,5 +1,6 @@
 import { int } from "../..";
 export type Maybe<T> = T | null | undefined;
+export type PromiseOr<T> = Promise<T> | T;
 export declare function clamp(value: number, min: number, max: number): number;
 export declare function classString(classes: (string | false | null | undefined)[]): string;
 /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "elbe-ui",
-  "version": "0.4.5",
+  "version": "0.4.8",
   "author": "Robin Naumann",
   "license": "MIT",
   "repository": {