adp-web-components 0.0.65 → 0.0.66

package/dist/collection/global/api/partInformation.js

@@ -0,0 +1,32 @@
+/*!
+ * Built by ShiftSoftware
+ * Copyright (c)
+ */
+export const getPartInformation = async (component, generalProps, headers = {}) => {
+    const { notAvailableMessage, mockData, partNumber, scopedTimeoutRef, middlewareCallback } = generalProps;
+    const { isDev, baseUrl, queryString, abortController, networkTimeoutRef, loadedResponse } = component;
+    const handleResult = (newPartInformation) => {
+        if (networkTimeoutRef === scopedTimeoutRef) {
+            if (!newPartInformation && partNumber)
+                throw new Error(notAvailableMessage || 'wrongResponseFormat');
+            if (loadedResponse)
+                loadedResponse(newPartInformation);
+            if (middlewareCallback)
+                middlewareCallback(newPartInformation);
+            return newPartInformation;
+        }
+    };
+    if (isDev) {
+        const newData = mockData[partNumber];
+        return handleResult(newData);
+    }
+    else {
+        if (!baseUrl)
+            throw new Error('noBaseUrl');
+        const response = await fetch(`${baseUrl}${partNumber}?${queryString}`, { signal: abortController.signal, headers: headers });
+        if (response.status === 204)
+            throw new Error('noPartsFound');
+        const newData = (await response.json());
+        return handleResult(newData);
+    }
+};

package/dist/collection/global/api/urls.js

@@ -0,0 +1,6 @@
+/*!
+ * Built by ShiftSoftware
+ * Copyright (c)
+ */
+export const TIQ_VEHICLES = 'https://tiq-tickets.azurewebsites.net';
+export const CITY_ENDPOINT = 'https://tiq-identity-server.azurewebsites.net/api/public/city';

package/dist/collection/global/api/vehicleInformation.js

@@ -0,0 +1,48 @@
+/*!
+ * Built by ShiftSoftware
+ * Copyright (c)
+ */
+const vehicleRequestHeaders = {
+    cityId: 'City-Id',
+    userId: 'User-Id',
+    companyId: 'Company-Id',
+    customerName: 'Customer-Name',
+    customerPhone: 'Customer-Phone',
+    customerEmail: 'Customer-Email',
+    companyBranchId: 'Company-Branch-Id',
+    cityIntegrationId: 'City-Integration-Id',
+    brandIntegrationId: 'Brand-Integration-Id',
+    companyIntegrationId: 'Company-Integration-Id',
+    companyBranchIntegrationId: 'Company-Branch-Integration-Id',
+};
+export const getVehicleInformation = async (component, generalProps, headers = {}) => {
+    const { notAvailableMessage, mockData, vin, scopedTimeoutRef, middlewareCallback } = generalProps;
+    const { isDev, baseUrl, queryString, abortController, networkTimeoutRef, loadedResponse } = component;
+    const handleResult = (newVehicleInformation) => {
+        if (networkTimeoutRef === scopedTimeoutRef) {
+            if (!newVehicleInformation && vin)
+                throw new Error(notAvailableMessage || 'wrongResponseFormat');
+            if (loadedResponse)
+                loadedResponse(newVehicleInformation);
+            if (middlewareCallback)
+                middlewareCallback(newVehicleInformation);
+            return newVehicleInformation;
+        }
+    };
+    if (isDev) {
+        const newData = mockData[vin];
+        return handleResult(newData);
+    }
+    else {
+        if (!baseUrl)
+            throw new Error('noBaseUrl');
+        const componentHeaders = Object.assign({}, headers);
+        Object.entries(vehicleRequestHeaders).forEach(([componentHeaderKey, headerField]) => {
+            if (component[componentHeaderKey])
+                componentHeaders[headerField] = component[componentHeaderKey];
+        });
+        const response = await fetch(`${baseUrl}${vin}?${queryString}`, { signal: abortController.signal, headers: componentHeaders });
+        const newData = (await response.json());
+        return handleResult(newData);
+    }
+};

