@3t-transform/threeteeui 0.1.5 → 0.1.7

package/dist/collection/components/atoms/tttx-loading-spinner/Test/tttx-loading-spinner.spec.js

@@ -0,0 +1,64 @@
+import { newSpecPage } from '@stencil/core/testing';
+import { TttxLoadingSpinner } from '../tttx-loading-spinner';
+describe('tttx-loading-spinner', () => {
+  it('renders the loading text when the loading message prop is set to true', async () => {
+    const page = await newSpecPage({
+      components: [TttxLoadingSpinner],
+      html: '<tttx-loading-spinner></tttx-loading-spinner>',
+    });
+    page.rootInstance.loadingMessage = true;
+    await page.waitForChanges();
+    expect(page.root).toEqualHtml(`
+      <tttx-loading-spinner>
+        <mock:shadow-root>
+          <div class='spinner-container'><div class="loading-box"><span class='spinner large'></span></div><div class='loading-text'>Loading, please wait...</div></div>
+        </mock:shadow-root>
+      </tttx-loading-spinner>
+    `);
+  });
+  it('renders without the loading text when the loading message prop is set to false', async () => {
+    const page = await newSpecPage({
+      components: [TttxLoadingSpinner],
+      html: '<tttx-loading-spinner></tttx-loading-spinner>',
+    });
+    page.rootInstance.loadingMessage = false;
+    await page.waitForChanges();
+    expect(page.root).toEqualHtml(`
+      <tttx-loading-spinner>
+        <mock:shadow-root>
+          <div class='spinner-container'><div class="loading-box"><span class='spinner large'></span></div></div>
+        </mock:shadow-root>
+      </tttx-loading-spinner>
+    `);
+  });
+  it('renders the small spinner when the size prop is set to small', async () => {
+    const page = await newSpecPage({
+      components: [TttxLoadingSpinner],
+      html: '<tttx-loading-spinner></tttx-loading-spinner>',
+    });
+    page.rootInstance.size = 'small';
+    await page.waitForChanges();
+    expect(page.root).toEqualHtml(`
+      <tttx-loading-spinner>
+        <mock:shadow-root>
+          <div class='spinner-container'><div class="loading-box"><span class='spinner small'></span></div></div>
+        </mock:shadow-root>
+      </tttx-loading-spinner>
+    `);
+  });
+  it('renders the large spinner when the size prop is set to large', async () => {
+    const page = await newSpecPage({
+      components: [TttxLoadingSpinner],
+      html: '<tttx-loading-spinner></tttx-loading-spinner>',
+    });
+    page.rootInstance.size = 'large';
+    await page.waitForChanges();
+    expect(page.root).toEqualHtml(`
+      <tttx-loading-spinner>
+        <mock:shadow-root>
+          <div class='spinner-container'><div class="loading-box"><span class='spinner large'></span></div></div>
+        </mock:shadow-root>
+      </tttx-loading-spinner>
+    `);
+  });
+});

package/dist/collection/components/atoms/tttx-loading-spinner/tttx-loading-spinner.js

