@vonq/hapi-elements-types 1.3.0 → 1.5.0

package/src/common/proxy.ts

@@ -0,0 +1,77 @@
+export type ProxyChangeHandler = (target: any, key: string, value: any) => void
+
+export type DeepProxyChangeHandler = (
+    target: any,
+    key: string,
+    value: any,
+    parentKey?: string,
+) => void
+
+const validatorWithLevelGet = (
+    target: any,
+    key: string,
+    level: number,
+    maxLevel: number,
+    changeFn: DeepProxyChangeHandler,
+    parentKey?: string,
+) => {
+    if (
+        typeof target[key] === "object" &&
+        target[key] !== null &&
+        level < maxLevel
+    ) {
+        return new Proxy(
+            target[key],
+            getValidatorWithLevel(level + 1, maxLevel, changeFn, parentKey),
+        )
+    } else {
+        return target[key]
+    }
+}
+
+const getValidatorWithLevel = (
+    level: number,
+    maxLevel: number,
+    changeFn: DeepProxyChangeHandler,
+    parentKey?: string,
+) => {
+    return {
+        get(target: any, key: string): any {
+            return validatorWithLevelGet(
+                target,
+                key,
+                level,
+                maxLevel,
+                changeFn,
+                parentKey,
+            )
+        },
+        set(target: any, key: string, value: any) {
+            target[key] = value
+            changeFn(target, key, value, parentKey)
+            return true
+        },
+    }
+}
+
+export const deepProxyByLevel = (
+    object: Record<string, any>,
+    maxLevel: number,
+    changeFn: DeepProxyChangeHandler,
+    parentKey?: string,
+): ProxyConstructor =>
+    new Proxy(object, getValidatorWithLevel(0, maxLevel, changeFn, parentKey))
+
+export const decorateVariableWithOnListener = (
+    variable: any,
+    callbackFn: (value: any) => void,
+) => {
+    return new Proxy(variable, {
+        get(target: any, key: string): any {
+            return {
+                value: target[key],
+                on: callbackFn,
+            }
+        },
+    })
+}

package/src/common/qa.types.ts

@@ -0,0 +1,9 @@
+import { ModuleWithConstructorArgs } from "../types"
+import { WindowHapiQA } from "../_window/qa.types"
+
+export type WindowHapiQACommon = ModuleWithConstructorArgs<
+    {
+        setComponentDebuggingIsEnabled: (isEnabled: boolean) => boolean
+    },
+    { readonly qa: WindowHapiQA }
+>

package/src/common/regExTest.ts

@@ -0,0 +1,12 @@
+export const regexRulesMap: Record<"id" | "number" | "utm", RegExp> = {
+    id: /^([a-zA-Z0-9_-]){36}$/,
+    number: /e|[-=+,.]/,
+    utm: /^([%.\-_!*a-zA-Z0-9]{1,}=[%.\-_!*+,;$()a-zA-Z0-9]{1,}[&]{0,}){1,}$/,
+}
+
+export function testRegexFromRegexRulesMap(
+    type: "id" | "number" | "utm",
+    str: string,
+) {
+    return regexRulesMap[type].test(str)
+}

package/src/common/tree.ts

