@vonq/hapi-elements-types 1.4.0 → 1.5.0

package/src/common/events/EventCommand/enums.ts

@@ -0,0 +1,49 @@
+export enum WindowHapiEventCommandName {
+    /* State */
+    stateHydrate = "state:hydrate",
+    stateTransfer = "state:transfer",
+    stateRestore = "state:restore",
+    stateLoad = "state:load",
+    stateInit = "state:init",
+
+    /* Service */
+    serviceLoad = "service:load",
+    serviceInit = "service:init",
+    serviceRequest = "service:request",
+    serviceStart = "service:start",
+    serviceSuccess = "service:success",
+    serviceFailure = "service:failure",
+    serviceFinish = "service:finish",
+
+    /* Config */
+    configSetPartnerId = "config:partnerId",
+    configSetClientId = "config:clientId",
+    configSetAreLogsEnabled = "config:areLogsEnabled",
+
+    /* App */
+    appLoad = "app:load",
+
+    /* API */
+    apiRequest = "api:request",
+
+    /* QA */
+    qaRequest = "qa:request",
+
+    /* DOM */
+    domAppendChild = "dom:append-child",
+    domElementEvent = "dom:element-event",
+    domRemoveChild = "dom:remove-child",
+    domHideElement = "dom:hide-element",
+    domShowElement = "dom:show-element",
+    domSetStyleAttribute = "dom:set-style-attribute",
+    domAddClass = "dom:add-class",
+    domRemoveClass = "dom:remove-class",
+    domSlotAvailable = "dom:slot-available",
+
+    /* Location */
+    locationSetHref = "location:href",
+}
+
+export enum EventCommandErrorResponse {
+    stateNotFound = "state-undefined-or-not-found",
+}

package/src/common/events/EventCommand/index.ts

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

package/src/common/events/EventCommand/types.ts

@@ -0,0 +1,18 @@
+import { WindowHapiEventCommandName } from "./enums"
+
+export type WindowHapiEventCommandNames =
+    | WindowHapiEventCommandName
+    | `dom:element-event-${string}`
+
+export type WindowHapiEventCommandData =
+    | [string]
+    | [string, ...any[]]
+    | [...any[]]
+    | undefined
+
+export type WindowHapiEventCommandStatus =
+    | "pending"
+    | "dispatched"
+    | "resolved"
+    | "rejected"
+    | "consumed"

package/src/common/events/index.ts

@@ -0,0 +1,4 @@
+// created from 'create-ts-index'
+
+export * from './EventCommand';
+export * from './types';

package/src/common/events/types.ts

@@ -0,0 +1,52 @@
+import {
+    WindowHapiEventCommandData,
+    WindowHapiEventCommandNames,
+    WindowHapiEventCommandStatus,
+} from "./EventCommand/types"
+import { Logger } from "../logger/Logger"
+import HapiInstance from "../instances/Instance"
+
+export type WindowHapiEventStrategy = {
+    handleEvent: (
+        event: WindowHapiEventCommand,
+    ) => Promise<WindowHapiEventCommand>
+}
+
+export type WindowHapiEventMediatorInstances = {
+    source: HapiInstance
+    targets: HapiInstance[]
+}
+
+export type WindowHapiEventMediatorGetInstancesHandler =
+    () => WindowHapiEventMediatorInstances
+
+export type WindowHapiEventCommand = {
+    id: string
+    name: WindowHapiEventCommandNames
+    createdAt: string
+    updatedAt: string | undefined
+    status: WindowHapiEventCommandStatus
+    logger: Logger
+    instance?: HapiInstance
+    data: WindowHapiEventCommandData | undefined
+    sourceInstanceName: string
+    targetInstancesNames: string[]
+    toJSON: Record<string, any>
+}
+
+export type WindowHapiEventCommandCallbackHandler = (data: any) => void
+export type WindowHapiEventCommandCommitHandler = (
+    ...args: any[]
+) => void | never | Promise<void | never>
+
+export type WindowHapiEventCommandWithCallback = WindowHapiEventCommand & {
+    callback?: WindowHapiEventCommandCallbackHandler
+}
+
+export type WindowHapiEventListener = {
+    id?: string
+    name: WindowHapiEventCommandNames
+    callback:
+        | WindowHapiEventCommandCallbackHandler
+        | WindowHapiEventCommandCommitHandler
+}

