dry-ux 1.52.0 → 1.54.0

package/dist/enhanced-inputs/interface.d.ts

@@ -0,0 +1,109 @@
+import { InputHTMLAttributes } from "react";
+export type IValidation = boolean | string;
+export interface IValueValidation<T> {
+    /**
+     * The value to be validated.
+     */
+    value: T;
+    /**
+     * Optional message to be displayed if validation fails.
+     */
+    message?: string;
+}
+export interface IValidations {
+    /**
+     * Indicates if the field is required.
+     */
+    required?: IValidation;
+    /**
+     * Indicates if the field should be validated as a number.
+     */
+    number?: IValidation;
+    /**
+     * Indicates if the field should be validated as a monetary value.
+     */
+    money?: IValidation;
+    /**
+     * Indicates if the field should be validated as a positive number.
+     */
+    positiveNumber?: IValidation;
+    /**
+     * Indicates if the field should be validated as an email.
+     */
+    email?: IValidation;
+    /**
+     * Indicates if the field should be validated as digits.
+     */
+    digits?: IValidation;
+    /**
+     * Indicates if the field should be validated as a date.
+     */
+    date?: IValidation;
+    /**
+     * Compares the field with another field specified by its ID.
+     */
+    compare?: IValueValidation<string>;
+    /**
+     * Minimum length validation for the field.
+     */
+    minLength?: IValueValidation<number>;
+    /**
+     * Minimum digits length validation for the field.
+     */
+    minDigitsLength?: IValueValidation<number>;
+    /**
+     * Maximum length validation for the field.
+     */
+    maxLength?: IValueValidation<number>;
+    /**
+     * Maximum value validation for the field.
+     */
+    maxValue?: IValueValidation<number>;
+    /**
+     * Maximum date validation for the field.
+     */
+    maxDate?: IValueValidation<Date>;
+    /**
+     * Minimum date validation for the field.
+     */
+    minDate?: IValueValidation<Date>;
+    /**
+     * Disallowed days of the week for the field.
+     */
+    disallowedDaysOfWeek?: number[];
+    /**
+     * Indicates if the field should be validated even if it is hidden.
+     */
+    validateHidden?: boolean;
+    /**
+     * JQuery selector of the element to add the error after.
+     */
+    errorRef?: string;
+}
+export interface IEnhancedProps {
+    /**
+     * Validation rules for the field.
+     */
+    validations?: IValidations;
+    /**
+     * Indicates if the field should have form control styling.
+     */
+    formControl?: boolean;
+    /**
+     * Maximum length for the field.
+     */
+    eMaxLength?: number;
+    /**
+     * Indicates if the field should select its content on focus.
+     */
+    selectOnFocus?: boolean;
+    /**
+     * Indicates if the field should not have error background styling.
+     */
+    noErrorBackground?: boolean;
+    /**
+     * Indicates if the field should validate on change (Default: true).
+     */
+    validateOnChange?: boolean;
+}
+export type InputAttributes = InputHTMLAttributes<HTMLInputElement | HTMLSelectElement | HTMLTextAreaElement>;

package/dist/enhanced-inputs/interface.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/enhanced-inputs/styles.css

@@ -0,0 +1,13 @@
+.error-background:not(.MuiFormControl-root),
+.error-background.MuiFormControl-root .MuiInputBase-root
+{
+    background-color: #F8DBDD !important;
+    border: 1px solid #E17984 !important;
+}
+div.error-message
+{
+    font-size:7pt;
+    color:Red;
+    display:block;
+    line-height: 1.5;
+}

package/dist/enhanced-inputs/withEnhancements.d.ts

