@everymatrix/general-input 1.10.0

package/dist/collection/components/radio-input/radio-input.js

@@ -0,0 +1,245 @@
+import { Component, h, Prop, State, Watch, Event } from '@stencil/core';
+import { translate } from '../../utils/locale.utils';
+export class RadioInput {
+  checkValidityHandler(newValue) {
+    if (newValue == true) {
+      this.isValid = this.setValidity();
+      this.errorMessage = this.setErrorMessage();
+      this.validityStateHandler({ valid: this.isValid, name: this.name });
+    }
+  }
+  validityChanged() {
+    if (this.checkValidity == true) {
+      this.validityStateHandler({ valid: this.isValid, name: this.name });
+    }
+    if (this.emitValue == true) {
+      this.valueHandler({ name: this.name, value: this.value });
+    }
+  }
+  emitValueHandler(newValue) {
+    if (newValue == true && this.isValid) {
+      this.valueHandler({ name: this.name, value: this.value });
+    }
+  }
+  valueHandler(inputValueEvent) {
+    this.sendInputValue.emit(inputValueEvent);
+  }
+  validityStateHandler(inputStateEvent) {
+    this.sendValidityState.emit(inputStateEvent);
+  }
+  connectedCallback() {
+  }
+  handleClick(event) {
+    this.value = event.target.value;
+    this.isValid = this.setValidity();
+    this.errorMessage = this.setErrorMessage();
+  }
+  setValidity() {
+    return this.inputReference.validity.valid;
+  }
+  setErrorMessage() {
+    if (this.inputReference.validity.valueMissing) {
+      return translate('requiredError', this.language);
+    }
+  }
+  render() {
+    return h("fieldset", { class: 'radio__fieldset' },
+      h("legend", { class: 'radio__legend' },
+        this.displayName,
+        ":"),
+      this.optionsGroup.map(option => h("div", { class: 'radio__wrapper' },
+        h("input", { type: "radio", class: 'radio__input', id: `${option.label}__input`, ref: (el) => this.inputReference = el, value: option.value, name: this.name, required: this.validation.mandatory, onClick: (e) => this.handleClick(e) }),
+        h("label", { htmlFor: `${option.label}__input` }, option.label))),
+      h("small", { class: 'radio__error-message' }, this.errorMessage));
+  }
+  static get is() { return "radio-input"; }
+  static get encapsulation() { return "shadow"; }
+  static get originalStyleUrls() { return {
+    "$": ["radio-input.scss"]
+  }; }
+  static get styleUrls() { return {
+    "$": ["radio-input.css"]
+  }; }
+  static get properties() { return {
+    "name": {
+      "type": "string",
+      "mutable": false,
+      "complexType": {
+        "original": "string",
+        "resolved": "string",
+        "references": {}
+      },
+      "required": false,
+      "optional": false,
+      "docs": {
+        "tags": [],
+        "text": "Name of the input."
+      },
+      "attribute": "name",
+      "reflect": false
+    },
+    "displayName": {
+      "type": "string",
+      "mutable": false,
+      "complexType": {
+        "original": "string",
+        "resolved": "string",
+        "references": {}
+      },
+      "required": false,
+      "optional": false,
+      "docs": {
+        "tags": [],
+        "text": "Name of input to be shown to the user."
+      },
+      "attribute": "display-name",
+      "reflect": false
+    },
+    "optionsGroup": {
+      "type": "unknown",
+      "mutable": false,
+      "complexType": {
+        "original": "Option[]",
+        "resolved": "Option[]",
+        "references": {
+          "Option": {
+            "location": "import",
+            "path": "../../utils/types"
+          }
+        }
+      },
+      "required": false,
+      "optional": false,
+      "docs": {
+        "tags": [],
+        "text": "Options of the input."
+      }
+    },
+    "validation": {
+      "type": "unknown",
+      "mutable": false,
+      "complexType": {
+        "original": "ValidationSchema",
+        "resolved": "ValidationSchema",
+        "references": {
+          "ValidationSchema": {
+            "location": "import",
+            "path": "../../utils/types"
+          }
+        }
+      },
+      "required": false,
+      "optional": false,
+      "docs": {
+        "tags": [],
+        "text": "Object of validation rules for the input."
+      }
+    },
+    "language": {
+      "type": "string",
+      "mutable": false,
+      "complexType": {
+        "original": "string",
+        "resolved": "string",
+        "references": {}
+      },
+      "required": false,
+      "optional": false,
+      "docs": {
+        "tags": [],
+        "text": "Currently selected language."
+      },
+      "attribute": "language",
+      "reflect": false
+    },
+    "checkValidity": {
+      "type": "boolean",
+      "mutable": false,
+      "complexType": {
+        "original": "boolean",
+        "resolved": "boolean",
+        "references": {}
+      },
+      "required": false,
+      "optional": false,
+      "docs": {
+        "tags": [],
+        "text": "State passed down from the parent element. Will trigger the input to check for validity."
+      },
+      "attribute": "check-validity",
+      "reflect": false
+    },
+    "emitValue": {
+      "type": "boolean",
+      "mutable": false,
+      "complexType": {
+        "original": "boolean",
+        "resolved": "boolean",
+        "references": {}
+      },
+      "required": false,
+      "optional": false,
+      "docs": {
+        "tags": [],
+        "text": "State passed down from the parent element. Will trigger the input to send it's value through an event."
+      },
+      "attribute": "emit-value",
+      "reflect": false
+    }
+  }; }
+  static get states() { return {
+    "errorMessage": {},
+    "isValid": {}
+  }; }
+  static get events() { return [{
+      "method": "sendInputValue",
+      "name": "sendInputValue",
+      "bubbles": true,
+      "cancelable": true,
+      "composed": true,
+      "docs": {
+        "tags": [],
+        "text": ""
+      },
+      "complexType": {
+        "original": "InputValueEvent",
+        "resolved": "InputValueEvent",
+        "references": {
+          "InputValueEvent": {
+            "location": "import",
+            "path": "../../utils/types"
+          }
+        }
+      }
+    }, {
+      "method": "sendValidityState",
+      "name": "sendValidityState",
+      "bubbles": true,
+      "cancelable": true,
+      "composed": true,
+      "docs": {
+        "tags": [],
+        "text": ""
+      },
+      "complexType": {
+        "original": "InputStateEvent",
+        "resolved": "InputStateEvent",
+        "references": {
+          "InputStateEvent": {
+            "location": "import",
+            "path": "../../utils/types"
+          }
+        }
+      }
+    }]; }
+  static get watchers() { return [{
+      "propName": "checkValidity",
+      "methodName": "checkValidityHandler"
+    }, {
+      "propName": "isValid",
+      "methodName": "validityChanged"
+    }, {
+      "propName": "emitValue",
+      "methodName": "emitValueHandler"
+    }]; }
+}