@@ -1,67 +1,67 @@
-// eslint-disable-next-line @typescript-eslint/no-unused-vars
-import { h } from '@stencil/core';
-export class TttxLoadingSpinner {
-  constructor() {
-    this.loadingMessage = undefined;
-    this.size = 'large';
-  }
-  renderLoadingMessage() {
-    if (!this.loadingMessage)
-      return '';
-    return h("div", { class: "loading-text" }, "Loading, please wait...");
-  }
-  render() {
-    return (h("div", { class: "spinner-container" }, h("div", { class: "loading-box" }, h("span", { class: `spinner ${this.size}` })), this.renderLoadingMessage()));
-  }
-  static get is() { return "tttx-loading-spinner"; }
-  static get encapsulation() { return "shadow"; }
-  static get originalStyleUrls() {
-    return {
-      "$": ["tttx-loading-spinner.scss"]
-    };
-  }
-  static get styleUrls() {
-    return {
-      "$": ["tttx-loading-spinner.css"]
-    };
-  }
-  static get properties() {
-    return {
-      "loadingMessage": {
-        "type": "boolean",
-        "mutable": true,
-        "complexType": {
-          "original": "boolean",
-          "resolved": "boolean",
-          "references": {}
-        },
-        "required": false,
-        "optional": false,
-        "docs": {
-          "tags": [],
-          "text": ""
-        },
-        "attribute": "loading-message",
-        "reflect": false
-      },
-      "size": {
-        "type": "string",
-        "mutable": true,
-        "complexType": {
-          "original": "'small' | 'large'",
-          "resolved": "\"large\" | \"small\"",
-          "references": {}
-        },
-        "required": false,
-        "optional": false,
-        "docs": {
-          "tags": [],
-          "text": ""
-        },
-        "attribute": "size",
-        "reflect": false,
-        "defaultValue": "'large'"
-      }
-    };
-  }
-}
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+import { h } from '@stencil/core';
+export class TttxLoadingSpinner {
+  constructor() {
+    this.loadingMessage = undefined;
+    this.size = 'large';
+  }
+  renderLoadingMessage() {
+    if (!this.loadingMessage)
+      return '';
+    return h("div", { class: "loading-text" }, "Loading, please wait...");
+  }
+  render() {
+    return (h("div", { class: "spinner-container" }, h("div", { class: "loading-box" }, h("span", { class: `spinner ${this.size}` })), this.renderLoadingMessage()));
+  }
+  static get is() { return "tttx-loading-spinner"; }
+  static get encapsulation() { return "shadow"; }
+  static get originalStyleUrls() {
+    return {
+      "$": ["tttx-loading-spinner.scss"]
+    };
+  }
+  static get styleUrls() {
+    return {
+      "$": ["tttx-loading-spinner.css"]
+    };
+  }
+  static get properties() {
+    return {
+      "loadingMessage": {
+        "type": "boolean",
+        "mutable": true,
+        "complexType": {
+          "original": "boolean",
+          "resolved": "boolean",
+          "references": {}
+        },
+        "required": false,
+        "optional": false,
+        "docs": {
+          "tags": [],
+          "text": ""
+        },
+        "attribute": "loading-message",
+        "reflect": false
+      },
+      "size": {
+        "type": "string",
+        "mutable": true,
+        "complexType": {
+          "original": "'small' | 'large'",
+          "resolved": "\"large\" | \"small\"",
+          "references": {}
+        },
+        "required": false,
+        "optional": false,
+        "docs": {
+          "tags": [],
+          "text": ""
+        },
+        "attribute": "size",
+        "reflect": false,
+        "defaultValue": "'large'"
+      }
+    };
+  }
+}

package/dist/collection/components/atoms/tttx-loading-spinner/tttx-loading-spinner.stories.js

@@ -1,17 +1,17 @@
-export default {
-  title: 'atoms/Loading Spinner',
-  component: 'tttx-loading-spinner',
-  argTypes: {
-    loadingMessage: {
-      control: 'boolean',
-    },
-    size: {
-      control: { type: 'radio' },
-      options: ['small', 'large'],
-    },
-  },
-};
-export const Example = args => {
-  const size = args.size || 'large';
-  return `<tttx-loading-spinner ${args.loadingMessage ? 'loading-message' : ''} size='${size}' />`;
-};
+export default {
+  title: 'atoms/Loading Spinner',
+  component: 'tttx-loading-spinner',
+  argTypes: {
+    loadingMessage: {
+      control: 'boolean',
+    },
+    size: {
+      control: { type: 'radio' },
+      options: ['small', 'large'],
+    },
+  },
+};
+export const Example = args => {
+  const size = args.size || 'large';
+  return `<tttx-loading-spinner ${args.loadingMessage ? 'loading-message' : ''} size='${size}' />`;
+};

package/dist/collection/components/molecules/tttx-form/lib/setErrorState.js

