cja-phoenix 1.2.39 → 1.2.41

package/dist/runtime/utils/formValidations.js

@@ -0,0 +1,180 @@
+import phoneDigits from "../data/phoneDigits.js";
+import * as yup from "yup";
+const string = (messages, options) => {
+  let validation = yup.string().transform((value) => value || void 0);
+  if (messages.required) {
+    validation = validation.required(messages.required);
+  }
+  if (options?.minLength && messages.minLength) {
+    validation = validation.min(options.minLength, messages.minLength);
+  }
+  if (options?.maxLength && messages.maxLength) {
+    validation = validation.max(options.maxLength, messages.maxLength);
+  }
+  return validation;
+};
+const boolean = (messages, options) => {
+  let validation = yup.boolean();
+  if (messages.required) {
+    validation = validation.required(messages.required);
+  }
+  if (options?.strictValue && messages.strictValue) {
+    validation = validation.oneOf([options.strictValue], messages.strictValue);
+  }
+  return validation;
+};
+const email = (messages) => {
+  let validation = yup.string().transform((value) => value || void 0).test(
+    "emailTest",
+    messages.email,
+    (v) => v ? /^[\w.%+-]+@[a-z0-9.-]+\.[a-z]{2,}$/i.test(v) : true
+  ).email(messages.email);
+  if (messages.required) {
+    validation = validation.required(messages.required);
+  }
+  return validation;
+};
+const number = (messages, options) => {
+  let validation = yup.number().transform((value) => Number.isNaN(value) ? void 0 : value);
+  if (messages.required) {
+    validation = validation.required(messages.required);
+  }
+  if (options?.min != void 0 && messages.min) {
+    validation = validation.min(options.min, messages.min);
+  }
+  if (options?.max != void 0 && messages.max) {
+    validation = validation.max(options.max, messages.max);
+  }
+  if (options?.lessThan != void 0 && messages.lessThan) {
+    validation = validation.lessThan(options.lessThan, messages.lessThan);
+  }
+  if (options?.moreThan != void 0 && messages.moreThan) {
+    validation = validation.moreThan(options.moreThan, messages.moreThan);
+  }
+  return validation;
+};
+const phone = (messages, options) => yup.lazy(() => {
+  let validation = yup.string().transform((value) => value || void 0).test(
+    "phoneTest",
+    messages.phone,
+    (v) => v && options.countryCode.value == "351" ? /^2\d|9[1236]\d{7}/.test(v) : true
+  ).length(phoneDigits[options.countryCode.value], messages.phone);
+  if (messages.required) {
+    validation = validation.required(messages.required);
+  }
+  return validation;
+});
+const zipcode = (messages) => {
+  let validation = yup.string().transform((value) => value || void 0).min(8, messages.zipcode);
+  if (messages.required) {
+    validation = validation.required(messages.required);
+  }
+  return validation;
+};
+const file = (messages, options) => {
+  let validation = yup.object({
+    extension: yup.string().matches(options?.extension || /(png|jpg|pdf)/g, messages.extension)
+  });
+  if (messages.required) {
+    validation = validation.test(
+      "fileRequired",
+      messages.required,
+      (v) => v ? !v.src ? v.file ? true : false : true : false
+    );
+  }
+  if (messages.size && options?.size) {
+    const byteSize = {
+      kb: 1e3,
+      mb: 1048576
+    };
+    validation = validation.test(
+      "fileSize",
+      messages.size,
+      (v) => v?.file && options.size?.collectionType ? v.file?.size < byteSize[options.size?.collectionType] * options.size.value : false
+    );
+  }
+  return validation;
+};
+const date = (messages, options) => {
+  let validation = yup.date().transform(
+    (v, ogV) => (
+      // ogV as "phone_number" is still as of yet unexplained
+      ogV == "phone_number" || ogV instanceof Date ? v : ogV
+    )
+  ).test("dateTest", messages.invalid, (v, context) => {
+    const formatRegex = (() => {
+      switch (options.format) {
+        case "DD/MM/YYYY":
+          return /^\d{2}\/\d{2}\/\d{4}$/g;
+        case "MM/YYYY":
+          return /^\d{2}\/\d{4}$/g;
+        case "YYYY":
+          return /^\d{4}$/g;
+        case "YYYY/MM/DD":
+          return /^\d{4}\/\d{2}\/\d{2}$/g;
+        case "YYYY/MM":
+          return /^\d{4}\/\d{2}$/g;
+      }
+    })();
+    return formatRegex.test(context.originalValue);
+  }).transform((v) => {
+    if (v.split) {
+      const vArr = v.split("/");
+      switch (options.format) {
+        case "DD/MM/YYYY":
+        case "MM/YYYY":
+          vArr.reverse();
+          break;
+      }
+      return new Date(vArr.join("-"));
+    }
+    return v;
+  }).typeError(messages.invalid);
+  if (messages.required) {
+    validation = validation.required(messages.required);
+  }
+  if (options?.minDate && messages.minDate) {
+    validation = validation.min(options.minDate, messages.minDate);
+  }
+  if (options?.maxDate && messages.maxDate) {
+    validation = validation.max(options.maxDate, messages.maxDate);
+  }
+  return validation;
+};
+const nif = (messages) => {
+  let validation = yup.string().transform((value) => value || void 0).min(9, messages.invalid).test("nifTest", messages.invalid, (v) => {
+    if (!v) return false;
+    const nif2 = v.toString().split("");
+    const mod = (Number(nif2[7]) * 2 + Number(nif2[6]) * 3 + Number(nif2[5]) * 4 + Number(nif2[4]) * 5 + Number(nif2[3]) * 6 + Number(nif2[2]) * 7 + Number(nif2[1]) * 8 + Number(nif2[0]) * 9) % 11;
+    return Number(nif2[8]) == (mod == 0 || mod == 1 ? 0 : 11 - mod);
+  });
+  if (messages.required) {
+    validation = validation.required(messages.required);
+  }
+  return validation;
+};
+const array = (messages, options) => {
+  let validation = yup.array();
+  if (messages.required) {
+    validation = validation.required(messages.required).min(1, messages.required);
+  }
+  if (options?.minLength && messages.minLength) {
+    validation = validation.min(options.minLength, messages.minLength);
+  }
+  if (options?.maxLength && messages.maxLength) {
+    validation = validation.max(options.maxLength, messages.maxLength);
+  }
+  return validation;
+};
+export const formValidation = {
+  string,
+  boolean,
+  email,
+  number,
+  phone,
+  zipcode,
+  file,
+  date,
+  nif,
+  array
+};

