@sohanemon/utils 6.2.8 → 6.3.0

package/dist/functions/utils.js

@@ -1,439 +0,0 @@
-import { clsx } from 'clsx';
-import { twMerge } from 'tailwind-merge';
-/**
- * Utility to merge class names with Tailwind CSS and additional custom merging logic.
- *
- * @param {...ClassValue[]} inputs - Class names to merge.
- * @returns {string} - A string of merged class names.
- */
-export function cn(...inputs) {
-    return twMerge(clsx(inputs));
-}
-/**
- * @deprecated Use isLinkActive instead.
- *
- * Determines if a navigation link is active based on the current path.
- *
- * @param  href - The target URL.
- * @param  path - The current browser path.
- * @returns - True if the navigation is active, false otherwise.
- */
-export function isNavActive(href, path) {
-    console.warn('isNavActive is deprecated. Use isLinkActive instead.');
-    const regex = new RegExp(`^/?${href}(/|$)`);
-    return regex.test(path);
-}
-/**
- * Checks if a link is active, considering optional localization prefixes.
- *
- * @param {Object} params - Parameters object.
- * @param {string} params.path - The target path of the link.
- * @param {string} params.currentPath - The current browser path.
- * @param {string[]} [params.locales=['en', 'es', 'de', 'zh', 'bn', 'fr', 'it', 'nl']] - Supported locale prefixes.
- * @returns {boolean} - True if the link is active, false otherwise.
- */
-export function isLinkActive({ path, currentPath, locales = ['en', 'es', 'de', 'zh', 'bn', 'fr', 'it', 'nl'], exact = true, }) {
-    const localeRegex = new RegExp(`^/?(${locales.join('|')})/`);
-    const normalizePath = (p) => {
-        return p
-            .replace(localeRegex, '') // Remove localization prefix (e.g., en/, fr/, etc.)
-            .replace(/^\/+|\/+$/g, ''); // Trim leading and trailing slashes
-    };
-    const normalizedPath = normalizePath(path);
-    const normalizedCurrentPath = normalizePath(currentPath);
-    return exact
-        ? normalizedPath === normalizedCurrentPath
-        : normalizedCurrentPath.startsWith(normalizedPath);
-}
-/**
- * Cleans a file path by removing the `/public/` prefix if present.
- *
- * @param  src - The source path to clean.
- * @returns - The cleaned path.
- */
-export function cleanSrc(src) {
-    let cleanedSrc = src;
-    if (src.includes('/public/')) {
-        cleanedSrc = src.replace('/public/', '/');
-    }
-    return cleanedSrc.trim();
-}
-/**
- * Smoothly scrolls to the top or bottom of a specified container.
- *
- * @param  containerSelector - The CSS selector or React ref for the container.
- * @param  to - Specifies whether to scroll to the top or bottom.
- */
-export const scrollTo = (containerSelector, to) => {
-    let container;
-    if (typeof containerSelector === 'string') {
-        container = document.querySelector(containerSelector);
-    }
-    else if (containerSelector.current) {
-        container = containerSelector.current;
-    }
-    else {
-        return;
-    }
-    if (container) {
-        container.scrollTo({
-            top: to === 'top' ? 0 : container.scrollHeight - container.clientHeight,
-            behavior: 'smooth',
-        });
-    }
-};
-/**
- * Copies a given string to the clipboard.
- *
- * @param  value - The value to copy to the clipboard.
- * @param  [onSuccess=() => {}] - Optional callback executed after successful copy.
- */
-export const copyToClipboard = (value, onSuccess = () => { }) => {
-    if (typeof window === 'undefined' || !navigator.clipboard?.writeText) {
-        return;
-    }
-    if (!value) {
-        return;
-    }
-    navigator.clipboard.writeText(value).then(onSuccess);
-};
-/**
- * Converts camelCase, PascalCase, kebab-case, snake_case into normal case.
- *
- * @param  inputString - The string need to be converted into normal case
- * @returns - Normal Case
- */
-export function convertToNormalCase(inputString) {
-    const splittedString = inputString.split('.').pop();
-    const string = splittedString || inputString;
-    const words = string.replace(/([a-z])([A-Z])/g, '$1 $2').split(/[-_|�\s]+/);
-    const capitalizedWords = words.map((word) => word.charAt(0).toUpperCase() + word.slice(1));
-    return capitalizedWords.join(' ');
-}
-const from = 'àáãäâèéëêìíïîòóöôùúüûñç·/_,:;';
-const to = 'aaaaaeeeeiiiioooouuuunc------';
-/**
- * Converts a string to a URL-friendly slug by trimming, converting to lowercase,
- * replacing diacritics, removing invalid characters, and replacing spaces with hyphens.
- * @param {string} [str] - The input string to convert.
- * @returns {string} The generated slug.
- * @example
- * convertToSlug("Hello World!"); // "hello-world"
- * convertToSlug("Déjà Vu"); // "deja-vu"
- */
-export const convertToSlug = (str) => {
-    if (typeof str !== 'string') {
-        throw new TypeError('Input must be a string');
-    }
-    // Trim the string and convert it to lowercase.
-    let slug = str.trim().toLowerCase();
-    // Build a mapping of accented characters to their non-accented equivalents.
-    const charMap = {};
-    for (let i = 0; i < from.length; i++) {
-        charMap[from.charAt(i)] = to.charAt(i);
-    }
-    // Replace all accented characters using the mapping.
-    slug = slug.replace(new RegExp(`[${from}]`, 'g'), (match) => charMap[match] || match);
-    return (slug
-        .replace(/[^a-z0-9 -]/g, '') // Remove invalid characters
-        .replace(/\s+/g, '-') // Replace spaces with hyphens
-        .replace(/-+/g, '-') // Collapse consecutive hyphens
-        .replace(/^-+/, '') // Remove leading hyphens
-        .replace(/-+$/, '') || // Remove trailing hyphens
-        '');
-};
-/**
- * Checks if the code is running in a server-side environment.
- *
- * @returns - True if the code is executed in SSR (Server-Side Rendering) context, false otherwise
- */
-export const isSSR = typeof window === 'undefined';
-/**
- * Converts an SVG string to a Base64-encoded string.
- *
- * @param str - The SVG string to encode
- * @returns - Base64-encoded string representation of the SVG
- */
-export const svgToBase64 = (str) => isSSR ? Buffer.from(str).toString('base64') : window.btoa(str);
-/**
- * Pauses execution for the specified time.
- *
- * `signal` allows cancelling the sleep via AbortSignal.
- *
- * @param time - Time in milliseconds to sleep (default is 1000ms)
- * @param signal - Optional AbortSignal to cancel the sleep early
- * @returns - A Promise that resolves after the specified time or when aborted
- */
-export const sleep = (time = 1000, signal) => new Promise((resolve) => {
-    if (signal?.aborted)
-        return resolve();
-    const id = setTimeout(() => {
-        cleanup();
-        resolve();
-    }, time);
-    function onAbort() {
-        clearTimeout(id);
-        cleanup();
-        resolve();
-    }
-    function cleanup() {
-        signal?.removeEventListener('abort', onAbort);
-    }
-    // only add listener if a signal was supplied
-    if (signal) {
-        signal.addEventListener('abort', onAbort, { once: true });
-    }
-});
-/**
- * Creates a debounced function that delays invoking the provided function until
- * after the specified `wait` time has elapsed since the last invocation.
- *
- * If the `immediate` option is set to `true`, the function will be invoked immediately
- * on the leading edge of the wait interval. Subsequent calls during the wait interval
- * will reset the timer but not invoke the function until the interval elapses again.
- *
- * The returned function includes the `isPending` property to check if the debounce
- * timer is currently active.
- *
- * @typeParam F - The type of the function to debounce.
- *
- * @param function_ - The function to debounce.
- * @param wait - The number of milliseconds to delay (default is 100ms).
- * @param options - An optional object with the following properties:
- *   - `immediate` (boolean): If `true`, invokes the function on the leading edge
- *     of the wait interval instead of the trailing edge.
- *
- * @returns A debounced version of the provided function, enhanced with the `isPending` property.
- *
- * @throws {TypeError} If the first parameter is not a function.
- * @throws {RangeError} If the `wait` parameter is negative.
- *
- * @example
- * const log = debounce((message: string) => console.log(message), 200);
- * log('Hello'); // Logs "Hello" after 200ms if no other call is made.
- * console.log(log.isPending); // true if the timer is active.
- */
-export function debounce(function_, wait = 100, options) {
-    if (typeof function_ !== 'function') {
-        throw new TypeError(`Expected the first parameter to be a function, got \`${typeof function_}\`.`);
-    }
-    if (wait < 0) {
-        throw new RangeError('`wait` must not be negative.');
-    }
-    const immediate = options?.immediate ?? false;
-    let timeoutId;
-    let lastArgs;
-    let lastContext;
-    let result;
-    function run() {
-        result = function_.apply(lastContext, lastArgs);
-        lastArgs = undefined;
-        lastContext = undefined;
-        return result;
-    }
-    const debounced = function (...args) {
-        lastArgs = args;
-        lastContext = this;
-        if (timeoutId === undefined && immediate) {
-            result = run.call(this);
-        }
-        if (timeoutId !== undefined) {
-            clearTimeout(timeoutId);
-        }
-        timeoutId = setTimeout(run.bind(this), wait);
-        return result;
-    };
-    Object.defineProperty(debounced, 'isPending', {
-        get() {
-            return timeoutId !== undefined;
-        },
-    });
-    return debounced;
-}
-/**
- * Creates a throttled function that invokes the provided function at most once
- * every `wait` milliseconds.
- *
- * If the `leading` option is set to `true`, the function will be invoked immediately
- * on the leading edge of the throttle interval. If the `trailing` option is set to `true`,
- * the function will also be invoked at the end of the throttle interval if additional
- * calls were made during the interval.
- *
- * The returned function includes the `isPending` property to check if the throttle
- * timer is currently active.
- *
- * @typeParam F - The type of the function to throttle.
- *
- * @param function_ - The function to throttle.
- * @param wait - The number of milliseconds to wait between invocations (default is 100ms).
- * @param options - An optional object with the following properties:
- *   - `leading` (boolean): If `true`, invokes the function on the leading edge of the interval.
- *   - `trailing` (boolean): If `true`, invokes the function on the trailing edge of the interval.
- *
- * @returns A throttled version of the provided function, enhanced with the `isPending` property.
- *
- * @throws {TypeError} If the first parameter is not a function.
- * @throws {RangeError} If the `wait` parameter is negative.
- *
- * @example
- * const log = throttle((message: string) => console.log(message), 200);
- * log('Hello'); // Logs "Hello" immediately if leading is true.
- * console.log(log.isPending); // true if the timer is active.
- */
-export function throttle(function_, wait = 100, options) {
-    if (typeof function_ !== 'function') {
-        throw new TypeError(`Expected the first parameter to be a function, got \`${typeof function_}\`.`);
-    }
-    if (wait < 0) {
-        throw new RangeError('`wait` must not be negative.');
-    }
-    const leading = options?.leading ?? true;
-    const trailing = options?.trailing ?? true;
-    let timeoutId;
-    let lastArgs;
-    let lastContext;
-    let lastCallTime;
-    let result;
-    function invoke() {
-        lastCallTime = Date.now();
-        result = function_.apply(lastContext, lastArgs);
-        lastArgs = undefined;
-        lastContext = undefined;
-    }
-    function later() {
-        timeoutId = undefined;
-        if (trailing && lastArgs) {
-            invoke();
-        }
-    }
-    const throttled = function (...args) {
-        const now = Date.now();
-        const timeSinceLastCall = lastCallTime
-            ? now - lastCallTime
-            : Number.POSITIVE_INFINITY;
-        lastArgs = args;
-        lastContext = this;
-        if (timeSinceLastCall >= wait) {
-            if (leading) {
-                invoke();
-            }
-            else {
-                timeoutId = setTimeout(later, wait);
-            }
-        }
-        else if (!timeoutId && trailing) {
-            timeoutId = setTimeout(later, wait - timeSinceLastCall);
-        }
-        return result;
-    };
-    Object.defineProperty(throttled, 'isPending', {
-        get() {
-            return timeoutId !== undefined;
-        },
-    });
-    return throttled;
-}
-/**
- * Formats a string by replacing each '%s' placeholder with the corresponding argument.
- * This function mimics the basic behavior of C's printf for %s substitution.
- *
- * It supports both calls like `printf(format, ...args)` and `printf(format, argsArray)`.
- *
- * @param format - The format string containing '%s' placeholders.
- * @param args - The values to substitute into the placeholders, either as separate arguments or as a single array.
- * @returns The formatted string with all '%s' replaced by the provided arguments.
- *
- * @example
- * ```ts
- * const message = printf("%s love %s", "I", "Bangladesh");
- * // message === "I love Bangladesh"
- *
- * const arr = ["I", "Bangladesh"];
- * const message2 = printf("%s love %s", arr);
- * // message2 === "I love Bangladesh"
- *
- * // If there are too few arguments:
- * const incomplete = printf("Bangladesh is %s %s", "beautiful");
- * // incomplete === "Bangladesh is beautiful"
- * ```
- */
-export function printf(format, ...args) {
-    const replacements = args.length === 1 && Array.isArray(args[0]) ? args[0] : args;
-    let idx = 0;
-    return format.replace(/%s/g, () => {
-        const arg = replacements[idx++];
-        return arg === undefined ? '' : String(arg);
-    });
-}
-export const mergeRefs = (...refs) => {
-    return (value) => {
-        for (const ref of refs) {
-            if (!ref)
-                continue;
-            if (typeof ref === 'function') {
-                ref(value);
-            }
-            else {
-                ref.current = value;
-            }
-        }
-    };
-};
-/**
- * Navigates to the specified client-side hash without ssr.
- * use `scroll-margin-top` with css to add margins
- *
- * @param id - The ID of the element without # to navigate to.
- *
- * @example goToClientSideHash('my-element');
- */
-export function goToClientSideHash(id, opts) {
-    const el = document.getElementById(id);
-    if (!el)
-        return;
-    el.scrollIntoView({ behavior: 'smooth', block: 'start', ...opts });
-    window.history.pushState(null, '', `#${id}`);
-}
-/**
- * Escapes a string for use in a regular expression.
- *
- * @param str - The string to escape
- * @returns - The escaped string
- *
- * @example
- * const escapedString = escapeRegExp('Hello, world!');
- * // escapedString === 'Hello\\, world!'
- */
-export function escapeRegExp(str) {
-    return str.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-}
-/**
- * Normalizes a string by:
- * - Applying Unicode normalization (NFC)
- * - Optionally removing diacritic marks (accents)
- * - Optionally trimming leading/trailing non-alphanumeric characters
- * - Optionally converting to lowercase
- *
- * @param str - The string to normalize
- * @param options - Normalization options
- * @param options.lowercase - Whether to convert the result to lowercase (default: true)
- * @param options.removeAccents - Whether to remove diacritic marks like accents (default: true)
- * @param options.removeNonAlphanumeric - Whether to trim non-alphanumeric characters from the edges (default: true)
- * @returns The normalized string
- */
-export function normalizeText(str, options = {}) {
-    if (!str)
-        return '';
-    const { lowercase = true, removeAccents = true, removeNonAlphanumeric = true, } = options;
-    let result = str.normalize('NFC');
-    if (removeAccents) {
-        result = result.normalize('NFD').replace(/\p{M}/gu, ''); // decompose and remove accents
-    }
-    if (removeNonAlphanumeric) {
-        result = result.replace(/^[^\p{L}\p{N}]*|[^\p{L}\p{N}]*$/gu, ''); // trim edges
-    }
-    if (lowercase) {
-        result = result.toLocaleLowerCase();
-    }
-    return result;
-}