package/dist/collection/components/select-input/select-input.css

@@ -0,0 +1,49 @@
+*,
+*::before,
+*::after {
+  padding: 0;
+  margin: 0;
+  box-sizing: border-box;
+}
+
+.select__wrapper {
+  position: relative;
+  display: flex;
+  padding-top: 10px;
+  width: 100%;
+}
+.select__label {
+  color: #474747;
+  font-size: 16px;
+  position: absolute;
+  bottom: 15px;
+  left: 5px;
+  transform: translateY(-25px);
+  transition: all 0.3s cubic-bezier(0.5, 0, 0.5, 1);
+}
+.select__label--hidden {
+  opacity: 0;
+  visibility: hidden;
+  transform: translateY(0);
+}
+.select__input {
+  width: inherit;
+  padding: 15px 6px;
+  position: relative;
+  border: none;
+  border-bottom: 3px solid #666666;
+  background-color: transparent;
+  color: #666666;
+  font-size: 16px;
+  font-family: inherit;
+}
+.select__input:focus {
+  outline: none;
+  box-shadow: 0 5px 5px rgba(16, 15, 15, 0.1);
+}
+.select__error-message {
+  position: absolute;
+  top: calc(100% + 5px);
+  left: 0;
+  color: #cc0000;
+}

package/dist/collection/components/select-input/select-input.js

