adp-web-components 0.0.45 → 0.0.48

package/dist/collection/global/lib/form-hook.js

@@ -10,14 +10,16 @@ export class FormHook {
         this.formErrors = {};
         this.getFormErrors = () => this.formErrors;
         this.getValues = () => {
-            const form = this.context.el.shadowRoot.querySelector('form');
+            const formDom = this.context.el.shadowRoot || this.context.el;
+            const form = formDom.querySelector('form');
             const formData = new FormData(form);
             const formObject = Object.fromEntries(formData.entries());
             return formObject;
         };
         this.focusFirstInput = (errorFields) => {
             if (errorFields.length) {
-                const domElements = errorFields.map(field => this.context.el.shadowRoot.querySelector(`input[name="${field.name}"]`)).filter(dom => dom);
+                const formDom = this.context.el.shadowRoot || this.context.el;
+                const domElements = errorFields.map(field => formDom.querySelector(`*[name="${field.name}"]`)).filter(dom => dom);
                 const sortedDomElements = domElements.sort((a, b) => {
                     if (a.compareDocumentPosition(b) & Node.DOCUMENT_POSITION_FOLLOWING)
                         return -1; // a comes before b
@@ -35,9 +37,9 @@ export class FormHook {
                 try {
                     this.isSubmitted = true;
                     this.context.isLoading = true;
-                    this.signal({ isError: false });
+                    this.signal({ isError: false, disabled: true });
                     const formObject = this.getValues();
-                    const values = await this.schemaObject.validate(formObject, { abortEarly: false, strict: true });
+                    const values = await this.schemaObject.validate(formObject, { abortEarly: false });
                     await this.context.formSubmit(values);
                 }
                 catch (error) {
@@ -47,12 +49,13 @@ export class FormHook {
                         error.inner.forEach((element) => {
                             if (element.path) {
                                 this.formErrors[element.path] = element.message;
-                                if (!errorFields.find(field => field.name === element.path))
+                                if (!errorFields.find(field => field.name === element.path)) {
                                     errorFields.push({
                                         isError: true,
                                         name: element.path,
                                         errorMessage: element.message,
                                     });
+                                }
                             }
                         });
                         this.signal(errorFields);
@@ -62,22 +65,30 @@ export class FormHook {
                         console.error('Unexpected Error:', error);
                 }
                 finally {
+                    this.signal({ disabled: false });
                     this.context.isLoading = false;
                 }
             })();
         };
         this.newController = (name, fieldType) => {
-            if (fieldType === 'text')
-                this.subscribedFields[name] = {
-                    name,
-                    isError: false,
-                    disabled: false,
-                    errorMessage: '',
-                    onInput: (event) => {
+            const validationDescription = this.schemaObject.describe().fields[name];
+            const sharedFields = {
+                name,
+                fieldType,
+                isError: false,
+                disabled: false,
+                errorMessage: '',
+                isRequired: validationDescription === null || validationDescription === void 0 ? void 0 : validationDescription.tests.some(test => test.name === 'required'),
+            };
+            if (fieldType === 'text' || fieldType === 'number' || fieldType === 'text-area')
+                this.subscribedFields[name] = Object.assign(Object.assign({}, sharedFields), { inputChanges: (event) => {
                         const value = event.target.value;
                         this.onChanges(name, value);
-                    },
-                };
+                    } });
+            else if (fieldType === 'select')
+                this.subscribedFields[name] = Object.assign(Object.assign({}, sharedFields), { inputChanges: (value) => {
+                        this.onChanges(name, value);
+                    } });
             return this.subscribedFields[name];
         };
         this.signal = (partialSignal) => {

package/dist/collection/global/lib/recaptcha.js

@@ -0,0 +1,25 @@
+/*!
+ * Built by ShiftSoftware
+ * Copyright (c)
+ */
+export const setupRecaptcha = (recaptchaKey, language = 'en', callback = () => { }) => {
+    console.log(language);
+    if (!recaptchaKey)
+        return;
+    const oldScript = document.querySelector("script[src*='recaptcha/api.js']");
+    if (oldScript) {
+        oldScript.remove();
+        console.log('Old reCAPTCHA script removed');
+    }
+    const recaptchaContainers = document.getElementsByClassName('g-recaptcha');
+    Array.from(recaptchaContainers).forEach(container => container.remove());
+    const script = document.createElement('script');
+    script.src = `https://www.google.com/recaptcha/api.js?render=explicit&hl=${language}`;
+    script.async = true;
+    script.defer = true;
+    script.onload = () => {
+        console.log(`reCAPTCHA script loaded with language: ${language}`);
+        callback();
+    };
+    document.head.appendChild(script);
+};

package/dist/collection/global/lib/validate-form-structure.js

@@ -0,0 +1,47 @@
+/*!
+ * Built by ShiftSoftware
+ * Copyright (c)
+ */
+function parseElement(str) {
+    const elementPart = str.split(/\.|#/)[0];
+    const classMatch = str.match(/\.(\w+)/);
+    const idMatch = str.match(/#(\w+)/);
+    return {
+        children: [],
+        element: elementPart,
+        id: idMatch ? idMatch[1] : '',
+        class: classMatch ? classMatch[1] : '',
+    };
+}
+const recursiveParser = (structuredArray) => {
+    if (!Array.isArray(structuredArray) || !structuredArray.length)
+        throw new Error('Invalid structure');
+    let parent = { element: '', class: '', id: '', children: [] };
+    let startIndex = 0;
+    if (typeof structuredArray[0] === 'string' && structuredArray[0].startsWith('div')) {
+        parent = parseElement(structuredArray[0]);
+        startIndex++;
+    }
+    for (let idx = startIndex; idx < structuredArray.length; idx++) {
+        const child = structuredArray[idx];
+        if (typeof child === 'string')
+            parent.children.push(parseElement(child));
+        else
+            parent.children.push(recursiveParser(child));
+    }
+    return parent;
+};
+export const formStructureStringExample = '[["div.kodo#j7","name.name#name"], "div.d3#s2"]';
+export const isValidStructure = (requestedStructure) => {
+    try {
+        const parsedStructure = typeof requestedStructure === 'string' ? JSON.parse(requestedStructure) : requestedStructure;
+        if (!Array.isArray(parsedStructure) || !parsedStructure.length)
+            throw new Error('Invalid structure');
+        const structuredObject = recursiveParser(parsedStructure);
+        return structuredObject;
+    }
+    catch (error) {
+        console.log(error);
+        return null;
+    }
+};

package/dist/collection/global/types/forms.js

@@ -0,0 +1 @@
+export {};

package/dist/collection/global/types/general.js

@@ -0,0 +1 @@
+export {};

package/dist/collection/global/types/locales/error-schema.js

@@ -9,6 +9,7 @@ export const errorsSchema = object({
     invalidVin: string().required(),
     noPartsFound: string().required(),
     vinNumberRequired: string().required(),
+    wrongFormStructure: string().required(),
     partNumberRequired: string().required(),
     noServiceAvailable: string().required(),
     wrongResponseFormat: string().required(),

package/dist/collection/global/types/locales/forms/contact-us-schema.js

@@ -0,0 +1,24 @@
+/*!
+ * Built by ShiftSoftware
+ * Copyright (c)
+ */
+import { object, string } from "yup";
+export const contactUsSchema = object({
+    fullName: string().required(),
+    fullNameMinimum: string().required(),
+    fullNameIsRequired: string().required(),
+    emailAddress: string().required(),
+    emailAddressNotValid: string().required(),
+    city: string().required(),
+    selectCity: string().required(),
+    cityIsRequired: string().required(),
+    phoneNumber: string().required(),
+    phoneNumberIsRequired: string().required(),
+    phoneNumberFormatInvalid: string().required(),
+    inquiryType: string().required(),
+    selectInquiryType: string().required(),
+    inquiryTypeIsRequired: string().required(),
+    writeAMessage: string().required(),
+    leaveUsMessage: string().required(),
+    messageIsRequired: string().required(),
+});

package/dist/collection/global/types/locales/forms/index.js

@@ -0,0 +1,11 @@
+/*!
+ * Built by ShiftSoftware
+ * Copyright (c)
+ */
+import { object, string } from "yup";
+import { contactUsSchema } from "./contact-us-schema";
+export const FormsSchema = object({
+    contactUs: contactUsSchema,
+    reCaptchaIsRequired: string().required(),
+    inputValueIsIncorrect: string().required(),
+});

package/dist/collection/global/types/locales/general.js

@@ -0,0 +1,8 @@
+/*!
+ * Built by ShiftSoftware
+ * Copyright (c)
+ */
+import { object, string } from "yup";
+export const generalSchema = object({
+    noSelectOptions: string().required(),
+});

package/dist/collection/global/types/locales/index.js

@@ -3,9 +3,12 @@
  * Copyright (c)
  */
 import { object, string } from "yup";
+import { FormsSchema } from "./forms";
+import { generalSchema } from "./general";
 import { errorsSchema } from "./error-schema";
 import { partLookupSchema } from "./part-lookup";
 import { vehicleLookupSchema } from "./vehicle-lookup";
+import { generalTicketTypesSchema } from "./inquiryTypes";
 export const ARABIC_JSON_FILE = 'ar.json';
 export const ENGLISH_JSON_FILE = 'en.json';
 export const KURDISH_JSON_FILE = 'ku.json';
@@ -17,11 +20,14 @@ export const languageMapper = {
     ru: RUSSIAN_JSON_FILE,
 };
 export const localeSchema = object({
+    forms: FormsSchema,
     errors: errorsSchema,
+    general: generalSchema,
     lang: string().required(),
     noData: string().required(),
     partLookup: partLookupSchema,
     language: string().required(),
     direction: string().required(),
     vehicleLookup: vehicleLookupSchema,
+    generalTicketTypes: generalTicketTypesSchema,
 });

package/dist/collection/global/types/locales/inquiryTypes.js

@@ -0,0 +1,15 @@
+/*!
+ * Built by ShiftSoftware
+ * Copyright (c)
+ */
+import { object, string } from "yup";
+export const generalTicketTypesSchema = object({
+    TLP: string().required(),
+    Complaint: string().required(),
+    PartInquiry: string().required(),
+    SalesCampaign: string().required(),
+    GeneralInquiry: string().required(),
+    ServiceCampaign: string().required(),
+    InstallmentPayment: string().required(),
+    ServicePriceInquiry: string().required(),
+});

package/dist/collection/templates/vehicle-lookup/mock-data.js

@@ -1680,11 +1680,7 @@ const mockData = {
       },
     ],
     ssc: null,
-    vehicleVariantInfo: {
-      modelCode: '13461',
-      sfx: 'HN',
-      modelYear: 2023,
-    },
+    vehicleVariantInfo: null,
     vehicleSpecification: {
       modelDesc: 'HILUX 2.7 D/C 4*4/AT/High/ADD',
       variantDesc: '2.7L/DC/4x4/AT/High/ADD',

package/dist/components/{general-inquiry-form.d.ts → contact-us-form.d.ts}

@@ -1,9 +1,9 @@
 import type { Components, JSX } from "../types/components";
 
-interface GeneralInquiryForm extends Components.GeneralInquiryForm, HTMLElement {}
-export const GeneralInquiryForm: {
-    prototype: GeneralInquiryForm;
-    new (): GeneralInquiryForm;
+interface ContactUsForm extends Components.ContactUsForm, HTMLElement {}
+export const ContactUsForm: {
+    prototype: ContactUsForm;
+    new (): ContactUsForm;
 };
 /**
  * Used to define this component and all nested components recursively.