@mrfylke/contact-form 0.1.3

package/lib/ticketing/ticketingStateMachine.js

@@ -0,0 +1,435 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ticketingStateMachine = exports.TravelCardForm = exports.WebshopForm = exports.AppForm = exports.FormCategory = void 0;
+exports.createTicketingStateMachine = createTicketingStateMachine;
+const xstate_1 = require("xstate");
+const events_1 = require("./events");
+const validation_1 = require("../validation");
+const utils_1 = require("../utils");
+var FormCategory;
+(function (FormCategory) {
+    FormCategory["PriceAndTicketTypes"] = "priceAndTicketTypes";
+    FormCategory["App"] = "app";
+    FormCategory["Webshop"] = "webshop";
+    FormCategory["TravelCard"] = "travelCard";
+})(FormCategory || (exports.FormCategory = FormCategory = {}));
+var AppForm;
+(function (AppForm) {
+    AppForm["AppTicketing"] = "appTicketing";
+    AppForm["AppTravelSuggestion"] = "appTravelSuggestion";
+    AppForm["AppAccount"] = "appAccount";
+})(AppForm || (exports.AppForm = AppForm = {}));
+var WebshopForm;
+(function (WebshopForm) {
+    WebshopForm["WebshopTicketing"] = "webshopTicketing";
+    WebshopForm["WebshopAccount"] = "webshopAccount";
+})(WebshopForm || (exports.WebshopForm = WebshopForm = {}));
+var TravelCardForm;
+(function (TravelCardForm) {
+    TravelCardForm["OrderTravelCard"] = "orderTravelCard";
+    TravelCardForm["TravelCardQuestion"] = "travelCardQuestion";
+})(TravelCardForm || (exports.TravelCardForm = TravelCardForm = {}));
+var FormType;
+(function (FormType) {
+    FormType["PriceAndTicketTypes"] = "priceAndTicketTypes";
+    FormType["AppTicketing"] = "appTicketing";
+    FormType["AppTravelSuggestion"] = "appTravelSuggestion";
+    FormType["AppAccount"] = "appAccount";
+    FormType["WebshopTicketing"] = "webshopTicketing";
+    FormType["WebshopAccount"] = "webshopAccount";
+    FormType["TravelCardQuestion"] = "travelCardQuestion";
+    FormType["OrderTravelCard"] = "orderTravelCard";
+})(FormType || (FormType = {}));
+const setInputsToValidate = (context) => {
+    const { formType, firstName, lastName, email, phoneNumber, question, orderId, customerNumber, travelCardNumber, } = context;
+    const commonFields = {
+        formType,
+        question,
+        firstName,
+        lastName,
+        email,
+    };
+    switch (formType) {
+        case FormType.PriceAndTicketTypes:
+            return {
+                ...commonFields,
+            };
+        case FormType.AppTicketing:
+            return {
+                ...commonFields,
+                orderId,
+                phoneNumber,
+                ...(customerNumber && { customerNumber }),
+            };
+        case FormType.AppTravelSuggestion:
+            return {
+                ...commonFields,
+            };
+        case FormType.AppAccount:
+            return {
+                ...commonFields,
+                customerNumber,
+                phoneNumber,
+            };
+        case FormType.TravelCardQuestion:
+            return {
+                ...commonFields,
+                travelCardNumber,
+                phoneNumber,
+            };
+        case FormType.WebshopTicketing:
+            return {
+                ...commonFields,
+                ...(customerNumber && { customerNumber }),
+                orderId,
+                phoneNumber,
+            };
+        case FormType.WebshopAccount:
+            return {
+                ...commonFields,
+                ...(customerNumber && { customerNumber }),
+                phoneNumber,
+            };
+    }
+};
+function createTicketingStateMachine(onSubmit, paths) {
+    const successPath = paths?.successPath ?? '/contact/success';
+    const errorPath = paths?.errorPath ?? '/contact/error';
+    return (0, xstate_1.setup)({
+        types: {
+            context: {},
+            events: events_1.ticketingFormEvents,
+        },
+        guards: {
+            isFormValid: ({ context }) => {
+                const inputsToValidate = setInputsToValidate(context);
+                const errors = (0, validation_1.commonInputValidator)(inputsToValidate);
+                return Object.keys(errors).length === 0;
+            },
+            isPriceAndTicketTypes: ({ event }) => event.type === 'SELECT_FORM_CATEGORY' &&
+                event.formCategory === FormCategory.PriceAndTicketTypes,
+            isApp: ({ event }) => event.type === 'SELECT_FORM_CATEGORY' &&
+                event.formCategory === FormCategory.App,
+            isTravelCard: ({ event }) => event.type === 'SELECT_FORM_CATEGORY' &&
+                event.formCategory === FormCategory.TravelCard,
+            isWebshop: ({ event }) => event.type === 'SELECT_FORM_CATEGORY' &&
+                event.formCategory === FormCategory.Webshop,
+            isAppAccount: ({ event }) => event.type === 'SELECT_APP_FORM' && event.appForm === AppForm.AppAccount,
+            isAppTicketing: ({ event }) => event.type === 'SELECT_APP_FORM' &&
+                event.appForm === AppForm.AppTicketing,
+            isAppTravelSuggestion: ({ event }) => event.type === 'SELECT_APP_FORM' &&
+                event.appForm === AppForm.AppTravelSuggestion,
+            isWebshopTicketing: ({ event }) => event.type === 'SELECT_WEBSHOP_FORM' &&
+                event.webshopForm === WebshopForm.WebshopTicketing,
+            isWebshopAccount: ({ event }) => event.type === 'SELECT_WEBSHOP_FORM' &&
+                event.webshopForm === WebshopForm.WebshopAccount,
+            isTravelCardQuestion: ({ event }) => event.type === 'SELECT_TRAVELCARD_FORM' &&
+                event.travelCardForm === TravelCardForm.TravelCardQuestion,
+            isOrderTravelCard: ({ event }) => event.type === 'SELECT_TRAVELCARD_FORM' &&
+                event.travelCardForm === TravelCardForm.OrderTravelCard,
+        },
+        actions: {
+            navigateToErrorPage: () => {
+                window.location.href = errorPath;
+            },
+            navigateToSuccessPage: () => {
+                window.location.href = successPath;
+            },
+            setFormTypeToUndefined: (0, xstate_1.assign)({
+                formType: () => undefined,
+            }),
+            clearValidationErrors: (0, xstate_1.assign)({ errorMessages: {} }),
+            setValidationErrors: (0, xstate_1.assign)(({ context, event }) => {
+                if (event.type === 'SUBMIT') {
+                    const inputsToValidate = setInputsToValidate(context);
+                    const errors = (0, validation_1.commonInputValidator)(inputsToValidate);
+                    return {
+                        firstIncorrectErrorMessage: (0, utils_1.findFirstErrorMessage)(event.orderedFormFieldNames, errors),
+                        errorMessages: { ...errors },
+                    };
+                }
+                return context;
+            }),
+            scrollToFirstErrorMessage: (0, xstate_1.assign)(({ context }) => {
+                (0, utils_1.scrollToFirstErrorMessage)(context.firstIncorrectErrorMessage);
+                return context;
+            }),
+            setSubmissionError: (0, xstate_1.assign)({
+                hasSubmissionError: () => true,
+            }),
+            clearSubmissionError: (0, xstate_1.assign)({
+                hasSubmissionError: () => undefined,
+            }),
+            onInputChange: (0, xstate_1.assign)(({ context, event }) => {
+                if (event.type === 'ON_INPUT_CHANGE') {
+                    const { inputName, value } = event;
+                    context.errorMessages[inputName] = [];
+                    if (inputName === 'isInitialAgreementChecked' && !value) {
+                        return {
+                            ...context,
+                            isInitialAgreementChecked: false,
+                            formType: undefined,
+                            hasSubmissionError: undefined,
+                        };
+                    }
+                    if (inputName === 'hasInternationalBankAccount') {
+                        const updatedContext = (0, utils_1.setBankAccountStatusAndResetBankInformation)(context, value);
+                        return {
+                            ...updatedContext,
+                            hasSubmissionError: undefined,
+                        };
+                    }
+                    return {
+                        ...context,
+                        [inputName]: value,
+                        hasSubmissionError: undefined,
+                    };
+                }
+                return context;
+            }),
+        },
+        actors: {
+            submit: (0, xstate_1.fromPromise)(async ({ input: actorInput }) => {
+                const base64EncodedAttachments = await (0, utils_1.convertFilesToBase64)(actorInput.attachments || []);
+                const state = {
+                    ...actorInput,
+                    attachments: base64EncodedAttachments,
+                };
+                const response = await onSubmit('ticketing', state);
+                if (!response.ok) {
+                    throw new Error('Failed to call API');
+                }
+                return response.ok;
+            }),
+        },
+    }).createMachine({
+        id: 'ticketingStateMachine',
+        initial: 'editing',
+        context: {
+            hasInternationalBankAccount: false,
+            isInitialAgreementChecked: false,
+            showInputTravelCardNumber: true,
+            errorMessages: {},
+        },
+        on: {
+            ON_INPUT_CHANGE: {
+                actions: 'onInputChange',
+            },
+            SELECT_FORM_CATEGORY: {
+                target: '#formCategoryHandler',
+            },
+            SELECT_APP_FORM: {
+                target: '#appFormHandler',
+            },
+            SELECT_WEBSHOP_FORM: {
+                target: '#webshopFormHandler',
+            },
+            SELECT_TRAVELCARD_FORM: {
+                target: '#travelCardFormHandler',
+            },
+            SUBMIT: { target: '#validating' },
+        },
+        states: {
+            formCategoryHandler: {
+                id: 'formCategoryHandler',
+                always: [
+                    {
+                        guard: 'isPriceAndTicketTypes',
+                        target: `#${FormCategory.PriceAndTicketTypes}`,
+                    },
+                    {
+                        guard: 'isApp',
+                        target: `#${FormCategory.App}`,
+                    },
+                    {
+                        guard: 'isTravelCard',
+                        target: `#${FormCategory.TravelCard}`,
+                    },
+                    {
+                        guard: 'isWebshop',
+                        target: `#${FormCategory.Webshop}`,
+                    },
+                ],
+            },
+            appFormHandler: {
+                id: 'appFormHandler',
+                always: [
+                    {
+                        guard: 'isAppAccount',
+                        target: `#${AppForm.AppAccount}`,
+                    },
+                    {
+                        guard: 'isAppTicketing',
+                        target: `#${AppForm.AppTicketing}`,
+                    },
+                    {
+                        guard: 'isAppTravelSuggestion',
+                        target: `#${AppForm.AppTravelSuggestion}`,
+                    },
+                ],
+            },
+            webshopFormHandler: {
+                id: 'webshopFormHandler',
+                always: [
+                    {
+                        guard: 'isWebshopTicketing',
+                        target: `#${WebshopForm.WebshopTicketing}`,
+                    },
+                    {
+                        guard: 'isWebshopAccount',
+                        target: `#${WebshopForm.WebshopAccount}`,
+                    },
+                ],
+            },
+            travelCardFormHandler: {
+                id: 'travelCardFormHandler',
+                always: [
+                    {
+                        guard: 'isTravelCardQuestion',
+                        target: `#${TravelCardForm.TravelCardQuestion}`,
+                    },
+                    {
+                        guard: 'isOrderTravelCard',
+                        target: `#${TravelCardForm.OrderTravelCard}`,
+                    },
+                ],
+            },
+            editing: {
+                initial: 'selectFormCategory',
+                states: {
+                    selectFormCategory: {},
+                    priceAndTicketTypes: {
+                        id: 'priceAndTicketTypes',
+                        entry: (0, xstate_1.assign)({
+                            formType: () => FormType.PriceAndTicketTypes,
+                        }),
+                        exit: 'clearValidationErrors',
+                    },
+                    app: {
+                        id: 'app',
+                        initial: 'selectAppForm',
+                        entry: 'setFormTypeToUndefined',
+                        exit: 'clearValidationErrors',
+                        states: {
+                            selectAppForm: {},
+                            appAccount: {
+                                id: 'appAccount',
+                                entry: (0, xstate_1.assign)({
+                                    formType: () => FormType.AppAccount,
+                                }),
+                            },
+                            appTicketing: {
+                                id: 'appTicketing',
+                                entry: (0, xstate_1.assign)({
+                                    formType: () => FormType.AppTicketing,
+                                }),
+                            },
+                            appTravelSuggestion: {
+                                id: 'appTravelSuggestion',
+                                entry: (0, xstate_1.assign)({
+                                    formType: () => FormType.AppTravelSuggestion,
+                                }),
+                            },
+                        },
+                    },
+                    travelCard: {
+                        id: 'travelCard',
+                        initial: 'selectTravelCardForm',
+                        entry: 'setFormTypeToUndefined',
+                        exit: 'clearValidationErrors',
+                        states: {
+                            selectTravelCardForm: {},
+                            travelCardQuestion: {
+                                id: 'travelCardQuestion',
+                                entry: (0, xstate_1.assign)({
+                                    formType: () => FormType.TravelCardQuestion,
+                                }),
+                            },
+                            orderTravelCard: {
+                                id: 'orderTravelCard',
+                                entry: (0, xstate_1.assign)({
+                                    formType: () => FormType.OrderTravelCard,
+                                }),
+                            },
+                        },
+                    },
+                    webshop: {
+                        id: 'webshop',
+                        initial: 'selectWebshopForm',
+                        entry: 'setFormTypeToUndefined',
+                        exit: 'clearValidationErrors',
+                        states: {
+                            selectWebshopForm: {},
+                            webshopTicketing: {
+                                id: 'webshopTicketing',
+                                entry: (0, xstate_1.assign)({
+                                    formType: () => FormType.WebshopTicketing,
+                                }),
+                            },
+                            webshopAccount: {
+                                id: 'webshopAccount',
+                                entry: (0, xstate_1.assign)({
+                                    formType: () => FormType.WebshopAccount,
+                                }),
+                            },
+                        },
+                    },
+                    history: {
+                        type: 'history',
+                        history: 'deep',
+                    },
+                },
+            },
+            validating: {
+                id: 'validating',
+                always: [
+                    {
+                        guard: 'isFormValid',
+                        target: '#submitting',
+                    },
+                    {
+                        actions: ['setValidationErrors', 'scrollToFirstErrorMessage'],
+                        target: 'editing.history',
+                    },
+                ],
+            },
+            submitting: {
+                id: 'submitting',
+                invoke: {
+                    src: 'submit',
+                    input: ({ context }) => ({
+                        formType: context.formType,
+                        attachments: context.attachments,
+                        firstName: context.firstName,
+                        lastName: context.lastName,
+                        email: context.email,
+                        phoneNumber: context.phoneNumber,
+                        address: context.address,
+                        question: context.question,
+                        orderId: context.orderId,
+                        customerNumber: context.customerNumber,
+                        travelCardNumber: context.travelCardNumber,
+                        ticketType: context.ticketType,
+                    }),
+                    onDone: {
+                        target: 'success',
+                    },
+                    onError: {
+                        target: 'editing.history',
+                        actions: 'setSubmissionError',
+                    },
+                },
+            },
+            success: {
+                entry: 'navigateToSuccessPage',
+                type: 'final',
+            },
+        },
+    });
+}
+exports.ticketingStateMachine = createTicketingStateMachine(async (data) => {
+    return fetch('/api/contact/ticketing', {
+        method: 'POST',
+        body: JSON.stringify(data),
+    });
+});

