@mgdis/mg-components 3.1.0

package/dist/collection/components/molecules/inputs/mg-input-numeric/mg-input-numeric.js

@@ -0,0 +1,633 @@
+import { Component, Element, Event, h, Prop, State, Watch } from '@stencil/core';
+import { MgInput } from '../MgInput';
+import { types, InputError } from './mg-input-numeric.conf';
+import { createID, ClassList } from '../../../../utils/components.utils';
+import { messages } from '../../../../locales';
+import { localeCurrency, localeNumber } from '../../../../utils/locale.utils';
+import { InputClass } from '../MgInput.conf';
+export class MgInputNumeric {
+  constructor() {
+    // Classes
+    this.classError = InputClass.ERROR;
+    /**
+     * Identifier is used for the element ID (id is a reserved prop in Stencil.js)
+     * If not set, it will be created.
+     */
+    this.identifier = createID('mg-input-numeric');
+    /**
+     * Input name
+     * If not set the value equals the identifier
+     */
+    this.name = this.identifier;
+    /**
+     * Define if label is visible
+     */
+    this.labelHide = false;
+    /**
+     * Define if input is required
+     */
+    this.required = false;
+    /**
+     * Define if input is readonly
+     */
+    this.readonly = false;
+    /**
+     * Define if input is disabled
+     */
+    this.disabled = false;
+    /**
+     * Define numeric type
+     */
+    this.type = types[0];
+    /**
+     * Override integer length
+     * integer is the number before the decimal point
+     */
+    this.integerLength = 13;
+    /**
+     * Override decimal length
+     * decimal is the number after the decimal point
+     */
+    this.decimalLength = 2;
+    /**
+     * Component classes
+     */
+    this.classList = new ClassList(['mg-input--numeric']);
+    /**
+     * Handle input event
+     */
+    this.handleInput = () => {
+      // Check validity
+      this.checkValidity();
+      this.value = this.input.value;
+    };
+    /**
+     * Handle focus event
+     */
+    this.handleFocus = () => {
+      this.displayValue = this.value;
+    };
+    /**
+     * Handle blur event
+     */
+    this.handleBlur = () => {
+      // Check validity
+      this.checkValidity();
+      this.checkError();
+      // Display readonly value
+      this.displayValue = this.readonlyValue;
+    };
+    /**
+     * get input error code
+     * @returns {null | InputError}
+     */
+    this.getInputError = () => {
+      let inputError = null;
+      if (this.input === undefined)
+        return inputError;
+      // required
+      if (!this.input.checkValidity() && this.input.validity.valueMissing) {
+        inputError = InputError.REQUIRED;
+      }
+      // Min & Max
+      if (this.min !== undefined && this.numericValue < this.min && this.max === undefined) {
+        // Only a min value is set
+        inputError = InputError.MIN;
+      }
+      else if (this.max !== undefined && this.numericValue > this.max && this.min === undefined) {
+        // Only a max value is set
+        inputError = InputError.MAX;
+      }
+      else if ((this.min !== undefined && this.numericValue < this.min) || (this.max !== undefined && this.numericValue > this.max)) {
+        // both min and max values are set
+        inputError = InputError.MINMAX;
+      }
+      return inputError;
+    };
+    /**
+     * Format value based on type
+     * @param value {number}
+     * @returns {string} formated local value
+     */
+    this.formatValue = (value) => (this.type === 'currency' ? localeCurrency(value) : localeNumber(value));
+  }
+  validateValue(newValue) {
+    if (newValue !== undefined && newValue !== null) {
+      // Split number and decimal
+      const [integer, decimal = ''] = newValue.replace('-', '').split(/[\.,]/);
+      // Regex
+      const regex = this.type === 'integer' ? /^[\-]?\d+$/ : /^[\-]?\d+[.,]?\d*$/;
+      // Filter input
+      if (newValue === '' || (newValue.match(regex) && integer.length <= this.integerLength && decimal.length <= (this.type === 'integer' ? 0 : this.decimalLength))) {
+        this.storedValue = newValue;
+      }
+      else if (this.storedValue !== undefined) {
+        newValue = this.storedValue;
+      }
+      else {
+        newValue = null;
+      }
+      // Set value and input value
+      this.value = newValue;
+      if (this.input !== undefined)
+        this.input.value = this.value;
+      // emit numeric value
+      this.numericValue = this.value !== '' && this.value !== null ? parseFloat(this.value.replace(',', '.')) : null;
+      this.valueChange.emit(this.numericValue);
+      // Set readOnlyValue
+      this.readonlyValue = this.numericValue !== null ? this.formatValue(this.numericValue) : '';
+    }
+  }
+  validateType(newValue) {
+    if (!types.includes(newValue)) {
+      throw new Error(`<mg-input-numeric> prop "type" must be one of : ${types.join(', ')}`);
+    }
+    this.classList.add(`mg-input--numeric--${this.type}`);
+  }
+  validateIntegerLength(newValue) {
+    if (newValue < 1) {
+      throw new Error(`<mg-input-numeric> prop "integer-length" must be a positive number.`);
+    }
+  }
+  validateDecimalLength(newValue) {
+    if (newValue < 1) {
+      throw new Error(`<mg-input-numeric> prop "decimal-length" must be a positive number, consider using prop "type" to "integer" instead.`);
+    }
+  }
+  /**
+   * Check if input is valid
+   */
+  checkValidity() {
+    if (!this.readonly) {
+      const validity = this.getInputError() === null;
+      // Set validity
+      this.valid = validity;
+      this.invalid = !validity;
+    }
+  }
+  /**
+   * Set error message
+   */
+  setErrorMessage() {
+    const inputError = this.getInputError();
+    if (inputError === InputError.REQUIRED) {
+      this.errorMessage = messages.errors[inputError];
+    }
+    else {
+      this.errorMessage = messages.errors.numeric[inputError].replace('{min}', `${this.formatValue(this.min)}`).replace('{max}', `${this.formatValue(this.max)}`);
+    }
+  }
+  /**
+   * Check input errors
+   */
+  checkError() {
+    // Set error message
+    this.errorMessage = undefined;
+    // Update class
+    if (!this.valid) {
+      this.setErrorMessage();
+      this.classList.add(this.classError);
+    }
+    else {
+      this.classList.delete(this.classError);
+    }
+  }
+  /**
+   * Validate append slot
+   */
+  validateAppendSlot() {
+    const slotAppendInput = this.element.querySelector('[slot="append-input"]');
+    if (slotAppendInput !== null && slotAppendInput.querySelector('.mg-button') !== null) {
+      this.classList.add('mg-input--is-input-group-append');
+      this.classList = new ClassList(this.classList.classes);
+    }
+    else if (slotAppendInput !== null) {
+      this.classList.add('mg-input--is-append-input-slot-content');
+      this.classList = new ClassList(this.classList.classes);
+    }
+  }
+  /*************
+   * Lifecycle *
+   *************/
+  componentWillLoad() {
+    this.validateValue(this.value);
+    // Set displayed value
+    this.displayValue = this.readonlyValue;
+    this.validateType(this.type);
+    this.validateIntegerLength(this.integerLength);
+    this.validateDecimalLength(this.decimalLength);
+    // return a promise to process action only in the FIRST render().
+    // https://stenciljs.com/docs/component-lifecycle#componentwillload
+    return setTimeout(() => this.checkValidity(), 0);
+  }
+  componentDidLoad() {
+    this.validateAppendSlot();
+  }
+  /**
+   * Check if component props are well configured on init
+   */
+  render() {
+    return (h(MgInput, { identifier: this.identifier, classList: this.classList, label: this.label, labelOnTop: this.labelOnTop, labelHide: this.labelHide, required: this.required, readonly: this.readonly, width: this.width, disabled: this.disabled, value: this.value, readonlyValue: this.readonlyValue, tooltip: this.tooltip, displayCharacterLeft: undefined, characterLeftTemplate: undefined, maxlength: undefined, helpText: this.helpText, errorMessage: this.errorMessage, isFieldset: false },
+      h("input", { type: "text", class: "mg-input__box", value: this.displayValue, id: this.identifier, name: this.name, placeholder: this.placeholder, title: this.placeholder, disabled: this.disabled, required: this.required, onInput: this.handleInput, onFocus: this.handleFocus, onBlur: this.handleBlur, ref: el => (this.input = el) }),
+      h("slot", { name: "append-input" })));
+  }
+  static get is() { return "mg-input-numeric"; }
+  static get encapsulation() { return "shadow"; }
+  static get originalStyleUrls() { return {
+    "$": ["mg-input-numeric.scss"]
+  }; }
+  static get styleUrls() { return {
+    "$": ["mg-input-numeric.css"]
+  }; }
+  static get properties() { return {
+    "value": {
+      "type": "string",
+      "mutable": true,
+      "complexType": {
+        "original": "string",
+        "resolved": "string",
+        "references": {}
+      },
+      "required": false,
+      "optional": false,
+      "docs": {
+        "tags": [],
+        "text": "Component value"
+      },
+      "attribute": "value",
+      "reflect": true
+    },
+    "identifier": {
+      "type": "string",
+      "mutable": false,
+      "complexType": {
+        "original": "string",
+        "resolved": "string",
+        "references": {}
+      },
+      "required": false,
+      "optional": true,
+      "docs": {
+        "tags": [],
+        "text": "Identifier is used for the element ID (id is a reserved prop in Stencil.js)\nIf not set, it will be created."
+      },
+      "attribute": "identifier",
+      "reflect": false,
+      "defaultValue": "createID('mg-input-numeric')"
+    },
+    "name": {
+      "type": "string",
+      "mutable": false,
+      "complexType": {
+        "original": "string",
+        "resolved": "string",
+        "references": {}
+      },
+      "required": false,
+      "optional": true,
+      "docs": {
+        "tags": [],
+        "text": "Input name\nIf not set the value equals the identifier"
+      },
+      "attribute": "name",
+      "reflect": false,
+      "defaultValue": "this.identifier"
+    },
+    "label": {
+      "type": "string",
+      "mutable": false,
+      "complexType": {
+        "original": "string",
+        "resolved": "string",
+        "references": {}
+      },
+      "required": true,
+      "optional": false,
+      "docs": {
+        "tags": [],
+        "text": "Input label\nRequired"
+      },
+      "attribute": "label",
+      "reflect": false
+    },
+    "labelOnTop": {
+      "type": "boolean",
+      "mutable": false,
+      "complexType": {
+        "original": "boolean",
+        "resolved": "boolean",
+        "references": {}
+      },
+      "required": false,
+      "optional": false,
+      "docs": {
+        "tags": [],
+        "text": "Define if label is displayed on top"
+      },
+      "attribute": "label-on-top",
+      "reflect": false
+    },
+    "labelHide": {
+      "type": "boolean",
+      "mutable": false,
+      "complexType": {
+        "original": "boolean",
+        "resolved": "boolean",
+        "references": {}
+      },
+      "required": false,
+      "optional": false,
+      "docs": {
+        "tags": [],
+        "text": "Define if label is visible"
+      },
+      "attribute": "label-hide",
+      "reflect": false,
+      "defaultValue": "false"
+    },
+    "placeholder": {
+      "type": "string",
+      "mutable": false,
+      "complexType": {
+        "original": "string",
+        "resolved": "string",
+        "references": {}
+      },
+      "required": false,
+      "optional": false,
+      "docs": {
+        "tags": [],
+        "text": "Input placeholder.\nIt should be a word or short phrase that demonstrates the expected type of data, not a replacement for labels or help text."
+      },
+      "attribute": "placeholder",
+      "reflect": false
+    },
+    "required": {
+      "type": "boolean",
+      "mutable": false,
+      "complexType": {
+        "original": "boolean",
+        "resolved": "boolean",
+        "references": {}
+      },
+      "required": false,
+      "optional": false,
+      "docs": {
+        "tags": [],
+        "text": "Define if input is required"
+      },
+      "attribute": "required",
+      "reflect": false,
+      "defaultValue": "false"
+    },
+    "readonly": {
+      "type": "boolean",
+      "mutable": false,
+      "complexType": {
+        "original": "boolean",
+        "resolved": "boolean",
+        "references": {}
+      },
+      "required": false,
+      "optional": false,
+      "docs": {
+        "tags": [],
+        "text": "Define if input is readonly"
+      },
+      "attribute": "readonly",
+      "reflect": false,
+      "defaultValue": "false"
+    },
+    "disabled": {
+      "type": "boolean",
+      "mutable": false,
+      "complexType": {
+        "original": "boolean",
+        "resolved": "boolean",
+        "references": {}
+      },
+      "required": false,
+      "optional": false,
+      "docs": {
+        "tags": [],
+        "text": "Define if input is disabled"
+      },
+      "attribute": "disabled",
+      "reflect": false,
+      "defaultValue": "false"
+    },
+    "width": {
+      "type": "any",
+      "mutable": false,
+      "complexType": {
+        "original": "Width",
+        "resolved": "\"full\" | 16 | 2 | 4",
+        "references": {
+          "Width": {
+            "location": "import",
+            "path": "../MgInput.conf"
+          }
+        }
+      },
+      "required": false,
+      "optional": false,
+      "docs": {
+        "tags": [],
+        "text": "Define input width"
+      },
+      "attribute": "width",
+      "reflect": false
+    },
+    "tooltip": {
+      "type": "string",
+      "mutable": false,
+      "complexType": {
+        "original": "string",
+        "resolved": "string",
+        "references": {}
+      },
+      "required": false,
+      "optional": false,
+      "docs": {
+        "tags": [],
+        "text": "Add a tooltip message next to the input"
+      },
+      "attribute": "tooltip",
+      "reflect": false
+    },
+    "helpText": {
+      "type": "string",
+      "mutable": false,
+      "complexType": {
+        "original": "string",
+        "resolved": "string",
+        "references": {}
+      },
+      "required": false,
+      "optional": false,
+      "docs": {
+        "tags": [],
+        "text": "Add a help text under the input, usually expected data format and example"
+      },
+      "attribute": "help-text",
+      "reflect": false
+    },
+    "type": {
+      "type": "string",
+      "mutable": false,
+      "complexType": {
+        "original": "string",
+        "resolved": "string",
+        "references": {}
+      },
+      "required": false,
+      "optional": false,
+      "docs": {
+        "tags": [],
+        "text": "Define numeric type"
+      },
+      "attribute": "type",
+      "reflect": false,
+      "defaultValue": "types[0]"
+    },
+    "max": {
+      "type": "number",
+      "mutable": false,
+      "complexType": {
+        "original": "number",
+        "resolved": "number",
+        "references": {}
+      },
+      "required": false,
+      "optional": false,
+      "docs": {
+        "tags": [],
+        "text": "Maximum value"
+      },
+      "attribute": "max",
+      "reflect": false
+    },
+    "min": {
+      "type": "number",
+      "mutable": false,
+      "complexType": {
+        "original": "number",
+        "resolved": "number",
+        "references": {}
+      },
+      "required": false,
+      "optional": false,
+      "docs": {
+        "tags": [],
+        "text": "Minimum value"
+      },
+      "attribute": "min",
+      "reflect": false
+    },
+    "integerLength": {
+      "type": "number",
+      "mutable": false,
+      "complexType": {
+        "original": "number",
+        "resolved": "number",
+        "references": {}
+      },
+      "required": false,
+      "optional": false,
+      "docs": {
+        "tags": [],
+        "text": "Override integer length\ninteger is the number before the decimal point"
+      },
+      "attribute": "integer-length",
+      "reflect": false,
+      "defaultValue": "13"
+    },
+    "decimalLength": {
+      "type": "number",
+      "mutable": false,
+      "complexType": {
+        "original": "number",
+        "resolved": "number",
+        "references": {}
+      },
+      "required": false,
+      "optional": false,
+      "docs": {
+        "tags": [],
+        "text": "Override decimal length\ndecimal is the number after the decimal point"
+      },
+      "attribute": "decimal-length",
+      "reflect": false,
+      "defaultValue": "2"
+    },
+    "valid": {
+      "type": "boolean",
+      "mutable": true,
+      "complexType": {
+        "original": "boolean",
+        "resolved": "boolean",
+        "references": {}
+      },
+      "required": false,
+      "optional": false,
+      "docs": {
+        "tags": [],
+        "text": "Define input pattern to validate"
+      },
+      "attribute": "valid",
+      "reflect": false
+    },
+    "invalid": {
+      "type": "boolean",
+      "mutable": true,
+      "complexType": {
+        "original": "boolean",
+        "resolved": "boolean",
+        "references": {}
+      },
+      "required": false,
+      "optional": false,
+      "docs": {
+        "tags": [],
+        "text": "Define input pattern error message"
+      },
+      "attribute": "invalid",
+      "reflect": false
+    }
+  }; }
+  static get states() { return {
+    "classList": {},
+    "errorMessage": {},
+    "displayValue": {}
+  }; }
+  static get events() { return [{
+      "method": "valueChange",
+      "name": "value-change",
+      "bubbles": true,
+      "cancelable": true,
+      "composed": true,
+      "docs": {
+        "tags": [],
+        "text": "Emmited event when value change"
+      },
+      "complexType": {
+        "original": "number",
+        "resolved": "number",
+        "references": {}
+      }
+    }]; }
+  static get elementRef() { return "element"; }
+  static get watchers() { return [{
+      "propName": "value",
+      "methodName": "validateValue"
+    }, {
+      "propName": "type",
+      "methodName": "validateType"
+    }, {
+      "propName": "integerLength",
+      "methodName": "validateIntegerLength"
+    }, {
+      "propName": "decimalLength",
+      "methodName": "validateDecimalLength"
+    }]; }
+}