package/dist/hooks/action.d.ts

@@ -1,20 +0,0 @@
-type ActionType<Input, Result> = (input: Input) => Promise<Result>;
-interface UseActionOptions<_Input, Result> {
-    onSuccess?: (data: Result) => void;
-    onError?: (error: Error) => void;
-    onSettled?: () => void;
-}
-export declare const useAction: <Input, Result>(action: ActionType<Input, Result>, options?: UseActionOptions<Input, Result>) => {
-    execute: (input: Input) => void;
-    executeAsync: (input: Input) => Promise<Result>;
-    reset: () => void;
-    useExecute: (input: Input) => void;
-    data: Result;
-    error: Error;
-    input: Input;
-    isIdle: boolean;
-    isLoading: boolean;
-    isSuccess: boolean;
-    isError: boolean;
-};
-export {};

package/dist/hooks/action.js

@@ -1,84 +0,0 @@
-import * as React from 'react';
-import { useIsomorphicEffect } from '.';
-export const useAction = (action, options) => {
-    const [status, setStatus] = React.useState('idle');
-    const [data, setData] = React.useState(null);
-    const [error, setError] = React.useState(null);
-    const [clientInput, setClientInput] = React.useState(undefined);
-    const [isTransitioning, startTransition] = React.useTransition();
-    // Derived state booleans
-    const isIdle = status === 'idle';
-    const isLoading = status === 'loading' || isTransitioning;
-    const isSuccess = status === 'success';
-    const isError = status === 'error';
-    const handleSuccess = React.useCallback((result) => {
-        setData(result);
-        setStatus('success');
-        options?.onSuccess?.(result); // Call onSuccess if provided
-        options?.onSettled?.(); // Call onSettled if provided
-    }, [options]);
-    const handleError = React.useCallback((err) => {
-        setError(err);
-        setStatus('error');
-        options?.onError?.(err); // Call onError if provided
-        options?.onSettled?.(); // Call onSettled if provided
-    }, [options]);
-    // Executes the action with the provided input, updating state accordingly
-    const execute = React.useCallback((input) => {
-        setClientInput(input);
-        setStatus('loading');
-        setError(null);
-        startTransition(() => {
-            action(input).then(handleSuccess).catch(handleError);
-        });
-    }, [action, handleSuccess, handleError]);
-    // Asynchronous version of execute for promise-based consumption
-    const executeAsync = React.useCallback((input) => {
-        return new Promise((resolve, reject) => {
-            setClientInput(input);
-            setStatus('loading');
-            setError(null);
-            startTransition(() => {
-                action(input)
-                    .then((res) => {
-                    handleSuccess(res);
-                    resolve(res);
-                })
-                    .catch((err) => {
-                    handleError(err);
-                    reject(err);
-                });
-            });
-        });
-    }, [action, handleSuccess, handleError]);
-    // Resets the hook's state to its initial "idle" status
-    const reset = React.useCallback(() => {
-        setStatus('idle');
-        setData(null);
-        setError(null);
-        setClientInput(undefined);
-    }, []);
-    // Hook to execute the action automatically on mount
-    const useExecute = (input) => {
-        useIsomorphicEffect(() => {
-            execute(input);
-        }, []);
-    };
-    return {
-        // Methods to trigger action
-        execute,
-        executeAsync,
-        reset,
-        // Hook for auto execution on mount
-        useExecute,
-        // Data and error objects
-        data,
-        error,
-        input: clientInput,
-        // Status booleans
-        isIdle,
-        isLoading,
-        isSuccess,
-        isError,
-    };
-};

