@fixefy/fixefy-ui-components 0.0.50 → 0.0.52

package/dist/FxAvatar/styles/avatar.styles.js

@@ -0,0 +1,192 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    AvatarGroup: function() {
+        return AvatarGroup;
+    },
+    AvatarWrapper: function() {
+        return AvatarWrapper;
+    },
+    EditIcon: function() {
+        return EditIcon;
+    },
+    FxTooltip: function() {
+        return FxTooltip;
+    },
+    StyledAvatar: function() {
+        return StyledAvatar;
+    },
+    StyledMoreAvatar: function() {
+        return StyledMoreAvatar;
+    }
+});
+const _jsxruntime = require("react/jsx-runtime");
+const _react = /*#__PURE__*/ _interop_require_default(require("react"));
+const _styles = require("@mui/material/styles");
+const _material = require("@mui/material");
+const _Tooltip = /*#__PURE__*/ _interop_require_default(require("@mui/material/Tooltip"));
+const _EditOutlined = /*#__PURE__*/ _interop_require_default(require("@mui/icons-material/EditOutlined"));
+function _define_property(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+function _object_spread(target) {
+    for(var i = 1; i < arguments.length; i++){
+        var source = arguments[i] != null ? arguments[i] : {};
+        var ownKeys = Object.keys(source);
+        if (typeof Object.getOwnPropertySymbols === "function") {
+            ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function(sym) {
+                return Object.getOwnPropertyDescriptor(source, sym).enumerable;
+            }));
+        }
+        ownKeys.forEach(function(key) {
+            _define_property(target, key, source[key]);
+        });
+    }
+    return target;
+}
+function ownKeys(object, enumerableOnly) {
+    var keys = Object.keys(object);
+    if (Object.getOwnPropertySymbols) {
+        var symbols = Object.getOwnPropertySymbols(object);
+        if (enumerableOnly) {
+            symbols = symbols.filter(function(sym) {
+                return Object.getOwnPropertyDescriptor(object, sym).enumerable;
+            });
+        }
+        keys.push.apply(keys, symbols);
+    }
+    return keys;
+}
+function _object_spread_props(target, source) {
+    source = source != null ? source : {};
+    if (Object.getOwnPropertyDescriptors) {
+        Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
+    } else {
+        ownKeys(Object(source)).forEach(function(key) {
+            Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
+        });
+    }
+    return target;
+}
+function _object_without_properties(source, excluded) {
+    if (source == null) return {};
+    var target = _object_without_properties_loose(source, excluded);
+    var key, i;
+    if (Object.getOwnPropertySymbols) {
+        var sourceSymbolKeys = Object.getOwnPropertySymbols(source);
+        for(i = 0; i < sourceSymbolKeys.length; i++){
+            key = sourceSymbolKeys[i];
+            if (excluded.indexOf(key) >= 0) continue;
+            if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue;
+            target[key] = source[key];
+        }
+    }
+    return target;
+}
+function _object_without_properties_loose(source, excluded) {
+    if (source == null) return {};
+    var target = {};
+    var sourceKeys = Object.keys(source);
+    var key, i;
+    for(i = 0; i < sourceKeys.length; i++){
+        key = sourceKeys[i];
+        if (excluded.indexOf(key) >= 0) continue;
+        target[key] = source[key];
+    }
+    return target;
+}
+const AvatarWrapper = (0, _styles.styled)("div")(()=>({
+        display: "flex",
+        alignItems: "center",
+        justifyContent: "space-between",
+        flexDirection: "row"
+    }));
+const AvatarGroup = (0, _styles.styled)("div")(()=>({
+        display: "flex",
+        alignItems: "center",
+        justifyContent: "space-between",
+        flexDirection: "row",
+        "&>:first-of-type": {
+            marginLeft: 0
+        }
+    }));
+const StyledAvatar = (0, _styles.styled)(_material.Avatar)(({ theme })=>({
+        width: 32,
+        height: 32,
+        border: `2px solid ${theme.palette.common.white}`,
+        marginLeft: "-8px",
+        fontFamily: "Open Sans",
+        fontStyle: "normal",
+        fontWeight: "normal",
+        fontSize: 14,
+        lineHeight: "20px",
+        letterSpacing: "0.15px"
+    }));
+const StyledMoreAvatar = (0, _styles.styled)(_material.Avatar)(({ theme })=>({
+        width: 32,
+        height: 32,
+        border: `2px solid ${theme.palette.common.white}`,
+        marginLeft: "-8px",
+        fontFamily: "Open Sans",
+        fontStyle: "normal",
+        fontWeight: "normal",
+        fontSize: 11,
+        lineHeight: "16px",
+        letterSpacing: "0.1px",
+        color: theme.palette.greyscale.dark,
+        backgroundColor: theme.palette.greyscale.light
+    }));
+const EditIcon = (0, _styles.styled)(_EditOutlined.default)(({ theme })=>({
+        cursor: "pointer",
+        color: theme.palette.primary.light
+    }));
+const FxTooltip = (0, _styles.styled)((_param)=>{
+    var { className } = _param, props = _object_without_properties(_param, [
+        "className"
+    ]);
+    return /*#__PURE__*/ (0, _jsxruntime.jsx)(_Tooltip.default, _object_spread_props(_object_spread({}, props), {
+        placement: "top",
+        arrow: true,
+        classes: {
+            popper: className
+        }
+    }));
+})(({ theme })=>({
+        [`& .${_material.tooltipClasses.arrow}`]: {
+            color: theme.palette.primary.main
+        },
+        [`& .${_material.tooltipClasses.tooltip}`]: {
+            backgroundColor: theme.palette.primary.main,
+            padding: 12,
+            fontFamily: "Open Sans",
+            fontStyle: "normal",
+            fontWeight: "normal",
+            fontSize: 14,
+            lineHeight: "20px",
+            textAlign: "center",
+            letterSpacing: "0.15px"
+        }
+    }));