package/dist/collection/components/molecules/inputs/mg-input-numeric/mg-input-numeric.stories.js

@@ -0,0 +1,68 @@
+import { h } from '@stencil/core';
+import { types } from './mg-input-numeric.conf';
+export default {
+  component: 'mg-input-numeric',
+  title: 'Molecules/Inputs/mg-input-numeric',
+  argTypes: {
+    type: {
+      options: types,
+      control: { type: 'select' },
+    },
+  },
+};
+/**
+ * 1. camelCase arguments must be written in the template, for exemple labelOnTop must be placed in the template as label-on-top={args.labelOnTop}
+ * 2. boolean arguments with a default true value must be added like display-character-left={args.displayCharacterLeft ? 'true' : 'false'}
+ */
+const Template = args => {
+  const labelOnTop = args.labelOnTop;
+  delete args.labelOnTop;
+  const labelHide = args.labelHide;
+  delete args.labelHide;
+  const helpText = args.helpText;
+  delete args.helpText;
+  // return element
+  return h("mg-input-numeric", Object.assign({}, args, { "label-on-top": labelOnTop, "label-hide": labelHide, "help-text": helpText }));
+};
+/**
+ * Global use
+ */
+export const MgInputNumeric = Template.bind({});
+MgInputNumeric.args = {
+  // Global
+  value: '',
+  identifier: 'identifier',
+  name: 'input-name',
+  type: types[0],
+  // Label
+  label: 'Label',
+  labelOnTop: false,
+  labelHide: false,
+  // Input
+  placeholder: 'placeholder',
+  required: true,
+  disabled: false,
+  readonly: false,
+  max: undefined,
+  min: undefined,
+  // Tooltip
+  tooltip: 'This is a tooltip',
+  // Help Text
+  helpText: 'Help text with html <strong>bold</strong>, <em>italic</em>.',
+};
+const TemplateSlot = args => {
+  const labelOnTop = args.labelOnTop;
+  delete args.labelOnTop;
+  const labelHide = args.labelHide;
+  delete args.labelHide;
+  const helpText = args.helpText;
+  delete args.helpText;
+  // return element
+  return (h("mg-input-numeric", Object.assign({}, args, { "label-on-top": labelOnTop, "label-hide": labelHide, "help-text": helpText }),
+    h("span", { slot: "append-input" }, "km")));
+};
+/**
+ * Global use
+ */
+export const AppendSlot = TemplateSlot.bind({});
+AppendSlot.args = Object.assign({}, MgInputNumeric.args);