package/dist/collection/global/assets/eye.svg

@@ -0,0 +1,5 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" fill="none" stroke="white"
+    stroke-width="2" stroke-linecap="round" stroke-linejoin="round" class="lucide lucide-eye">
+    <path d="M2.062 12.348a1 1 0 0 1 0-.696 10.75 10.75 0 0 1 19.876 0 1 1 0 0 1 0 .696 10.75 10.75 0 0 1-19.876 0" />
+    <circle cx="12" cy="12" r="3" />
+</svg>

package/dist/collection/global/assets/loader.svg

@@ -0,0 +1,11 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" fill="none" stroke="currentColor"
+    stroke-width="2" stroke-linecap="round" stroke-linejoin="round" class="lucide lucide-loader">
+    <path d="M12 2v4" />
+    <path d="m16.2 7.8 2.9-2.9" />
+    <path d="M18 12h4" />
+    <path d="m16.2 16.2 2.9 2.9" />
+    <path d="M12 18v4" />
+    <path d="m4.9 19.1 2.9-2.9" />
+    <path d="M2 12h4" />
+    <path d="m4.9 4.9 2.9 2.9" />
+</svg>

package/dist/collection/global/assets/white-loader.svg

@@ -0,0 +1,11 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" fill="none" stroke="white"
+    stroke-width="2" stroke-linecap="round" stroke-linejoin="round" class="lucide lucide-loader">
+    <path d="M12 2v4" />
+    <path d="m16.2 7.8 2.9-2.9" />
+    <path d="M18 12h4" />
+    <path d="m16.2 16.2 2.9 2.9" />
+    <path d="M12 18v4" />
+    <path d="m4.9 19.1 2.9-2.9" />
+    <path d="M2 12h4" />
+    <path d="m4.9 4.9 2.9 2.9" />
+</svg>

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

@@ -0,0 +1,9 @@
+/*!
+ * Built by ShiftSoftware
+ * Copyright (c)
+ */
+import { clsx } from "clsx";
+import { twMerge } from "tailwind-merge";
+export default function cn(...inputs) {
+    return twMerge(clsx(inputs));
+}

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

