@vonq/hapi-elements-types 1.5.0 → 1.6.0

package/src/common/logger/Logger.ts

@@ -1,70 +0,0 @@
-import { LogLevel } from "./enums"
-import { LogOutput } from "./types"
-
-export class Logger {
-    static level = LogLevel.Debug
-    static outputs: LogOutput[] = []
-    public id = `logger-${this.source}`
-
-    constructor(
-        public source?: string,
-        public isEnabled: boolean = true, // // by default all logs should be disabled, ATS should enable it if they want
-    ) {
-        /*const areAllLogsEnabled =
-            cookie.get(DEBUG_COOKIE_ARE_LOGS_ENABLED) === "true"
-
-        if (areAllLogsEnabled) {
-            this.isEnabled = areAllLogsEnabled
-        }*/
-    }
-
-    setIsEnabled = (isEnabled: boolean) => {
-        //this.isEnabled = isEnabled
-    }
-
-    static enableProductionMode() {
-        Logger.level = LogLevel.Warning
-    }
-
-    debug(...objects: any[]) {
-        this.log(console.log, LogLevel.Debug, objects)
-    }
-
-    info(...objects: any[]) {
-        this.log(console.info, LogLevel.Info, objects)
-    }
-
-    warn(...objects: any[]) {
-        this.log(console.warn, LogLevel.Warning, objects)
-    }
-
-    error(...objects: any[]) {
-        this.log(console.error, LogLevel.Error, objects)
-    }
-
-    timeStart(message: string) {
-        this.log(console.time, LogLevel.Info, [message])
-    }
-
-    timeEnd(message: string) {
-        this.log(console.log, LogLevel.Info, [message, "timer finished"])
-        this.log(console.timeEnd, LogLevel.Info, [message])
-    }
-
-    private log(func: Function, level: LogLevel, objects: any[]) {
-        if (level <= Logger.level && this.isEnabled) {
-            let sourceString = "[HAPI]"
-
-            sourceString += `[${this.source}]`
-
-            const log = this.source ? [sourceString].concat(objects) : objects
-            func.apply(console, log)
-            Logger.outputs.forEach((output) =>
-                output.apply(
-                    output,
-                    [this.source, level].concat(objects) as any,
-                ),
-            )
-        }
-    }
-}

package/src/common/logger/index.ts

@@ -1,5 +0,0 @@
-// created from 'create-ts-index'
-
-export * from './Logger';
-export * from './enums';
-export * from './types';

package/src/common/logger-datadog/LoggerDatadog.ts

@@ -1,42 +0,0 @@
-import { datadogLogs, Logger } from "@datadog/browser-logs"
-import { HandlerType } from "@datadog/browser-logs/cjs/domain/logger"
-
-export default class LoggerDatadog {
-    prefix: string
-    logger: Logger
-    commonContext: Record<string, any> = {}
-    handler: HandlerType = "http"
-    constructor(
-        prefix: string,
-        commonContext?: Record<string, any>,
-        handler?: HandlerType,
-    ) {
-        this.prefix = `[${prefix}]`
-        this.logger = datadogLogs.createLogger(this.prefix)
-        this.commonContext = commonContext || {}
-        this.handler = handler || "http"
-    }
-
-    info = (message: string, messageContext?: Record<string, any>) => {
-        this.logger.info(message, this.getMergedContext(messageContext))
-    }
-
-    debug = (message: string, messageContext?: Record<string, any>) => {
-        this.logger.debug(message, this.getMergedContext(messageContext))
-    }
-
-    error = (message: string, messageContext?: Record<string, any>) => {
-        this.logger.error(message, this.getMergedContext(messageContext))
-    }
-
-    warn = (message: string, messageContext?: Record<string, any>) => {
-        this.logger.warn(message, this.getMergedContext(messageContext))
-    }
-
-    private getMergedContext = (messageContext?: Record<string, any>) => {
-        return {
-            ...this.commonContext,
-            ...messageContext,
-        }
-    }
-}

package/src/common/logger-datadog/index.ts

@@ -1,3 +0,0 @@
-// created from 'create-ts-index'
-
-export * from './LoggerDatadog';

package/src/common/misc.ts

