dry-ux 1.42.0 → 1.44.0

package/dist/error/ErrorBoundary.d.ts

@@ -1,13 +1,21 @@
 import * as React from "react";
-export declare class ErrorBoundary extends React.Component<{
-    fallback?: JSX.Element;
-    children: JSX.Element;
-}, {
-    hasError: boolean;
-}> {
-    constructor(props: any);
-    static getDerivedStateFromError(error: any): {
-        hasError: boolean;
+export interface IErrorBoundaryProps {
+    errorHandler?: (error?: Error, info?: React.ErrorInfo) => void;
+    onErrorCallback?: (error?: Error) => void;
+    rethrowError?: boolean;
+    fallbackUI?: React.ReactNode | ((error: Error, resetError: () => void) => JSX.Element);
+}
+interface IErrorBoundaryInnerState {
+    error: Error | null;
+}
+export declare class ErrorBoundary extends React.PureComponent<IErrorBoundaryProps, IErrorBoundaryInnerState> {
+    constructor(props: IErrorBoundaryProps);
+    static getDerivedStateFromError(error: Error): {
+        error: Error;
     };
-    render(): JSX.Element & React.ReactNode;
+    componentDidCatch(error: Error, info: React.ErrorInfo): void;
+    render: () => any;
+    private handleError;
+    private resetError;
 }
+export {};

package/dist/error/ErrorBoundary.js

@@ -3,19 +3,46 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.ErrorBoundary = void 0;
 const React = require("react");
 const ErrorScreen_1 = require("./ErrorScreen");
-class ErrorBoundary extends React.Component {
+class ErrorBoundary extends React.PureComponent {
     constructor(props) {
         super(props);
-        this.state = { hasError: false };
+        this.render = () => {
+            const { children, fallbackUI = null } = this.props;
+            const { error } = this.state;
+            if (error) {
+                if (typeof fallbackUI === "function") {
+                    return fallbackUI(error, this.resetError.bind(this));
+                }
+                return fallbackUI || React.createElement(ErrorScreen_1.ErrorScreen, null);
+            }
+            return children;
+        };
+        this.handleError = (error, info) => {
+            const { errorHandler, onErrorCallback, rethrowError } = this.props;
+            if (onErrorCallback) {
+                onErrorCallback(error);
+            }
+            if (errorHandler) {
+                errorHandler(error, info);
+                if (rethrowError) {
+                    throw error;
+                }
+                return;
+            }
+            if (rethrowError) {
+                throw error;
+            }
+        };
+        this.state = { error: null };
     }
     static getDerivedStateFromError(error) {
-        return { hasError: true };
+        return { error };
     }
-    render() {
-        if (this.state.hasError) {
-            return this.props.fallback || React.createElement(ErrorScreen_1.ErrorScreen, null);
-        }
-        return this.props.children;
+    componentDidCatch(error, info) {
+        this.handleError(error, info);
+    }
+    resetError() {
+        this.setState({ error: null });
     }
 }
 exports.ErrorBoundary = ErrorBoundary;

package/dist/helpers/logger.d.ts

@@ -0,0 +1,9 @@
+export interface ILogger {
+    log(...message: string[]): void;
+    error(...message: string[]): void;
+    debug(...message: string[]): void;
+    warn(...message: string[]): void;
+}
+export declare const initLoggerFactory: (path: string) => {
+    useLogger: (name: string) => ILogger;
+};

package/dist/helpers/logger.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.initLoggerFactory = void 0;
+const useLogger = (path, name) => {
+    const convertMessage = (message) => message
+        .map(m => {
+        try {
+            if (typeof m === "string" || typeof m === "number" || typeof m === "boolean") {
+                return m.toString();
+            }
+            return JSON.stringify(m);
+        }
+        catch (e) {
+            return m;
+        }
+    })
+        .join(" ");
+    const log = (level, message) => fetch(path, {
+        method: "POST",
+        headers: {
+            "Content-Type": "application/json",
+        },
+        body: JSON.stringify({ logger_name: name, level, message: convertMessage(message) }),
+    });
+    return {
+        log: (...message) => log("info", message),
+        error: (...message) => log("error", message),
+        debug: (...message) => log("debug", message),
+        warn: (...message) => log("warn", message),
+    };
+};
+const initLoggerFactory = (path) => ({
+    useLogger: (name) => useLogger(path, name),
+});
+exports.initLoggerFactory = initLoggerFactory;

package/dist/index.d.ts

@@ -4,6 +4,7 @@ export { Money as Money } from "./ui-utils/Money";
 export * from "./ui-utils/uiUtil.interface";
 export { DryUXProvider } from "./provider";
 export * from "./helpers/utilities";
+export * from "./helpers/logger";
 export { classSet } from "./helpers/classSet";
 export { flatten, unflatten } from "./helpers/flat";
 export { DajaxiceProxy } from "./dajaxice/DajaxiceProxy";

package/dist/index.js

@@ -26,6 +26,7 @@ __exportStar(require("./ui-utils/uiUtil.interface"), exports);
 var provider_1 = require("./provider");
 Object.defineProperty(exports, "DryUXProvider", { enumerable: true, get: function () { return provider_1.DryUXProvider; } });
 __exportStar(require("./helpers/utilities"), exports);
+__exportStar(require("./helpers/logger"), exports);
 var classSet_1 = require("./helpers/classSet");
 Object.defineProperty(exports, "classSet", { enumerable: true, get: function () { return classSet_1.classSet; } });
 var flat_1 = require("./helpers/flat");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dry-ux",
-  "version": "1.42.0",
+  "version": "1.44.0",
   "description": "",
   "main": "dist/index",
   "scripts": {