elbe-ui 2.0.15 → 2.0.17

package/dist/bit/_bit_provider.js

@@ -8,7 +8,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 import { jsx as _jsx } from "react/jsx-runtime";
-import { useEffect, useState } from "react";
+import { useEffect, useRef, useState } from "react";
 import { Column, ErrorView, Spinner, } from "..";
 import { _isFn } from "./_bit_types";
 function _LoadView({}) {
@@ -16,45 +16,60 @@ function _LoadView({}) {
 }
 export function _makeBitProvider(context, bitP) {
     function _BitProvider(p) {
-        const [streamCancel, setStreamCancel] = useState(null);
+        const streamCancelRef = useRef(null);
+        const stateRef = useRef({
+            v: { type: "loading" },
+            history: [],
+        });
         const [state, setState] = useState({
             v: { type: "loading" },
             history: [],
         });
+        stateRef.current = state;
         // ========== 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 },
+                    setState((prev) => {
+                        // if it's the same data, don't update
+                        if (prev.v.type === "data" && prev.v.value === d)
+                            return prev;
+                        return {
+                            history: bitP.useHistory ? [...prev.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),
+                setLoading: () => setState((prev) => (Object.assign(Object.assign({}, prev), { v: { type: "loading" } }))),
+                setError: (e) => setState((prev) => (Object.assign(Object.assign({}, prev), { v: { type: "error", value: e } }))),
+                canGoBack: !!(bitP.useHistory && stateRef.current.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 },
+                    let didGoBack = false;
+                    setState((prev) => {
+                        if (prev.history.length < 2)
+                            return prev;
+                        didGoBack = true;
+                        const newHistory = prev.history.slice(0, -1);
+                        const newData = newHistory[newHistory.length - 1];
+                        return {
+                            history: newHistory,
+                            v: { type: "data", value: newData },
+                        };
                     });
-                    return true;
+                    return didGoBack;
                 },
-                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,
+                state: stateRef.current.v.type,
+                isData: stateRef.current.v.type === "data",
+                isLoading: stateRef.current.v.type === "loading",
+                isError: stateRef.current.v.type === "error",
+                data: stateRef.current.v.type === "data"
+                    ? stateRef.current.v.value
+                    : undefined,
+                error: stateRef.current.v.type === "error"
+                    ? stateRef.current.v.value
+                    : undefined,
             };
             // ========== DEFINE QoL FUNCTIONS ==========
             function _worker(fn, silent, reset) {
@@ -81,10 +96,14 @@ export function _makeBitProvider(context, bitP) {
                     try {
                         if (!silent)
                             _partCtrl.setLoading();
-                        if (streamCancel)
-                            streamCancel();
+                        const prevCancel = streamCancelRef.current;
+                        streamCancelRef.current = null;
+                        if (prevCancel)
+                            prevCancel();
                         const cancel = _bit.stream(p, _partCtrl);
-                        setStreamCancel(() => cancel());
+                        streamCancelRef.current = () => {
+                            cancel();
+                        };
                         return;
                     }
                     catch (e) {
@@ -96,7 +115,9 @@ export function _makeBitProvider(context, bitP) {
             };
             function act(fn, silent) {
                 return __awaiter(this, void 0, void 0, function* () {
-                    const data = _partCtrl.data;
+                    const data = stateRef.current.v.type === "data"
+                        ? stateRef.current.v.value
+                        : undefined;
                     if (data === undefined)
                         return;
                     _worker(() => fn(data), silent);
@@ -104,14 +125,15 @@ export function _makeBitProvider(context, bitP) {
             }
             function map(onData, onError, onLoading) {
                 var _a, _b, _c;
-                if (state.v.type === "data") {
+                const currentState = stateRef.current.v;
+                if (currentState.type === "data") {
                     return _isFn(onData)
-                        ? onData(state.v.value)
+                        ? onData(currentState.value)
                         : ((_a = onData) !== null && _a !== void 0 ? _a : null);
                 }
-                if (state.v.type === "error") {
+                if (currentState.type === "error") {
                     return _isFn(onError)
-                        ? onError(state.v.value)
+                        ? onError(currentState.value)
                         : ((_b = onError) !== null && _b !== void 0 ? _b : null);
                 }
                 return _isFn(onLoading) ? onLoading() : ((_c = onLoading) !== null && _c !== void 0 ? _c : null);
@@ -126,14 +148,51 @@ export function _makeBitProvider(context, bitP) {
                 return children();
             }
             const userCtrl = bitP.control(Object.assign(Object.assign({}, baseCtrl), { parameters: p, reload: _reload, consider: consider }));
-            return Object.assign(Object.assign(Object.assign({}, baseCtrl), userCtrl), { reload: _reload, parameters: p, consider: consider });
+            const ctrl = Object.assign(Object.assign(Object.assign({}, baseCtrl), userCtrl), { reload: _reload, parameters: p, consider: consider });
+            Object.defineProperties(ctrl, {
+                state: {
+                    enumerable: true,
+                    get: () => stateRef.current.v.type,
+                },
+                isData: {
+                    enumerable: true,
+                    get: () => stateRef.current.v.type === "data",
+                },
+                isLoading: {
+                    enumerable: true,
+                    get: () => stateRef.current.v.type === "loading",
+                },
+                isError: {
+                    enumerable: true,
+                    get: () => stateRef.current.v.type === "error",
+                },
+                data: {
+                    enumerable: true,
+                    get: () => stateRef.current.v.type === "data"
+                        ? stateRef.current.v.value
+                        : undefined,
+                },
+                error: {
+                    enumerable: true,
+                    get: () => stateRef.current.v.type === "error"
+                        ? stateRef.current.v.value
+                        : undefined,
+                },
+                canGoBack: {
+                    enumerable: true,
+                    get: () => !!(bitP.useHistory && stateRef.current.history.length > 1),
+                },
+            });
+            return ctrl;
         }
         const ctrl = _make();
         useEffect(() => {
             ctrl.reload(true);
             return () => {
-                if (streamCancel)
-                    streamCancel();
+                const cancel = streamCancelRef.current;
+                streamCancelRef.current = null;
+                if (cancel)
+                    cancel();
                 // call dispose if exists
                 const d = ctrl.dispose;
                 if (typeof d !== "function")
@@ -147,7 +206,7 @@ export function _makeBitProvider(context, bitP) {
             };
         }, []);
         // ========== DEFINE THE JSX ELEMENT ==========
-        return (_jsx(context.Provider, { value: Object.assign({}, ctrl), children: p.children }));
+        return _jsx(context.Provider, { value: ctrl, children: p.children });
     }
     return _BitProvider;
 }

package/dist/index.js

@@ -1,5 +1,6 @@
 import { jsx as _jsx } from "react/jsx-runtime";
 import * as Lucide from "lucide-react";
+//@ts-ignore
 import "./elbe.css";
 export * as Wouter from "wouter";
 export * as wouter_hash from "wouter/use-hash-location";

package/dist/ui/components/dialog/dialog_ctx.d.ts

@@ -1,4 +1,4 @@
-import { ColorSelection, ElbeChildren } from "../../..";
+import { ColorSelection, Dict, ElbeChildren } from "../../..";
 declare const _dialogs: {
     showConfirmDialog: DialogsConfig<{
         message: string;

package/dist/ui/components/tooltip.js

@@ -44,7 +44,6 @@ export function WithTooltip(p) {
             var _a;
             timeoutRef.current = window.setTimeout(() => setVisible(true), (_a = p.delay) !== null && _a !== void 0 ? _a : 1000);
         }, onMouseLeave: () => {
-            console.log("leave");
             if (timeoutRef.current) {
                 clearTimeout(timeoutRef.current);
                 timeoutRef.current = null;

package/dist/ui/theme/subthemes/_theme_type.d.ts

@@ -1,3 +1,4 @@
+import { Dict } from "../../util/util";
 import { ElbeSubThemeData } from "../theme";
 export type TypeStyle<T extends Dict<any> = {}> = T & {
     bold?: boolean;

package/dist/ui/theme/subthemes/color/colors/_colordef.d.ts

@@ -1,3 +1,4 @@
+import { Dict } from "../../../../..";
 export type ElbeColor<T extends string, Data extends Dict<any>, Computed extends Dict<any>> = {
     type: [T, ...string[]];
 } & Data & Computed;

package/dist/ui/theme/theme.d.ts

@@ -1,4 +1,4 @@
-import "../../elbe.css";
+import { Dict } from "../..";
 export type ElbeSubThemeData<Computed extends Dict<any>, Seed extends Dict<any> = Computed, Config extends Dict<any> = Computed> = {
     seed: Seed;
     _configType: Config;

package/dist/ui/theme/theme.js

@@ -1,4 +1,5 @@
-import "../../elbe.css";
+//@ts-ignore
+//import "./elbe.css";
 import { geometryThemeData } from "./subthemes/_theme_geometry";
 import { menuThemeData } from "./subthemes/_theme_menu";
 import { motionThemeData } from "./subthemes/_theme_motion";

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

@@ -1 +1,2 @@
+import { Dict } from "../..";
 export declare function deepMerge<T extends Dict<any>>(original: T, toMerge: Partial<T>, depth?: number): T;

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

@@ -1,6 +1,9 @@
 import { int } from "../..";
 export type Maybe<T> = T | null | undefined;
 export type PromiseOr<T> = Promise<T> | T;
+export type Dict<T> = {
+    [key: string]: 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": "2.0.15",
+  "version": "2.0.17",
   "author": "Robin Naumann",
   "license": "MIT",
   "repository": {