@@ -0,0 +1,148 @@
+import { flatten, partition, without } from "lodash"
+
+export type TreeItem<FileData, FolderData> =
+    | FolderItem<FileData, FolderData>
+    | FileItem<FileData>
+
+export interface FolderItem<FileData, FolderData> {
+    children: Array<TreeItem<FileData, FolderData>>
+    data: FolderData
+    isLeaf: false
+}
+
+export interface FileItem<FileData> {
+    data: FileData
+    isLeaf: true
+}
+
+function folderItemFactory<FileData, FolderData>(
+    data: FolderData,
+    children: Array<TreeItem<FileData, FolderData>> = [],
+): FolderItem<FileData, FolderData> {
+    return {
+        children,
+        data,
+        isLeaf: false,
+    }
+}
+
+function fileItemFactory<FileData>(data: FileData): FileItem<FileData> {
+    return {
+        data,
+        isLeaf: true,
+    }
+}
+
+function checkRecursive<T>(
+    list: Array<T>,
+    isParentOf: (parent: T, children: T) => boolean,
+) {
+    const isParentOfItself = list.some((item) => isParentOf(item, item))
+    if (isParentOfItself) {
+        throw new Error("An item cannot be a parent of itself")
+    }
+}
+
+/**
+ * Create a tree hierarchy from an array of items both files and folders mixed. Using treeItemFromFolderAndFileList is preferred
+ **/
+export function treeItemFromList<FileData, FolderData>(
+    list: Array<FileData | FolderData>,
+    isFolder: (data: FileData | FolderData) => boolean,
+    isParentOfFile: (parent: FolderData, children: FileData) => boolean,
+    isParentOfFolder?: (parent: FolderData, children: FolderData) => boolean,
+): Array<TreeItem<FileData, FolderData>> {
+    const [folderData, fileData] = partition(list, isFolder) as [
+        Array<FolderData>,
+        Array<FileData>,
+    ]
+    return treeItemFromFolderAndFileList<FileData, FolderData>(
+        fileData,
+        folderData,
+        isParentOfFile,
+        isParentOfFolder,
+    )
+}
+
+/**
+ * Create a tree hierarchy from 2 array of items, one representing files (or leaves) and the second folders (or directories)
+ **/
+export function treeItemFromFolderAndFileList<FileData, FolderData>(
+    fileData: Array<FileData>,
+    folderData: Array<FolderData>,
+    isParentOfFile: (parent: FolderData, children: FileData) => boolean,
+    // only if this is a multi level tree hierarchy (folder containing folders)
+    isParentOfFolder: (
+        parent: FolderData,
+        children: FolderData,
+    ) => boolean = () => false,
+): Array<TreeItem<FileData, FolderData>> {
+    checkRecursive(folderData, isParentOfFolder)
+
+    const folderTreeItems: Array<FolderItem<FileData, FolderData>> =
+        folderData.map((data) => folderItemFactory(data))
+    const fileTreeItems: Array<FileItem<FileData>> = fileData.map((data) =>
+        fileItemFactory(data),
+    ) as Array<FileItem<FileData>>
+    const allTreeItems = [...folderTreeItems, ...fileTreeItems]
+
+    folderTreeItems.forEach((folderTreeItem) => {
+        const fileChildren = fileTreeItems.filter((childTreeItem) =>
+            isParentOfFile(folderTreeItem.data, childTreeItem.data),
+        )
+        const folderChildren = folderTreeItems.filter((childTreeItem) =>
+            isParentOfFolder(folderTreeItem.data, childTreeItem.data),
+        )
+        folderTreeItem.children.push(...fileChildren, ...folderChildren)
+    })
+
+    return filterOrphans(allTreeItems)
+}
+
+function filterOrphans<T, V>(
+    treeItems: Array<TreeItem<T, V>>,
+): Array<TreeItem<T, V>> {
+    const flatItems: Array<TreeItem<T, V>> = flattenTreeItemDeep(treeItems)
+    const folderItems: Array<FolderItem<T, V>> = flatItems.filter((item) =>
+        isFolderTreeItem(item),
+    ) as Array<FolderItem<T, V>>
+    const allChildren: Array<TreeItem<T, V>> = flatten(
+        folderItems.map(({ children }) => children),
+    )
+    return without(flatItems, ...allChildren)
+}
+
+export function flattenTreeItemDeep<T, V>(
+    treeItems: Array<TreeItem<T, V>>,
+): Array<TreeItem<T, V>> {
+    return Array.from(walkTreeItem(...treeItems))
+}
+
+/**
+ * Visitor going through all the nodes of the tree
+ */
+function* walkTreeItem<FileData, FolderData>(
+    ...treeItems: TreeItem<FileData, FolderData>[]
+): Generator<TreeItem<FileData, FolderData>> {
+    for (const treeItem of treeItems) {
+        yield treeItem
+        if (isFolderTreeItem(treeItem)) {
+            const children = treeItem.children
+            yield* walkTreeItem(...children)
+        }
+    }
+}
+
+function isFolderTreeItem<FileData, FolderData>(
+    treeItem: TreeItem<FileData, FolderData>,
+): treeItem is FolderItem<FileData, FolderData> {
+    return !treeItem.isLeaf
+}
+
+export function flattenTreeItem<T, V>(
+    treeItem: TreeItem<T, V>,
+): Array<TreeItem<T, V>> {
+    return isFolderTreeItem(treeItem)
+        ? [treeItem, ...treeItem.children]
+        : [treeItem]
+}