package/lib/translations/__tests__/utils.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=utils.test.d.ts.map

package/lib/translations/__tests__/utils.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.test.d.ts","sourceRoot":"","sources":["../../../src/translations/__tests__/utils.test.ts"],"names":[],"mappings":""}

package/lib/translations/__tests__/utils.test.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const utils_1 = require("../utils");
+const commons_1 = require("../commons");
+(0, vitest_1.describe)('orgSpecificTranslations', () => {
+    (0, vitest_1.test)('should override specific fields when specifying one org', () => {
+        const TitlesInternal = {
+            title: (0, commons_1.translation)('A', 'A', 'A'),
+        };
+        const Titles = (0, utils_1.orgSpecificTranslations)(TitlesInternal, {
+            nfk: {
+                title: (0, commons_1.translation)('B', 'B', 'B'),
+            },
+        }, 'nfk');
+        (0, vitest_1.expect)(Titles.title.no).toEqual('B');
+    });
+    (0, vitest_1.test)('should override specific fields for multiple orgs', () => {
+        const TitlesInternal = {
+            title: (0, commons_1.translation)('A', 'A', 'A'),
+        };
+        const overrides = {
+            nfk: {
+                title: (0, commons_1.translation)('B', 'B', 'B'),
+            },
+            fram: {
+                title: (0, commons_1.translation)('C', 'C', 'C'),
+            },
+        };
+        const TitlesNfk = (0, utils_1.orgSpecificTranslations)(TitlesInternal, overrides, 'nfk');
+        const TitlesFram = (0, utils_1.orgSpecificTranslations)(TitlesInternal, overrides, 'fram');
+        (0, vitest_1.expect)(TitlesNfk.title.no).toEqual('B');
+        (0, vitest_1.expect)(TitlesFram.title.no).toEqual('C');
+    });
+});