package/dist/FxButton/FxButton.js

@@ -0,0 +1,106 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "FxButton", {
+    enumerable: true,
+    get: function() {
+        return FxButton;
+    }
+});
+const _jsxruntime = require("react/jsx-runtime");
+const _react = /*#__PURE__*/ _interop_require_default(require("react"));
+const _buttonstyles = require("./styles/button.styles");
+function _define_property(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+function _object_spread(target) {
+    for(var i = 1; i < arguments.length; i++){
+        var source = arguments[i] != null ? arguments[i] : {};
+        var ownKeys = Object.keys(source);
+        if (typeof Object.getOwnPropertySymbols === "function") {
+            ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function(sym) {
+                return Object.getOwnPropertyDescriptor(source, sym).enumerable;
+            }));
+        }
+        ownKeys.forEach(function(key) {
+            _define_property(target, key, source[key]);
+        });
+    }
+    return target;
+}
+function ownKeys(object, enumerableOnly) {
+    var keys = Object.keys(object);
+    if (Object.getOwnPropertySymbols) {
+        var symbols = Object.getOwnPropertySymbols(object);
+        if (enumerableOnly) {
+            symbols = symbols.filter(function(sym) {
+                return Object.getOwnPropertyDescriptor(object, sym).enumerable;
+            });
+        }
+        keys.push.apply(keys, symbols);
+    }
+    return keys;
+}
+function _object_spread_props(target, source) {
+    source = source != null ? source : {};
+    if (Object.getOwnPropertyDescriptors) {
+        Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
+    } else {
+        ownKeys(Object(source)).forEach(function(key) {
+            Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
+        });
+    }
+    return target;
+}
+function _object_without_properties(source, excluded) {
+    if (source == null) return {};
+    var target = _object_without_properties_loose(source, excluded);
+    var key, i;
+    if (Object.getOwnPropertySymbols) {
+        var sourceSymbolKeys = Object.getOwnPropertySymbols(source);
+        for(i = 0; i < sourceSymbolKeys.length; i++){
+            key = sourceSymbolKeys[i];
+            if (excluded.indexOf(key) >= 0) continue;
+            if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue;
+            target[key] = source[key];
+        }
+    }
+    return target;
+}
+function _object_without_properties_loose(source, excluded) {
+    if (source == null) return {};
+    var target = {};
+    var sourceKeys = Object.keys(source);
+    var key, i;
+    for(i = 0; i < sourceKeys.length; i++){
+        key = sourceKeys[i];
+        if (excluded.indexOf(key) >= 0) continue;
+        target[key] = source[key];
+    }
+    return target;
+}
+function FxButton(_param) {
+    var { type = 'primary', children } = _param, rest = _object_without_properties(_param, [
+        "type",
+        "children"
+    ]);
+    return /*#__PURE__*/ (0, _jsxruntime.jsx)(_buttonstyles.ButtonStyled, _object_spread_props(_object_spread({}, rest), {
+        children: children
+    }));
+}