@@ -0,0 +1,162 @@
+/*!
+ * Built by ShiftSoftware
+ * Copyright (c)
+ */
+export class FormHook {
+    constructor(context, schemaObject, formStateOptions) {
+        this.successAnimation = () => { };
+        this.isSubmitted = false;
+        this.cachedValues = {};
+        this.subscribers = [];
+        this.haltValidation = false;
+        this.validationType = 'onSubmit';
+        this.subscribedFields = {};
+        this.formErrors = {};
+        this.setSuccessAnimation = (newSuccessAnimation) => (this.successAnimation = newSuccessAnimation);
+        this.subscribe = (formName, formElement) => this.subscribers.push({ name: formName, context: formElement });
+        this.unsubscribe = (formName) => (this.subscribers = this.subscribers.filter(({ name }) => name !== formName));
+        this.onInput = (event) => {
+            const target = event.target;
+            if (this.onValuesUpdate)
+                this.onValuesUpdate(Object.assign(Object.assign({}, this.getValues()), { [target.name]: target.value }));
+            this.validateForm(target.name, target.value);
+        };
+        this.resetFormErrorMessage = () => (this.context.errorMessage = '');
+        this.getFormErrors = () => this.formErrors;
+        this.setCachedValues = (newValues) => {
+            this.cachedValues = newValues;
+        };
+        this.getValues = () => {
+            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 Object.assign(Object.assign({}, this.cachedValues), formObject);
+        };
+        this.focusFirstInput = (errorFields) => {
+            if (errorFields.length) {
+                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
+                    if (a.compareDocumentPosition(b) & Node.DOCUMENT_POSITION_PRECEDING)
+                        return 1; // b comes before a
+                    return 0; // They are the same
+                });
+                if (sortedDomElements[0])
+                    sortedDomElements[0].focus();
+            }
+        };
+        this.onSubmit = (formEvent) => {
+            formEvent.preventDefault();
+            (async () => {
+                try {
+                    this.isSubmitted = true;
+                    this.context.isLoading = true;
+                    this.signal({ isError: false, disabled: true });
+                    const formObject = Object.assign(Object.assign({}, this.cachedValues), this.getValues());
+                    const values = await this.schemaObject.validate(formObject, { abortEarly: false });
+                    await this.context.formSubmit(values);
+                }
+                catch (error) {
+                    if (error.name === 'ValidationError') {
+                        this.formErrors = {};
+                        const errorFields = [];
+                        error.inner.forEach((element) => {
+                            if (element.path) {
+                                this.formErrors[element.path] = element.message;
+                                if (!errorFields.find(field => field.name === element.path)) {
+                                    errorFields.push({
+                                        isError: true,
+                                        name: element.path,
+                                        errorMessage: element.message,
+                                    });
+                                }
+                            }
+                        });
+                        this.signal(errorFields);
+                        this.focusFirstInput(errorFields);
+                        this.context.renderControl = {};
+                    }
+                    else
+                        console.error('Unexpected Error:', error);
+                }
+                finally {
+                    this.signal({ disabled: false });
+                    this.context.isLoading = false;
+                }
+            })();
+        };
+        this.getInputState = (name) => {
+            const validationDescription = this.schemaObject.describe().fields[name];
+            if (!this.subscribedFields[name])
+                this.subscribedFields[name] = {
+                    name,
+                    isError: false,
+                    disabled: false,
+                    errorMessage: '',
+                    continuousValidation: false,
+                    isRequired: validationDescription === null || validationDescription === void 0 ? void 0 : validationDescription.tests.some(test => test.name === 'required'),
+                };
+            return this.subscribedFields[name];
+        };
+        this.signal = (partialSignal) => {
+            if (Array.isArray(partialSignal)) {
+                partialSignal.forEach(field => {
+                    if (this.subscribedFields[field.name])
+                        Object.assign(this.subscribedFields[field.name], field);
+                });
+            }
+            else {
+                Object.values(this.subscribedFields).forEach(field => Object.assign(field, partialSignal));
+            }
+        };
+        this.validateInput = (name) => {
+            const value = (this.getValues()[name] || '');
+            return this.validateForm(name, value, false);
+        };
+        this.validateForm = (name, value, strict = true) => {
+            if (strict) {
+                if (this.haltValidation)
+                    return;
+                if (!this.isSubmitted && this.validationType !== 'always' && !this.subscribedFields[name].continuousValidation)
+                    return;
+            }
+            const wasError = this.subscribedFields[name].isError;
+            try {
+                // @ts-ignore
+                this.schemaObject.fields[name].validateSync(value);
+                this.signal([{ name, isError: false }]);
+                if (wasError !== false)
+                    this.context.renderControl = {};
+                return { isError: false, errorMessage: '' };
+            }
+            catch (error) {
+                if (error.message) {
+                    this.signal([{ name, isError: true, errorMessage: error.message }]);
+                    this.context.renderControl = {};
+                    return { isError: true, errorMessage: error.message };
+                }
+            }
+            finally {
+                this.subscribedFields[name].continuousValidation = true;
+            }
+        };
+        this.context = context;
+        this.schemaObject = schemaObject;
+        this.formController = { onSubmit: this.onSubmit, onInput: this.onInput };
+        if (formStateOptions === null || formStateOptions === void 0 ? void 0 : formStateOptions.validationType)
+            this.validationType = formStateOptions.validationType;
+    }
+    reset() {
+        this.haltValidation = true;
+        this.signal({ isError: false, disabled: false });
+        this.subscribers.forEach(subscriber => {
+            subscriber.context.reset();
+        });
+        this.isSubmitted = false;
+        this.haltValidation = false;
+        this.context.renderControl = {};
+    }
+}

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