package/lib/translations/common/index.d.ts

@@ -0,0 +1,3 @@
+export { Titles } from './titles';
+export { Layout } from './layout';
+//# sourceMappingURL=index.d.ts.map

package/lib/translations/common/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/translations/common/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,MAAM,EAAC,MAAM,UAAU,CAAC;AAChC,OAAO,EAAC,MAAM,EAAC,MAAM,UAAU,CAAC"}

package/lib/translations/common/index.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Layout = exports.Titles = void 0;
+var titles_1 = require("./titles");
+Object.defineProperty(exports, "Titles", { enumerable: true, get: function () { return titles_1.Titles; } });
+var layout_1 = require("./layout");
+Object.defineProperty(exports, "Layout", { enumerable: true, get: function () { return layout_1.Layout; } });

package/lib/translations/common/layout.d.ts

@@ -0,0 +1,8 @@
+export declare const Layout: {
+    homeLink: (name: string) => import("../../translations/commons").TranslatedString;
+    contactLink: import("../../translations/commons").TranslatedString;
+    meta: {
+        defaultDescription: import("../../translations/commons").TranslatedString;
+    };
+};
+//# sourceMappingURL=layout.d.ts.map

package/lib/translations/common/layout.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"layout.d.ts","sourceRoot":"","sources":["../../../src/translations/common/layout.ts"],"names":[],"mappings":"AAkBA,eAAO,MAAM,MAAM;qBAdE,MAAM;;;;;CA4DzB,CAAC"}

