@i-novus/n2o-components 1.0.0

package/lib/inputs/InputMoney/InputMoney.d.ts

@@ -0,0 +1,101 @@
+import React from 'react';
+import { TBaseProps } from '../../types';
+import { PresetType } from '../InputMask/InputMask';
+declare type InputMoneyProps = TBaseProps & typeof defaultProps & {
+    allowDecimal?: boolean;
+    allowLeadingZeroes?: boolean;
+    allowNegative?: boolean;
+    decimalLimit?: number;
+    decimalSymbol?: string;
+    guide?: boolean;
+    includeThousandsSeparator?: boolean;
+    integerLimit?: number;
+    onBlur?(value: number | null): void;
+    onChange?(value: number | '-' | null): void;
+    prefix?: string;
+    suffix?: string;
+    t?(str?: string): string;
+    thousandsSeparatorSymbol?: string;
+    value?: string;
+};
+export declare const ReplaceableChar: {
+    readonly PREFIX: "prefix";
+    readonly SUFFIX: "suffix";
+    readonly THOUSANDS_SYMBOL: "thousandsSeparatorSymbol";
+    readonly DECIMAL_SYMBOL: "decimalSymbol";
+};
+declare const defaultProps: {
+    value: string;
+    includeThousandsSeparator: boolean;
+    thousandsSeparatorSymbol: string;
+    allowDecimal: boolean;
+    decimalSymbol: string;
+    decimalLimit: number;
+    integerLimit: number;
+    allowNegative: boolean;
+    allowLeadingZeroes: boolean;
+    guide: boolean;
+    t: (str: string) => string;
+};
+declare type State = {
+    value: string;
+};
+export declare class InputMoney extends React.Component<InputMoneyProps, State> {
+    constructor(props: InputMoneyProps);
+    componentDidUpdate(prevProps: InputMoneyProps): void;
+    onBlur(value: string): void;
+    convertToMoney(value: string): string;
+    convertToFloat(value: string): string;
+    onChange(value: string): void;
+    getInputMoneyProps(): {
+        preset: PresetType;
+        value: string;
+        onChange: (value: string) => void;
+        onBlur: (value: string) => void;
+        className: string;
+        presetConfig: {
+            suffix: string;
+            prefix: string | undefined;
+            includeThousandsSeparator: boolean;
+            thousandsSeparatorSymbol: string;
+            allowDecimal: boolean;
+            decimalSymbol: string;
+            decimalLimit: number;
+            integerLimit: number;
+            requireDecimal: boolean;
+            allowNegative: boolean;
+            allowLeadingZeroes: boolean;
+        };
+        disabled?: boolean | undefined;
+        style?: object | undefined;
+        visible?: boolean | undefined;
+        includeThousandsSeparator: boolean;
+        thousandsSeparatorSymbol: string;
+        allowDecimal: boolean;
+        decimalSymbol: string;
+        decimalLimit: number;
+        integerLimit: number;
+        allowNegative: boolean;
+        allowLeadingZeroes: boolean;
+        guide: boolean;
+        t: ((str: string) => string) & ((str?: string | undefined) => string);
+        prefix?: string | undefined;
+        suffix?: string | undefined;
+        children?: React.ReactNode;
+    };
+    render(): JSX.Element;
+    static defaultProps: {
+        value: string;
+        includeThousandsSeparator: boolean;
+        thousandsSeparatorSymbol: string;
+        allowDecimal: boolean;
+        decimalSymbol: string;
+        decimalLimit: number;
+        integerLimit: number;
+        allowNegative: boolean;
+        allowLeadingZeroes: boolean;
+        guide: boolean;
+        t: (str: string) => string;
+    };
+}
+export {};

package/lib/inputs/InputMoney/InputMoney.js

