@mgdis/mg-components 3.1.0

package/dist/collection/components/molecules/inputs/mg-input-date/mg-input-date.css

@@ -0,0 +1,171 @@
+/**
+ * Common style for MGDIS inputs
+ */
+:host {
+  display: block;
+}
+
+.mg-input {
+  display: flex;
+  align-items: flex-start;
+  min-height: var(--default-size);
+  max-width: 100%;
+  /* Style when input is not valid */
+  /* Label */
+  /* Label-on-top */
+}
+.mg-input.is-not-valid {
+  color: hsl(var(--color-danger));
+}
+.mg-input.is-not-valid .mg-input__box {
+  border-color: hsl(var(--color-danger));
+}
+.mg-input mg-input-title {
+  flex-shrink: var(--mg-inputs-shrink, 1);
+  width: var(--mg-inputs-title-width, auto);
+  margin-top: calc((var(--default-size) - var(--font-size) * var(--line-height)) / 2);
+  margin-right: var(--mg-inputs-title-horizontal-space, var(--mg-inputs-spacer));
+  text-align: right;
+}
+.mg-input.mg-input--label-on-top {
+  flex-direction: column;
+}
+.mg-input.mg-input--label-on-top .mg-input__input-container {
+  width: 100%;
+}
+
+/* Label-on-top */
+.mg-input__title {
+  display: flex;
+  align-items: baseline;
+  margin-bottom: 0.3rem;
+}
+.mg-input__title mg-input-title {
+  flex-shrink: 1;
+  width: auto;
+  margin-top: 0;
+  margin-right: var(--mg-inputs-spacer);
+  text-align: left;
+}
+.mg-input__title mg-tooltip {
+  margin-top: 0;
+}
+.mg-input__title mg-icon {
+  display: inline-flex;
+  vertical-align: text-bottom;
+}
+
+.mg-input__input-container {
+  min-height: var(--default-size);
+  /* Readonly */
+}
+.mg-input__input-container > strong {
+  display: inline-block;
+  margin-top: calc((var(--default-size) - var(--font-size) * var(--line-height)) / 2);
+  min-height: var(--font-size);
+}
+.mg-input__input-container mg-tooltip {
+  display: inline-flex;
+  width: var(--mg-icon-regular-size);
+  height: var(--mg-icon-regular-size);
+  margin-left: var(--mg-inputs-spacer);
+}
+.mg-input__input-container mg-icon {
+  display: flex;
+}
+
+.mg-input__input {
+  display: flex;
+  /* Manage space between input and first message */
+}
+.mg-input__input mg-tooltip {
+  margin-top: calc((var(--default-size) - var(--mg-icon-regular-size)) / 2);
+}
+.mg-input__input + * {
+  text-align: start;
+  margin-top: 0.5rem;
+}
+
+/**
+ * Style for input "box":
+ * - input[type="text"]
+ * - input[type="date"]
+ * - input[type="password"]
+ * - textarea
+ * - select
+ */
+.mg-input__box {
+  padding: calc((var(--default-size) - var(--font-size) * var(--line-height)) / 2) var(--mg-inputs-spacer);
+  height: var(--default-size);
+  box-sizing: border-box;
+  border-width: var(--mg-inputs-border-width);
+  border-style: solid;
+  border-color: var(--mg-inputs-color);
+  border-radius: var(--mg-inputs-border-radius);
+  background-color: hsl(var(--color-light));
+  font-family: inherit;
+  color: hsl(var(--color-dark));
+  font-size: var(--font-size);
+}
+.mg-input__box::placeholder {
+  color: var(--mg-inputs-color);
+  font-style: italic;
+}
+.mg-input__box:focus {
+  box-shadow: 0 0 0.6rem hsla(var(--mg-inputs-color-shadow-focus-hsl), 0.5);
+}
+.mg-input__box:disabled {
+  opacity: 0.3;
+}
+
+/**
+* Variations
+*/
+.mg-input.mg-input--is-input-group-append {
+  --mg-button-border-radius-top-left: 0;
+  --mg-button-border-radius-bottom-left: 0;
+  /**
+  * Append input slot
+  */
+  /**
+  * Readonly variation
+  */
+}
+.mg-input.mg-input--is-input-group-append .mg-input__box {
+  margin-right: -0.1rem;
+  border-top-right-radius: 0%;
+  border-bottom-right-radius: 0%;
+}
+.mg-input.mg-input--is-input-group-append .mg-input__box:focus-visible {
+  outline-style: solid;
+  outline-offset: -0.2rem;
+  outline-width: 0.2rem;
+}
+.mg-input.mg-input--is-input-group-append.mg-input--readonly slot[name=append-input] {
+  display: none;
+}
+
+.mg-input.mg-input--is-append-input-slot-content:not(.mg-input--readonly) ::slotted([slot=append-input]) {
+  padding-top: calc((var(--default-size) - var(--mg-icon-regular-size)) / 2);
+}
+
+/**
+ * A11Y
+ */
+.sr-only {
+  border: 0 !important;
+  clip: rect(1px, 1px, 1px, 1px) !important;
+  -webkit-clip-path: inset(50%) !important;
+  clip-path: inset(50%) !important;
+  height: 1px !important;
+  margin: -1px !important;
+  overflow: hidden !important;
+  padding: 0 !important;
+  position: absolute !important;
+  width: 1px !important;
+  white-space: nowrap !important;
+}
+
+*:focus:not(:focus-visible) {
+  outline: none;
+}

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