package/src/common/types.ts

@@ -0,0 +1,110 @@
+import validator from "validator"
+import validators from "./validators"
+import { MessageDescriptor } from "react-intl"
+import { Logger } from "./logger/Logger"
+import { Stores } from "../types"
+
+export type ValueOf<T> = T[keyof T]
+export type AnyNonFunction<T> = Omit<T, "function">
+export declare type PrimitiveType =
+    | string
+    | number
+    | boolean
+    | null
+    | undefined
+    | Date
+export type PartialBy<T, K extends keyof T> = Omit<T, K> & Partial<Pick<T, K>>
+export type RecursivePartial<T> = {
+    [P in keyof T]?: RecursivePartial<T[P]>
+}
+export type PartialRecord<K extends keyof any, T> = Partial<Record<K, T>>
+export type RemoveIndex<T> = {
+    [K in keyof T as string extends K
+        ? never
+        : number extends K
+        ? never
+        : K]: T[K]
+}
+export type PaginationLimitOffset = {
+    limit?: number
+    offset?: number
+}
+export type PaginationResponseV1 = {
+    count?: number
+    next?: string | null
+    previous?: string | null
+} & PaginationLimitOffset
+export type PaginationResponseV2 = {
+    total?: number
+    meta?: {
+        first: string
+        last: string
+        next: string
+        previous: string
+    }
+} & PaginationLimitOffset
+export type PaginatedAPIResponseV1<T> = {
+    results: T[]
+} & PaginationResponseV1
+export type PaginatedAPIResponseV2<T> = {
+    data: T[]
+} & PaginationResponseV2
+export type HapiInputErrorMessageOrValidity =
+    | MessageDescriptor
+    | boolean
+    | undefined
+    | null
+export type UseValidatorResult = {
+    validityOrErrorMessages: Record<string, HapiInputErrorMessageOrValidity>
+    areAllValid: boolean
+}
+export type ValidatorKey =
+    | Exclude<
+          keyof typeof validator,
+          | "version"
+          | "AlphaLocale"
+          | "isAlphaLocales"
+          | "AlphanumericLocale"
+          | "isAlphanumericLocales"
+          | "ibanLocales"
+          | "FloatLocale"
+          | "isFloatLocales"
+          | "MobilePhoneLocale"
+          | "PhoneLocale"
+          | "PhoneLocaleAlias"
+          | "isMobilePhoneLocales"
+          | "PostalCodeLocale"
+          | "isPostalCodeLocales"
+      >
+    | keyof typeof validators
+export type NestedValidatorKeys =
+    | ValidatorKey
+    | {
+          [k: string]: ValidatorKey | NestedValidatorKeys
+      }
+export type BaseService = {
+    logger: Logger
+}
+// the reason there are no types like enums here is because
+// the options should be a serializable JSON during generation of web component files
+export type HapiWebComponent = {
+    title: string
+    description: string
+    moduleName: string //WindowHapiModuleName
+    secondaryModuleName?: string //WindowHapiModuleName
+    notes?: string //additional remarks like some best practices for this individual widget
+    path: string
+    key: string
+    id: string
+    injects?: string[]
+    initialState?: Partial<Record<keyof Stores, any>>
+    isUserJourney?: boolean
+    webComponentCSS?: Record<string, any> //React.CSSProperties
+    attributes?: Record<string, string>
+    qaFunctionToMockId?: Record<string, string> //some widgets have attributes like <widget campaign-id=IDHERE> and they show 404 inside demo pages and documentation so this will map to window.hapiQA function that will grab that id. example below
+    /* mock id example
+    {
+        "campaignId": "campaign.getRandomCampaignId" //campaignId being the path parameter like [campaignId].tsx
+    }
+    */
+}

package/src/common/utm.ts