package/lib/translations/common/layout.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Layout = void 0;
+const commons_1 = require("../../translations/commons");
+const utils_1 = require("../utils");
+const LayoutInternal = {
+    homeLink: (name) => (0, commons_1.translation)(`Gå til ${name}`, `Go to ${name}`, `Gå til ${name}`),
+    contactLink: (0, commons_1.translation)('Kontaktskjema', 'Contact form', 'Kontaktskjema'),
+    meta: {
+        defaultDescription: (0, commons_1.translation)('Finn rutetider, holdeplasser og tilbud for buss, trikk, båt og tog i Trøndelag med reiseplanleggeren.', 'Find timetables, stops and offers for bus, tram, boat and train in Trøndelag with the travel planner.', 'Finn rutetider, haldeplassar og tilbod for buss, trikk, båt og tog i Trøndelag med reiseplanleggaren.'),
+    },
+};
+exports.Layout = (0, utils_1.orgSpecificTranslations)(LayoutInternal, {
+    nfk: {
+        meta: {
+            defaultDescription: (0, commons_1.translation)('Finn rutetider, holdeplasser og tilbud for buss, båt og tog i Nordland med reiseplanleggeren.', 'Find timetables, stops and offers for bus, boat and train in Nordland with the travel planner.', 'Finn rutetider, haldeplassar og tilbod for buss, båt og tog i Nordland med reiseplanleggaren.'),
+        },
+    },
+    fram: {
+        meta: {
+            defaultDescription: (0, commons_1.translation)('Finn rutetider, holdeplasser, kaier og tilbud for buss, hurtigbåt og ferge i Møre og Romsdal med reiseplanleggeren.', 'Find timetables, stops and offers for bus, boat and ferry in Møre og Romsdal with the travel planner.', 'Finn rutetider, haldeplassar, kaier og tilbod for buss, hurtigbåt og ferje i Møre og Romsdal med reiseplanleggaren.'),
+        },
+    },
+    troms: {
+        meta: {
+            defaultDescription: (0, commons_1.translation)('Finn rutetider, holdeplasser, kaier og tilbud for buss, hurtigbåt og ferge i Troms med reiseplanleggeren.', 'Find timetables, stops and offers for bus, boat and ferry in Troms with the travel planner.', 'Finn rutetider, haldeplassar, kaier og tilbod for buss, hurtigbåt og ferje i Troms med reiseplanleggaren.'),
+        },
+    },
+    vkt: {
+        meta: {
+            defaultDescription: (0, commons_1.translation)('Finn rutetider, holdeplasser, kaier og tilbud for buss, hurtigbåt og ferge i Vestfold med reiseplanleggeren.', 'Find timetables, stops and offers for bus, boat and ferry in Vestfold with the travel planner.', 'Finn rutetider, haldeplassar, kaier og tilbod for buss, hurtigbåt og ferje i Vestfold med reiseplanleggaren.'),
+        },
+    },
+    farte: {
+        meta: {
+            defaultDescription: (0, commons_1.translation)('Finn rutetider, holdeplasser, kaier og tilbud for buss, hurtigbåt og ferge i Telemark med reiseplanleggeren.', 'Find timetables, stops and offers for bus, boat and ferry in Telemark with the travel planner.', 'Finn rutetider, haldeplassar, kaier og tilbod for buss, hurtigbåt og ferje i Telemark med reiseplanleggaren.'),
+        },
+    },
+});