@@ -0,0 +1,467 @@
+import { Component, Event, h, Prop, State, Watch } from '@stencil/core';
+import { MgInput } from '../MgInput';
+import { InputError } from './mg-input-date.conf';
+import { createID, ClassList } from '../../../../utils/components.utils';
+import { localeDate, dateRegExp } from '../../../../utils/locale.utils';
+import { messages } from '../../../../locales';
+import { InputClass } from '../MgInput.conf';
+export class MgInputDate {
+  constructor() {
+    /************
+     * Internal *
+     ************/
+    // 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-date');
+    /**
+     * 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;
+    /**
+     * Component classes
+     */
+    this.classList = new ClassList(['mg-input--date']);
+    /**
+     * Handle input event
+     */
+    this.handleInput = () => {
+      this.checkValidity();
+      this.value = this.input.value;
+      this.valueChange.emit(this.value);
+    };
+    /**
+     * Handle blur event
+     */
+    this.handleBlur = () => {
+      this.checkValidity();
+      this.checkError();
+    };
+    /**
+     * get input error code
+     * @returns {null | InputError}
+     */
+    this.getInputError = () => {
+      var _a, _b;
+      let inputError = null;
+      // required
+      if (this.input.validity.valueMissing) {
+        inputError = InputError.REQUIRED;
+      }
+      // min & max
+      else if ((this.input.validity.rangeUnderflow || this.input.validity.rangeOverflow) && ((_a = this.min) === null || _a === void 0 ? void 0 : _a.length) > 0 && ((_b = this.max) === null || _b === void 0 ? void 0 : _b.length) > 0) {
+        inputError = InputError.MINMAX;
+      }
+      // min
+      else if (this.input.validity.rangeUnderflow) {
+        inputError = InputError.MIN;
+      }
+      //max
+      else if (this.input.validity.rangeOverflow) {
+        inputError = InputError.MAX;
+      }
+      return inputError;
+    };
+  }
+  validateValue(newValue) {
+    if (newValue !== undefined && newValue !== '' && !(typeof newValue === 'string' && dateRegExp.test(newValue))) {
+      throw new Error("<mg-input-date> props 'value' doesn't match pattern: yyyy-mm-dd");
+    }
+  }
+  validateMin(newValue) {
+    this.validateDateFormat(newValue);
+  }
+  validateMax(newValue) {
+    this.validateDateFormat(newValue);
+  }
+  /**
+   * Date format validation
+   * @param date
+   */
+  validateDateFormat(date) {
+    if ((date === null || date === void 0 ? void 0 : date.length) > 0 && !(typeof date === 'string' && dateRegExp.test(date))) {
+      throw new Error("<mg-input-date> props 'min/max' doesn't match pattern: yyyy-mm-dd");
+    }
+  }
+  /**
+   * Check if input is valid
+   */
+  checkValidity() {
+    if (!this.readonly && this.input !== undefined) {
+      const validity = this.input.checkValidity();
+      // Set validity
+      this.valid = validity;
+      this.invalid = !validity;
+    }
+  }
+  /**
+   * Set error message
+   */
+  setErrorMessage() {
+    var _a;
+    const inputError = this.getInputError();
+    // required
+    if (inputError === InputError.REQUIRED) {
+      this.errorMessage = messages.errors[inputError];
+    }
+    // min, max & minMax
+    else if ([InputError.MIN, InputError.MAX, InputError.MINMAX].includes(inputError)) {
+      this.errorMessage = messages.errors.date[inputError].replace('{min}', localeDate(this.min)).replace('{max}', localeDate(this.max));
+    }
+    // wrong date format
+    // element.validity.badInput is default error message
+    else {
+      this.errorMessage = messages.errors.date.badInput.replace('{min}', ((_a = this.min) === null || _a === void 0 ? void 0 : _a.length) > 0 ? localeDate(this.min) : localeDate('1900-01-01'));
+    }
+  }
+  /**
+   * Check input errors
+   */
+  checkError() {
+    // Set error message
+    this.errorMessage = undefined;
+    if (!this.valid) {
+      this.setErrorMessage();
+      this.classList.add(this.classError);
+    }
+    else {
+      this.classList.delete(this.classError);
+    }
+  }
+  /*************
+   * Lifecycle *
+   *************/
+  componentWillLoad() {
+    this.validateValue(this.value);
+    this.validateMin(this.min);
+    this.validateMax(this.max);
+    // return a promise to process action only in the FIRST render().
+    // https://stenciljs.com/docs/component-lifecycle#componentwillload
+    return setTimeout(() => this.checkValidity(), 0);
+  }
+  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: undefined, disabled: this.disabled, value: this.value, readonlyValue: localeDate(this.value), tooltip: this.tooltip, displayCharacterLeft: undefined, characterLeftTemplate: undefined, maxlength: undefined, helpText: this.helpText, errorMessage: this.errorMessage, isFieldset: false },
+      h("input", { type: "date", class: "mg-input__box", min: this.min, max: this.max, value: this.value, id: this.identifier, name: this.name, disabled: this.disabled, required: this.required, onInput: this.handleInput, onBlur: this.handleBlur, pattern: "[0-9]{4}-[0-9]{2}-[0-9]{2}", ref: el => (this.input = el) })));
+  }
+  static get is() { return "mg-input-date"; }
+  static get encapsulation() { return "shadow"; }
+  static get originalStyleUrls() { return {
+    "$": ["./mg-input-date.scss"]
+  }; }
+  static get styleUrls() { return {
+    "$": ["mg-input-date.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-date')"
+    },
+    "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"
+    },
+    "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"
+    },
+    "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
+    },
+    "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
+    },
+    "min": {
+      "type": "string",
+      "mutable": false,
+      "complexType": {
+        "original": "string",
+        "resolved": "string",
+        "references": {}
+      },
+      "required": false,
+      "optional": false,
+      "docs": {
+        "tags": [],
+        "text": "Define input minimum date\nformat: yyyy-mm-dd"
+      },
+      "attribute": "min",
+      "reflect": false
+    },
+    "max": {
+      "type": "string",
+      "mutable": false,
+      "complexType": {
+        "original": "string",
+        "resolved": "string",
+        "references": {}
+      },
+      "required": false,
+      "optional": false,
+      "docs": {
+        "tags": [],
+        "text": "Define input maximum date\nformat: yyyy-mm-dd"
+      },
+      "attribute": "max",
+      "reflect": false
+    }
+  }; }
+  static get states() { return {
+    "classList": {},
+    "errorMessage": {}
+  }; }
+  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": "string",
+        "resolved": "string",
+        "references": {}
+      }
+    }]; }
+  static get watchers() { return [{
+      "propName": "value",
+      "methodName": "validateValue"
+    }, {
+      "propName": "min",
+      "methodName": "validateMin"
+    }, {
+      "propName": "max",
+      "methodName": "validateMax"
+    }]; }
+}

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