@@ -0,0 +1,19 @@
+import { Product } from "../product/types"
+import { Contract } from "../contract/types"
+import { getBasketProductTitle } from "../basket/utils"
+import { testRegexFromRegexRulesMap } from "./regExTest"
+
+export const getUtmCodeForProductOrContract = (
+    productOrContract: Product | Contract,
+    utmMedium: string = "jobposting",
+    utmCampaign: string = "jobmarketing",
+): [string, boolean] => {
+    const cName = getBasketProductTitle(productOrContract)
+        .replace(/ /g, "_")
+        .replace(/[^a-z0-9]_+/gi, "")
+        .toLowerCase()
+    const autoUtm = `utm_source=${cName}&utm_medium=${utmMedium}&utm_campaign=${utmCampaign}`
+    const isValid = testRegexFromRegexRulesMap("utm", autoUtm) || !autoUtm
+
+    return [autoUtm, isValid]
+}

package/src/common/validations.types.ts

@@ -0,0 +1,89 @@
+import {
+    ZodAny,
+    ZodArray,
+    ZodBoolean,
+    ZodFunction,
+    ZodNullable,
+    ZodNumber,
+    ZodObject,
+    ZodOptional,
+    ZodRecord,
+    ZodString,
+    ZodTuple,
+    ZodUnion,
+    ZodUnknown,
+} from "zod"
+
+export type ZodIntlDescriptor = ZodObject<{
+    id: ZodString
+    defaultMessage: ZodString
+}>
+export type ZodPaginationLimit = ZodNumber
+export type ZodPaginationOffset = ZodNumber
+export type ZodPaginationLimitOffsetDefinition = {
+    limit: ZodOptional<ZodPaginationLimit>
+    offset: ZodOptional<ZodPaginationOffset>
+}
+export type ZodPaginationLimitOffset =
+    ZodObject<ZodPaginationLimitOffsetDefinition>
+export type ZodPaginationNext = ZodString
+export type ZodPaginationPrevious = ZodString
+export type ZodPaginationFirst = ZodString
+export type ZodPaginationLast = ZodString
+export type ZodPaginationNextPreviousDefinition = {
+    next: ZodOptional<ZodNullable<ZodPaginationNext>>
+    previous: ZodOptional<ZodNullable<ZodPaginationPrevious>>
+}
+export type ZodPaginationFirstLastDefinition = {
+    first: ZodOptional<ZodNullable<ZodPaginationFirst>>
+    last: ZodOptional<ZodNullable<ZodPaginationLast>>
+}
+export type ZodPaginationTotal = ZodNumber
+export type ZodPaginationResponseV1 = ZodObject<
+    {
+        count: ZodOptional<ZodNullable<ZodNumber>>
+    } & ZodPaginationLimitOffsetDefinition &
+        ZodPaginationNextPreviousDefinition
+>
+export type ZodPaginationMeta = ZodObject<
+    ZodPaginationFirstLastDefinition & ZodPaginationNextPreviousDefinition
+>
+export type ZodPaginationResponseV2 = ZodObject<
+    {
+        total: ZodOptional<ZodNullable<ZodPaginationTotal>>
+        meta: ZodOptional<ZodPaginationMeta>
+    } & ZodPaginationLimitOffsetDefinition
+>
+export type WindowHapiValidationsCommon = {
+    genericBoolean: ZodBoolean
+    genericNumber: ZodNumber
+    genericNumberArray: ZodArray<ZodNumber>
+    genericString: ZodString
+    genericStringArray: ZodArray<ZodString>
+    genericObject: ZodObject<any>
+    genericRecordFunction: ZodRecord<
+        ZodString,
+        ZodFunction<ZodTuple<[], ZodUnknown>, ZodUnknown>
+    >
+    genericRecordBoolean: ZodRecord<ZodString, ZodBoolean>
+    genericRecordString: ZodRecord<ZodString, ZodString>
+    genericStringOrNumber: ZodUnion<[ZodNumber, ZodString]>
+    genericNullableStringOrNumber: ZodNullable<ZodUnion<[ZodNumber, ZodString]>>
+    genericNullableString: ZodNullable<ZodString>
+    genericAny: ZodAny
+    genericAnyArray: ZodArray<ZodAny>
+    genericStringOrNumberArray: ZodArray<ZodUnion<[ZodNumber, ZodString]>>
+    recordString: ZodRecord<ZodString, ZodString>
+    intlDescriptor: ZodIntlDescriptor
+    limitOffsetPagination: ZodPaginationLimitOffsetDefinition
+    paginationMetaV1: ZodPaginationResponseV1
+    paginationMetaV2: ZodPaginationResponseV2
+    hexRegex: RegExp
+    hex: ZodString
+    camelCaseRegex: RegExp
+    camelCase: ZodString
+    urlRegex: RegExp
+    url: ZodString
+    apiResourceRegex: RegExp
+    apiResource: ZodString
+}