@@ -1,114 +0,0 @@
-export const convertNumberToTime = (num: number) => {
-    const hours = Math.floor(num / 60)
-    const minutes = num % 60
-    return `${hours}:${minutes.toString().padStart(2, "0")}`
-}
-
-export const getDomainWithSubdomains = (url: any) => {
-    let domainParts = 2
-    url = url.replace(/(https?:\/\/)?(www.)?/i, "")
-    url = url.split(".")
-    if (url.length > 2) {
-        domainParts = 3
-    }
-    url = url.slice(url.length - domainParts).join(".")
-    if (url.indexOf("/") !== -1) {
-        return url.split("/")[0]
-    }
-    return url
-}
-
-export const abbreviateNumber = (value: number) => {
-    // from https://stackoverflow.com/a/10601315/2302269
-    let newValue: any = value
-    if (value >= 1000) {
-        const suffixes = ["", "K", "M", "B", "T"]
-        const suffixNum = Math.floor(("" + value).length / 3)
-        let shortValue: any = ""
-        for (let precision = 2; precision >= 1; precision--) {
-            shortValue = parseFloat(
-                (suffixNum != 0
-                    ? value / Math.pow(1000, suffixNum)
-                    : value
-                ).toPrecision(precision),
-            )
-            const dotLessShortValue = (shortValue + "").replace(
-                /[^a-zA-Z 0-9]+/g,
-                "",
-            )
-            if (dotLessShortValue.length <= 2) {
-                break
-            }
-        }
-        if (shortValue % 1 != 0) shortValue = shortValue.toFixed(1)
-        newValue = shortValue + suffixes[suffixNum]
-    }
-    return newValue
-}
-
-export const replaceBrTagsWithNewLines = (str: string) => {
-    return str.replace(/<br\s*\/?>/gi, "\n")
-}
-
-export const capitalizeText = (s: string | null) => {
-    if (typeof s !== "string") return ""
-    return s.charAt(0).toUpperCase() + s.slice(1)
-}
-
-export const optionalKeyValue = (key: string, value: any) => {
-    return !!value ? { [key]: value } : {}
-}
-
-export const getDomainWithDotPrefix = (domain: string) => {
-    return `.${domain}`
-}
-export const getDomainWithoutDotPrefix = (
-    cookieDomainWithDotPrefix?: string,
-) => {
-    return cookieDomainWithDotPrefix
-        ? cookieDomainWithDotPrefix.substring(1)
-        : ""
-}
-
-export const isObject = (item: any) => {
-    return item && typeof item === "object" && !Array.isArray(item)
-}
-
-export const padZero = (str: string | number, len?: number) => {
-    len = len || 2
-    let zeros = new Array(len).join("0")
-    return (zeros + str).slice(-len)
-}
-
-export const getFunctionArgumentNames = (func: Function) => {
-    const STRIP_COMMENTS =
-        /(\/\/.*$)|(\/\*[\s\S]*?\*\/)|(\s*=[^,\)]*(('(?:\\'|[^'\r\n])*')|("(?:\\"|[^"\r\n])*"))|(\s*=[^,\)]*))/gm
-    const ARGUMENT_NAMES = /([^\s,]+)/g
-    const fnStr = func.toString().replace(STRIP_COMMENTS, "")
-    let result: any = fnStr
-        .slice(fnStr.indexOf("(") + 1, fnStr.indexOf(")"))
-        .match(ARGUMENT_NAMES)
-    if (result === null) result = []
-    return result
-}
-
-export const removeByIndex = (array: any[], index: number | number[]) => {
-    return array.filter((el, i) => {
-        return Array.isArray(index) ? !index.includes(i) : index !== i
-    })
-}
-
-export const getRandomIdOfNCharacters = (length: number) => {
-    let result = ""
-    const characters =
-        "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789"
-    const charactersLength = characters.length
-    let counter = 0
-    while (counter < length) {
-        result += characters.charAt(
-            Math.floor(Math.random() * charactersLength),
-        )
-        counter += 1
-    }
-    return result
-}

package/src/common/promise.ts

