optimized-react-component-library-xyz123 0.1.102 → 0.1.104

package/dist/NewHelpMethodsStandard/ApplicationContentSlice/applicationContentSlice.d.ts

@@ -0,0 +1,87 @@
+import { PayloadAction } from '@reduxjs/toolkit';
+/** ----- Typer ----- */
+export interface LanguageEntry {
+    language: string;
+    backButton: string;
+    forwardButton: string;
+    sendButton: string;
+}
+export interface LanguageSupportConfig {
+    activatedLanguage: string;
+    languageSupport: LanguageEntry[];
+}
+export interface LanguageState {
+    activatedLanguage: string;
+    languageSupport: LanguageEntry[];
+    languageSupportLoaded: boolean;
+    backButton: string;
+    forwardButton: string;
+    sendButton: string;
+}
+/** ----- Helpers ----- */
+export declare const pickLang: (cfg: LanguageSupportConfig, lang: string) => LanguageEntry;
+/** ----- Slice-fabrik (ingen app-specifik state/RootState här) ----- */
+export declare const createLanguageSlice: (initialConfig: LanguageSupportConfig, options?: {
+    name?: string;
+}) => import("@reduxjs/toolkit").Slice<LanguageState, {
+    setActivatedLanguage: (state: import("immer").WritableDraft<LanguageState>, action: PayloadAction<string>) => void;
+    setLabelsFromLanguageEntry: (state: import("immer").WritableDraft<LanguageState>, action: PayloadAction<Pick<LanguageEntry, "backButton" | "forwardButton" | "sendButton">>) => void;
+    replaceLanguageSupport: (state: import("immer").WritableDraft<LanguageState>, action: PayloadAction<LanguageSupportConfig>) => void;
+}, string, string, import("@reduxjs/toolkit").SliceSelectors<LanguageState>>;
+/** ----- Selector-fabrik (helt generisk, ingen RootState) ----- */
+export declare const makeLanguageSelectors: <TState>(selectSlice: (state: TState) => LanguageState) => {
+    selectActivatedLanguage: (state: TState) => string;
+    selectLanguageSupportLoaded: (state: TState) => boolean;
+    selectLanguageSupport: (state: TState) => LanguageEntry[];
+    selectOverallContentState: (state: TState) => LanguageState;
+    selectOverallContentFromLanguageSupport: ((state: TState, activatedLanguage: string) => {
+        activatedLanguage: string;
+        languageSupport: LanguageEntry[];
+        languageSupportLoaded: boolean;
+        backButton: string;
+        forwardButton: string;
+        sendButton: string;
+    }) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    } & {
+        resultFunc: (resultFuncArgs_0: LanguageState, resultFuncArgs_1: string) => {
+            activatedLanguage: string;
+            languageSupport: LanguageEntry[];
+            languageSupportLoaded: boolean;
+            backButton: string;
+            forwardButton: string;
+            sendButton: string;
+        };
+        memoizedResultFunc: ((resultFuncArgs_0: LanguageState, resultFuncArgs_1: string) => {
+            activatedLanguage: string;
+            languageSupport: LanguageEntry[];
+            languageSupportLoaded: boolean;
+            backButton: string;
+            forwardButton: string;
+            sendButton: string;
+        }) & {
+            clearCache: () => void;
+            resultsCount: () => number;
+            resetResultsCount: () => void;
+        };
+        lastResult: () => {
+            activatedLanguage: string;
+            languageSupport: LanguageEntry[];
+            languageSupportLoaded: boolean;
+            backButton: string;
+            forwardButton: string;
+            sendButton: string;
+        };
+        dependencies: [(state: TState) => LanguageState, (_: TState, activatedLanguage: string) => string];
+        recomputations: () => number;
+        resetRecomputations: () => void;
+        dependencyRecomputations: () => number;
+        resetDependencyRecomputations: () => void;
+    } & {
+        memoize: typeof import("reselect").weakMapMemoize;
+        argsMemoize: typeof import("reselect").weakMapMemoize;
+    };
+};
+export type { PayloadAction } from '@reduxjs/toolkit';