@@ -0,0 +1,86 @@
+import * as React from "react";
+import { IEnhancedProps, InputAttributes, IValidations } from "./interface";
+/**
+ * Extracts enhanced properties from the passed props.
+ * @param passedProps The props passed to the component.
+ * @returns An object containing the extracted enhanced properties and the remaining props.
+ */
+export declare const extractEnhancedProps: <P>(passedProps: P & IEnhancedProps) => {
+    validations: IValidations;
+    formControl: boolean;
+    eMaxLength: number;
+    selectOnFocus: boolean;
+    noErrorBackground: boolean;
+    validateOnChange: boolean;
+    props: Omit<P & IEnhancedProps, "validations" | "formControl" | "eMaxLength" | "selectOnFocus" | "noErrorBackground" | "validateOnChange">;
+};
+/**
+ * Gets the enhanced attributes for an input element.
+ * @param className The class name of the input element.
+ * @param validations The validations to apply to the input element.
+ * @param formControl Whether the input element is a form control.
+ * @param noErrorBackground Whether to disable the error background.
+ * @returns An object containing the class name and attributes for the input element.
+ */
+export declare const getEnhancedAttributes: (className: string, validations: IValidations, formControl: boolean, noErrorBackground: boolean) => {
+    className: string;
+    attributes: {};
+};
+/**
+ * Higher-order component that adds enhancements to an input component.
+ * @param Component The input component to enhance.
+ * @returns The enhanced input component.
+ */
+export declare const withEnhancements: <P extends InputAttributes>(Component: React.ComponentType<P>) => {
+    new (props: (P & IEnhancedProps) | Readonly<P & IEnhancedProps>): {
+        render(): React.JSX.Element;
+        context: any;
+        setState<K extends never>(state: {} | ((prevState: Readonly<{}>, props: Readonly<P & IEnhancedProps>) => {} | Pick<{}, K>) | Pick<{}, K>, callback?: () => void): void;
+        forceUpdate(callback?: () => void): void;
+        readonly props: Readonly<P & IEnhancedProps> & Readonly<{
+            children?: React.ReactNode | undefined;
+        }>;
+        state: Readonly<{}>;
+        refs: {
+            [key: string]: React.ReactInstance;
+        };
+        componentDidMount?(): void;
+        shouldComponentUpdate?(nextProps: Readonly<P & IEnhancedProps>, nextState: Readonly<{}>, nextContext: any): boolean;
+        componentWillUnmount?(): void;
+        componentDidCatch?(error: Error, errorInfo: React.ErrorInfo): void;
+        getSnapshotBeforeUpdate?(prevProps: Readonly<P & IEnhancedProps>, prevState: Readonly<{}>): any;
+        componentDidUpdate?(prevProps: Readonly<P & IEnhancedProps>, prevState: Readonly<{}>, snapshot?: any): void;
+        componentWillMount?(): void;
+        UNSAFE_componentWillMount?(): void;
+        componentWillReceiveProps?(nextProps: Readonly<P & IEnhancedProps>, nextContext: any): void;
+        UNSAFE_componentWillReceiveProps?(nextProps: Readonly<P & IEnhancedProps>, nextContext: any): void;
+        componentWillUpdate?(nextProps: Readonly<P & IEnhancedProps>, nextState: Readonly<{}>, nextContext: any): void;
+        UNSAFE_componentWillUpdate?(nextProps: Readonly<P & IEnhancedProps>, nextState: Readonly<{}>, nextContext: any): void;
+    };
+    new (props: P & IEnhancedProps, context: any): {
+        render(): React.JSX.Element;
+        context: any;
+        setState<K extends never>(state: {} | ((prevState: Readonly<{}>, props: Readonly<P & IEnhancedProps>) => {} | Pick<{}, K>) | Pick<{}, K>, callback?: () => void): void;
+        forceUpdate(callback?: () => void): void;
+        readonly props: Readonly<P & IEnhancedProps> & Readonly<{
+            children?: React.ReactNode | undefined;
+        }>;
+        state: Readonly<{}>;
+        refs: {
+            [key: string]: React.ReactInstance;
+        };
+        componentDidMount?(): void;
+        shouldComponentUpdate?(nextProps: Readonly<P & IEnhancedProps>, nextState: Readonly<{}>, nextContext: any): boolean;
+        componentWillUnmount?(): void;
+        componentDidCatch?(error: Error, errorInfo: React.ErrorInfo): void;
+        getSnapshotBeforeUpdate?(prevProps: Readonly<P & IEnhancedProps>, prevState: Readonly<{}>): any;
+        componentDidUpdate?(prevProps: Readonly<P & IEnhancedProps>, prevState: Readonly<{}>, snapshot?: any): void;
+        componentWillMount?(): void;
+        UNSAFE_componentWillMount?(): void;
+        componentWillReceiveProps?(nextProps: Readonly<P & IEnhancedProps>, nextContext: any): void;
+        UNSAFE_componentWillReceiveProps?(nextProps: Readonly<P & IEnhancedProps>, nextContext: any): void;
+        componentWillUpdate?(nextProps: Readonly<P & IEnhancedProps>, nextState: Readonly<{}>, nextContext: any): void;
+        UNSAFE_componentWillUpdate?(nextProps: Readonly<P & IEnhancedProps>, nextState: Readonly<{}>, nextContext: any): void;
+    };
+    contextType?: React.Context<any> | undefined;
+};