package/lib/translations/common/titles.d.ts

@@ -0,0 +1,4 @@
+export declare const Titles: {
+    siteTitle: import("../../translations/commons").TranslatedString;
+};
+//# sourceMappingURL=titles.d.ts.map

package/lib/translations/common/titles.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"titles.d.ts","sourceRoot":"","sources":["../../../src/translations/common/titles.ts"],"names":[],"mappings":"AAOA,eAAO,MAAM,MAAM;;CA4BjB,CAAC"}

package/lib/translations/common/titles.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Titles = void 0;
+const commons_1 = require("../../translations/commons");
+const utils_1 = require("../utils");
+const TitlesInternal = {
+    siteTitle: (0, commons_1.translation)('AtB Reisesøk', 'AtB Travel Search', 'AtB Reisesøk'),
+};
+exports.Titles = (0, utils_1.orgSpecificTranslations)(TitlesInternal, {
+    nfk: {
+        siteTitle: (0, commons_1.translation)('Reis Reisesøk', 'Reis Travel Search', 'Reis Reisesøk'),
+    },
+    fram: {
+        siteTitle: (0, commons_1.translation)('FRAM Reiseplanlegger', 'FRAM Travel Search', 'FRAM Reiseplanleggar'),
+    },
+    troms: {
+        siteTitle: (0, commons_1.translation)('Svipper Reisesøk', 'Svipper Travel Search', 'Svipper Reisesøk'),
+    },
+    vkt: {
+        siteTitle: (0, commons_1.translation)('Vestfold Kollektivtrafikk Reisesøk', 'Vestfold Kollektivtrafikk Travel Search', 'Vestfold Kollektivtrafikk Reisesøk'),
+    },
+    farte: {
+        siteTitle: (0, commons_1.translation)('Farte Reisesøk', 'Farte Travel Search', 'Farte Reisesøk'),
+    },
+});