package/dist/NewHelpMethodsStandard/ApplicationContentSlice/applicationContentSlice.js

@@ -0,0 +1,75 @@
+// src/languageSlice.ts (i NPM-paketet)
+import { createSlice, createSelector } from '@reduxjs/toolkit';
+/** ----- Helpers ----- */
+export const pickLang = (cfg, lang) => {
+    var _a;
+    return (_a = cfg.languageSupport.find((l) => l.language === lang)) !== null && _a !== void 0 ? _a : cfg.languageSupport[0];
+};
+/** ----- Slice-fabrik (ingen app-specifik state/RootState här) ----- */
+export const createLanguageSlice = (initialConfig, options) => {
+    var _a;
+    const name = (_a = options === null || options === void 0 ? void 0 : options.name) !== null && _a !== void 0 ? _a : 'applicationContent';
+    const initialLang = pickLang(initialConfig, initialConfig.activatedLanguage);
+    const initialState = {
+        activatedLanguage: initialConfig.activatedLanguage,
+        languageSupport: initialConfig.languageSupport,
+        languageSupportLoaded: true,
+        backButton: initialLang.backButton,
+        forwardButton: initialLang.forwardButton,
+        sendButton: initialLang.sendButton,
+    };
+    const slice = createSlice({
+        name,
+        initialState,
+        reducers: {
+            setActivatedLanguage: (state, action) => {
+                state.activatedLanguage = action.payload;
+                const lang = pickLang({ activatedLanguage: state.activatedLanguage, languageSupport: state.languageSupport }, action.payload);
+                state.backButton = lang.backButton;
+                state.forwardButton = lang.forwardButton;
+                state.sendButton = lang.sendButton;
+            },
+            setLabelsFromLanguageEntry: (state, action) => {
+                state.backButton = action.payload.backButton;
+                state.forwardButton = action.payload.forwardButton;
+                state.sendButton = action.payload.sendButton;
+            },
+            replaceLanguageSupport: (state, action) => {
+                state.languageSupport = action.payload.languageSupport;
+                state.activatedLanguage = action.payload.activatedLanguage;
+                const lang = pickLang(action.payload, action.payload.activatedLanguage);
+                state.backButton = lang.backButton;
+                state.forwardButton = lang.forwardButton;
+                state.sendButton = lang.sendButton;
+                state.languageSupportLoaded = true;
+            },
+        },
+    });
+    return slice;
+};
+/** ----- Selector-fabrik (helt generisk, ingen RootState) ----- */
+export const makeLanguageSelectors = (selectSlice) => {
+    const selectState = selectSlice;
+    const selectActivatedLanguage = (state) => selectState(state).activatedLanguage;
+    const selectLanguageSupportLoaded = (state) => selectState(state).languageSupportLoaded;
+    const selectLanguageSupport = (state) => selectState(state).languageSupport;
+    const selectOverallContentState = (state) => selectState(state);
+    const selectOverallContentFromLanguageSupport = createSelector([selectState, (_, activatedLanguage) => activatedLanguage], (applicationContent, activatedLanguage) => {
+        const match = applicationContent.languageSupport.find((l) => l.language === activatedLanguage);
+        if (!match)
+            return { ...applicationContent };
+        return {
+            ...applicationContent,
+            backButton: match.backButton,
+            forwardButton: match.forwardButton,
+            sendButton: match.sendButton,
+        };
+    });
+    return {
+        selectActivatedLanguage,
+        selectLanguageSupportLoaded,
+        selectLanguageSupport,
+        selectOverallContentState,
+        selectOverallContentFromLanguageSupport,
+    };
+};

package/dist/NewHelpMethodsStandard/CookieHandler/cookieHandler.d.ts