package/dist/hooks/async.d.ts

@@ -1,30 +0,0 @@
-import * as React from 'react';
-type AsyncStatus = 'idle' | 'pending' | 'success' | 'error';
-type OnSuccess<TData> = (data: TData) => void | Promise<void>;
-type OnError<TError extends Error = Error> = (error: TError) => void | Promise<void>;
-type OnSettled<TData, TError extends Error = Error> = (data: TData | undefined, error: TError | undefined) => void | Promise<void>;
-interface UseAsyncOptions<TData = unknown, TError extends Error = Error> {
-    mode?: 'auto' | 'manual';
-    deps?: React.DependencyList;
-    onSuccess?: OnSuccess<TData>;
-    onError?: OnError<TError>;
-    onSettled?: OnSettled<TData, TError>;
-}
-interface UseAsyncReturn<TData, TError extends Error = Error> {
-    data: TData | undefined;
-    error: TError | undefined;
-    status: AsyncStatus;
-    isIdle: boolean;
-    isPending: boolean;
-    isSuccess: boolean;
-    isError: boolean;
-    execute: () => Promise<TData>;
-}
-/**
- * A fully typesafe async hook inspired by TanStack Query
- * @param asyncFn - Async function that returns data
- * @param options - Configuration options including callbacks
- * @returns Object with data, error, status and helper methods
- */
-export declare function useAsync<TData, TError extends Error = Error>(asyncFn: (signal: AbortSignal) => Promise<TData>, options?: UseAsyncOptions<TData, TError>): UseAsyncReturn<TData, TError>;
-export {};