package/lib/translations/commons.d.ts

@@ -0,0 +1,21 @@
+import { TFunc } from '@leile/lobo-t';
+import type { Translatable } from '@leile/lobo-t';
+export declare enum Language {
+    Norwegian = "no",
+    English = "en-US",
+    Nynorsk = "nn"
+}
+export declare const appLanguages: readonly Language[];
+export declare const DEFAULT_LANGUAGE = Language.Norwegian;
+export declare const DEFAULT_LANGUAGE_STRING = "no";
+export declare const FALLBACK_LANGUAGE = Language.English;
+export type TranslatedString = Translatable<typeof Language, string>;
+export type TranslateFunction = TFunc<typeof Language>;
+export declare function translation(norwegian: string, english: string, nynorsk: string): TranslatedString;
+export declare function isTranslatedString(a: any): a is TranslatedString;
+export type LocalizedString = {
+    lang: 'nob' | 'eng' | 'nno';
+    value: string;
+};
+export declare function convertLocalizedString(language: Language, localizedStrings: LocalizedString[]): string | undefined;
+//# sourceMappingURL=commons.d.ts.map

package/lib/translations/commons.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"commons.d.ts","sourceRoot":"","sources":["../../src/translations/commons.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,KAAK,EAAC,MAAM,eAAe,CAAC;AAEpC,OAAO,KAAK,EAAC,YAAY,EAAC,MAAM,eAAe,CAAC;AAEhD,oBAAY,QAAQ;IAChB,SAAS,OAAO;IAChB,OAAO,UAAU;IACjB,OAAO,OAAO;CACjB;AAED,eAAO,MAAM,YAAY,EAAE,SAAS,QAAQ,EAIlC,CAAC;AAEX,eAAO,MAAM,gBAAgB,qBAAqB,CAAC;AACnD,eAAO,MAAM,uBAAuB,OAAO,CAAC;AAC5C,eAAO,MAAM,iBAAiB,mBAAmB,CAAC;AAClD,MAAM,MAAM,gBAAgB,GAAG,YAAY,CAAC,OAAO,QAAQ,EAAE,MAAM,CAAC,CAAC;AAErE,MAAM,MAAM,iBAAiB,GAAG,KAAK,CAAC,OAAO,QAAQ,CAAC,CAAC;AAEvD,wBAAgB,WAAW,CACvB,SAAS,EAAE,MAAM,EACjB,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,MAAM,GAChB,gBAAgB,CAMlB;AAED,wBAAgB,kBAAkB,CAAC,CAAC,EAAE,GAAG,GAAG,CAAC,IAAI,gBAAgB,CAEhE;AAED,MAAM,MAAM,eAAe,GAAG;IAC1B,IAAI,EAAE,KAAK,GAAG,KAAK,GAAG,KAAK,CAAC;IAC5B,KAAK,EAAE,MAAM,CAAC;CACjB,CAAC;AAEF,wBAAgB,sBAAsB,CAClC,QAAQ,EAAE,QAAQ,EAClB,gBAAgB,EAAE,eAAe,EAAE,GACpC,MAAM,GAAG,SAAS,CASpB"}