@@ -0,0 +1,12 @@
+export interface CookieConsentConfig {
+    cookieName: string;
+    choiceKey: string;
+    expiryYears?: number;
+}
+export declare const createCookieConsent: (config: CookieConsentConfig) => {
+    acceptCookies: () => void;
+    rejectCookies: () => void;
+    areCookiesAccepted: () => boolean;
+    hasChoiceBeenMade: () => boolean;
+    clearChoiceFromSession: () => void;
+};

package/dist/NewHelpMethodsStandard/CookieHandler/cookieHandler.js

@@ -0,0 +1,42 @@
+const getCookie = (name) => {
+    const match = document.cookie.match(new RegExp('(^| )' + name + '=([^;]+)'));
+    return match ? match[2] : null;
+};
+const setCookie = (name, value, expirationDate) => {
+    let cookieString = `${name}=${value}; path=/; SameSite=Strict`;
+    if (expirationDate) {
+        cookieString += `; expires=${expirationDate.toUTCString()}`;
+    }
+    if (window.location.protocol === 'https:') {
+        cookieString += '; Secure';
+    }
+    document.cookie = cookieString;
+};
+const removeCookie = (name) => {
+    const pastDate = new Date(0);
+    setCookie(name, '', pastDate);
+};
+export const createCookieConsent = (config) => {
+    const { cookieName, choiceKey, expiryYears = 1 } = config;
+    const acceptCookies = () => {
+        const expires = new Date();
+        expires.setFullYear(expires.getFullYear() + expiryYears);
+        setCookie(cookieName, 'true', expires);
+        localStorage.setItem(cookieName, 'true');
+    };
+    const rejectCookies = () => {
+        removeCookie(cookieName);
+        localStorage.removeItem(cookieName);
+        sessionStorage.setItem(choiceKey, 'true');
+    };
+    const areCookiesAccepted = () => getCookie(cookieName) === 'true';
+    const hasChoiceBeenMade = () => sessionStorage.getItem(choiceKey) === 'true';
+    const clearChoiceFromSession = () => sessionStorage.removeItem(choiceKey);
+    return {
+        acceptCookies,
+        rejectCookies,
+        areCookiesAccepted,
+        hasChoiceBeenMade,
+        clearChoiceFromSession,
+    };
+};

package/dist/NewHelpMethodsStandard/CreateApiDataObject/CreateApiDataObject.d.ts

@@ -0,0 +1,3 @@
+import type { TranslatedAnswers, ApiDataObject } from './CreateApiDataObject.types';
+declare function CreateApiDataObject(data: any[], specialMappedQuestions: Set<string>, translatedAnswers: TranslatedAnswers): ApiDataObject;
+export default CreateApiDataObject;

package/dist/NewHelpMethodsStandard/CreateApiDataObject/CreateApiDataObject.js

@@ -0,0 +1,44 @@
+const normalize = (str) => {
+    return str.toString().toLowerCase().replace(/\s+/g, '');
+};
+function CreateApiDataObject(data, specialMappedQuestions, translatedAnswers) {
+    return data.reduce((acc, question) => {
+        var _a;
+        let translatedAnswer = question.answer;
+        if (question.answer &&
+            typeof question.answer === 'string' &&
+            Array.isArray(question.options) &&
+            question.mappingId &&
+            specialMappedQuestions.has(question.mappingId)) {
+            const answerNormalized = normalize(question.answer);
+            const matchingIds = question.options
+                .filter((option) => answerNormalized.includes(normalize(option.label)))
+                .map((option) => `^${option.id}^`);
+            if (matchingIds.length > 0) {
+                translatedAnswer = matchingIds.join(',');
+            }
+        }
+        else {
+            const shouldTranslate = question.mappingId
+                ? translatedAnswers[question.mappingId]
+                : undefined;
+            translatedAnswer = shouldTranslate
+                ? shouldTranslate[question.answer] || question.answer
+                : question.answer;
+        }
+        return {
+            ...acc,
+            ...(question.mappingId &&
+                question.isDisplayed &&
+                question.answer && {
+                [question.mappingId]: translatedAnswer,
+            }),
+            ...(question.questionType === 'AddFiles' &&
+                ((_a = question.files) === null || _a === void 0 ? void 0 : _a.length) &&
+                question.files.length > 0 && {
+                files: question.files,
+            }),
+        };
+    }, {});
+}
+export default CreateApiDataObject;