package/dist/runtime/utils/formatValue.d.ts

@@ -0,0 +1,4 @@
+export declare const formatCurrency: (n: number | undefined, maxDigits?: number, minDigits?: number) => string;
+export declare const formatPercent: (n: number | undefined, maxDigits?: number, minDigits?: number) => string;
+export declare const formatDateString: (d: string, format?: "DD/MM/YYYY" | "MM/YYYY") => string;
+export declare const formatPositiveNumber: (n: number) => number;

package/dist/runtime/utils/formatValue.js

@@ -0,0 +1,20 @@
+export const formatCurrency = (n, maxDigits = 2, minDigits = 0) => {
+  const { format } = new Intl.NumberFormat("de-DE", {
+    style: "currency",
+    currency: "EUR",
+    maximumFractionDigits: maxDigits,
+    minimumFractionDigits: minDigits > maxDigits ? maxDigits : minDigits,
+    trailingZeroDisplay: minDigits == 0 ? "stripIfInteger" : void 0
+  });
+  return format(n || 0);
+};
+export const formatPercent = (n, maxDigits = 2, minDigits = 2) => `${n ? n.toLocaleString("de-DE", {
+  maximumFractionDigits: maxDigits,
+  minimumFractionDigits: minDigits > maxDigits ? maxDigits : minDigits,
+  trailingZeroDisplay: minDigits == 0 ? "stripIfInteger" : void 0
+}) : 0}%`;
+export const formatDateString = (d, format) => {
+  const date = new Date(d).toLocaleDateString("pt");
+  return format == "MM/YYYY" ? date.slice(3) : date;
+};
+export const formatPositiveNumber = (n) => n < 0 ? n * -1 : n;