package/src/common/validators.ts

@@ -0,0 +1,21 @@
+import validator from "validator"
+
+export const isNotEmpty = (value: string | Record<string, any> | any[]) => {
+    return Array.isArray(value)
+        ? value?.length > 0
+        : typeof value === "object"
+        ? validator.isLength(value?.["value"], { min: 1 })
+        : validator.isLength(value, { min: 1 })
+}
+
+export const isNotZero = (value: number) => value !== 0
+
+// it is important that the functions are not exported individually
+// the store data needs to be serializable so we need to assign the names of these functions to variables
+// rather than the function itself
+const validators = {
+    isNotEmpty,
+    isNotZero,
+}
+
+export default validators

package/src/common/webComponents.ts

@@ -0,0 +1,26 @@
+import { WindowHapiModuleName } from "../../enums"
+import { _window } from "../consts"
+
+export const getWebComponentElementCode = (key: string) => `<${key}></${key}>`
+
+export const getWebComponentsFromHapiConfigByModuleName = (
+    activeModule: WindowHapiModuleName,
+) => {
+    return _window!.hapiConfig?.webComponents
+        .filter((component) => component.moduleName === activeModule)
+        .map((component) => {
+            return {
+                name: component.title,
+                id: component.key,
+                language: "component",
+            }
+        })
+}
+
+export const getWebComponentFromHapiConfigByWidgetName = (
+    widgetName: string,
+) => {
+    return _window!.hapiConfig?.webComponents.find(
+        (component) => component.key === widgetName,
+    )
+}

package/src/config/functions.types.ts

@@ -0,0 +1,23 @@
+import { ClientID, PartnerID } from "./state.types"
+import { DemoATSLayoutType } from "../types"
+
+export type ConfigStoreSetPartnerIdHandler = (partnerId: PartnerID) => void
+export type ConfigStoreSetClientIdHandler = (clientId: ClientID) => void
+
+export type ConfigStoreSetShouldCallInitOfServicesHandler = (
+    shouldCallInitOfServices: boolean,
+) => void
+
+export type ConfigStoreSetDemoATSLayoutHandler = (
+    layout: DemoATSLayoutType,
+) => void
+
+export type ConfigStoreFunctions = {
+    /* App Related */
+    setPartnerId: ConfigStoreSetPartnerIdHandler
+    setClientId: ConfigStoreSetClientIdHandler
+
+    /* Demo ATS Related */
+    setShouldCallInitOfServices: ConfigStoreSetShouldCallInitOfServicesHandler
+    setDemoATSLayout: ConfigStoreSetDemoATSLayoutHandler
+}

package/src/config/index.ts

@@ -0,0 +1,5 @@
+// created from 'create-ts-index'
+
+export * from './functions.types';
+export * from './state.initial';
+export * from './state.types';

package/src/config/state.initial.ts

@@ -0,0 +1,11 @@
+import { ConfigStoreState } from "./state.types"
+
+export const initialConfigStoreState: ConfigStoreState = {
+    /* App Related */
+    partnerId: undefined,
+    clientId: undefined,
+
+    /* Demo ATS Related */
+    shouldCallInitOfServices: false,
+    demoATSLayout: "technical",
+}

package/src/config/state.types.ts

@@ -0,0 +1,15 @@
+import { DemoATSLayoutType } from "../types"
+
+export type PartnerID = string | undefined
+export type ClientID = string | undefined
+export type ClientToken = string | undefined
+
+export type ConfigStoreState = {
+    /* App Related */
+    partnerId: PartnerID
+    clientId: ClientID
+
+    /* Demo ATS Related */
+    shouldCallInitOfServices: boolean
+    demoATSLayout: DemoATSLayoutType
+}