@rivtn/noseur 1.0.0

package/dist/esm/utils/BoolHelper.d.ts

@@ -0,0 +1,13 @@
+export declare const BoolHelper: {
+    bothEquals(var1: any, var2: any): boolean;
+    equalsAny<T>(obj: any, compares: T[]): boolean;
+    equalsAll<T>(obj: any, compares: T[]): boolean;
+    equalsNone(obj: any, compares: string[]): boolean;
+    allEquals<T>(comparator: (o: T) => boolean, ...values: T[]): boolean;
+    anyEquals<T>(comparator: (o: T) => boolean, ...values: T[]): boolean;
+    notAllEquals<T>(comparator: (o: T) => boolean, ...values: T[]): boolean;
+    deepEqual(value1: any, value2: any, keys?: any[] | undefined, recurse?: boolean, processedKeys?: any[]): boolean;
+    arrayDeepEquals(arr1: any[], arr2: any[], keys?: any[] | undefined, recurse?: boolean, processedKeys?: any[]): boolean;
+    objectDeepEquals(obj1: any, obj2: any, keys?: any[] | undefined, recurse?: boolean, processedKeys?: any[]): boolean;
+    compare(a: any, b: any): any;
+};

package/dist/esm/utils/BoolHelper.js

@@ -0,0 +1,105 @@
+import { TypeChecker } from "./TypeChecker";
+export const BoolHelper = {
+    bothEquals(var1, var2) {
+        return (var1 === var2);
+    },
+    equalsAny(obj, compares) {
+        for (var compare of compares) {
+            if (BoolHelper.bothEquals(obj, compare)) {
+                return true;
+            }
+        }
+        return false;
+    },
+    equalsAll(obj, compares) {
+        for (var compare of compares) {
+            if (!BoolHelper.bothEquals(obj, compare)) {
+                return false;
+            }
+        }
+        return true;
+    },
+    equalsNone(obj, compares) {
+        for (var compare of compares) {
+            if (BoolHelper.bothEquals(obj, compare)) {
+                return false;
+            }
+        }
+        return true;
+    },
+    allEquals(comparator, ...values) {
+        for (const value of values) {
+            if (!comparator(value))
+                return false;
+        }
+        return true;
+    },
+    anyEquals(comparator, ...values) {
+        for (const value of values) {
+            if (comparator(value))
+                return true;
+        }
+        return false;
+    },
+    notAllEquals(comparator, ...values) {
+        let anyAlreadEqual = false;
+        for (const value of values) {
+            if (comparator(value)) {
+                anyAlreadEqual = true;
+            }
+            else {
+                if (anyAlreadEqual)
+                    return true;
+            }
+        }
+        return anyAlreadEqual;
+    },
+    deepEqual(value1, value2, keys = undefined, recurse = false, processedKeys = []) {
+        if (BoolHelper.allEquals(TypeChecker.isDict, value1, value2))
+            return BoolHelper.objectDeepEquals(value1, value2, keys, recurse, processedKeys);
+        if (BoolHelper.allEquals(TypeChecker.isArray, value1, value2))
+            return BoolHelper.arrayDeepEquals(value1, value2, keys, recurse, processedKeys);
+        return value1 === value2;
+    },
+    arrayDeepEquals(arr1, arr2, keys = undefined, recurse = false, processedKeys = []) {
+        if (!(arr1 && arr2))
+            return false;
+        if (arr1.length != arr2.length)
+            return false;
+        for (let index = 0; index < arr1.length; index++) {
+            const arr1Value = arr1[index];
+            const arr2Value = arr2[index];
+            if (!BoolHelper.deepEqual(arr1Value, arr2Value, keys, recurse, processedKeys))
+                return false;
+        }
+        return true;
+    },
+    objectDeepEquals(obj1, obj2, keys = undefined, recurse = true, processedKeys = []) {
+        if (!(obj1 && obj2 && TypeChecker.isObject(obj1) && TypeChecker.isObject(obj2)))
+            return false;
+        const obj1Keys = Object.keys(obj1);
+        const obj2Keys = Object.keys(obj2);
+        const iterKeys = obj1Keys.length > obj2Keys.length ? obj1Keys : obj2Keys;
+        for (const key of iterKeys) {
+            if (key in processedKeys)
+                continue;
+            if (keys && !keys.includes(key))
+                continue;
+            if (!((obj1Keys.includes(key)) && (obj2Keys.includes(key))))
+                return false;
+            const obj1KeyValue = obj1[key];
+            const obj2KeyValue = obj2[key];
+            processedKeys.push(key);
+            if (!BoolHelper.deepEqual(obj1KeyValue, obj2KeyValue, keys, recurse, processedKeys))
+                return false;
+        }
+        return true;
+    },
+    compare(a, b) {
+        if (a < b)
+            return -1;
+        if (a > b)
+            return 1;
+        return 0;
+    }
+};