package/src/common/immutable.ts

@@ -0,0 +1,28 @@
+import { isObject } from "./misc"
+import isEqual from "lodash/isEqual"
+
+export const mergeDeepOverwriteArrays = (original: any, _overwrites: any) => {
+    const output = Object.assign({}, original)
+    const overwrites = Object.assign({}, _overwrites)
+
+    if (isObject(overwrites) && Object.keys(overwrites).length > 0) {
+        Object.keys(overwrites).forEach((key) => {
+            const value = overwrites[key]
+            if (Array.isArray(value) && !isEqual(output[key], value)) {
+                output[key] = value
+            } else if (
+                isObject(value) &&
+                !isEqual(
+                    output[key],
+                    mergeDeepOverwriteArrays(output[key], value),
+                )
+            ) {
+                output[key] = mergeDeepOverwriteArrays(output[key], value)
+            } else if (!isEqual(output[key], value)) {
+                output[key] = value
+            }
+        })
+    }
+
+    return output
+}

package/src/common/index.ts

@@ -0,0 +1,22 @@
+// created from 'create-ts-index'
+
+export * from './events';
+export * from './instances';
+export * from './logger';
+export * from './logger-datadog';
+export * from './LocalStorage';
+export * from './browser';
+export * from './color';
+export * from './immutable';
+export * from './json';
+export * from './misc';
+export * from './promise';
+export * from './proxy';
+export * from './qa.types';
+export * from './regExTest';
+export * from './tree';
+export * from './types';
+export * from './utm';
+export * from './validations.types';
+export * from './validators';
+export * from './webComponents';

package/src/common/instances/Instance.ts

@@ -0,0 +1,13 @@
+import { Logger } from "../logger/Logger"
+import { BaseService } from "../types"
+
+export default class HapiInstance implements BaseService {
+    logger: Logger
+    name: string
+    window?: Window
+    constructor(private _name: string, private _window?: Window) {
+        this.name = _name
+        this.logger = new Logger(this.name)
+        this.window = _window
+    }
+}

package/src/common/instances/consts.ts

@@ -0,0 +1 @@
+export const atsInstanceName: string = "ats"

package/src/common/instances/index.ts

@@ -0,0 +1,4 @@
+// created from 'create-ts-index'
+
+export * from './Instance';
+export * from './consts';

package/src/common/json.ts

@@ -0,0 +1,25 @@
+export const decycle = (obj: any, stack: any[] = []): any => {
+    if (!obj || typeof obj !== "object") return obj
+
+    if (stack.includes(obj)) return null
+
+    let s = stack.concat([obj])
+
+    return Array.isArray(obj)
+        ? obj.map((x) => decycle(x, s))
+        : Object.fromEntries(
+              Object.entries(obj)
+                  .filter(
+                      ([k]) =>
+                          k !== "window" &&
+                          k !== "_window" &&
+                          k !== "core" &&
+                          k !== "events" &&
+                          k !== "state",
+                  )
+                  .map(([k, v]) => [
+                      k.startsWith("_") ? k.replace("_", "") : k,
+                      decycle(v, s),
+                  ]),
+          )
+}

package/src/common/logger/Logger.ts

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

@@ -0,0 +1,12 @@
+export enum LogLevel {
+    Off = 0,
+    Error,
+    Warning,
+    Info,
+    Debug,
+}
+
+export enum NetworkErrorLoggerType {
+    "XHR" = "XHR",
+    "WS" = "WS",
+}

package/src/common/logger/index.ts

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

package/src/common/logger/types.ts

@@ -0,0 +1,7 @@
+import { LogLevel } from "./enums"
+
+export type LogOutput = (
+    source: string,
+    level: LogLevel,
+    ...objects: any[]
+) => void

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

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

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

package/src/common/misc.ts

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

@@ -0,0 +1,161 @@
+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)
+    )
+}