@@ -0,0 +1,308 @@
+import { Component, h, Prop, State, Watch, Event } from '@stencil/core';
+import { translate } from '../../utils/locale.utils';
+export class SelectInput {
+  constructor() {
+    /**
+     * Options of the input.
+     */
+    this.options = [];
+  }
+  checkValidityHandler(newValue) {
+    if (newValue == true) {
+      this.isValid = this.setValidity();
+      this.errorMessage = this.setErrorMessage();
+      this.validityStateHandler({ valid: this.isValid, name: this.name });
+    }
+  }
+  validityChanged() {
+    if (this.checkValidity == true) {
+      this.validityStateHandler({ valid: this.isValid, name: this.name });
+    }
+    if (this.emitValue == true) {
+      this.valueHandler({ name: this.name, value: this.value });
+    }
+  }
+  validityStateHandler(inputStateEvent) {
+    this.sendValidityState.emit(inputStateEvent);
+  }
+  emitValueHandler(newValue) {
+    if (newValue == true && this.isValid) {
+      this.valueHandler({ name: this.name, value: this.value });
+    }
+  }
+  valueHandler(inputValueEvent) {
+    this.sendInputValue.emit(inputValueEvent);
+  }
+  connectedCallback() {
+    this.displayedOptions = this.options;
+    console.log(this.displayedOptions);
+  }
+  componentWillLoad() {
+    console.log(this.action, this.options);
+    if (this.action && !this.options.length) {
+      if (this.action.split(" ")[0] == 'GET') {
+        return this.getOptions().then((options) => {
+          this.displayedOptions = options.countries.map(option => {
+            return { label: option.Name, value: option.Alpha2Code };
+          });
+        });
+      }
+    }
+  }
+  getOptions() {
+    // TEMPORARY FOR DEMO PURPOSES UNTIL NORWAY CONFIGURES AN ACTUAL ENDPOINT...
+    const url = new URL("https://demo-api.stage.norway.everymatrix.com/v1/player/countries");
+    return new Promise((resolve, reject) => {
+      fetch(url.href)
+        .then((res) => res.json())
+        .then((options) => {
+        resolve(options);
+      }).catch((err) => {
+        console.error(err);
+        reject(err);
+      });
+    });
+  }
+  handleChange(event) {
+    this.value = event.target.value;
+    this.errorMessage = this.setErrorMessage();
+    this.isValid = this.setValidity();
+    this.inputReference.previousElementSibling.classList.remove('select__label--hidden');
+    console.log(this.action, this.options);
+  }
+  setValidity() {
+    return this.inputReference.validity.valid;
+  }
+  setErrorMessage() {
+    if (this.inputReference.validity.valueMissing) {
+      return translate('requiredError', this.language);
+    }
+  }
+  render() {
+    console.log('RENDER');
+    return h("div", { class: 'select__wrapper' },
+      h("label", { class: 'select__label select__label--hidden', htmlFor: `${this.name}__input` },
+        this.displayName,
+        ":"),
+      h("select", { ref: (el) => this.inputReference = el, name: this.name, id: `${this.name}__input`, required: this.validation.mandatory, class: 'select__input', onChange: (e) => this.handleChange(e) },
+        h("option", { value: "", selected: true, disabled: true },
+          " ",
+          this.displayName,
+          " "),
+        this.displayedOptions.map(option => {
+          return h("option", { value: option.value },
+            " ",
+            option.label,
+            " ");
+        })),
+      h("small", { class: 'select__error-message' }, this.errorMessage));
+  }
+  static get is() { return "select-input"; }
+  static get encapsulation() { return "shadow"; }
+  static get originalStyleUrls() { return {
+    "$": ["select-input.scss"]
+  }; }
+  static get styleUrls() { return {
+    "$": ["select-input.css"]
+  }; }
+  static get properties() { return {
+    "name": {
+      "type": "string",
+      "mutable": false,
+      "complexType": {
+        "original": "string",
+        "resolved": "string",
+        "references": {}
+      },
+      "required": false,
+      "optional": false,
+      "docs": {
+        "tags": [],
+        "text": "Name of the input."
+      },
+      "attribute": "name",
+      "reflect": false
+    },
+    "displayName": {
+      "type": "string",
+      "mutable": false,
+      "complexType": {
+        "original": "string",
+        "resolved": "string",
+        "references": {}
+      },
+      "required": false,
+      "optional": false,
+      "docs": {
+        "tags": [],
+        "text": "Name of input to be shown to the user."
+      },
+      "attribute": "display-name",
+      "reflect": false
+    },
+    "action": {
+      "type": "string",
+      "mutable": false,
+      "complexType": {
+        "original": "string",
+        "resolved": "string",
+        "references": {}
+      },
+      "required": false,
+      "optional": false,
+      "docs": {
+        "tags": [],
+        "text": "Special behaviour an input should have. Can be fetching for data."
+      },
+      "attribute": "action",
+      "reflect": false
+    },
+    "options": {
+      "type": "unknown",
+      "mutable": false,
+      "complexType": {
+        "original": "Option[]",
+        "resolved": "Option[]",
+        "references": {
+          "Option": {
+            "location": "import",
+            "path": "../../utils/types"
+          }
+        }
+      },
+      "required": false,
+      "optional": false,
+      "docs": {
+        "tags": [],
+        "text": "Options of the input."
+      },
+      "defaultValue": "[]"
+    },
+    "validation": {
+      "type": "unknown",
+      "mutable": false,
+      "complexType": {
+        "original": "ValidationSchema",
+        "resolved": "ValidationSchema",
+        "references": {
+          "ValidationSchema": {
+            "location": "import",
+            "path": "../../utils/types"
+          }
+        }
+      },
+      "required": false,
+      "optional": false,
+      "docs": {
+        "tags": [],
+        "text": "Object of validation rules for the input."
+      }
+    },
+    "language": {
+      "type": "string",
+      "mutable": false,
+      "complexType": {
+        "original": "string",
+        "resolved": "string",
+        "references": {}
+      },
+      "required": false,
+      "optional": false,
+      "docs": {
+        "tags": [],
+        "text": "Currently selected language."
+      },
+      "attribute": "language",
+      "reflect": false
+    },
+    "checkValidity": {
+      "type": "boolean",
+      "mutable": false,
+      "complexType": {
+        "original": "boolean",
+        "resolved": "boolean",
+        "references": {}
+      },
+      "required": false,
+      "optional": false,
+      "docs": {
+        "tags": [],
+        "text": "State passed down from the parent element. Will trigger the input to check for validity."
+      },
+      "attribute": "check-validity",
+      "reflect": false
+    },
+    "emitValue": {
+      "type": "boolean",
+      "mutable": false,
+      "complexType": {
+        "original": "boolean",
+        "resolved": "boolean",
+        "references": {}
+      },
+      "required": false,
+      "optional": false,
+      "docs": {
+        "tags": [],
+        "text": "State passed down from the parent element. Will trigger the input to send it's value through an event."
+      },
+      "attribute": "emit-value",
+      "reflect": false
+    }
+  }; }
+  static get states() { return {
+    "errorMessage": {},
+    "isValid": {}
+  }; }
+  static get events() { return [{
+      "method": "sendValidityState",
+      "name": "sendValidityState",
+      "bubbles": true,
+      "cancelable": true,
+      "composed": true,
+      "docs": {
+        "tags": [],
+        "text": ""
+      },
+      "complexType": {
+        "original": "InputStateEvent",
+        "resolved": "InputStateEvent",
+        "references": {
+          "InputStateEvent": {
+            "location": "import",
+            "path": "../../utils/types"
+          }
+        }
+      }
+    }, {
+      "method": "sendInputValue",
+      "name": "sendInputValue",
+      "bubbles": true,
+      "cancelable": true,
+      "composed": true,
+      "docs": {
+        "tags": [],
+        "text": ""
+      },
+      "complexType": {
+        "original": "InputValueEvent",
+        "resolved": "InputValueEvent",
+        "references": {
+          "InputValueEvent": {
+            "location": "import",
+            "path": "../../utils/types"
+          }
+        }
+      }
+    }]; }
+  static get watchers() { return [{
+      "propName": "checkValidity",
+      "methodName": "checkValidityHandler"
+    }, {
+      "propName": "isValid",
+      "methodName": "validityChanged"
+    }, {
+      "propName": "emitValue",
+      "methodName": "emitValueHandler"
+    }]; }
+}