package/dist/esm/utils/Classname.d.ts

@@ -0,0 +1,9 @@
+type Mapping = {
+    [key: string]: any;
+};
+type Value = string | undefined | null;
+type Argument = Value | Mapping | Argument[];
+export declare const Classname: {
+    build(...args: Argument[]): string;
+};
+export {};

package/dist/esm/utils/Classname.js

@@ -0,0 +1,20 @@
+import { TypeChecker } from "./TypeChecker";
+export const Classname = {
+    build(...args) {
+        const classNames = args.reduce((acc, arg) => {
+            if (!arg)
+                return acc;
+            if (TypeChecker.isString(arg) && arg != "undefined") {
+                acc.add(arg.trim());
+                return acc;
+            }
+            const argObject = arg;
+            for (const key of Object.keys(arg)) {
+                if (argObject[key])
+                    acc.add(key);
+            }
+            return acc;
+        }, new Set());
+        return Array.from(classNames.values()).join(" ");
+    }
+};

package/dist/esm/utils/ColorHelper.d.ts

@@ -0,0 +1,127 @@
+export declare const ColorHelper: {
+    alpha(a: number | string): number;
+    hexToRgb(hex: string): {
+        r: number;
+        g: number;
+        b: number;
+        a: number;
+    };
+    hexToRgba(hex: string): {
+        r: number;
+        g: number;
+        b: number;
+        a: number;
+    };
+    rgbToCmyk(rgb: {
+        r: number;
+        g: number;
+        b: number;
+    }): {
+        c: number;
+        m: number;
+        y: number;
+        k: number;
+    };
+    hexToColor(hex?: string): {
+        hex: string;
+        rgb: {
+            r: number;
+            g: number;
+            b: number;
+        };
+        alpha: number;
+        hsb: {
+            h: number;
+            s: number;
+            b: number;
+        };
+        cmyk: {
+            c: number;
+            m: number;
+            y: number;
+            k: number;
+        };
+    } | undefined;
+    hsbToColor(hsb?: {
+        h: number;
+        s: number;
+        b: number;
+    }, alpha?: number): {
+        hsb: {
+            h: number;
+            s: number;
+            b: number;
+        };
+        rgb: {
+            r: number;
+            g: number;
+            b: number;
+        };
+        alpha: number;
+        hex: string;
+        cmyk: {
+            c: number;
+            m: number;
+            y: number;
+            k: number;
+        };
+    } | undefined;
+    hexToHsb(hex: string): {
+        h: number;
+        s: number;
+        b: number;
+    };
+    rgbToHex(rgba: {
+        r: number;
+        g: number;
+        b: number;
+        a?: number;
+    }): string;
+    hsbToHex(hsb: {
+        h: number;
+        s: number;
+        b: number;
+    }): string;
+    rgbToHsb(rgba: {
+        r: number;
+        g: number;
+        b: number;
+        a?: number;
+    }): {
+        h: number;
+        s: number;
+        b: number;
+    };
+    hsbToRgb(hsb: {
+        h: number;
+        s: number;
+        b: number;
+    }): {
+        r: number;
+        g: number;
+        b: number;
+    };
+    normalizeHsB(hsb: {
+        h: number;
+        s: number;
+        b: number;
+    }): {
+        h: number;
+        s: number;
+        b: number;
+    };
+    /**
+     * Generates a color similar to the input rgb.
+     * @param {string} rgb - The target color (e.g., { r: 121, g: 3, b: 20})
+     * @param {number} deviationAmount - Deviation amount (0 to 1, default 0.1)
+     */
+    similarColor(rgb: {
+        r: number;
+        g: number;
+        b: number;
+    }, deviationAmount?: number): {
+        r: number;
+        g: number;
+        b: number;
+    };
+};

package/dist/esm/utils/ColorHelper.js