@@ -1,161 +0,0 @@
-import isPromise from "is-promise"
-
-function hasSymbols() {
-    if (
-        typeof Symbol !== "function" ||
-        typeof Object.getOwnPropertySymbols !== "function"
-    ) {
-        return false
-    }
-    if (typeof Symbol.iterator === "symbol") {
-        return true
-    }
-
-    var obj: any = {}
-    var sym = Symbol("test")
-    var symObj = Object(sym)
-    if (typeof sym === "string") {
-        return false
-    }
-
-    if (Object.prototype.toString.call(sym) !== "[object Symbol]") {
-        return false
-    }
-    if (Object.prototype.toString.call(symObj) !== "[object Symbol]") {
-        return false
-    }
-
-    // temp disabled per https://github.com/ljharb/object.assign/issues/17
-    // if (sym instanceof Symbol) { return false; }
-    // temp disabled per https://github.com/WebReflection/get-own-property-symbols/issues/4
-    // if (!(symObj instanceof Symbol)) { return false; }
-
-    // if (typeof Symbol.prototype.toString !== 'function') { return false; }
-    // if (String(sym) !== Symbol.prototype.toString.call(sym)) { return false; }
-
-    var symVal = 42
-    obj[sym] = symVal
-    for (const sym in obj) {
-        return false
-    } // eslint-disable-line no-restricted-syntax, no-unreachable-loop
-    if (typeof Object.keys === "function" && Object.keys(obj).length !== 0) {
-        return false
-    }
-
-    if (
-        typeof Object.getOwnPropertyNames === "function" &&
-        Object.getOwnPropertyNames(obj).length !== 0
-    ) {
-        return false
-    }
-
-    var syms = Object.getOwnPropertySymbols(obj)
-    if (syms.length !== 1 || syms[0] !== sym) {
-        return false
-    }
-
-    if (!Object.prototype.propertyIsEnumerable.call(obj, sym)) {
-        return false
-    }
-
-    if (typeof Object.getOwnPropertyDescriptor === "function") {
-        var descriptor: any = Object.getOwnPropertyDescriptor(obj, sym)
-        if (descriptor.value !== symVal || descriptor.enumerable !== true) {
-            return false
-        }
-    }
-
-    return true
-}
-
-function hasToStringTagShams() {
-    return hasSymbols() && !!Symbol.toStringTag
-}
-
-const toStr = Object.prototype.toString
-const fnToStr = Function.prototype.toString
-const isFnRegex = /^\s*async(?:\s+function(?:\s+|\()|\s*\()/
-const hasToStringTag = hasToStringTagShams()
-const getProto = Object.getPrototypeOf
-const getAsyncFunc = function () {
-    // eslint-disable-line consistent-return
-    if (!hasToStringTag) {
-        return false
-    }
-    try {
-        return Function("return async function () {}")()
-    } catch (e) {}
-}
-
-export const isAsyncFunction = (fn: Function) => {
-    let AsyncFunction: any
-    if (typeof fn !== "function") {
-        return false
-    }
-    if (isFnRegex.test(fnToStr.call(fn))) {
-        return true
-    }
-    if (!hasToStringTag) {
-        const str = toStr.call(fn)
-        return str === "[object AsyncFunction]"
-    }
-    if (!getProto) {
-        return false
-    }
-    if (typeof AsyncFunction === "undefined") {
-        const asyncFunc = getAsyncFunc()
-        AsyncFunction = asyncFunc ? getProto(asyncFunc) : false
-    }
-    return getProto(fn) === AsyncFunction
-}
-
-const isFnRegexNormal = /^\s*(?:function)?\*/
-const getGeneratorFunc = function () {
-    // eslint-disable-line consistent-return
-    if (!hasToStringTag) {
-        return false
-    }
-    try {
-        return Function("return function*() {}")()
-    } catch (e) {}
-}
-
-const isGeneratorFunction = (fn: any) => {
-    let GeneratorFunction: any
-    if (typeof fn !== "function") {
-        return false
-    }
-    if (isFnRegexNormal.test(fnToStr.call(fn))) {
-        return true
-    }
-    if (!hasToStringTag) {
-        var str = toStr.call(fn)
-        return str === "[object GeneratorFunction]"
-    }
-    if (!getProto) {
-        return false
-    }
-    if (typeof GeneratorFunction === "undefined") {
-        var generatorFunc = getGeneratorFunc()
-        GeneratorFunction = generatorFunc ? getProto(generatorFunc) : false
-    }
-    return getProto(fn) === GeneratorFunction
-}
-
-export const isPromiseOrAsyncFunction = (fn: Function) => {
-    const stringFn = fn.toString()
-
-    const isJestFn = (fn as any)._isMockFunction === true
-    const isJestFnAsync = isJestFn && (fn as any).getMockName() === "async"
-    // it is required while defining jest.fn that .mockName("async") is specified
-    // so this FN can recognize that it's async
-
-    return (
-        isPromise(fn) ||
-        isAsyncFunction(fn) ||
-        isGeneratorFunction(fn) ||
-        stringFn.includes("this,null,function*") ||
-        (stringFn.includes("__async") && stringFn.includes("function* ()")) ||
-        (isJestFn && isJestFnAsync)
-    )
-}

package/src/common/proxy.ts

@@ -1,77 +0,0 @@
-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/regExTest.ts

@@ -1,12 +0,0 @@
-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

@@ -1,148 +0,0 @@
-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/utm.ts

@@ -1,19 +0,0 @@
-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/validators.ts

@@ -1,21 +0,0 @@
-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