@@ -1,35 +1,35 @@
-/**
- * Sets the error state of an input field by updating its class and error message.
- * If an error was detected, it sets the input field's class to "invalid" and
- * displays the error message in an error bubble. If no error was detected,
- * it removes the "invalid" class from the input field and clears the error bubble.
- *
- * @param {HTMLInputElement} target - The input field to update.
- * @param {boolean} hasError - Whether an error was detected in the field.
- * @param {string} errorMessage - The error message to display (if any).
- * @return {void}
- */
-function setErrorState(target, hasError, errorMessage) {
-  // Find the error bubble element for the input field
-  const errorBubble = target.parentElement.querySelector('.errorBubble');
-  // If an error was detected, set the input field's class to "invalid" and display the error message in the error bubble
-  if (hasError) {
-    target.className = 'invalid';
-    const errorIcon = document.createElement('span');
-    // Set the class of the error icon to a pre-defined CSS class that specifies the icon's appearance
-    errorIcon.className = 'material-symbols-rounded';
-    // Set the text content of the error icon to the word "warning"
-    errorIcon.textContent = 'warning';
-    // errorBubble.replaceChildren cannot be used here because the tests don't support this new feature :(
-    errorBubble.innerHTML = '';
-    errorBubble.append(errorIcon);
-    errorBubble.append(errorMessage);
-    // errorBubble.replaceChildren(errorIcon, errorMessage);
-  }
-  // If no error was detected, remove the "invalid" class from the input field and clear the error bubble
-  else {
-    target.className = '';
-    errorBubble.innerHTML = '';
-  }
-}
-export default setErrorState;
+/**
+ * Sets the error state of an input field by updating its class and error message.
+ * If an error was detected, it sets the input field's class to "invalid" and
+ * displays the error message in an error bubble. If no error was detected,
+ * it removes the "invalid" class from the input field and clears the error bubble.
+ *
+ * @param {HTMLInputElement} target - The input field to update.
+ * @param {boolean} hasError - Whether an error was detected in the field.
+ * @param {string} errorMessage - The error message to display (if any).
+ * @return {void}
+ */
+function setErrorState(target, hasError, errorMessage) {
+  // Find the error bubble element for the input field
+  const errorBubble = target.parentElement.querySelector('.errorBubble');
+  // If an error was detected, set the input field's class to "invalid" and display the error message in the error bubble
+  if (hasError) {
+    target.className = 'invalid';
+    const errorIcon = document.createElement('span');
+    // Set the class of the error icon to a pre-defined CSS class that specifies the icon's appearance
+    errorIcon.className = 'material-symbols-rounded';
+    // Set the text content of the error icon to the word "warning"
+    errorIcon.textContent = 'warning';
+    // errorBubble.replaceChildren cannot be used here because the tests don't support this new feature :(
+    errorBubble.innerHTML = '';
+    errorBubble.append(errorIcon);
+    errorBubble.append(errorMessage);
+    // errorBubble.replaceChildren(errorIcon, errorMessage);
+  }
+  // If no error was detected, remove the "invalid" class from the input field and clear the error bubble
+  else {
+    target.className = '';
+    errorBubble.innerHTML = '';
+  }
+}
+export default setErrorState;

package/dist/collection/components/molecules/tttx-form/lib/setErrorState.spec.js

@@ -0,0 +1,38 @@
+import setErrorState from './setErrorState';
+describe('setErrorState', () => {
+  let target;
+  let errorBubble;
+  beforeEach(() => {
+    target = document.createElement('input');
+    errorBubble = document.createElement('div');
+    errorBubble.className = 'errorBubble';
+    target.parentElement = document.createElement('div');
+    target.parentElement.appendChild(errorBubble);
+  });
+  afterEach(() => {
+    target = null;
+    errorBubble = null;
+  });
+  test('should set error state correctly when hasError is true', () => {
+    setErrorState(target, true, 'Invalid value');
+    expect(target.className).toBe('invalid');
+    expect(errorBubble.innerHTML).toBe('<span class="material-symbols-rounded">warning</span>Invalid value');
+  });
+  test('should clear error state correctly when hasError is false', () => {
+    target.className = 'invalid';
+    errorBubble.innerHTML = '<span class="material-symbols-rounded">warning</span>Invalid value';
+    setErrorState(target, false, '');
+    expect(target.className).toBe('');
+    expect(errorBubble.innerHTML).toBe('');
+  });
+  test('should set error state correctly with custom error message', () => {
+    setErrorState(target, true, 'Custom error message');
+    expect(target.className).toBe('invalid');
+    expect(errorBubble.innerHTML).toBe('<span class="material-symbols-rounded">warning</span>Custom error message');
+  });
+  test('should set error state correctly with no error message', () => {
+    setErrorState(target, true, '');
+    expect(target.className).toBe('invalid');
+    expect(errorBubble.innerHTML).toBe('<span class="material-symbols-rounded">warning</span> ');
+  });
+});

package/dist/collection/components/molecules/tttx-form/lib/validityCheck.js