package/dist/FxButton/index.d.ts

@@ -0,0 +1 @@
+export { FxButton, ButtonPropsType } from './FxButton';

package/dist/FxButton/index.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    ButtonPropsType: function() {
+        return _FxButton.ButtonPropsType;
+    },
+    FxButton: function() {
+        return _FxButton.FxButton;
+    }
+});
+const _FxButton = require("./FxButton");

package/dist/FxButton/styles/button.styles.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "ButtonStyled", {
+    enumerable: true,
+    get: function() {
+        return ButtonStyled;
+    }
+});
+const _material = require("@mui/material");
+const _styles = require("@mui/material/styles");
+const ButtonStyled = (0, _styles.styled)(_material.Button)(({ theme, variant })=>{
+    const border = variant === 'text' ? `0px solid #0000` : `1px solid ${theme.palette.primary.main}`;
+    return {
+        border,
+        minHeight: '40px',
+        borderRadius: '100px',
+        minWidth: '87px',
+        fontSize: '12px',
+        letterSpacing: '0.5px'
+    };
+});

package/dist/FxChip/FxChip.d.ts

@@ -0,0 +1,18 @@
+import React from 'react';
+import { EntityStatusType, ChargeStateType, InvoiceStateType, RecoStateType } from '@fixefy/fixefy-ui-utils';
+type ChipType = {
+    score: string;
+    status: EntityStatusType | ChargeStateType | InvoiceStateType | RecoStateType;
+};
+export interface ChipPropsType {
+    status?: EntityStatusType | ChargeStateType | InvoiceStateType | RecoStateType;
+    label: string | number;
+    variant?: 'outlined' | 'filled';
+    type?: ChipType;
+    scoreValue?: number;
+    minimized?: boolean;
+    [x: string]: any;
+    onClick?: (e: any) => void;
+}
+export declare const FxChip: (props: ChipPropsType) => React.JSX.Element;
+export {};

package/dist/FxChip/FxChip.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "FxChip", {
+    enumerable: true,
+    get: function() {
+        return FxChip;
+    }
+});
+const _jsxruntime = require("react/jsx-runtime");
+const _react = /*#__PURE__*/ _interop_require_default(require("react"));
+const _fixefyuiutils = require("@fixefy/fixefy-ui-utils");
+const _chipstyles = require("./styles/chip.styles");
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+const FxChip = (props)=>{
+    const { status, label, type = 'status', scoreValue = 0, minimized = false, variant = 'outlined', onClick } = props;
+    const newStatus = status ? status.split(' ').join('_') : status;
+    const value = typeof label === 'number' ? label.toFixed(2) : label;
+    return type === 'status' ? /*#__PURE__*/ (0, _jsxruntime.jsx)(_chipstyles.StatusChipStyled, {
+        status: newStatus,
+        label: (0, _fixefyuiutils.titleCase)(value),
+        variant: variant,
+        onClick: onClick
+    }) : /*#__PURE__*/ (0, _jsxruntime.jsx)(_chipstyles.ScoreChipStyled, {
+        score: scoreValue,
+        scoreLabel: (0, _fixefyuiutils.getScoreColor)(scoreValue),
+        label: (0, _fixefyuiutils.titleCase)(value),
+        minimized: minimized,
+        variant: variant,
+        onClick: onClick
+    });
+};

package/dist/FxChip/index.d.ts

@@ -0,0 +1 @@
+export { FxChip, ChipPropsType } from './FxChip';

package/dist/FxChip/index.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    ChipPropsType: function() {
+        return _FxChip.ChipPropsType;
+    },
+    FxChip: function() {
+        return _FxChip.FxChip;
+    }
+});
+const _FxChip = require("./FxChip");