@@ -0,0 +1,198 @@
+export const ColorHelper = {
+    alpha(a) {
+        let na;
+        console.log("EEE", a, typeof a);
+        if (typeof a === "string") {
+            na = parseInt(a, 16);
+        }
+        else {
+            na = a;
+        }
+        if (na > 1)
+            na = na / 255;
+        return na;
+    },
+    hexToRgb(hex) {
+        const reg = hex.length < 6 ? "\\w" : "\\w\\w";
+        const parts = hex.match(new RegExp(reg, "g"))?.map((x) => parseInt(x.repeat(2 / x.length), 16));
+        const rgb = { r: parts[0], g: parts[1], b: parts[2] };
+        return rgb;
+    },
+    hexToRgba(hex) {
+        const reg = hex.length < 6 ? "\\w" : "\\w\\w";
+        const parts = hex.match(new RegExp(reg, "g"))?.map((x) => parseInt(x.repeat(2 / x.length), 16));
+        const rgba = { r: parts[0], g: parts[1], b: parts[2] };
+        rgba["a"] = (parts.length > 3 ? ColorHelper.alpha(parts[3]) : 1);
+        return rgba;
+    },
+    rgbToCmyk(rgb) {
+        const r = rgb.r / 255;
+        const g = rgb.g / 255;
+        const b = rgb.b / 255;
+        const k = +(1 - Math.max(r, g, b));
+        const c = +((1 - r - k) / (1 - k) || 0);
+        const m = +((1 - g - k) / (1 - k) || 0);
+        const y = +((1 - b - k) / (1 - k) || 0);
+        return { c: (c * 1000), m: (m * 1000), y: (y * 1000), k: (k * 1000) };
+    },
+    hexToColor(hex) {
+        if (!hex)
+            return undefined;
+        const { r, g, b, a } = ColorHelper.hexToRgba(hex);
+        const alpha = a;
+        const rgb = { r, g, b };
+        return {
+            hex,
+            rgb,
+            alpha,
+            hsb: ColorHelper.rgbToHsb(rgb),
+            cmyk: ColorHelper.rgbToCmyk(rgb),
+        };
+    },
+    hsbToColor(hsb, alpha = 1) {
+        if (!hsb)
+            return undefined;
+        const { r, g, b } = ColorHelper.hsbToRgb(hsb);
+        const rgb = { r, g, b };
+        return {
+            hsb,
+            rgb,
+            alpha,
+            hex: ColorHelper.hsbToHex(hsb),
+            cmyk: ColorHelper.rgbToCmyk(rgb),
+        };
+    },
+    hexToHsb(hex) {
+        return ColorHelper.rgbToHsb(ColorHelper.hexToRgba(hex));
+    },
+    rgbToHex(rgba) {
+        let hex = [rgba.r.toString(16), rgba.g.toString(16), rgba.b.toString(16)];
+        for (let key in hex) {
+            if (hex[key].length === 1) {
+                hex[key] = '0' + hex[key];
+            }
+        }
+        return "#" + hex.join('');
+    },
+    hsbToHex(hsb) {
+        return ColorHelper.rgbToHex(ColorHelper.hsbToRgb(hsb));
+    },
+    rgbToHsb(rgba) {
+        let hsb = {
+            h: 0,
+            s: 0,
+            b: 0
+        };
+        let min = Math.min(rgba.r, rgba.g, rgba.b);
+        let max = Math.max(rgba.r, rgba.g, rgba.b);
+        let delta = max - min;
+        hsb.b = max;
+        hsb.s = max !== 0 ? (255 * delta) / max : 0;
+        if (hsb.s !== 0) {
+            if (rgba.r === max) {
+                hsb.h = (rgba.g - rgba.b) / delta;
+            }
+            else if (rgba.g === max) {
+                hsb.h = 2 + (rgba.b - rgba.r) / delta;
+            }
+            else {
+                hsb.h = 4 + (rgba.r - rgba.g) / delta;
+            }
+        }
+        else {
+            hsb.h = -1;
+        }
+        hsb.h = hsb.h * 60;
+        if (hsb.h < 0) {
+            hsb.h = hsb.h + 360;
+        }
+        hsb.s = hsb.s * (100 / 255);
+        hsb.b = hsb.b * (100 / 255);
+        return hsb;
+    },
+    hsbToRgb(hsb) {
+        let rgb = {
+            r: null,
+            g: null,
+            b: null
+        };
+        let h = Math.round(hsb.h);
+        let s = Math.round((hsb.s * 255) / 100);
+        let v = Math.round((hsb.b * 255) / 100);
+        if (s === 0) {
+            rgb = {
+                r: v,
+                g: v,
+                b: v
+            };
+        }
+        else {
+            let t1 = v;
+            let t2 = ((255 - s) * v) / 255;
+            let t3 = ((t1 - t2) * (h % 60)) / 60;
+            if (h === 360) {
+                h = 0;
+            }
+            if (h < 60) {
+                rgb.r = t1;
+                rgb.b = t2;
+                rgb.g = t2 + t3;
+            }
+            else if (h < 120) {
+                rgb.g = t1;
+                rgb.b = t2;
+                rgb.r = t1 - t3;
+            }
+            else if (h < 180) {
+                rgb.g = t1;
+                rgb.r = t2;
+                rgb.b = t2 + t3;
+            }
+            else if (h < 240) {
+                rgb.b = t1;
+                rgb.r = t2;
+                rgb.g = t1 - t3;
+            }
+            else if (h < 300) {
+                rgb.b = t1;
+                rgb.g = t2;
+                rgb.r = t2 + t3;
+            }
+            else if (h < 360) {
+                rgb.r = t1;
+                rgb.g = t2;
+                rgb.b = t1 - t3;
+            }
+            else {
+                rgb.r = 0;
+                rgb.g = 0;
+                rgb.b = 0;
+            }
+        }
+        return { r: Math.round(rgb.r), g: Math.round(rgb.g), b: Math.round(rgb.b) };
+    },
+    normalizeHsB(hsb) {
+        return {
+            h: Math.min(360, Math.max(0, hsb.h)),
+            s: Math.min(100, Math.max(0, hsb.s)),
+            b: Math.min(100, Math.max(0, hsb.b))
+        };
+    },
+    /**
+     * Generates a color similar to the input rgb.
+     * @param {string} rgb - The target color (e.g., { r: 121, g: 3, b: 20})
+     * @param {number} deviationAmount - Deviation amount (0 to 1, default 0.1)
+     */
+    similarColor(rgb, deviationAmount = 0.1) {
+        let { r, g, b } = rgb;
+        const jitter = (val) => {
+            const range = 255 * deviationAmount;
+            const noise = (Math.random() * range * 2) - range;
+            return Math.min(255, Math.max(0, Math.round(val + noise)));
+        };
+        const newR = jitter(r);
+        const newG = jitter(g);
+        const newB = jitter(b);
+        return { r: newR, g: newG, b: newB };
+    }
+};