package/dist/NewHelpMethodsStandard/CreateApiDataObject/CreateApiDataObject.types.d.ts

@@ -0,0 +1,8 @@
+export interface TranslatedAnswers {
+    [questionId: string]: {
+        [originalAnswer: string]: string;
+    };
+}
+export interface ApiDataObject {
+    [key: string]: string | number | boolean | File[];
+}

package/dist/NewHelpMethodsStandard/CreateApiDataObject/CreateApiDataObject.types.js

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

package/dist/NewHelpMethodsStandard/CreateApiDataObject/index.d.ts

@@ -0,0 +1,2 @@
+export { default } from './CreateApiDataObject';
+export type { TranslatedAnswers, ApiDataObject } from './CreateApiDataObject.types';

package/dist/NewHelpMethodsStandard/CreateApiDataObject/index.js

@@ -0,0 +1 @@
+export { default } from './CreateApiDataObject';

package/dist/NewHelpMethodsStandard/DoCategoriesAndQuestionsVisible/DoCategoriesAndQuestionsVisible.d.ts

@@ -0,0 +1,3 @@
+import { IQuestion } from '../../NewTypesStandard';
+declare const doCategoriesAndQuestionsVisible: (questions: IQuestion[], validationErrorsList: number[]) => any[];
+export default doCategoriesAndQuestionsVisible;

package/dist/NewHelpMethodsStandard/DoCategoriesAndQuestionsVisible/DoCategoriesAndQuestionsVisible.js

@@ -0,0 +1,11 @@
+import isDependsOnOtherQuestionTrue from '../IsDependsOnOtherQuestionTrue';
+const doCategoriesAndQuestionsVisible = (questions, validationErrorsList) => {
+    const updatedQuestions = questions.map((question) => {
+        const hasLinkedConditions = question.dependsOnOtherQuestion && question.dependsOnOtherQuestion.length > 0;
+        const isVisible = hasLinkedConditions ? isDependsOnOtherQuestionTrue(questions, question) : true; // om inget länkat, visa frågan
+        const hasError = validationErrorsList.includes(question.id);
+        return { ...question, visible: isVisible, hasValidationError: hasError };
+    });
+    return updatedQuestions;
+};
+export default doCategoriesAndQuestionsVisible;

package/dist/NewHelpMethodsStandard/DoCategoriesAndQuestionsVisible/index.d.ts

@@ -0,0 +1 @@
+export { default } from './DoCategoriesAndQuestionsVisible';

package/dist/NewHelpMethodsStandard/DoCategoriesAndQuestionsVisible/index.js

@@ -0,0 +1 @@
+export { default } from './DoCategoriesAndQuestionsVisible';

package/dist/NewHelpMethodsStandard/FocusElement/focusElement.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Sätter fokus på ett element med givet id (eller HTMLElement),
+ * sätter tabindex="-1" om inte redan finns, och scrollar dit smidigt.
+ *
+ * @param target Elementets id (t.ex. 'main-content') eller själva elementet.
+ */
+export declare const focusElement: (target: string | HTMLElement | null) => void;

package/dist/NewHelpMethodsStandard/FocusElement/focusElement.js