package/dist/hooks/async.js

@@ -1,82 +0,0 @@
-'use client';
-import * as React from 'react';
-/**
- * A fully typesafe async hook inspired by TanStack Query
- * @param asyncFn - Async function that returns data
- * @param options - Configuration options including callbacks
- * @returns Object with data, error, status and helper methods
- */
-export function useAsync(asyncFn, options = {}) {
-    const { mode = 'manual', deps, onSuccess, onError, onSettled } = options;
-    const [data, setData] = React.useState(undefined);
-    const [error, setError] = React.useState(undefined);
-    const [status, setStatus] = React.useState('idle');
-    const abortControllerRef = React.useRef(null);
-    const memoizedOnSuccess = React.useCallback(onSuccess || (() => { }), [
-        onSuccess,
-    ]);
-    const memoizedOnError = React.useCallback(onError || (() => { }), [onError]);
-    const memoizedOnSettled = React.useCallback(onSettled || (() => { }), [
-        onSettled,
-    ]);
-    const execute = React.useCallback(async () => {
-        if (abortControllerRef.current) {
-            abortControllerRef.current.abort();
-        }
-        abortControllerRef.current = new AbortController();
-        const signal = abortControllerRef.current.signal;
-        setStatus('pending');
-        setError(undefined);
-        try {
-            const result = await asyncFn(signal);
-            if (!signal.aborted) {
-                setData(result);
-                setStatus('success');
-                await memoizedOnSuccess(result);
-                await memoizedOnSettled(result, undefined);
-            }
-            return result;
-        }
-        catch (err) {
-            if (err instanceof Error && err.name === 'AbortError') {
-                return undefined;
-            }
-            const error = err instanceof Error ? err : new Error(String(err));
-            const typedError = error;
-            if (!signal.aborted) {
-                setError(typedError);
-                setStatus('error');
-                await memoizedOnError(typedError);
-                await memoizedOnSettled(undefined, typedError);
-            }
-            throw error;
-        }
-    }, [asyncFn, memoizedOnSuccess, memoizedOnError, memoizedOnSettled]);
-    React.useEffect(() => {
-        if (mode === 'auto' && !deps) {
-            execute();
-        }
-    }, [asyncFn, mode, execute, deps]);
-    React.useEffect(() => {
-        if (deps && mode === 'auto') {
-            execute();
-        }
-    }, deps ? deps : []);
-    React.useEffect(() => {
-        return () => {
-            if (abortControllerRef.current) {
-                abortControllerRef.current.abort();
-            }
-        };
-    }, []);
-    return {
-        data,
-        error,
-        status,
-        isIdle: status === 'idle',
-        isPending: status === 'pending',
-        isSuccess: status === 'success',
-        isError: status === 'error',
-        execute,
-    };
-}