@@ -0,0 +1,9 @@
+/*!
+ * Built by ShiftSoftware
+ * Copyright (c)
+ */
+export function capitalize(str) {
+    if (!str)
+        return str;
+    return str.charAt(0).toUpperCase() + str.slice(1).toLowerCase();
+}

package/dist/collection/global/lib/get-local-language.js

@@ -0,0 +1,20 @@
+/*!
+ * Built by ShiftSoftware
+ * Copyright (c)
+ */
+import { Build } from "@stencil/core";
+import { version } from "../../../package.json";
+import { languageMapper } from "../types/locales/index";
+const cachedLocales = {};
+export const getLocaleLanguage = async (fileKey) => {
+    const languageFile = languageMapper[fileKey] || languageMapper.en;
+    if (cachedLocales[languageFile])
+        return await cachedLocales[languageFile];
+    let localeResponse;
+    if (Build.isDev)
+        localeResponse = fetch('../../locales/' + languageFile).then(res => res.json());
+    else
+        localeResponse = fetch(`https://cdn.jsdelivr.net/npm/adp-web-components@${version}/dist/locales/${languageFile}`).then(res => res.json());
+    cachedLocales[languageFile] = localeResponse;
+    return await localeResponse;
+};

package/dist/collection/global/lib/image-expansion.js

@@ -0,0 +1,69 @@
+/*!
+ * Built by ShiftSoftware
+ * Copyright (c)
+ */
+export function openImageViewer(context, target, imageSrc) {
+    if (context.expandedImage === imageSrc)
+        return;
+    context.originalImage = target;
+    const expandedImageRef = context.el.shadowRoot.getElementById('expanded-image');
+    expandedImageRef.src = target.src;
+    document.addEventListener('keydown', context.closeImageListener);
+    const rect = target.getBoundingClientRect();
+    document.body.style.overflow = 'hidden';
+    Object.assign(expandedImageRef.style, {
+        top: `${rect.top}px`,
+        pointerEvents: 'auto',
+        left: `${rect.left}px`,
+        transitionDuration: '0s',
+        width: `${rect.width}px`,
+        height: `${rect.height}px`,
+    });
+    setTimeout(() => {
+        const naturalWidth = target.naturalWidth;
+        const naturalHeight = target.naturalHeight;
+        const maxWidth = window.innerWidth - 160;
+        const maxHeight = window.innerHeight - 32;
+        const aspectRatio = naturalWidth / naturalHeight;
+        let width, height;
+        if (maxWidth / aspectRatio <= maxHeight) {
+            width = maxWidth;
+            height = maxWidth / aspectRatio;
+        }
+        else {
+            height = maxHeight;
+            width = maxHeight * aspectRatio;
+        }
+        expandedImageRef.style.transitionDuration = '0.3s';
+        Object.assign(expandedImageRef.style, {
+            opacity: '1',
+            width: `${width}px`,
+            height: `${height}px`,
+            top: `${(window.innerHeight - height) / 2}px`,
+            left: `${(window.innerWidth - width) / 2}px`,
+        });
+        context.expandedImage = imageSrc;
+    }, 200);
+}
+export function closeImageViewer(context, event) {
+    if (event && event.key !== 'Escape')
+        return;
+    document.removeEventListener('keydown', context.closeImageListener);
+    const expandedImageRef = context.el.shadowRoot.getElementById('expanded-image');
+    const rect = context.originalImage.getBoundingClientRect();
+    Object.assign(expandedImageRef.style, {
+        top: `${rect.top}px`,
+        pointerEvents: 'none',
+        left: `${rect.left}px`,
+        width: `${rect.width}px`,
+        height: `${rect.height}px`,
+        transitionDuration: '0.3s',
+    });
+    setTimeout(() => {
+        expandedImageRef.src = '';
+        expandedImageRef.style.opacity = '0';
+        expandedImageRef.style.transitionDuration = '0s';
+    }, 300);
+    document.body.style.overflow = '';
+    context.expandedImage = null;
+}

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