@@ -0,0 +1,16 @@
+/**
+ * Sätter fokus på ett element med givet id (eller HTMLElement),
+ * sätter tabindex="-1" om inte redan finns, och scrollar dit smidigt.
+ *
+ * @param target Elementets id (t.ex. 'main-content') eller själva elementet.
+ */
+export const focusElement = (target) => {
+    const element = typeof target === 'string' ? document.getElementById(target) : target;
+    if (!element)
+        return;
+    if (!element.hasAttribute('tabindex')) {
+        element.setAttribute('tabindex', '-1');
+    }
+    element.focus();
+    element.scrollIntoView({ behavior: 'smooth' });
+};

package/dist/NewHelpMethodsStandard/GetIdsGroupCheckValidationTypes/getIdsGroupCheckValidationTypes.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Plockar ut alla id:n från validationType som börjar med "groupCheck-"
+ */
+declare const getIdsGroupCheckValidationTypes: (validationType?: string[]) => number[];
+export { getIdsGroupCheckValidationTypes };

package/dist/NewHelpMethodsStandard/GetIdsGroupCheckValidationTypes/getIdsGroupCheckValidationTypes.js

@@ -0,0 +1,14 @@
+/**
+ * Plockar ut alla id:n från validationType som börjar med "groupCheck-"
+ */
+const getIdsGroupCheckValidationTypes = (validationType) => {
+    if (!(validationType === null || validationType === void 0 ? void 0 : validationType.length))
+        return [];
+    const ids = validationType
+        .filter((t) => t.startsWith('groupCheck-'))
+        .flatMap((t) => t.split('-').slice(1))
+        .map((s) => Number(s))
+        .filter((n) => Number.isFinite(n));
+    return Array.from(new Set(ids));
+};
+export { getIdsGroupCheckValidationTypes };

package/dist/NewHelpMethodsStandard/GroupQuestionByStepPreviewPage/GroupQuestionByStepPreviewPage.d.ts

@@ -0,0 +1,3 @@
+import { IStepObject, IQuestion } from '../../NewTypesStandard/TypesStandard.types';
+declare function groupQuestionByStepPreviewPage(steps: IStepObject[], questions: IQuestion[]): any[];
+export default groupQuestionByStepPreviewPage;

package/dist/NewHelpMethodsStandard/GroupQuestionByStepPreviewPage/GroupQuestionByStepPreviewPage.js

@@ -0,0 +1,12 @@
+function groupQuestionByStepPreviewPage(steps, questions) {
+    return steps
+        .map(step => {
+        const filteredQuestions = questions.filter(q => q.step === step.step && q.isDisplayed);
+        return {
+            step,
+            questions: filteredQuestions,
+        };
+    })
+        .filter(group => group.questions.length > 0);
+}
+export default groupQuestionByStepPreviewPage;

package/dist/NewHelpMethodsStandard/GroupQuestionByStepPreviewPage/index.d.ts

@@ -0,0 +1 @@
+export { default } from './GroupQuestionByStepPreviewPage';

package/dist/NewHelpMethodsStandard/GroupQuestionByStepPreviewPage/index.js

@@ -0,0 +1 @@
+export { default } from './GroupQuestionByStepPreviewPage';

package/dist/NewHelpMethodsStandard/GroupQuestionsByStepCategoryGroup/GroupQuestionsByStepCategoryGroup.d.ts

@@ -0,0 +1,3 @@
+import { IQuestion, IStepObject } from '../../NewTypesStandard';
+declare function groupQuestionsByStepCategoryGroup(questions: IQuestion[], steps: IStepObject[], validationErrorsList: number[]): any[];
+export default groupQuestionsByStepCategoryGroup;

package/dist/NewHelpMethodsStandard/GroupQuestionsByStepCategoryGroup/GroupQuestionsByStepCategoryGroup.js