@@ -1,58 +1,58 @@
-/**
- * Validates the input field on focusout event by checking its validity state,
- * sets an error message if there's an issue, and emits a "dataChanged" event to
- * the parent component with the field name and its new value.
- *
- * @param {Event} event - The focusout event triggered by the input field.
- * @return {void}
- */
-function validityCheck(event) {
-  var _a, _b, _c, _d;
-  event.preventDefault();
-  const target = event.target;
-  let hasError = true;
-  let errorMessage = '';
-  // validity object on HTML5 inputs has the following options
-  // badInput
-  // customError
-  // patternMismatch
-  // rangeOverflow
-  // rangeUnderflow
-  // stepMismatch
-  // tooLong
-  // tooShort
-  // typeMismatch
-  // valid
-  // valueMissing
-  // customErrors can be set with
-  // target.setCustomValidity('custom error!');
-  // and cleared with
-  // target.setCustomValidity('');
-  // Check the validity of the input field and set an error message if needed
-  switch (true) {
-    // The field is required, but has no value
-    case target.validity.valueMissing:
-      errorMessage = (_a = target.dataset.required) !== null && _a !== void 0 ? _a : 'This field is required';
-      break;
-    // The field's value does not match the expected pattern
-    case target.validity.patternMismatch:
-      errorMessage = (_b = target.dataset.pattern) !== null && _b !== void 0 ? _b : 'Incorrect format';
-      break;
-    // The field's value is not of the correct input type
-    case target.validity.badInput:
-      // IE string in a number field
-      errorMessage = (_c = target.dataset.badinput) !== null && _c !== void 0 ? _c : 'Wrong input type';
-      break;
-    // The field's value is above or below the range set in the "min" and "max" attributes
-    case target.validity.rangeOverflow || target.validity.rangeUnderflow:
-      // IE date or number is above or below value set in min or max tags
-      errorMessage = (_d = target.dataset.range) !== null && _d !== void 0 ? _d : 'Invalid value';
-      break;
-    // No error detected
-    default:
-      hasError = false;
-  }
-  // Return the error state
-  return { target, hasError, errorMessage };
-}
-export default validityCheck;
+/**
+ * Validates the input field on focusout event by checking its validity state,
+ * sets an error message if there's an issue, and emits a "dataChanged" event to
+ * the parent component with the field name and its new value.
+ *
+ * @param {Event} event - The focusout event triggered by the input field.
+ * @return {void}
+ */
+function validityCheck(event) {
+  var _a, _b, _c, _d;
+  event.preventDefault();
+  const target = event.target;
+  let hasError = true;
+  let errorMessage = '';
+  // validity object on HTML5 inputs has the following options
+  // badInput
+  // customError
+  // patternMismatch
+  // rangeOverflow
+  // rangeUnderflow
+  // stepMismatch
+  // tooLong
+  // tooShort
+  // typeMismatch
+  // valid
+  // valueMissing
+  // customErrors can be set with
+  // target.setCustomValidity('custom error!');
+  // and cleared with
+  // target.setCustomValidity('');
+  // Check the validity of the input field and set an error message if needed
+  switch (true) {
+    // The field is required, but has no value
+    case target.validity.valueMissing:
+      errorMessage = (_a = target.dataset.required) !== null && _a !== void 0 ? _a : 'This field is required';
+      break;
+    // The field's value does not match the expected pattern
+    case target.validity.patternMismatch:
+      errorMessage = (_b = target.dataset.pattern) !== null && _b !== void 0 ? _b : 'Incorrect format';
+      break;
+    // The field's value is not of the correct input type
+    case target.validity.badInput:
+      // IE string in a number field
+      errorMessage = (_c = target.dataset.badinput) !== null && _c !== void 0 ? _c : 'Wrong input type';
+      break;
+    // The field's value is above or below the range set in the "min" and "max" attributes
+    case target.validity.rangeOverflow || target.validity.rangeUnderflow:
+      // IE date or number is above or below value set in min or max tags
+      errorMessage = (_d = target.dataset.range) !== null && _d !== void 0 ? _d : 'Invalid value';
+      break;
+    // No error detected
+    default:
+      hasError = false;
+  }
+  // Return the error state
+  return { target, hasError, errorMessage };
+}
+export default validityCheck;

package/dist/collection/components/molecules/tttx-form/lib/validityCheck.spec.js