@@ -0,0 +1,39 @@
+/*!
+ * Built by ShiftSoftware
+ * Copyright (c)
+ */
+(async function () {
+    if (!window['blazorInvoke']) {
+        window['blazorInvoke'] = async function (selector, functionName, ...args) {
+            const element = document.querySelector(selector);
+            if (!element) {
+                console.error(`Element with selector "${selector}" not found.`);
+                return;
+            }
+            if (typeof element[functionName] !== 'function') {
+                console.error(`Function "${functionName}" not found on the element.`);
+                return;
+            }
+            try {
+                return await element[functionName](...args);
+            }
+            catch (error) {
+                console.error(`Error invoking function "${functionName}" on element "${selector}":`, error);
+            }
+        };
+        window['blazorInvokeSet'] = async function (selector, field, value) {
+            const element = document.querySelector(selector);
+            if (!element) {
+                console.error(`Element with selector "${selector}" not found.`);
+                return;
+            }
+            try {
+                return (element[field] = value);
+            }
+            catch (error) {
+                console.error(`Setting field ${field} failed to set value: ${value}:`, error);
+            }
+        };
+        console.log('Global blazorInvoke initialized.');
+    }
+})();

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/utils.js

@@ -0,0 +1,7 @@
+/*!
+ * Built by ShiftSoftware
+ * Copyright (c)
+ */
+export function format(first, middle, last) {
+    return (first || '') + (middle ? ` ${middle}` : '') + (last ? ` ${last}` : '');
+}

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/lib/validate-vin.js

@@ -0,0 +1,62 @@
+/*!
+ * Built by ShiftSoftware
+ * Copyright (c)
+ */
+export default function validateVin(vin) {
+    const TransliterationTable = {
+        0: 0,
+        1: 1,
+        2: 2,
+        3: 3,
+        4: 4,
+        5: 5,
+        6: 6,
+        7: 7,
+        8: 8,
+        9: 9,
+        A: 1,
+        B: 2,
+        C: 3,
+        D: 4,
+        E: 5,
+        F: 6,
+        G: 7,
+        H: 8,
+        J: 1,
+        K: 2,
+        L: 3,
+        M: 4,
+        N: 5,
+        P: 7,
+        R: 9,
+        S: 2,
+        T: 3,
+        U: 4,
+        V: 5,
+        W: 6,
+        X: 7,
+        Y: 8,
+        Z: 9,
+    };
+    const WeightTable = [8, 7, 6, 5, 4, 3, 2, 10, 0, 9, 8, 7, 6, 5, 4, 3, 2];
+    let sum = 0;
+    let valid = true;
+    for (let i = 0; i < vin.length; i++) {
+        const char = vin[i].toUpperCase();
+        const value = TransliterationTable[char];
+        if (value === undefined) {
+            valid = false;
+            break;
+        }
+        const weight = WeightTable[i];
+        const product = value * weight;
+        sum = sum + product;
+    }
+    let reminder = (sum % 11).toString();
+    if (reminder === '10')
+        reminder = 'X';
+    if (vin[8] != reminder) {
+        valid = false;
+    }
+    return valid;
+}

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

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

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

@@ -0,0 +1,17 @@
+/*!
+ * Built by ShiftSoftware
+ * Copyright (c)
+ */
+import { object, string } from "yup";
+export const errorsSchema = object({
+    wildCard: string().required(),
+    noBaseUrl: string().required(),
+    invalidVin: string().required(),
+    noPartsFound: string().required(),
+    vinNumberRequired: string().required(),
+    wrongFormStructure: string().required(),
+    partNumberRequired: string().required(),
+    noServiceAvailable: string().required(),
+    wrongResponseFormat: string().required(),
+    requestFailedPleaseTryAgainLater: 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,11 @@
+/*!
+ * Built by ShiftSoftware
+ * Copyright (c)
+ */
+import { object, string } from "yup";
+export const generalSchema = object({
+    close: string().required(),
+    submit: string().required(),
+    noSelectOptions: string().required(),
+    formSubmittedSuccessfully: string().required(),
+});