@@ -0,0 +1,61 @@
+import doCategoriesAndQuestionsVisible from '../DoCategoriesAndQuestionsVisible';
+function groupQuestionsByStepCategoryGroup(questions, steps, validationErrorsList) {
+    var _a, _b;
+    const formatedQuestions = doCategoriesAndQuestionsVisible(questions, validationErrorsList);
+    const result = [];
+    const stepsMap = new Map();
+    formatedQuestions.forEach((question) => {
+        var _a, _b;
+        const step = (_a = question.step) !== null && _a !== void 0 ? _a : 0;
+        const category = ((_b = question.categoryLabel) === null || _b === void 0 ? void 0 : _b.trim()) || 'Okänd kategori';
+        const groupId = question.questionGroupId || 'unknown';
+        if (!stepsMap.has(step)) {
+            stepsMap.set(step, new Map());
+        }
+        const categoryMap = stepsMap.get(step);
+        if (!categoryMap.has(category)) {
+            categoryMap.set(category, new Map());
+        }
+        const groupMap = categoryMap.get(category);
+        if (!groupMap.has(groupId)) {
+            groupMap.set(groupId, []);
+        }
+        groupMap.get(groupId).push(question);
+    });
+    for (const [step, categoryMap] of Array.from(stepsMap.entries())) {
+        const categories = [];
+        for (const [category, groupMap] of Array.from(categoryMap.entries())) {
+            const questionGroups = [];
+            for (const [groupId, questions] of Array.from(groupMap.entries())) {
+                questionGroups.push({
+                    questionGroupId: groupId,
+                    questionGroupType: questions[0].questionGroupType,
+                    questions,
+                    legend: questions[0].categoryDescription,
+                });
+            }
+            const isVisible = questionGroups.some((group) => group.questions.some((question) => question.visible));
+            categories.push({
+                category,
+                visible: isVisible,
+                isDisplayed: isVisible,
+                questionGroups,
+            });
+        }
+        const stepHeadline = ((_a = steps.find((s) => s.step === step)) === null || _a === void 0 ? void 0 : _a.stepHeadline) || undefined;
+        const stepDescription = ((_b = steps.find((s) => s.step === step)) === null || _b === void 0 ? void 0 : _b.stepDescription) || undefined;
+        result.push({
+            step,
+            stepHeadline,
+            stepDescription,
+            categories,
+        });
+    }
+    result.push({
+        step: steps.length,
+        stepHeadline: steps[steps.length - 1].stepHeadline,
+        stepDescription: steps[steps.length - 1].stepDescription,
+    });
+    return result;
+}
+export default groupQuestionsByStepCategoryGroup;

package/dist/NewHelpMethodsStandard/GroupQuestionsByStepCategoryGroup/index.d.ts

@@ -0,0 +1 @@
+export { default } from './GroupQuestionsByStepCategoryGroup';

package/dist/NewHelpMethodsStandard/GroupQuestionsByStepCategoryGroup/index.js

@@ -0,0 +1 @@
+export { default } from './GroupQuestionsByStepCategoryGroup';

package/dist/NewHelpMethodsStandard/InputElements.types.d.ts

@@ -0,0 +1,51 @@
+export interface IQuestionObjectStandard {
+    Id?: number;
+    Order?: number;
+    Step?: number;
+    Category?: string;
+    CategoryOrder?: number;
+    CategoryDescription?: string;
+    CategoryMandatory?: boolean;
+    QuestionPreviewLabel?: string;
+    GroupId?: number;
+    Question?: string;
+    Answer?: string;
+    PlaceholderText?: string;
+    About?: string;
+    Mandatory?: boolean;
+    Dependent?: boolean;
+    DependentOnOrder?: number;
+    QuestionType?: string;
+    InputName?: string;
+    Options?: Array<any>;
+    isTouched?: boolean;
+    error?: boolean;
+    errorType?: Array<string>;
+    errorSpecificMessage?: string;
+    Files?: Array<any>;
+    MoreFields?: Array<string>;
+    questionArray?: Array<any>;
+    answerColumnArray?: Array<any>;
+    languageSupport?: Array<{}>;
+    Width?: string;
+    InputSize?: string;
+    CheckboxOrder?: number;
+    Details?: string;
+    Info?: string;
+    MaxLength?: number;
+    HideQuestion?: boolean;
+    InputType?: string;
+    autocomplete?: string;
+    HideMaxLength?: boolean;
+    isDisplayed?: boolean;
+}
+export declare enum IQuestionTypeStandard {
+    TextFieldStandard = 0,
+    TextAreaStandard = 1,
+    SelectStandard = 2,
+    RadioStandard = 3,
+    CheckboxStandard = 4,
+    DatePickerStandard = 5,
+    FileUploadStandard = 6,
+    QuestionHasValidationError = 7
+}