package/dist/esm/utils/DOMUtils.d.ts

@@ -0,0 +1,142 @@
+import { NoseurObject } from "../constants/Types";
+import { Alignment } from "../constants/Alignment";
+import { SetURLSearchParams } from "react-router-dom";
+import { Orientation } from "../constants/Orientation";
+import { Bound, Ceiling, Direction } from "../constants/Direction";
+export type URLSearchParamsValue = string | string[] | number | number[] | undefined | null;
+export declare const DOMHelper: {
+    uniqueElementId(prefix?: string): string;
+    isElement(element: any): element is Element | HTMLDocument;
+    getBrowser(): NoseurObject<any>;
+    resolveUserAgent(): {
+        browser: string;
+        version: string;
+    };
+    hasClass(element: Element, className: string): boolean;
+    addClass(element: Element, className: string): void;
+    removeClass(element: Element, className: string): void;
+    addClassToElementById(id: string, className: string): void;
+    removeClassFromElementById(id: string, className: string): void;
+    removeClassFromElementsByClassname(clazzName: string, className: string): void;
+    getTarget: (event: any) => any;
+    getElementOffset(element: Element, defaultValue?: NoseurObject<any>): NoseurObject<any>;
+    getElementRectWithOffset(element: Element): {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+        top: number;
+        left: number;
+    };
+    getDocumentScrollTop(): number;
+    getDocumentScrollLeft(): number;
+    getViewport(): {
+        width: number;
+        height: number;
+    };
+    getHiddenElementDimensions(_: any): {
+        width: number;
+        height: number;
+    };
+    sanitizeStyleValue(dirtyValue: string): number;
+    getElementStyle(element: any): CSSStyleDeclaration;
+    getElementWidth(element: any, excludeMargin?: boolean): any;
+    getElementHeight(element: any, excludeMargin?: boolean): any;
+    getElementSuperfluousWidth(element: any, withPadding?: boolean): number;
+    getElementSuperfluousHeight(element: any, withPadding?: boolean): number;
+    absolutePositionRelatively(element: any, target: any, horizontal?: "left" | "right"): void;
+    appendChild(element: any, target: any): void;
+    convertToCamelCase(styleKey: any): any;
+    matchStyles(sourceElement: any, targetElements: any, styleKeys: any, cb?: (styleKey: string, styleValue: string, sourceComputedStyle: CSSStyleDeclaration, targetComputedStyle: CSSStyleDeclaration) => string): void;
+    remToPx: (value: number) => number;
+    pxToRem: (value: number) => number;
+    calculateContentHeight(el: any, scanAmount: any): any;
+    calculateLines(el: any): number;
+    calculateHeight(el: any): number;
+    inViewport(el: HTMLElement, con?: any, orientation?: Orientation): boolean;
+    getElementParents(element: Node, parents?: any[]): Node[];
+    findParentElement(child: any, cond: (node: any) => boolean): Node;
+    alignChildToParent(parent: any, child: any, alignment: Alignment): void;
+    elementParent(el: HTMLElement): ParentNode | null;
+    elementRelativeAndAbsolutePositions(el: HTMLElement, evt: {
+        clientX: number;
+        clientY: number;
+    }, boundToParent?: boolean | Bound, allowedOverflow?: number, direction?: Direction, ceiling?: Ceiling): {
+        x: number;
+        y: number;
+        top: number;
+        left: number;
+        scrollY: number;
+        scrollX: number;
+        parentRect: {
+            x: number;
+            y: number;
+            width: number;
+            height: number;
+            top: number;
+            left: number;
+        };
+        clientTop: number;
+        clientLeft: number;
+        clientX: number;
+        clientY: number;
+    };
+    positionElement(el: HTMLElement, position: {
+        x: number;
+        y: number;
+    }): void;
+    copyToClipboard(text: string, cb?: (err?: any) => void): any;
+    getImageAspectRatio(image: HTMLImageElement): number;
+    getSizeRelativeToImageAspectRatio(image: HTMLImageElement, size: {
+        width?: number;
+        height?: number;
+    }, mutate?: "WIDTH" | "HEIGHT" | "WIDTH_HEIGHT"): {
+        width: number;
+        height: number;
+    };
+    getCanvasFont(el: HTMLElement): string;
+    getTextWidth(text: string, el: HTMLElement): number;
+    imageDataFromFileBlock(fileBlob: any): Promise<{
+        width: number;
+        height: number;
+        imageData: any;
+    }>;
+    removeAllChildren(el: HTMLElement): void;
+    openInNewTab(url?: string | URL, target?: string, features?: string): void;
+    updateSearchParam(setSearchParams: SetURLSearchParams | URLSearchParams, key: string, value: URLSearchParamsValue, cb?: Function): void;
+    updateSearchParams(setSearchParams: SetURLSearchParams | URLSearchParams, values: NoseurObject<URLSearchParamsValue>, cb?: Function): void;
+};
+export declare const ScrollHandler: {
+    querySelector(element: Element, selector: any): any;
+    getScrollableParents(element: Node, nuclearParentOnly?: boolean): Node[];
+    attachScrollListener(scrollableParents: Node[], listener: any): void;
+    detachScrollListener(scrollableParents: Node[], listener: any): void;
+    handle(element: Node | Node[], listener: any, nuclearParentOnly?: boolean): {
+        attach: () => void;
+        detach: () => void;
+    };
+};
+export declare enum BaseZIndex {
+    MENU = 1000,
+    MODAL = 1001,
+    TOAST = 1002,
+    OVERLAY = 1003,
+    TOOLTIP = 1004
+}
+export declare const ZIndexHandler: {
+    ZINDEXES: number[];
+    generateZIndex(zindex: number): number;
+    getCurrentZIndex(): number;
+    setElementZIndex(element: any, zIndex: number): void;
+    getElementZIndex(element: any): number;
+    removeElementZIndex(element: any): void;
+};
+export type NoseurObservationType = "resize";
+export type NoseurObservationEventHandler = (...args: any) => any;
+export declare class ObserverHandler {
+    private static __OBSERVERS;
+    private static __OBSERVERS_EVENT_HANDLERS;
+    static observe(type: NoseurObservationType, eventHandler: NoseurObservationEventHandler, target?: any, options?: any): void;
+    static unobserve(type: NoseurObservationType, eventHandler: NoseurObservationEventHandler, target?: any): void;
+    private static registerObserver;
+}