@@ -0,0 +1,258 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.InputMoney = exports.ReplaceableChar = void 0;
+
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+
+var _assertThisInitialized2 = _interopRequireDefault(require("@babel/runtime/helpers/assertThisInitialized"));
+
+var _inherits2 = _interopRequireDefault(require("@babel/runtime/helpers/inherits"));
+
+var _possibleConstructorReturn2 = _interopRequireDefault(require("@babel/runtime/helpers/possibleConstructorReturn"));
+
+var _getPrototypeOf2 = _interopRequireDefault(require("@babel/runtime/helpers/getPrototypeOf"));
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+var _react = _interopRequireDefault(require("react"));
+
+var _classnames = _interopRequireDefault(require("classnames"));
+
+var _isNaN = _interopRequireDefault(require("lodash/isNaN"));
+
+var _toNumber = _interopRequireDefault(require("lodash/toNumber"));
+
+var _isEqual = _interopRequireDefault(require("lodash/isEqual"));
+
+var _isNil = _interopRequireDefault(require("lodash/isNil"));
+
+var _forOwn = _interopRequireDefault(require("lodash/forOwn"));
+
+var _includes = _interopRequireDefault(require("lodash/includes"));
+
+var _last2 = _interopRequireDefault(require("lodash/last"));
+
+var _split = _interopRequireDefault(require("lodash/split"));
+
+var _replace = _interopRequireDefault(require("lodash/replace"));
+
+var _isUndefined = _interopRequireDefault(require("lodash/isUndefined"));
+
+var _InputMask = require("../InputMask/InputMask");
+
+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 _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { (0, _defineProperty2["default"])(target, key, source[key]); }); } else 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 _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = (0, _getPrototypeOf2["default"])(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = (0, _getPrototypeOf2["default"])(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return (0, _possibleConstructorReturn2["default"])(this, result); }; }
+
+function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
+
+var ReplaceableChar = {
+  PREFIX: 'prefix',
+  SUFFIX: 'suffix',
+  THOUSANDS_SYMBOL: 'thousandsSeparatorSymbol',
+  DECIMAL_SYMBOL: 'decimalSymbol'
+};
+exports.ReplaceableChar = ReplaceableChar;
+
+var replaceSpecialSymbol = function replaceSpecialSymbol(value, searchValue, replaceValue) {
+  return value.replace(searchValue, replaceValue);
+};
+
+var defaultProps = {
+  value: '',
+  includeThousandsSeparator: true,
+  thousandsSeparatorSymbol: ' ',
+  allowDecimal: true,
+  decimalSymbol: ',',
+  decimalLimit: 2,
+  integerLimit: 15,
+  allowNegative: false,
+  allowLeadingZeroes: false,
+  guide: false,
+  t: function t(str) {
+    return str;
+  }
+};
+
+var InputMoney = /*#__PURE__*/function (_React$Component) {
+  (0, _inherits2["default"])(InputMoney, _React$Component);
+
+  var _super = _createSuper(InputMoney);
+
+  function InputMoney(props) {
+    var _this;
+
+    (0, _classCallCheck2["default"])(this, InputMoney);
+    _this = _super.call(this, props);
+    _this.state = {
+      value: props.value
+    };
+    _this.onBlur = _this.onBlur.bind((0, _assertThisInitialized2["default"])(_this));
+    _this.onChange = _this.onChange.bind((0, _assertThisInitialized2["default"])(_this));
+    _this.convertToMoney = _this.convertToMoney.bind((0, _assertThisInitialized2["default"])(_this));
+    _this.convertToFloat = _this.convertToFloat.bind((0, _assertThisInitialized2["default"])(_this));
+    _this.getInputMoneyProps = _this.getInputMoneyProps.bind((0, _assertThisInitialized2["default"])(_this));
+    return _this;
+  }
+
+  (0, _createClass2["default"])(InputMoney, [{
+    key: "componentDidUpdate",
+    value: function componentDidUpdate(prevProps) {
+      var value = this.props.value;
+
+      if (!(0, _isEqual["default"])(prevProps.value, value)) {
+        this.setState({
+          value: value
+        });
+      }
+    }
+  }, {
+    key: "onBlur",
+    value: function onBlur(value) {
+      var onBlur = this.props.onBlur;
+      var convertedValue = parseFloat(this.convertToFloat(value));
+
+      if (onBlur) {
+        onBlur(!(0, _isNaN["default"])(convertedValue) ? convertedValue : null);
+      }
+
+      this.setState({
+        value: String(convertedValue)
+      });
+    }
+  }, {
+    key: "convertToMoney",
+    value: function convertToMoney(value) {
+      var _this$props = this.props,
+          allowDecimal = _this$props.allowDecimal,
+          DECIMAL_SYMBOL = _this$props[ReplaceableChar.DECIMAL_SYMBOL];
+
+      if (value !== '') {
+        value = (0, _replace["default"])(value, '.', DECIMAL_SYMBOL);
+      }
+
+      var splitBySymbol = (0, _split["default"])(value, DECIMAL_SYMBOL);
+
+      if (!allowDecimal) {
+        return splitBySymbol[0];
+      }
+
+      return value;
+    }
+  }, {
+    key: "convertToFloat",
+    value: function convertToFloat(value) {
+      var _this2 = this,
+          _last;
+
+      var _this$props2 = this.props,
+          allowDecimal = _this$props2.allowDecimal,
+          DECIMAL_SYMBOL = _this$props2[ReplaceableChar.DECIMAL_SYMBOL];
+      var convertedValue = value.toString();
+      (0, _forOwn["default"])(ReplaceableChar, function (_char) {
+        var replaceableChar = _this2.props[_char];
+
+        if (!(0, _isUndefined["default"])(replaceableChar)) {
+          var pattern = replaceableChar.replace(/[$()*+./?[\\\]^{|}-]/g, '\\$&');
+          var regExp = new RegExp(pattern, 'g');
+          var replaceableValue = _char === ReplaceableChar.DECIMAL_SYMBOL ? '.' : '';
+          convertedValue = replaceSpecialSymbol(convertedValue, regExp, replaceableValue);
+        }
+      });
+      var stateValue = this.state.value;
+
+      if (allowDecimal && (0, _includes["default"])(stateValue, '.') && !(0, _includes["default"])(value, DECIMAL_SYMBOL)) {
+        convertedValue = convertedValue.substring(0, convertedValue.length - 3);
+      }
+
+      if ((0, _includes["default"])(convertedValue, '.') && ((_last = (0, _last2["default"])((0, _split["default"])(convertedValue, '.'))) === null || _last === void 0 ? void 0 : _last.length) === 1) {
+        convertedValue += '0';
+      }
+
+      this.setState({
+        value: convertedValue
+      });
+      return convertedValue;
+    }
+  }, {
+    key: "onChange",
+    value: function onChange(value) {
+      var _this$props3 = this.props,
+          onChange = _this$props3.onChange,
+          allowNegative = _this$props3.allowNegative;
+
+      if ((0, _isNaN["default"])((0, _toNumber["default"])(value))) {
+        return;
+      }
+
+      var convertedValue = allowNegative && value === '-' || (0, _isNil["default"])(value) ? value : parseFloat(this.convertToFloat(value));
+
+      if (onChange) {
+        onChange(!(0, _isNaN["default"])(convertedValue) ? convertedValue : null);
+      }
+
+      this.setState({
+        value: String(convertedValue)
+      });
+    }
+  }, {
+    key: "getInputMoneyProps",
+    value: function getInputMoneyProps() {
+      var _this$props4 = this.props,
+          t = _this$props4.t,
+          value = _this$props4.value,
+          className = _this$props4.className,
+          _this$props4$suffix = _this$props4.suffix,
+          suffix = _this$props4$suffix === void 0 ? t('rub') : _this$props4$suffix,
+          prefix = _this$props4.prefix,
+          includeThousandsSeparator = _this$props4.includeThousandsSeparator,
+          thousandsSeparatorSymbol = _this$props4.thousandsSeparatorSymbol,
+          allowDecimal = _this$props4.allowDecimal,
+          decimalSymbol = _this$props4.decimalSymbol,
+          decimalLimit = _this$props4.decimalLimit,
+          integerLimit = _this$props4.integerLimit,
+          allowNegative = _this$props4.allowNegative,
+          allowLeadingZeroes = _this$props4.allowLeadingZeroes;
+      var stateValue = this.state.value;
+      return _objectSpread(_objectSpread({}, this.props), {}, {
+        preset: 'money',
+        value: this.convertToMoney(value || stateValue),
+        onChange: this.onChange,
+        onBlur: this.onBlur,
+        className: (0, _classnames["default"])('n2o-input-money', className),
+        presetConfig: {
+          suffix: suffix,
+          prefix: prefix,
+          includeThousandsSeparator: includeThousandsSeparator,
+          thousandsSeparatorSymbol: thousandsSeparatorSymbol,
+          allowDecimal: allowDecimal,
+          decimalSymbol: decimalSymbol,
+          decimalLimit: decimalLimit,
+          integerLimit: integerLimit,
+          requireDecimal: false,
+          allowNegative: allowNegative,
+          allowLeadingZeroes: allowLeadingZeroes
+        }
+      });
+    }
+  }, {
+    key: "render",
+    value: function render() {
+      return /*#__PURE__*/_react["default"].createElement(_InputMask.InputMask, this.getInputMoneyProps());
+    }
+  }]);
+  return InputMoney;
+}(_react["default"].Component);
+
+exports.InputMoney = InputMoney;
+(0, _defineProperty2["default"])(InputMoney, "defaultProps", defaultProps);
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../../src/inputs/InputMoney/InputMoney.tsx"],"names":["ReplaceableChar","PREFIX","SUFFIX","THOUSANDS_SYMBOL","DECIMAL_SYMBOL","replaceSpecialSymbol","value","searchValue","replaceValue","replace","defaultProps","includeThousandsSeparator","thousandsSeparatorSymbol","allowDecimal","decimalSymbol","decimalLimit","integerLimit","allowNegative","allowLeadingZeroes","guide","t","str","InputMoney","props","state","onBlur","bind","onChange","convertToMoney","convertToFloat","getInputMoneyProps","prevProps","setState","convertedValue","parseFloat","String","splitBySymbol","toString","char","replaceableChar","pattern","regExp","RegExp","replaceableValue","stateValue","substring","length","className","suffix","prefix","preset","presetConfig","requireDecimal","React","Component"],"mappings":"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","sourcesContent":["import React from 'react'\nimport cn from 'classnames'\nimport isNaN from 'lodash/isNaN'\nimport toNumber from 'lodash/toNumber'\nimport isEqual from 'lodash/isEqual'\nimport isNil from 'lodash/isNil'\nimport forOwn from 'lodash/forOwn'\nimport includes from 'lodash/includes'\nimport last from 'lodash/last'\nimport split from 'lodash/split'\nimport replace from 'lodash/replace'\nimport isUndefined from 'lodash/isUndefined'\n\nimport { TBaseProps } from '../../types'\nimport { InputMask, PresetType } from '../InputMask/InputMask'\n\ntype InputMoneyProps = TBaseProps & typeof defaultProps & {\n    allowDecimal?: boolean,\n    allowLeadingZeroes?: boolean,\n    allowNegative?: boolean,\n    decimalLimit?: number,\n    decimalSymbol?: string,\n    guide?: boolean,\n    includeThousandsSeparator?: boolean,\n    integerLimit?: number,\n    onBlur?(value: number | null): void,\n    onChange?(value: number | '-' | null): void,\n    prefix?: string,\n    suffix?: string,\n    t?(str?: string): string,\n    thousandsSeparatorSymbol?: string,\n    value?: string\n}\n\nexport const ReplaceableChar = {\n    PREFIX: 'prefix',\n    SUFFIX: 'suffix',\n    THOUSANDS_SYMBOL: 'thousandsSeparatorSymbol',\n    DECIMAL_SYMBOL: 'decimalSymbol',\n} as const\n\nconst replaceSpecialSymbol = (value: string, searchValue: RegExp | string, replaceValue: string) => (\n    value.replace(searchValue, replaceValue)\n)\n\nconst defaultProps = {\n    value: '',\n    includeThousandsSeparator: true,\n    thousandsSeparatorSymbol: ' ',\n    allowDecimal: true,\n    decimalSymbol: ',',\n    decimalLimit: 2,\n    integerLimit: 15,\n    allowNegative: false,\n    allowLeadingZeroes: false,\n    guide: false,\n    t: (str: string) => str,\n}\n\ntype State = {\n    value: string\n}\n\nexport class InputMoney extends React.Component<InputMoneyProps, State> {\n    constructor(props: InputMoneyProps) {\n        super(props)\n\n        this.state = {\n            value: props.value,\n        }\n\n        this.onBlur = this.onBlur.bind(this)\n        this.onChange = this.onChange.bind(this)\n        this.convertToMoney = this.convertToMoney.bind(this)\n        this.convertToFloat = this.convertToFloat.bind(this)\n        this.getInputMoneyProps = this.getInputMoneyProps.bind(this)\n    }\n\n    componentDidUpdate(prevProps: InputMoneyProps) {\n        const { value } = this.props\n\n        if (!isEqual(prevProps.value, value)) {\n            this.setState({ value })\n        }\n    }\n\n    onBlur(value: string) {\n        const { onBlur } = this.props\n        const convertedValue = parseFloat(this.convertToFloat(value))\n\n        if (onBlur) {\n            onBlur(!isNaN(convertedValue) ? convertedValue : null)\n        }\n        this.setState({ value: String(convertedValue) })\n    }\n\n    convertToMoney(value: string) {\n        const {\n            allowDecimal,\n            [ReplaceableChar.DECIMAL_SYMBOL]: DECIMAL_SYMBOL,\n        } = this.props\n\n        if (value !== '') {\n            value = replace(value, '.', DECIMAL_SYMBOL)\n        }\n\n        const splitBySymbol = split(value, DECIMAL_SYMBOL)\n\n        if (!allowDecimal) {\n            return splitBySymbol[0]\n        }\n\n        return value\n    }\n\n    convertToFloat(value: string) {\n        const {\n            allowDecimal,\n            [ReplaceableChar.DECIMAL_SYMBOL]: DECIMAL_SYMBOL,\n        } = this.props\n        let convertedValue = value.toString()\n\n        forOwn(ReplaceableChar, (char) => {\n            const { [char]: replaceableChar } = this.props\n\n            if (!isUndefined(replaceableChar)) {\n                const pattern = replaceableChar.replace(\n                    /[$()*+./?[\\\\\\]^{|}-]/g,\n                    '\\\\$&',\n                )\n                const regExp = new RegExp(pattern, 'g')\n                const replaceableValue = char === ReplaceableChar.DECIMAL_SYMBOL ? '.' : ''\n\n                convertedValue = replaceSpecialSymbol(\n                    convertedValue,\n                    regExp,\n                    replaceableValue,\n                )\n            }\n        })\n\n        const { value: stateValue } = this.state\n\n        if (\n            allowDecimal &&\n            includes(stateValue, '.') &&\n            !includes(value, DECIMAL_SYMBOL)\n        ) {\n            convertedValue = convertedValue.substring(0, convertedValue.length - 3)\n        }\n\n        if (\n            includes(convertedValue, '.') &&\n            last(split(convertedValue, '.'))?.length === 1\n        ) {\n            convertedValue += '0'\n        }\n\n        this.setState({ value: convertedValue })\n\n        return convertedValue\n    }\n\n    onChange(value: string) {\n        const { onChange, allowNegative } = this.props\n\n        if (isNaN(toNumber(value))) { return }\n\n        const convertedValue = (allowNegative && value === '-') || isNil(value)\n            ? value\n            : parseFloat(this.convertToFloat(value))\n\n        if (onChange) {\n            onChange(!isNaN(convertedValue) ? convertedValue : null)\n        }\n        this.setState({ value: String(convertedValue) })\n    }\n\n    getInputMoneyProps() {\n        const {\n            t,\n            value,\n            className,\n            suffix = t('rub'),\n            prefix,\n            includeThousandsSeparator,\n            thousandsSeparatorSymbol,\n            allowDecimal,\n            decimalSymbol,\n            decimalLimit,\n            integerLimit,\n            allowNegative,\n            allowLeadingZeroes,\n        } = this.props\n        const { value: stateValue } = this.state\n\n        return {\n            ...this.props,\n            preset: 'money' as PresetType,\n            value: this.convertToMoney(value || stateValue),\n            onChange: this.onChange,\n            onBlur: this.onBlur,\n            className: cn('n2o-input-money', className),\n            presetConfig: {\n                suffix,\n                prefix,\n                includeThousandsSeparator,\n                thousandsSeparatorSymbol,\n                allowDecimal,\n                decimalSymbol,\n                decimalLimit,\n                integerLimit,\n                requireDecimal: false,\n                allowNegative,\n                allowLeadingZeroes,\n            },\n        }\n    }\n\n    render() {\n        return <InputMask {...this.getInputMoneyProps()} />\n    }\n\n    static defaultProps = defaultProps\n}\n"]}