@@ -0,0 +1,46 @@
+import { h } from '@stencil/core';
+export default {
+  component: 'mg-input-date',
+  title: 'Molecules/Inputs/mg-input-date',
+};
+/**
+ * 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-date", Object.assign({}, args, { "label-on-top": labelOnTop, "label-hide": labelHide, "help-text": helpText }));
+};
+const date = new Date();
+const getFormatedNumber = (number) => {
+  return `${number > 9 ? number : '0' + number}`;
+};
+export const MgInputDate = Template.bind({});
+MgInputDate.args = {
+  // Global
+  value: `${date.getFullYear()}-${getFormatedNumber(date.getMonth())}-${getFormatedNumber(date.getDate())}`,
+  identifier: 'identifier',
+  name: 'input-name',
+  // Label
+  label: 'Label',
+  labelOnTop: false,
+  labelHide: false,
+  // Input
+  required: true,
+  readonly: false,
+  disabled: false,
+  // Tooltip
+  tooltip: 'This is a tooltip',
+  // Help Text
+  helpText: 'Help text with html <strong>bold</strong>, <em>italic</em>.',
+};
+export const MgInputDateMinMax = Template.bind({});
+MgInputDateMinMax.args = Object.assign(Object.assign({}, MgInputDate.args), { 
+  // date range
+  min: `${date.getFullYear()}-01-01`, max: `${date.getFullYear() + 1}-12-31` });

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

@@ -0,0 +1,11 @@
+/**
+ * List of all possibles types
+ */
+export const types = ['decimal', 'integer', 'currency'];
+export var InputError;
+(function (InputError) {
+  InputError["MIN"] = "min";
+  InputError["MAX"] = "max";
+  InputError["MINMAX"] = "minMax";
+  InputError["REQUIRED"] = "required";
+})(InputError || (InputError = {}));