package/dist/enhanced-inputs/withEnhancements.js

@@ -0,0 +1,74 @@
+"use strict";
+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;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.withEnhancements = exports.getEnhancedAttributes = exports.extractEnhancedProps = void 0;
+const React = require("react");
+/**
+ * Extracts enhanced properties from the passed props.
+ * @param passedProps The props passed to the component.
+ * @returns An object containing the extracted enhanced properties and the remaining props.
+ */
+const extractEnhancedProps = (passedProps) => {
+    const { validations, formControl, eMaxLength, selectOnFocus, noErrorBackground, validateOnChange } = passedProps, props = __rest(passedProps, ["validations", "formControl", "eMaxLength", "selectOnFocus", "noErrorBackground", "validateOnChange"]);
+    return { validations, formControl, eMaxLength, selectOnFocus, noErrorBackground, validateOnChange, props };
+};
+exports.extractEnhancedProps = extractEnhancedProps;
+/**
+ * Gets the enhanced attributes for an input element.
+ * @param className The class name of the input element.
+ * @param validations The validations to apply to the input element.
+ * @param formControl Whether the input element is a form control.
+ * @param noErrorBackground Whether to disable the error background.
+ * @returns An object containing the class name and attributes for the input element.
+ */
+const getEnhancedAttributes = (className, validations, formControl, noErrorBackground) => {
+    className = className || "";
+    className += (!className.length ? "" : " ") + "enhanced-input";
+    let attributes = {};
+    if (validations) {
+        const addValidation = (validation, name) => {
+            !!validation && (className += " validate-" + name);
+            return !!validation && typeof validation == "string" && { [`data-${name}-message`]: validation };
+        };
+        const addValueValidation = (validation, name) => {
+            !!validation && (className += " validate-" + name);
+            return (!!validation && Object.assign(Object.assign({}, (validation.message !== undefined && { [`data-${name}-message`]: validation.message })), { [`data-${name}`]: validation.value }));
+        };
+        const addGenericValidation = (validation, name) => {
+            !!validation && (className += " validate-" + name);
+            return !!validation && { [`data-${name}`]: validation };
+        };
+        attributes = Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign({}, addValidation(validations.required, "required")), addValidation(validations.number, "number")), addValidation(validations.positiveNumber, "positive-number")), addValidation(validations.email, "email")), addValidation(validations.digits, "digits")), addValidation(validations.date, "date")), addValidation(validations.money, "money")), addValidation(validations.validateHidden, "hidden")), (validations.errorRef && { [`data-validation-error-ref`]: validations.errorRef })), addValueValidation(validations.compare, "compare")), addValueValidation(validations.minLength, "min-length")), addValueValidation(validations.minDigitsLength, "min-digits-length")), addValueValidation(validations.maxLength, "max-length")), addValueValidation(validations.maxValue, "max-value")), addValueValidation(validations.maxDate, "max-date")), addValueValidation(validations.minDate, "min-date")), addGenericValidation(validations.disallowedDaysOfWeek, "disallowed-days-of-week"));
+    }
+    className.match("validate-") && (className += " validate");
+    formControl && (className += " form-control");
+    noErrorBackground && (className += " validation-no-error-background");
+    return {
+        className,
+        attributes,
+    };
+};
+exports.getEnhancedAttributes = getEnhancedAttributes;
+/**
+ * Higher-order component that adds enhancements to an input component.
+ * @param Component The input component to enhance.
+ * @returns The enhanced input component.
+ */
+const withEnhancements = (Component) => class EnhancedInput extends React.Component {
+    render() {
+        const { validations, formControl, noErrorBackground, validateOnChange, props } = (0, exports.extractEnhancedProps)(this.props);
+        const { className, attributes } = (0, exports.getEnhancedAttributes)(props.className, validations, formControl, noErrorBackground);
+        return React.createElement(Component, Object.assign({}, props, attributes, { className: className }));
+    }
+};
+exports.withEnhancements = withEnhancements;

package/dist/error/ErrorBoundary.d.ts