package/lib/inputs/InputNumber/InputNumber.d.ts

@@ -0,0 +1,29 @@
+import React, { KeyboardEvent } from 'react';
+import '../../styles/controls/InputNumber.scss';
+import { InputMode, InputNumberProps, InputNumberState, TInputNumberValue } from './types';
+export declare class InputNumberComponent extends React.Component<InputNumberProps, InputNumberState> {
+    stepPrecition: number;
+    input: HTMLDivElement | null;
+    constructor(props: InputNumberProps);
+    componentDidUpdate(prevProps: InputNumberProps): void;
+    resolveValue: (value: TInputNumberValue) => TInputNumberValue;
+    onChange: (value: TInputNumberValue) => void;
+    buttonHandler(type: string): void;
+    onBlur: () => void;
+    onKeyDown: (e: KeyboardEvent<HTMLInputElement>) => void;
+    render(): false | JSX.Element;
+}
+export declare const InputNumber: {
+    ({ measure, ...props }: import("../../types").TBaseProps & import("../../types").TBaseInputProps<TInputNumberValue> & {
+        max?: number | undefined;
+        min?: number | undefined;
+        mode?: InputMode | undefined;
+        onBlur?(value: TInputNumberValue): void;
+        precision?: number | undefined;
+        showButtons?: boolean | undefined;
+        step?: string | number | undefined;
+    } & {
+        measure?: string | undefined;
+    }): JSX.Element;
+    displayName: string;
+};