package/dist/runtime/utils/getAbTestVersion.d.ts

@@ -0,0 +1,9 @@
+export declare const getAbTestVersion: (journeyId: string | undefined, config: {
+    formType: "FUNNEL" | "LANDING" | "RESULTS_PAGE";
+    enabled: boolean;
+    experiment: string;
+    condition?: {
+        type: "utmSource";
+        utmSource: string;
+    };
+}) => Promise<any>;

package/dist/runtime/utils/getAbTestVersion.js

@@ -0,0 +1,48 @@
+import {
+  useRuntimeConfig,
+  useCookie,
+  updateForm,
+  useRequestFetch
+} from "#imports";
+export const getAbTestVersion = async (journeyId, config) => {
+  const { apiURL } = useRuntimeConfig().public;
+  const requestFetch = useRequestFetch();
+  const abTestCookie = useCookie(`abTestVersion_${config.experiment}`);
+  const fetchAbTestVersion = async () => requestFetch("/core/apis/data/abTestServiceLookup", {
+    baseURL: apiURL,
+    method: "post",
+    body: {
+      experimentName: config.experiment,
+      journeyId
+    }
+  }).then(async (d) => {
+    const abTestVersion = d.version || "control";
+    abTestCookie.value = abTestVersion;
+    await updateForm({
+      journeyId,
+      step: 0,
+      stepName: "AB Test Version",
+      formType: config.formType,
+      eventType: "STEP_CHANGED",
+      payload: {
+        abTestName: config.experiment,
+        abTestVersion
+      }
+    });
+    return abTestVersion;
+  });
+  if (!abTestCookie.value && journeyId && config.enabled) {
+    if (config.condition) {
+      switch (config.condition.type) {
+        case "utmSource":
+          const url = new URL(location.href);
+          if (url.searchParams.get("utm_source") == config.condition.utmSource) {
+            return fetchAbTestVersion();
+          }
+      }
+    } else {
+      return fetchAbTestVersion();
+    }
+  }
+  return abTestCookie.value || "control";
+};

package/dist/runtime/utils/getCalendarUrl.d.ts

@@ -0,0 +1,8 @@
+export declare const getCalendarUrl: (options: {
+    title: string;
+    description?: string;
+    location?: string;
+    dateStart: Date;
+    dateEnd: Date;
+    allDay?: boolean;
+}) => string;

package/dist/runtime/utils/getCalendarUrl.js

@@ -0,0 +1,24 @@
+export const getCalendarUrl = (options) => {
+  const url = new URL("calendar/render", "https://www.google.com");
+  const formatText = (text) => text.trim();
+  const formatDate = (date) => {
+    const targetDate = new Date(date).toISOString().replaceAll(/:/g, "").replaceAll(/-/g, "").replaceAll(/\.\d{3}(?=Z)/g, "");
+    if (options.allDay) {
+      targetDate.replaceAll(/T\d{6}(?=Z)/g, "");
+    }
+    return targetDate;
+  };
+  url.searchParams.set("action", "TEMPLATE");
+  url.searchParams.set("text", formatText(options.title));
+  if (options.description) {
+    url.searchParams.set("details", formatText(options.description));
+  }
+  if (options.location) {
+    url.searchParams.set("location", formatText(options.location));
+  }
+  url.searchParams.set(
+    "dates",
+    `${formatDate(options.dateStart)}/${formatDate(options.dateEnd)}`
+  );
+  return url.toString();
+};

package/dist/runtime/utils/getFromUrl.d.ts

@@ -0,0 +1,2 @@
+export declare const getFromUrl: (searchParam: string, removeFromUrl?: boolean) => string | string[] | undefined;
+export declare const removeFromUrl: (searchParam: string) => void;