@@ -1,22 +1,66 @@
 import * as React from "react";
+/**
+ * Props for the ErrorBoundary component.
+ */
 export interface IErrorBoundaryProps {
+    /**
+     * An optional function to handle the error.
+     */
     errorHandler?: (error?: Error, info?: React.ErrorInfo) => void;
+    /**
+     * An optional callback function to call when an error is caught.
+     */
     onErrorCallback?: (error?: Error) => void;
+    /**
+     * If true, rethrows the error after handling it. Defaults to false.
+     */
     rethrowError?: boolean;
+    /**
+     * An optional function to render a fallback UI when an error is caught.
+     */
     fallback?: (error: Error, resetError: () => void) => JSX.Element;
+    /**
+     * The child components to render.
+     */
     children: JSX.Element;
 }
 interface IErrorBoundaryInnerState {
     error: Error | null;
 }
+/**
+ * A React component that acts as an error boundary to catch JavaScript errors anywhere in its child component tree.
+ * It displays a fallback UI when an error is caught.
+ */
 export declare class ErrorBoundary extends React.PureComponent<IErrorBoundaryProps, IErrorBoundaryInnerState> {
     constructor(props: IErrorBoundaryProps);
+    /**
+     * Updates the state with the error.
+     * @param error The error that was thrown.
+     * @returns The updated state.
+     */
     static getDerivedStateFromError(error: Error): {
         error: Error;
     };
+    /**
+     * Handles the error and updates the state.
+     * @param error The error that was thrown.
+     * @param info Additional information about the error.
+     */
     componentDidCatch(error: Error, info: React.ErrorInfo): void;
+    /**
+     * Renders the component.
+     * @returns The rendered component.
+     */
     render: () => React.JSX.Element;
+    /**
+     * Handles the error based on the provided props.
+     * @param error The error that was thrown.
+     * @param info Additional information about the error.
+     */
     private handleError;
+    /**
+     * Resets the error state.
+     */
     private resetError;
 }
 export {};

package/dist/error/ErrorBoundary.js

@@ -3,9 +3,17 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.ErrorBoundary = void 0;
 const React = require("react");
 const ErrorScreen_1 = require("./ErrorScreen");