package/dist/NewHelpMethodsStandard/InputElements.types.js

@@ -0,0 +1,12 @@
+//Todo: Ej implementerad i IQuestionObject
+export var IQuestionTypeStandard;
+(function (IQuestionTypeStandard) {
+    IQuestionTypeStandard[IQuestionTypeStandard["TextFieldStandard"] = 0] = "TextFieldStandard";
+    IQuestionTypeStandard[IQuestionTypeStandard["TextAreaStandard"] = 1] = "TextAreaStandard";
+    IQuestionTypeStandard[IQuestionTypeStandard["SelectStandard"] = 2] = "SelectStandard";
+    IQuestionTypeStandard[IQuestionTypeStandard["RadioStandard"] = 3] = "RadioStandard";
+    IQuestionTypeStandard[IQuestionTypeStandard["CheckboxStandard"] = 4] = "CheckboxStandard";
+    IQuestionTypeStandard[IQuestionTypeStandard["DatePickerStandard"] = 5] = "DatePickerStandard";
+    IQuestionTypeStandard[IQuestionTypeStandard["FileUploadStandard"] = 6] = "FileUploadStandard";
+    IQuestionTypeStandard[IQuestionTypeStandard["QuestionHasValidationError"] = 7] = "QuestionHasValidationError";
+})(IQuestionTypeStandard || (IQuestionTypeStandard = {}));

package/dist/NewHelpMethodsStandard/IsDependsOnOtherQuestionTrue/IsDependsOnOtherQuestionTrue.d.ts

@@ -0,0 +1,2 @@
+declare const isDependsOnOtherQuestionTrue: (data: any[], question: any) => boolean;
+export default isDependsOnOtherQuestionTrue;

package/dist/NewHelpMethodsStandard/IsDependsOnOtherQuestionTrue/IsDependsOnOtherQuestionTrue.js

@@ -0,0 +1,13 @@
+const isDependsOnOtherQuestionTrue = (data, question) => {
+    const isParentTrue = (questionId, questionArrayAnswerId, answer) => {
+        const parent = data.find((q) => q.id === questionId);
+        if (!parent)
+            return false;
+        return ((questionArrayAnswerId !== undefined && parent.questionArrayAnswerId === questionArrayAnswerId) ||
+            parent.answer === answer);
+    };
+    if (!question.dependsOnOtherQuestion || question.dependsOnOtherQuestion.length === 0)
+        return false;
+    return question.dependsOnOtherQuestion.some((conditions) => conditions.every((cond) => isParentTrue(cond.LinkedToQuestionId, cond.questionArrayAnswerId, cond.Answer)));
+};
+export default isDependsOnOtherQuestionTrue;

package/dist/NewHelpMethodsStandard/IsDependsOnOtherQuestionTrue/index.d.ts

@@ -0,0 +1 @@
+export { default } from './IsDependsOnOtherQuestionTrue';

package/dist/NewHelpMethodsStandard/IsDependsOnOtherQuestionTrue/index.js

@@ -0,0 +1 @@
+export { default } from './IsDependsOnOtherQuestionTrue';

package/dist/NewHelpMethodsStandard/QuestionHasValidationError/QuestionHasValidationError.d.ts

@@ -0,0 +1,2 @@
+declare const questionHasValidationError: (questionObject: any, arrayOfQuestionObjects: any[]) => boolean;
+export default questionHasValidationError;