package/dist/collection/components/tel-input/tel-input.css

@@ -0,0 +1,67 @@
+*,
+*::before,
+*::after {
+  padding: 0;
+  margin: 0;
+  box-sizing: border-box;
+}
+
+.tel__wrapper {
+  position: relative;
+  display: flex;
+  flex-direction: column-reverse;
+  padding-top: 10px;
+}
+.tel__label {
+  color: #474747;
+  font-size: 16px;
+  position: absolute;
+  bottom: 15px;
+  left: 5px;
+  transform: translateY(-25px);
+  transition: all 0.3s cubic-bezier(0.5, 0, 0.5, 1);
+}
+.tel__label--required::after {
+  content: "*";
+  margin-left: 5px;
+  color: #666666;
+}
+.tel__input {
+  width: inherit;
+  padding: 15px 6px;
+  position: relative;
+  border: none;
+  border-bottom: 3px solid #666666;
+  background-color: transparent;
+  color: #666666;
+  font-size: 16px;
+  font-family: inherit;
+  /* Firefox */
+  -moz-appearance: textfield;
+  /* Chrome, Safari, Edge, Opera */
+}
+.tel__input::-webkit-outer-spin-button, .tel__input::-webkit-inner-spin-button {
+  -webkit-appearance: none;
+  margin: 0;
+}
+.tel__input:focus {
+  outline: none;
+  box-shadow: 0 5px 5px rgba(16, 15, 15, 0.1);
+}
+.tel__input::placeholder {
+  color: #666666;
+}
+.tel__input--invalid {
+  border-bottom: 3px solid #cc0000;
+}
+.tel__input:placeholder-shown + .tel__label {
+  opacity: 0;
+  visibility: hidden;
+  transform: translateY(0);
+}
+.tel__error-message {
+  position: absolute;
+  top: calc(100% + 5px);
+  left: 0;
+  color: #cc0000;
+}