+/**
+ * A React component that acts as an error boundary to catch JavaScript errors anywhere in its child component tree.
+ * It displays a fallback UI when an error is caught.
+ */
 class ErrorBoundary extends React.PureComponent {
     constructor(props) {
         super(props);
+        /**
+         * Renders the component.
+         * @returns The rendered component.
+         */
         this.render = () => {
             const { children, fallback = null } = this.props;
             const { error } = this.state;
@@ -14,6 +22,11 @@ class ErrorBoundary extends React.PureComponent {
             }
             return children;
         };
+        /**
+         * Handles the error based on the provided props.
+         * @param error The error that was thrown.
+         * @param info Additional information about the error.
+         */
         this.handleError = (error, info) => {
             const { errorHandler, onErrorCallback, rethrowError } = this.props;
             if (onErrorCallback) {
@@ -32,12 +45,25 @@ class ErrorBoundary extends React.PureComponent {
         };
         this.state = { error: null };
     }
+    /**
+     * Updates the state with the error.
+     * @param error The error that was thrown.
+     * @returns The updated state.
+     */
     static getDerivedStateFromError(error) {
         return { error };
     }
+    /**
+     * Handles the error and updates the state.
+     * @param error The error that was thrown.
+     * @param info Additional information about the error.
+     */
     componentDidCatch(error, info) {
         this.handleError(error, info);
     }
+    /**
+     * Resets the error state.
+     */
     resetError() {
         this.setState({ error: null });
     }

package/dist/error/ErrorScreen.d.ts

@@ -1,2 +1,6 @@
 import * as React from "react";
+/**
+ * A React component that displays an error screen with a message and a button to go back to the home page.
+ * @returns A JSX element representing the error screen.
+ */
 export declare const ErrorScreen: React.MemoExoticComponent<() => React.JSX.Element>;

package/dist/error/ErrorScreen.js

@@ -2,6 +2,10 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ErrorScreen = void 0;
 const React = require("react");
+/**
+ * A React component that displays an error screen with a message and a button to go back to the home page.
+ * @returns A JSX element representing the error screen.
+ */
 exports.ErrorScreen = React.memo(() => (React.createElement("div", { className: "text-center", style: { marginTop: 70 } },
     React.createElement("h1", { style: { fontSize: 70 } },
         React.createElement("i", { className: "fa fa-exclamation-triangle" })),

package/dist/helpers/flat.d.ts

@@ -1,7 +1,19 @@
 type FlattenOptions = {
+    /**
+     * The delimiter to use for separating keys. Defaults to ".".
+     */
     delimiter?: string;
+    /**
+     * The maximum depth to flatten the object to.
+     */
     maxDepth?: number;
+    /**
+     * A function to transform the keys.
+     */
     transformKey?: (key: any) => any;
+    /**
+     * If true, ensures arrays are not flattened.
+     */
     safe?: boolean;
 };
 /**

package/dist/helpers/logger.d.ts

@@ -1,7 +1,23 @@
 export interface ILogger {
+    /**
+     * Logs a message with the info level.
+     * @param {...any[]} message - The message to log.
+     */
     log(...message: any[]): void;
+    /**
+     * Logs a message with the error level.
+     * @param {...any[]} message - The message to log.
+     */
     error(...message: any[]): void;
+    /**
+     * Logs a message with the debug level.
+     * @param {...any[]} message - The message to log.
+     */
     debug(...message: any[]): void;
+    /**
+     * Logs a message with the warn level.
+     * @param {...any[]} message - The message to log.
+     */
     warn(...message: any[]): void;
 }
 export declare const initLoggerFactory: (path: string) => {

package/dist/helpers/utilities.d.ts

@@ -38,25 +38,77 @@ export declare const formatDollar: (amount: number, decimal_places?: boolean) =>
  * @param authRedirectUrl The URL to redirect to if the user is not authenticated.
  */
 export declare const fnWithAuthCheck: (fn: Function, authCheckUrl: string, authRedirectUrl: string) => Promise<void>;
-export declare const StorageUtils: {
-    isStorageAvailable: () => boolean;
-};
+/**
+ * Utility class for storage-related operations.
+ */
+export declare class StorageUtils {
+    /**
+     * Checks if the storage is available.
+     * @returns A boolean indicating if the storage is available.
+     */
+    static isStorageAvailable(): boolean;
+}
+/**
+ * Converts a string to a hash code.
+ * @param input The string to convert.
+ * @returns The hash code of the input string.
+ */
 export declare const toHashCode: (input: string) => number;
+/**
+ * Inserts a URL parameter.
+ * @param key The key of the parameter.
+ * @param value The value of the parameter.
+ */
 export declare const insertUrlParam: (key: string, value: any) => void;
+/**
+ * Inserts multiple URL parameters.
+ * @param params An object containing key-value pairs of parameters.
+ */
 export declare const insertUrlParams: (params: {
     [key: string]: any;
 }) => void;
+/**
+ * Retrieves URL parameters as an object.
+ * @returns An object containing the URL parameters.
+ */
 export declare const getUrlParams: <T>() => T;
+/**
+ * A class representing a deferred promise.
+ */
 export declare class Deferred<T> {
     private _resolve;
     private _reject;
+    /**
+     * The promise object.
+     */
     readonly promise: Promise<T>;
     constructor();
+    /**
+     * Resolves the promise with the given result.
+     */
     get resolve(): (result: T) => void;
+    /**
+     * Rejects the promise with the given error.
+     */
     get reject(): (error: any) => void;
 }
+/**
+ * Parses a JSON string and returns the corresponding object.
+ * @param json The JSON string to parse.
+ * @param errorValue The value to return if parsing fails.
+ * @returns The parsed object or the error value.
+ */
 export declare const tryParseJson: <T = any>(json: string, errorValue?: {}) => {};
+/**
+ * Hook to check if an element is visible in the viewport.
+ * @param ref The reference to the element.
+ * @returns A boolean indicating if the element is visible.
+ */
 export declare const useIsVisible: (ref: React.MutableRefObject<any>) => boolean;
+/**
+ * Hook to publish and subscribe to custom events.
+ * @returns An object containing the usePub and useSub hooks.
+ */
 export declare const usePubSub: <T>() => {
     usePub: () => <TName extends keyof T, TPayload extends T[TName]>(event: TName, data?: TPayload) => void;
     useSub: <TName extends keyof T, TPayload_1 extends T[TName]>(event: TName, callback: (data: TPayload_1) => void) => () => void;