package/lib/translations/commons.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FALLBACK_LANGUAGE = exports.DEFAULT_LANGUAGE_STRING = exports.DEFAULT_LANGUAGE = exports.appLanguages = exports.Language = void 0;
+exports.translation = translation;
+exports.isTranslatedString = isTranslatedString;
+exports.convertLocalizedString = convertLocalizedString;
+var Language;
+(function (Language) {
+    Language["Norwegian"] = "no";
+    Language["English"] = "en-US";
+    Language["Nynorsk"] = "nn";
+})(Language || (exports.Language = Language = {}));
+exports.appLanguages = [
+    Language.Norwegian,
+    Language.English,
+    Language.Nynorsk,
+];
+exports.DEFAULT_LANGUAGE = Language.Norwegian;
+exports.DEFAULT_LANGUAGE_STRING = 'no';
+exports.FALLBACK_LANGUAGE = Language.English;
+function translation(norwegian, english, nynorsk) {
+    return {
+        [Language.Norwegian]: norwegian,
+        [Language.English]: english,
+        [Language.Nynorsk]: nynorsk,
+    };
+}
+function isTranslatedString(a) {
+    return typeof a[Language.Norwegian] !== 'undefined';
+}
+function convertLocalizedString(language, localizedStrings) {
+    const messageLanguages = {
+        nob: 'no',
+        eng: 'en-US',
+        nno: 'nn',
+    };
+    return localizedStrings.find((ls) => messageLanguages[ls.lang] === language)
+        ?.value;
+}

package/lib/translations/components/clear-button.d.ts

@@ -0,0 +1,4 @@
+export declare const ClearButton: {
+    alt: import("../../translations/commons").TranslatedString;
+};
+//# sourceMappingURL=clear-button.d.ts.map

package/lib/translations/components/clear-button.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"clear-button.d.ts","sourceRoot":"","sources":["../../../src/translations/components/clear-button.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,WAAW;;CAEvB,CAAC"}