@@ -0,0 +1,214 @@
+import validityCheck from './validityCheck';
+// badInput
+// customError
+// patternMismatch
+// rangeOverflow
+// rangeUnderflow
+// stepMismatch
+// tooLong
+// tooShort
+// typeMismatch
+// valid
+// valueMissing
+describe('validityCheck', () => {
+  it('should return a valid response when there are no validation issues', async () => {
+    const preventDefault = jest.fn();
+    const event = {
+      target: {
+        value: 'test',
+        validity: {
+          valid: true
+        },
+        dataset: {}
+      },
+      preventDefault
+    };
+    const result = validityCheck(event);
+    expect(preventDefault).toHaveBeenCalledTimes(1);
+    expect(result).toStrictEqual({
+      "errorMessage": "",
+      "hasError": false,
+      "target": event.target
+    });
+  });
+  it('should return the required property when there is a value missing', async () => {
+    const preventDefault = jest.fn();
+    const event = {
+      target: {
+        dataset: {
+          required: 'This is required'
+        },
+        value: 'test',
+        validity: {
+          valid: false,
+          valueMissing: true
+        }
+      },
+      preventDefault
+    };
+    const result = validityCheck(event);
+    expect(preventDefault).toHaveBeenCalledTimes(1);
+    expect(result).toStrictEqual({
+      "errorMessage": "This is required",
+      "hasError": true,
+      "target": event.target
+    });
+  });
+  it('should return a default error message property when there is a value missing', async () => {
+    const preventDefault = jest.fn();
+    const event = {
+      target: {
+        dataset: {},
+        value: 'test',
+        validity: {
+          valid: false,
+          valueMissing: true
+        }
+      },
+      preventDefault
+    };
+    const result = validityCheck(event);
+    expect(preventDefault).toHaveBeenCalledTimes(1);
+    expect(result).toStrictEqual({
+      "errorMessage": 'This field is required',
+      "hasError": true,
+      "target": event.target
+    });
+  });
+  it('should return the pattern property when there is a patternMismatch', async () => {
+    const preventDefault = jest.fn();
+    const event = {
+      target: {
+        dataset: {
+          pattern: 'Incorrect format CUSTOM'
+        },
+        value: 'test',
+        validity: {
+          valid: false,
+          patternMismatch: true
+        }
+      },
+      preventDefault
+    };
+    const result = validityCheck(event);
+    expect(preventDefault).toHaveBeenCalledTimes(1);
+    expect(result).toStrictEqual({
+      "errorMessage": "Incorrect format CUSTOM",
+      "hasError": true,
+      "target": event.target
+    });
+  });
+  it('should return the a default error message when there is a patternMismatch', async () => {
+    const preventDefault = jest.fn();
+    const event = {
+      target: {
+        dataset: {},
+        value: 'test',
+        validity: {
+          valid: false,
+          patternMismatch: true
+        }
+      },
+      preventDefault
+    };
+    const result = validityCheck(event);
+    expect(preventDefault).toHaveBeenCalledTimes(1);
+    expect(result).toStrictEqual({
+      "errorMessage": 'Incorrect format',
+      "hasError": true,
+      "target": event.target
+    });
+  });
+  it('should return the badinput error message property when there is a badInput', async () => {
+    const preventDefault = jest.fn();
+    const event = {
+      target: {
+        dataset: {
+          badinput: 'There is a bad input'
+        },
+        value: 'test',
+        validity: {
+          valid: false,
+          badInput: true
+        }
+      },
+      preventDefault
+    };
+    const result = validityCheck(event);
+    expect(preventDefault).toHaveBeenCalledTimes(1);
+    expect(result).toStrictEqual({
+      "errorMessage": "There is a bad input",
+      "hasError": true,
+      "target": event.target
+    });
+  });
+  it('should return a default error message property when there is a badInput', async () => {
+    const preventDefault = jest.fn();
+    const event = {
+      target: {
+        value: 'test',
+        validity: {
+          valid: false,
+          badInput: true
+        },
+        dataset: {}
+      },
+      preventDefault
+    };
+    const result = validityCheck(event);
+    expect(preventDefault).toHaveBeenCalledTimes(1);
+    expect(result).toStrictEqual({
+      "errorMessage": 'Wrong input type',
+      "hasError": true,
+      "target": event.target
+    });
+  });
+  it('should return a message for an item out of range (underflow) with custom message', async () => {
+    const preventDefault = jest.fn();
+    const event = {
+      target: {
+        value: '0',
+        validity: {
+          valid: false,
+          rangeOverflow: true
+        },
+        dataset: {
+          range: 'Value is out of range'
+        }
+      },
+      preventDefault
+    };
+    const result = validityCheck(event);
+    expect(preventDefault).toHaveBeenCalledTimes(1);
+    expect(result).toStrictEqual({
+      "errorMessage": "Value is out of range",
+      "hasError": true,
+      "target": event.target
+    });
+  });
+  it('should return a message for an item out of range (underflow)', async () => {
+    const preventDefault = jest.fn();
+    const event = {
+      target: {
+        value: '0',
+        validity: {
+          valid: false,
+          rangeOverflow: true
+        },
+        dataset: {}
+      },
+      preventDefault
+    };
+    const result = validityCheck(event);
+    expect(preventDefault).toHaveBeenCalledTimes(1);
+    expect(result).toStrictEqual({
+      "errorMessage": "Invalid value",
+      "hasError": true,
+      "target": event.target
+    });
+  });
+  // it('target.validity.rangeOverflow', async () => {
+  // });  
+  // it('target.validity.rangeUnderflow', async () => {
+  // });    
+});