package/dist/runtime/utils/getFromUrl.js

@@ -0,0 +1,25 @@
+export const getFromUrl = (searchParam, removeFromUrl2) => {
+  const url = new URL(window.location.href);
+  return url.searchParams.has(searchParam) ? (() => {
+    const param = url.searchParams.getAll(searchParam).map((p) => decodeURIComponent(p));
+    if (removeFromUrl2) {
+      url.searchParams.delete(searchParam);
+      history.replaceState(history.state, "", url.toString());
+    }
+    switch (param.length) {
+      case 0:
+        return void 0;
+      case 1:
+        return param[0];
+      default:
+        return param;
+    }
+  })() : void 0;
+};
+export const removeFromUrl = (searchParam) => {
+  const url = new URL(window.location.href);
+  if (url.searchParams.has(searchParam)) {
+    url.searchParams.delete(searchParam);
+    history.replaceState(history.state, "", url.toString());
+  }
+};

package/dist/runtime/utils/getStoryblokUrl.d.ts

@@ -0,0 +1,71 @@
+type MultilinkStoryblok = {
+    fieldtype: 'multilink';
+    id: string;
+    url: string;
+    cached_url: string;
+    target?: '_blank' | '_self';
+    anchor?: string;
+    rel?: string;
+    title?: string;
+    prep?: string;
+    linktype: 'story';
+    story?: {
+        name: string;
+        created_at?: string;
+        published_at?: string;
+        id: number;
+        uuid: string;
+        content?: {
+            [k: string]: any;
+        };
+        slug: string;
+        full_slug: string;
+        sort_by_date?: null | string;
+        position?: number;
+        tag_list?: string[];
+        is_startpage?: boolean;
+        parent_id?: null | number;
+        meta_data?: null | {
+            [k: string]: any;
+        };
+        group_id?: string;
+        first_published_at?: string;
+        release_id?: null | number;
+        lang?: string;
+        path?: null | string;
+        alternates?: any[];
+        default_full_slug?: null | string;
+        translated_slugs?: null | any[];
+        [k: string]: any;
+    };
+    [k: string]: any;
+} | {
+    fieldtype: 'multilink';
+    id: string;
+    url: string;
+    cached_url: string;
+    target?: '_blank' | '_self';
+    linktype: 'url';
+    rel?: string;
+    title?: string;
+    [k: string]: any;
+} | {
+    fieldtype: 'multilink';
+    id: string;
+    url: string;
+    cached_url: string;
+    target?: '_blank' | '_self';
+    email?: string;
+    linktype: 'email';
+    [k: string]: any;
+} | {
+    fieldtype: 'multilink';
+    id: string;
+    url: string;
+    cached_url: string;
+    target?: '_blank' | '_self';
+    linktype: 'asset';
+    [k: string]: any;
+};
+export declare const getStoryblokUrl: (link: MultilinkStoryblok | undefined) => string | undefined;
+export {};

package/dist/runtime/utils/getStoryblokUrl.js

@@ -0,0 +1,35 @@
+const parametersList = ["category"];
+export const getStoryblokUrl = (link) => {
+  if (link) {
+    const url = link.url || link.cached_url;
+    const parameters = [];
+    if (url) {
+      let finalUrl = (() => {
+        switch (link.linktype) {
+          case "story":
+            if (url === "/") {
+              return "/";
+            }
+            return `/${url.replace(/\/$/g, "")}`;
+          case "url":
+            return url.replace(/\/$/g, "");
+          case "asset":
+            return url;
+        }
+      })();
+      if (Object.keys(link).filter((k) => parametersList.includes(k)).length) {
+        parametersList.forEach((p) => {
+          if (link[p]) {
+            parameters.push([p, link[p]]);
+          }
+        });
+        finalUrl += `?${new URLSearchParams(parameters)}`;
+      }
+      if (link.anchor) {
+        finalUrl += `#${link.anchor}`;
+      }
+      return finalUrl;
+    }
+  }
+  return void 0;
+};

package/dist/runtime/utils/jsonReviver.d.ts