package/dist/NewHelpMethodsStandard/QuestionHasValidationError/QuestionHasValidationError.js

@@ -0,0 +1,58 @@
+import { isValid, parseISO } from 'date-fns';
+const questionHasValidationError = (questionObject, arrayOfQuestionObjects) => {
+    var _a, _b, _c, _d, _e;
+    let error = false;
+    if (questionObject.isQuestionMandatory) {
+        if (questionObject.isTouched === false) {
+            error = true;
+        }
+        if (questionObject.answer.trim() === '') {
+            error = true;
+        }
+        if (questionObject.answer === 'false' &&
+            ((_a = questionObject.validationType) === null || _a === void 0 ? void 0 : _a.find((e) => e === 'mustBeTrue'))) {
+            error = true;
+        }
+    }
+    if (((_b = questionObject.validationType) === null || _b === void 0 ? void 0 : _b.find((e) => e === 'email')) &&
+        (questionObject.isQuestionMandatory || questionObject.answer !== '')) {
+        const emailRegex = /^[a-zA-Z0-9._-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$/;
+        if (!emailRegex.test(questionObject.answer)) {
+            error = true;
+        }
+    }
+    if (((_c = questionObject.validationType) === null || _c === void 0 ? void 0 : _c.find((e) => e === 'fourNumbers')) &&
+        (questionObject.isQuestionMandatory || questionObject.answer !== '')) {
+        const fourNumbersRegex = /^\d{4}$/.test(questionObject.answer);
+        if (!fourNumbersRegex) {
+            error = true;
+        }
+    }
+    if (((_d = questionObject.validationType) === null || _d === void 0 ? void 0 : _d.find((e) => e === 'isDateFormatValid')) &&
+        questionObject.answer !== '') {
+        const regex = /^\d{4}-\d{2}-\d{2}$/;
+        if (!regex.test(questionObject.answer)) {
+            error = true;
+        }
+        const isValidDate = (dateString) => {
+            const date = parseISO(dateString);
+            return isValid(date);
+        };
+        const validDate = isValidDate(questionObject.answer);
+        if (!validDate) {
+            error = true;
+        }
+    }
+    const groupCheckError = (_e = questionObject.validationType) === null || _e === void 0 ? void 0 : _e.find((e) => e.startsWith('groupCheck-'));
+    if (groupCheckError) {
+        const ids = groupCheckError.replace('groupCheck-', '').split('-');
+        const relatedAnswers = ids.map((id) => { var _a; return (_a = arrayOfQuestionObjects.find((q) => { var _a; return ((_a = q.id) === null || _a === void 0 ? void 0 : _a.toString()) === id; })) === null || _a === void 0 ? void 0 : _a.answer; });
+        const currentAnswer = questionObject.answer;
+        const allAnswers = [...relatedAnswers, currentAnswer];
+        if (allAnswers.every((ans) => ans === '')) {
+            error = true;
+        }
+    }
+    return error;
+};
+export default questionHasValidationError;

package/dist/NewHelpMethodsStandard/QuestionHasValidationError/QuestionHasValidationError.types.d.ts

@@ -0,0 +1,5 @@
+import { IQuestionObjectStandard } from '../InputElements.types';
+export interface ValidationProps {
+    questionObject: IQuestionObjectStandard;
+    arrayOfQuestionObjects: IQuestionObjectStandard[];
+}

package/dist/NewHelpMethodsStandard/QuestionHasValidationError/QuestionHasValidationError.types.js

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

package/dist/NewHelpMethodsStandard/QuestionHasValidationError/index.d.ts

@@ -0,0 +1 @@
+export { default } from './QuestionHasValidationError';

package/dist/NewHelpMethodsStandard/QuestionHasValidationError/index.js

@@ -0,0 +1 @@
+export { default } from './QuestionHasValidationError';