package/{dist-cjs → dist}/FxChip/styles/chip.styles.d.ts

@@ -1,3 +1,2 @@
-import '@fixefy/fixefy-ui-utils';
 export declare const ScoreChipStyled: StyledComponent<ComponentProps & AdditionalProps, SpecificComponentProps, JSXProps>;
 export declare const StatusChipStyled: StyledComponent<ComponentProps & AdditionalProps, SpecificComponentProps, JSXProps>;

package/{dist-cjs → dist}/FxChip/styles/chip.styles.js

@@ -1,10 +1,24 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.StatusChipStyled = exports.ScoreChipStyled = void 0;
-const material_1 = require("@mui/material");
-const styles_1 = require("@mui/material/styles");
-require("@fixefy/fixefy-ui-utils");
-exports.ScoreChipStyled = (0, styles_1.styled)(material_1.Chip)(({ theme, scoreLabel, minimized }) => {
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    ScoreChipStyled: function() {
+        return ScoreChipStyled;
+    },
+    StatusChipStyled: function() {
+        return StatusChipStyled;
+    }
+});
+const _material = require("@mui/material");
+const _styles = require("@mui/material/styles");
+const ScoreChipStyled = (0, _styles.styled)(_material.Chip)(({ theme, scoreLabel, minimized })=>{
     const color = theme.palette.score[scoreLabel];
     return {
         height: 20,
@@ -16,18 +30,17 @@ exports.ScoreChipStyled = (0, styles_1.styled)(material_1.Chip)(({ theme, scoreL
             fontSize: 9,
             fontWeight: 600,
             paddingLeft: minimized ? 0 : 'inherit',
-            paddingRight: minimized ? 0 : 'inherit',
-        },
+            paddingRight: minimized ? 0 : 'inherit'
+        }
     };
 });
-exports.StatusChipStyled = (0, styles_1.styled)(material_1.Chip)(({ theme, status, variant }) => {
+const StatusChipStyled = (0, _styles.styled)(_material.Chip)(({ theme, status, variant })=>{
     let backgroundColor, border, labelColor;
     if (theme.palette.status[status]) {
         if (variant === 'filled') {
             backgroundColor = theme.palette.status[status]['border'];
             labelColor = theme.palette.common.white;
-        }
-        else {
+        } else {
             backgroundColor = theme.palette.status[status]['background'];
         }
         border = theme.palette.status[status]['border'];
@@ -40,10 +53,9 @@ exports.StatusChipStyled = (0, styles_1.styled)(material_1.Chip)(({ theme, statu
             fontSize: 9,
             fontWeight: 600,
             lineHeight: '12px',
-            color: labelColor ? labelColor : theme.palette.statistics.label,
+            color: labelColor ? labelColor : theme.palette.statistics.label
         },
         backgroundColor,
-        border: `1px solid ${border}`,
+        border: `1px solid ${border}`
     };
 });
-//# sourceMappingURL=chip.styles.js.map

package/dist/FxIcon/FxIcon.d.ts

@@ -0,0 +1,11 @@
+export type IconPropsType = {
+    className?: string;
+    color?: unknown;
+    fontSize?: string | number;
+    height?: `${number}` | number;
+    icon: string;
+    sx?: any;
+    root: string;
+    width?: `${number}` | number;
+};
+export declare const FxIcon: ({ className, color, fontSize, icon, height, sx, width }: IconPropsType) => JSX.Element;

package/dist/FxIcon/FxIcon.js

@@ -0,0 +1,147 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "FxIcon", {
+    enumerable: true,
+    get: function() {
+        return FxIcon;
+    }
+});
+const _jsxruntime = require("react/jsx-runtime");
+const _react = /*#__PURE__*/ _interop_require_default(require("react"));
+const _content = require("./content");
+const _fixefyuiutils = require("@fixefy/fixefy-ui-utils");
+const _iconsmaterial = /*#__PURE__*/ _interop_require_wildcard(require("@mui/icons-material"));
+function _define_property(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+function _getRequireWildcardCache(nodeInterop) {
+    if (typeof WeakMap !== "function") return null;
+    var cacheBabelInterop = new WeakMap();
+    var cacheNodeInterop = new WeakMap();
+    return (_getRequireWildcardCache = function(nodeInterop) {
+        return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
+    })(nodeInterop);
+}
+function _interop_require_wildcard(obj, nodeInterop) {
+    if (!nodeInterop && obj && obj.__esModule) {
+        return obj;
+    }
+    if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
+        return {
+            default: obj
+        };
+    }
+    var cache = _getRequireWildcardCache(nodeInterop);
+    if (cache && cache.has(obj)) {
+        return cache.get(obj);
+    }
+    var newObj = {
+        __proto__: null
+    };
+    var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
+    for(var key in obj){
+        if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
+            var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
+            if (desc && (desc.get || desc.set)) {
+                Object.defineProperty(newObj, key, desc);
+            } else {
+                newObj[key] = obj[key];
+            }
+        }
+    }
+    newObj.default = obj;
+    if (cache) {
+        cache.set(obj, newObj);
+    }
+    return newObj;
+}
+function _object_spread(target) {
+    for(var i = 1; i < arguments.length; i++){
+        var source = arguments[i] != null ? arguments[i] : {};
+        var ownKeys = Object.keys(source);
+        if (typeof Object.getOwnPropertySymbols === "function") {
+            ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function(sym) {
+                return Object.getOwnPropertyDescriptor(source, sym).enumerable;
+            }));
+        }
+        ownKeys.forEach(function(key) {
+            _define_property(target, key, source[key]);
+        });
+    }
+    return target;
+}
+function ownKeys(object, enumerableOnly) {
+    var keys = Object.keys(object);
+    if (Object.getOwnPropertySymbols) {
+        var symbols = Object.getOwnPropertySymbols(object);
+        if (enumerableOnly) {
+            symbols = symbols.filter(function(sym) {
+                return Object.getOwnPropertyDescriptor(object, sym).enumerable;
+            });
+        }
+        keys.push.apply(keys, symbols);
+    }
+    return keys;
+}
+function _object_spread_props(target, source) {
+    source = source != null ? source : {};
+    if (Object.getOwnPropertyDescriptors) {
+        Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
+    } else {
+        ownKeys(Object(source)).forEach(function(key) {
+            Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
+        });
+    }
+    return target;
+}
+// importing all the local icons - in the future should be removed to CDN server
+const iconsModule = [];
+const FxIcon = ({ className, color, fontSize, icon, height, sx, width })=>{
+    if (!icon) throw Error('Provide a property `icon`');
+    let rv;
+    const splittedPath = icon.split('/');
+    const iconWithoutPath = (0, _fixefyuiutils.toPascalCase)(splittedPath[splittedPath.length - 1]);
+    // const name = toPascalCase(icon)
+    if (iconsModule[iconWithoutPath]) {
+        rv = /*#__PURE__*/ (0, _jsxruntime.jsx)(_content.DynamicIcon, {
+            icon: iconsModule[iconWithoutPath],
+            sx: sx
+        });
+    // @ts-ignore
+    } else if (_iconsmaterial[iconWithoutPath]) {
+        // @ts-ignore
+        const MUIIcon = _iconsmaterial[iconWithoutPath];
+        rv = /*#__PURE__*/ (0, _jsxruntime.jsx)(MUIIcon, {
+            className: className,
+            color: color,
+            sx: _object_spread_props(_object_spread({}, sx), {
+                fontSize
+            })
+        });
+    } else {
+        rv = /*#__PURE__*/ (0, _jsxruntime.jsx)(_content.LazyIcon, {
+            icon: icon,
+            sx: sx,
+            width: width,
+            height: height
+        });
+    }
+    return rv;
+};

package/dist/FxIcon/content/dynamic_icon.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "DynamicIcon", {
+    enumerable: true,
+    get: function() {
+        return DynamicIcon;
+    }
+});
+const _jsxruntime = require("react/jsx-runtime");
+const _react = /*#__PURE__*/ _interop_require_default(require("react"));
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+const DynamicIcon = ({ icon: IconComponent, sx })=>IconComponent ? /*#__PURE__*/ (0, _jsxruntime.jsx)(IconComponent, {
+        sx: sx
+    }) : null;