@@ -0,0 +1 @@
+export declare const jsonReviver: (data: any) => any;

package/dist/runtime/utils/jsonReviver.js

@@ -0,0 +1,18 @@
+export const jsonReviver = (data) => JSON.parse(data, (_, v) => {
+  if (typeof v == "string" && v.includes(",")) {
+    return v.split(",");
+  }
+  if (v === "true" || v === "false") {
+    return v === "true";
+  }
+  if ((Number(v) || v === "0") && typeof v != "boolean") {
+    return Number(v);
+  }
+  if (v === "undefined") {
+    return void 0;
+  }
+  if (v === "null") {
+    return null;
+  }
+  return v;
+});

package/dist/runtime/utils/mediaBreakpoints.d.ts

@@ -0,0 +1,28 @@
+export declare const mediaBreakpoints: {
+    xxs: {
+        max: number;
+    };
+    xs: {
+        min: number;
+        max: number;
+    };
+    sm: {
+        min: number;
+        max: number;
+    };
+    md: {
+        min: number;
+        max: number;
+    };
+    lg: {
+        min: number;
+        max: number;
+    };
+    xl: {
+        min: number;
+        max: number;
+    };
+    xxl: {
+        min: number;
+    };
+};

package/dist/runtime/utils/mediaBreakpoints.js

@@ -0,0 +1,28 @@
+export const mediaBreakpoints = {
+  xxs: {
+    max: 419
+  },
+  xs: {
+    min: 420,
+    max: 559
+  },
+  sm: {
+    min: 560,
+    max: 767
+  },
+  md: {
+    min: 768,
+    max: 1023
+  },
+  lg: {
+    min: 1024,
+    max: 1199
+  },
+  xl: {
+    min: 1200,
+    max: 1439
+  },
+  xxl: {
+    min: 1440
+  }
+};

package/dist/runtime/utils/toggleScroll.d.ts

@@ -0,0 +1 @@
+export declare const toggleScroll: () => void;

package/dist/runtime/utils/toggleScroll.js

@@ -0,0 +1,6 @@
+export const toggleScroll = () => {
+  const el = document.querySelector("html");
+  const scrollDisabled = el.getAttribute("scroll-disabled") === "true";
+  el.style.overflow = scrollDisabled ? "" : "clip";
+  el.setAttribute("scroll-disabled", `${!scrollDisabled}`);
+};

package/dist/runtime/utils/updateForm.d.ts

@@ -0,0 +1,11 @@
+export declare const updateForm: (options: {
+    journeyId: string | undefined;
+    nucleusJourneyId?: string | null;
+    step: number;
+    payload: Record<string, any>;
+    stepName: string;
+    isCompleted?: boolean;
+    sentToDialer?: boolean;
+    eventType?: string;
+    formType: string;
+}) => Promise<void>;

package/dist/runtime/utils/updateForm.js

@@ -0,0 +1,74 @@
+import { useCookie, useRoute, useRuntimeConfig } from "#imports";
+export const updateForm = async (options) => {
+  const { apiURL, nucleusURL } = useRuntimeConfig().public;
+  const { fullPath } = useRoute();
+  let legacyOk = false;
+  let nucleusOk = false;
+  const errors = [];
+  try {
+    const res = await $fetch("/core/apis/data/updateForm", {
+      method: "PUT",
+      baseURL: apiURL,
+      body: {
+        eventType: options.eventType || "STEP_CHANGED",
+        isActionEvent: true,
+        journeyId: options.journeyId,
+        stepName: options.stepName,
+        isCompleted: options.isCompleted || false,
+        sentToDialer: options.sentToDialer || true,
+        lastStepNumber: options.step,
+        lastStepType: options.formType,
+        lastStepUrl: fullPath,
+        data: JSON.stringify({
+          ...options.payload,
+          formType: options.formType
+        })
+      }
+    });
+    if (res.status != "OK") {
+      throw new Error(`HTTP ${res.status}`);
+    }
+    legacyOk = true;
+  } catch (err) {
+    errors.push(`[OLD] ${String(err)}`);
+  }
+  if (options.nucleusJourneyId) {
+    try {
+      const deviceIdCookie = useCookie("device_id");
+      if (!deviceIdCookie.value) {
+        throw new Error("deviceId missing");
+      }
+      await $fetch(`/journeys/${options.nucleusJourneyId}`, {
+        method: "PUT",
+        baseURL: nucleusURL,
+        body: {
+          journey_id: options.nucleusJourneyId,
+          device_id: deviceIdCookie.value,
+          form_data_json: {
+            ...options.payload,
+            formType: options.formType,
+            eventType: options.eventType || "STEP_CHANGED"
+          },
+          last_step_url: fullPath,
+          last_step_type: options.formType,
+          last_step_number: options.step,
+          last_step_name: options.stepName,
+          last_activity_at: (/* @__PURE__ */ new Date()).toISOString(),
+          is_completed: options.isCompleted ?? false
+        }
+      }).then(() => {
+        nucleusOk = true;
+      }).catch((err) => {
+        throw new Error(`HTTP ${err}`);
+      });
+    } catch (err) {
+      errors.push(`[NEW] ${String(err)}`);
+    }
+  } else {
+    nucleusOk = true;
+  }
+  if (legacyOk || nucleusOk) {
+    return;
+  }
+  throw new Error(`updateForm failed in BOTH systems. ${errors.join(" | ")}`);
+};

package/dist/runtime/utils/updateMarketingConsent.d.ts

@@ -0,0 +1,4 @@
+export declare const updateMarketingConsent: (options: {
+    email: string;
+    journeyId?: string;
+}) => Promise<unknown>;

package/dist/runtime/utils/updateMarketingConsent.js

@@ -0,0 +1,13 @@
+import { useRuntimeConfig } from "#imports";
+export const updateMarketingConsent = (options) => {
+  const { apiURL } = useRuntimeConfig().public;
+  return $fetch("/core/apis/data/verifyConsent", {
+    baseURL: apiURL,
+    method: "POST",
+    body: {
+      email: options.email,
+      currentPageUrl: location.origin + location.pathname,
+      journeyId: options.journeyId
+    }
+  });
+};

package/dist/runtime/utils/uploadFile.d.ts

@@ -0,0 +1,8 @@
+export declare const uploadFile: (options: {
+    basePath: string;
+    journeyId: string;
+    file: Blob;
+    fileName: string;
+    extension: string;
+    bucketName: string;
+}) => Promise<unknown>;

package/dist/runtime/utils/uploadFile.js

@@ -0,0 +1,13 @@
+import { useRuntimeConfig } from "#imports";
+export const uploadFile = (options) => {
+  const { apiURL } = useRuntimeConfig().public;
+  return $fetch("/core/apis/data/saveFileToS3", {
+    baseURL: apiURL,
+    method: "POST",
+    body: {
+      path: `${options.basePath}/${options.journeyId}/${options.fileName}.${options.extension}`,
+      file: options.file,
+      bucketName: options.bucketName
+    }
+  });
+};

package/dist/types.d.mts

@@ -1,13 +1,9 @@
-import type { ModuleHooks, ModuleRuntimeHooks, ModuleRuntimeConfig, ModulePublicRuntimeConfig } from './module.mjs'
+import type { NuxtModule } from '@nuxt/schema'
 
-declare module '#app' {
-  interface RuntimeNuxtHooks extends ModuleRuntimeHooks {}
-}
+import type { default as Module } from './module.mjs'
 
-declare module '@nuxt/schema' {
-  interface NuxtHooks extends ModuleHooks {}
-  interface RuntimeConfig extends ModuleRuntimeConfig {}
-  interface PublicRuntimeConfig extends ModulePublicRuntimeConfig {}
-}
+export type ModuleOptions = typeof Module extends NuxtModule<infer O> ? Partial<O> : Record<string, any>
 
-export * from "./module.mjs"
+export { default } from './module.mjs'
+
+export * from '../dist/runtime/types/index.js'