@cloudparker/moldex.js 4.1.7 → 4.1.8

package/dist/services/utils/image-service.d.ts

@@ -0,0 +1,107 @@
+import { DialogSizeEnum } from "../dialog/dialog-service.js";
+export type ImageCaptures = ImageCaptureEnum.USER | ImageCaptureEnum.ENVIRONMENT;
+export declare enum ImageCaptureEnum {
+    USER = "user",
+    ENVIRONMENT = "environment"
+}
+export type OutputImageFormats = OutputImageFormatEnum.JPG | OutputImageFormatEnum.WEBP | OutputImageFormatEnum.PNG;
+export declare enum OutputImageFormatEnum {
+    WEBP = "image/webp",
+    JPG = "image/jpeg",
+    PNG = "image/png"
+}
+export declare class FilePickerAccepts {
+    static image: string;
+    static document: string;
+    static video: string;
+    static audio: string;
+    static text: string;
+}
+/**
+ * Processes an image file by resizing, reducing file size, and converting it to a specified format based on the provided options.
+ * @param file - The original image file.
+ * @param options - Options for resizing, compressing, and converting the image.
+ * @returns A promise that resolves to a processed File object with the correct filename and extension.
+ */
+export declare function processImageFile(file: File, options?: {
+    maxWidth?: number;
+    maxHeight?: number;
+    maxSizeInBytes?: number;
+    outputFormat?: OutputImageFormats;
+    quality?: number;
+}): Promise<File>;
+/**
+ * Generates a new filename based on the original filename and output format.
+ * @param originalName - The original filename.
+ * @param outputFormat - The desired output format (e.g., 'image/jpeg', 'image/png').
+ * @returns A new filename with the correct extension.
+ */
+export declare function generateNewFileName(originalName: string, outputFormat: string): string;
+/**
+ * Calculates the new dimensions for resizing the image while maintaining aspect ratio.
+ * @param img - The original image.
+ * @param maxWidth - The maximum width for the new image.
+ * @param maxHeight - The maximum height for the new image.
+ * @returns An object with the new width and height.
+ */
+export declare function calculateNewDimensions(img: HTMLImageElement, maxWidth?: number, maxHeight?: number): {
+    width: number;
+    height: number;
+};
+/**
+ * Compresses an image to reduce its file size to be under the specified max size.
+ * @param canvas - The canvas element with the image drawn on it.
+ * @param maxSizeInBytes - The maximum allowed size in bytes.
+ * @param format - The output format of the image (e.g., 'image/webp', 'image/jpeg').
+ * @param initialQuality - The initial image quality (0 to 1).
+ * @returns A promise that resolves to a compressed Blob object.
+ */
+export declare function compressImage(canvas: HTMLCanvasElement, maxSizeInBytes: number, format: string, initialQuality: number): Promise<Blob>;
+/**
+ * Reads the contents of a given File object as an HTMLImageElement.
+ *
+ * This function uses the FileReader API to read the file content and returns it as an HTMLImageElement.
+ * It is useful for loading images for display or further processing.
+ *
+ * @param file - The File object to be read and converted into an HTMLImageElement.
+ * @returns A promise that resolves to an HTMLImageElement representing the image content of the file.
+ *
+ * @throws An error if the file could not be read or if the image could not be loaded.
+ *
+ * @example
+ * // Create an image file and read it as an HTMLImageElement
+ * const imageFile = new File([ binary data here , 'example.png', { type: 'image/png' });
+ * readFileAsImage(imageFile).then((img) => {
+ *     document.body.appendChild(img); // Display the image on the page
+ * });
+ */
+export declare function readFileAsImage(file: File): Promise<HTMLImageElement>;
+/**
+ * Converts a Base64 or Data URL string into an HTMLImageElement.
+ *
+ * This function creates an HTMLImageElement from a given Base64 or Data URL string.
+ * It is useful for displaying images on the page or performing further image processing.
+ *
+ * @param dataUrl - The Base64 or Data URL string representing the image.
+ * @returns A promise that resolves to an HTMLImageElement when the image is successfully loaded.
+ *
+ * @throws An error if the image cannot be loaded.
+ *
+ * @example
+ * // Convert a Base64 string to an image element and append it to the document
+ * const base64String = 'data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAA...';
+ * dataUrlToImage(base64String).then((img) => {
+ *     document.body.appendChild(img); // Display the image on the page
+ * }).catch((error) => {
+ *     console.error('Failed to load image:', error.message);
+ * });
+ */
+export declare function dataUrlToImage(dataUrl: string): Promise<HTMLImageElement>;
+export declare function cropImageFile({ inputImageFile, outputFormat, outputWidth, outputQuality, outputAspectRatio, dialogSize, }: {
+    inputImageFile: File;
+    outputFormat?: OutputImageFormats;
+    outputWidth?: number;
+    outputQuality?: number;
+    outputAspectRatio?: number;
+    dialogSize?: DialogSizeEnum;
+}): Promise<File | null>;

package/dist/services/utils/image-service.js

@@ -0,0 +1,260 @@
+import { DialogSizeEnum, openCropperDialog } from "../dialog/dialog-service.js";
+import { getExtFromFileType, readFileAsDataURL } from "./file-service.js";
+import { nanoid } from "nanoid";
+export var ImageCaptureEnum;
+(function (ImageCaptureEnum) {
+    ImageCaptureEnum["USER"] = "user";
+    ImageCaptureEnum["ENVIRONMENT"] = "environment";
+})(ImageCaptureEnum || (ImageCaptureEnum = {}));
+export var OutputImageFormatEnum;
+(function (OutputImageFormatEnum) {
+    OutputImageFormatEnum["WEBP"] = "image/webp";
+    OutputImageFormatEnum["JPG"] = "image/jpeg";
+    OutputImageFormatEnum["PNG"] = "image/png";
+})(OutputImageFormatEnum || (OutputImageFormatEnum = {}));
+export class FilePickerAccepts {
+    static image = '.png,.PNG,.jpg,.JPG,.jpeg,.JPEG,.webp,.WEBP';
+    static document = '.pdf,.PDF,.doc,.DOC,.docx,.DOCX,.xls,.XLS,.xlsx,.XLSX,.ppt,.PPT,.pptx,.PPTX,.txt,.TXT,';
+    static video = '.mp4,.MP4,.mov,.MOV,.avi,.AVI,.wmv,.WMV,.flv,.FLV,.mkv,.MKV,.webm,.WEBM,';
+    static audio = '.mp3,.MP3,.wav,.WAV,.aac,.AAC,.flac,.FLAC,.ogg,.OGG,.wma,.WMA,';
+    static text = '.txt,.TXT,';
+}
+/**
+ * Processes an image file by resizing, reducing file size, and converting it to a specified format based on the provided options.
+ * @param file - The original image file.
+ * @param options - Options for resizing, compressing, and converting the image.
+ * @returns A promise that resolves to a processed File object with the correct filename and extension.
+ */
+export async function processImageFile(file, options = {}) {
+    // // Return the original file if no processing is needed
+    // if (!options?.maxWidth && !options?.maxHeight && !options?.maxSizeInBytes && !options?.outputFormat) {
+    //     return file;
+    // }
+    options = options || {};
+    if (!options.maxWidth) {
+        options.maxWidth = 1920;
+    }
+    if (!options.maxHeight) {
+        options.maxHeight = options.maxWidth;
+    }
+    if (!options.quality || options.quality < 0) {
+        options.quality = 0.8;
+    }
+    if (options.quality > 1) {
+        options.quality = options.quality / 100;
+    }
+    if (options.outputFormat) {
+        options.outputFormat = OutputImageFormatEnum.WEBP;
+    }
+    // Read the image as a data URL
+    const imageDataUrl = await readFileAsDataURL(file);
+    const img = new Image();
+    return new Promise((resolve, reject) => {
+        img.onload = async () => {
+            // Create a canvas to resize/compress/convert the image
+            const canvas = document.createElement('canvas');
+            const context = canvas.getContext('2d');
+            // Calculate the new dimensions
+            const { width, height } = calculateNewDimensions(img, options.maxWidth, options.maxHeight);
+            canvas.width = width;
+            canvas.height = height;
+            // Draw the image on the canvas
+            context?.drawImage(img, 0, 0, width, height);
+            // Determine the output format and quality
+            const outputFormat = options?.outputFormat || file.type;
+            const quality = options?.quality !== undefined ? options.quality : 0.8; // Default quality 80%
+            // Convert canvas to Blob (compressed image in specified format)
+            canvas.toBlob(async (blob) => {
+                if (!blob) {
+                    reject(new Error('Canvas conversion to Blob failed.'));
+                    return;
+                }
+                // Check the file size and reduce quality if necessary
+                let compressedBlob = blob;
+                if (options.maxSizeInBytes && blob.size > options.maxSizeInBytes) {
+                    compressedBlob = await compressImage(canvas, options.maxSizeInBytes, outputFormat, quality);
+                }
+                // Create a new File from the compressed Blob with the correct filename and extension
+                const newFileName = generateNewFileName(file.name, outputFormat);
+                const processedFile = new File([compressedBlob], newFileName, { type: outputFormat });
+                resolve(processedFile);
+            }, outputFormat, quality // Use the specified quality
+            );
+        };
+        img.onerror = (error) => reject(error);
+        img.src = imageDataUrl; // Set the image source
+    });
+}
+/**
+ * Generates a new filename based on the original filename and output format.
+ * @param originalName - The original filename.
+ * @param outputFormat - The desired output format (e.g., 'image/jpeg', 'image/png').
+ * @returns A new filename with the correct extension.
+ */
+export function generateNewFileName(originalName, outputFormat) {
+    // Get the file extension based on the output format
+    const formatExtensionMap = {
+        'image/jpeg': '.jpeg',
+        'image/png': '.png',
+        'image/webp': '.webp',
+    };
+    // Extract the base name without the extension
+    const baseName = originalName.replace(/\.[^/.]+$/, ''); // Remove existing extension
+    const newExtension = formatExtensionMap[outputFormat] || ''; // Get the new extension
+    return `${baseName}${newExtension}`;
+}
+/**
+ * Calculates the new dimensions for resizing the image while maintaining aspect ratio.
+ * @param img - The original image.
+ * @param maxWidth - The maximum width for the new image.
+ * @param maxHeight - The maximum height for the new image.
+ * @returns An object with the new width and height.
+ */
+export function calculateNewDimensions(img, maxWidth, maxHeight) {
+    let width = img.width;
+    let height = img.height;
+    // Maintain aspect ratio while resizing
+    if (maxWidth && width > maxWidth) {
+        height = (maxWidth / width) * height;
+        width = maxWidth;
+    }
+    if (maxHeight && height > maxHeight) {
+        width = (maxHeight / height) * width;
+        height = maxHeight;
+    }
+    return { width, height };
+}
+/**
+ * Compresses an image to reduce its file size to be under the specified max size.
+ * @param canvas - The canvas element with the image drawn on it.
+ * @param maxSizeInBytes - The maximum allowed size in bytes.
+ * @param format - The output format of the image (e.g., 'image/webp', 'image/jpeg').
+ * @param initialQuality - The initial image quality (0 to 1).
+ * @returns A promise that resolves to a compressed Blob object.
+ */
+export function compressImage(canvas, maxSizeInBytes, format, initialQuality) {
+    return new Promise((resolve) => {
+        let quality = initialQuality; // Start with the specified quality
+        let compressedBlob = null;
+        // Reduce quality iteratively until the Blob size is below the max size
+        const compressIteration = () => {
+            canvas.toBlob((blob) => {
+                if (!blob)
+                    return;
+                if (blob.size <= maxSizeInBytes || quality <= 0.1) {
+                    resolve(blob);
+                }
+                else {
+                    quality -= 0.1; // Reduce quality
+                    compressIteration(); // Recurse
+                }
+            }, format, quality);
+        };
+        compressIteration();
+    });
+}
+/**
+ * Reads the contents of a given File object as an HTMLImageElement.
+ *
+ * This function uses the FileReader API to read the file content and returns it as an HTMLImageElement.
+ * It is useful for loading images for display or further processing.
+ *
+ * @param file - The File object to be read and converted into an HTMLImageElement.
+ * @returns A promise that resolves to an HTMLImageElement representing the image content of the file.
+ *
+ * @throws An error if the file could not be read or if the image could not be loaded.
+ *
+ * @example
+ * // Create an image file and read it as an HTMLImageElement
+ * const imageFile = new File([ binary data here , 'example.png', { type: 'image/png' });
+ * readFileAsImage(imageFile).then((img) => {
+ *     document.body.appendChild(img); // Display the image on the page
+ * });
+ */
+export async function readFileAsImage(file) {
+    return new Promise((resolve, reject) => {
+        const reader = new FileReader();
+        // Event handler executed when the file reading operation is completed
+        reader.onloadend = () => {
+            if (reader.readyState === FileReader.DONE) {
+                const img = new Image();
+                img.src = reader.result;
+                // Resolve the promise when the image is successfully loaded
+                img.onload = () => resolve(img);
+                // Reject the promise if an error occurs while loading the image
+                img.onerror = () => reject(new Error('Failed to load image from file.'));
+            }
+            else {
+                reject(new Error('Failed to read file as Image.'));
+            }
+        };
+        // Event handler executed when an error occurs while reading the file
+        reader.onerror = () => {
+            reject(new Error(`Error reading file as Image: ${reader.error?.message || 'Unknown error'}`));
+        };
+        // Read the file content as a data URL for image loading
+        reader.readAsDataURL(file);
+    });
+}
+/**
+ * Converts a Base64 or Data URL string into an HTMLImageElement.
+ *
+ * This function creates an HTMLImageElement from a given Base64 or Data URL string.
+ * It is useful for displaying images on the page or performing further image processing.
+ *
+ * @param dataUrl - The Base64 or Data URL string representing the image.
+ * @returns A promise that resolves to an HTMLImageElement when the image is successfully loaded.
+ *
+ * @throws An error if the image cannot be loaded.
+ *
+ * @example
+ * // Convert a Base64 string to an image element and append it to the document
+ * const base64String = 'data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAA...';
+ * dataUrlToImage(base64String).then((img) => {
+ *     document.body.appendChild(img); // Display the image on the page
+ * }).catch((error) => {
+ *     console.error('Failed to load image:', error.message);
+ * });
+ */
+export async function dataUrlToImage(dataUrl) {
+    return new Promise((resolve, reject) => {
+        const img = new Image();
+        // Resolve the promise when the image loads successfully
+        img.onload = () => resolve(img);
+        // Reject the promise if an error occurs while loading the image
+        img.onerror = () => reject(new Error('Failed to load image from the provided Data URL or Base64 string.'));
+        // Set the source of the image to the provided Data URL
+        img.src = dataUrl;
+    });
+}
+export async function cropImageFile({ inputImageFile, outputFormat = OutputImageFormatEnum.WEBP, outputWidth = 600, outputQuality = 0.6, outputAspectRatio = 1, dialogSize = DialogSizeEnum.MD, }) {
+    let imageFile = null;
+    let fileName = '';
+    if (inputImageFile) {
+        imageFile = (await openCropperDialog({
+            inputImageFile,
+            outputFormat,
+            outputWidth,
+            outputQuality,
+            outputAspectRatio,
+            size: dialogSize,
+        }));
+        if (imageFile) {
+            try {
+                // console.log('imageFile', imageFile);
+                let filenameNanoid = nanoid(10);
+                fileName = (imageFile.name || '').toLocaleLowerCase().trim().replace(/ /g, '_').substring(0, 4);
+                fileName = (fileName ? fileName + '-' + filenameNanoid : filenameNanoid) + `.${getExtFromFileType(outputFormat)}`;
+            }
+            catch (e) {
+                console.error(e);
+            }
+        }
+    }
+    let newFile = null;
+    if (imageFile && fileName) {
+        // Add the file name to the file object, so that it can be used in the form.
+        newFile = new File([imageFile], fileName, { type: imageFile.type || 'image/webp' });
+    }
+    return newFile;
+}

package/dist/services/utils/melody-service.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Play a melody given as an array of note names and durations.
+ * @param melody - Array of note-duration pairs, e.g., [['C4', 500], ['D4', 500]].
+ */
+export declare function playMelody(melody: [string, number][]): Promise<void>;

package/dist/services/utils/melody-service.js

@@ -0,0 +1,41 @@
+const noteFrequencies = {
+    A0: 27.5, B0: 30.87, C1: 32.7, D1: 36.71, E1: 41.2, F1: 43.65, G1: 49.0,
+    A1: 55.0, B1: 61.74, C2: 65.41, D2: 73.42, E2: 82.41, F2: 87.31, G2: 98.0,
+    A2: 110.0, B2: 123.47, C3: 130.81, D3: 146.83, E3: 164.81, F3: 174.61, G3: 196.0,
+    A3: 220.0, B3: 246.94, C4: 261.63, D4: 293.66, E4: 329.63, F4: 349.23, G4: 392.0,
+    A4: 440.0, B4: 493.88, C5: 523.25, D5: 587.33, E5: 659.25, F5: 698.46, G5: 783.99,
+    A5: 880.0, B5: 987.77, C6: 1046.5, D6: 1174.66, E6: 1318.51, F6: 1396.91, G6: 1567.98,
+    A6: 1760.0, B6: 1975.53, C7: 2093.0, D7: 2349.32, E7: 2637.02, F7: 2793.83, G7: 3135.96,
+    A7: 3520.0, B7: 3951.07, C8: 4186.01,
+};
+/**
+ * Play a melody given as an array of note names and durations.
+ * @param melody - Array of note-duration pairs, e.g., [['C4', 500], ['D4', 500]].
+ */
+export async function playMelody(melody) {
+    try {
+        const audioContext = new (window.AudioContext || window.webkitAudioContext)();
+        for (const [note, duration] of melody) {
+            const frequency = noteFrequencies[note];
+            if (!frequency)
+                continue; // Skip invalid notes
+            const oscillator = audioContext.createOscillator();
+            const gainNode = audioContext.createGain();
+            oscillator.type = 'sine'; // You can use 'square', 'triangle', 'sawtooth', etc.
+            oscillator.frequency.setValueAtTime(frequency, audioContext.currentTime);
+            oscillator.connect(gainNode);
+            gainNode.connect(audioContext.destination);
+            oscillator.start();
+            await new Promise((resolve) => {
+                setTimeout(() => {
+                    oscillator.stop();
+                    resolve(null);
+                }, duration);
+            });
+        }
+        audioContext.close();
+    }
+    catch (error) {
+        console.error('Error playing melody:', error);
+    }
+}

package/dist/services/utils/utils-service.d.ts

@@ -0,0 +1,260 @@
+/**
+ * Generates a random number between the specified minimum and maximum values (inclusive of the minimum and exclusive of the maximum).
+ *
+ * @param min - The minimum value (inclusive) of the random number range.
+ * @param max - The maximum value (exclusive) of the random number range.
+ * @returns A random number between `min` (inclusive) and `max` (exclusive).
+ *
+ * @example
+ * // Generate a random number between 1 (inclusive) and 5 (exclusive)
+ * const randomNumber = random(1, 5); // Possible values: 1.0, 2.4, 3.6, etc.
+ *
+ * @example
+ * // Generate a random number between 10 (inclusive) and 20 (exclusive)
+ * const randomNumber = random(10, 20); // Possible values: 10.0, 15.3, 19.8, etc.
+ */
+export declare function random(min: number, max: number): number;
+/**
+ * Strips the Base64 content from a Data URL string.
+ *
+ * This function removes the `data:[<mediatype>][;base64],` prefix from a Data URL string,
+ * leaving only the Base64 content. If the input is not a valid Data URL, the original input is returned.
+ *
+ * @param dataUrl - The Data URL string to be stripped.
+ * @returns The stripped Base64 content, or the original string if it is not a valid Data URL.
+ *
+ * @example
+ * // Remove the prefix from a Data URL string
+ * const dataUrl = 'data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAA...';
+ * const base64Content = stripDataUrl(dataUrl);
+ * console.log(base64Content); // Output: "iVBORw0KGgoAAAANSUhEUgAA..."
+ */
+export declare function stripDataUrl(dataUrl: string): string;
+/**
+* Function to download content from a given URL and convert it to a Base64-encoded string.
+* @param url - The URL to download the content from.
+* @returns A promise that resolves to the Base64-encoded string of the downloaded content.
+*/
+export declare function readUrlAsBase64(url: string): Promise<string>;
+/**
+ * Validates if a given string is a valid email address.
+ *
+ * This function uses a regular expression to validate email addresses based on common patterns.
+ *
+ * @param email - The email address string to validate.
+ * @returns A boolean indicating whether the email is valid.
+ *
+ * @example
+ * const isValid = isValidEmailAddress('test@example.com');
+ * console.log(isValid); // Output: true
+ */
+export declare function isValidEmailAddress(email: string): boolean;
+/**
+ * Validates if a given string is a valid URL.
+ *
+ * This function uses a regular expression to validate URLs based on common URL patterns.
+ *
+ * @param url - The URL string to validate.
+ * @returns A boolean indicating whether the URL is valid.
+ *
+ * @example
+ * const isValid = isValidUrl('https://www.example.com');
+ * console.log(isValid); // Output: true
+ */
+export declare function isValidUrl(url: string): boolean;
+/**
+ * Creates a mailto URI and opens it in the user's default email client.
+ *
+ * This function constructs a mailto URI based on the provided email details and opens it using `window.open`.
+ * It supports specifying the recipient, subject, and body of the email.
+ *
+ * @param param - An object containing the email details:
+ *    - `to`: The recipient email address.
+ *    - `body`: Optional. The body content of the email.
+ *    - `subject`: Optional. The subject of the email.
+ *
+ * @example
+ * // Create a mailto link with recipient, subject, and body
+ * createMailtoLink({
+ *     to: 'recipient@example.com',
+ *     subject: 'Hello',
+ *     body: 'This is a sample email message.'
+ * });
+ */
+export declare function createMailtoLink({ to, body, subject }: {
+    to: string;
+    body?: string;
+    subject?: string;
+}): void;
+/**
+ * Copies the provided text or HTML content to the clipboard.
+ *
+ * This function handles copying both plain text and rich text (HTML) content.
+ * It uses the Clipboard API where available and falls back to older methods for unsupported browsers.
+ *
+ * @param content - The content to be copied to the clipboard. It can be either a string (plain text) or an HTMLElement (rich text).
+ * @returns A promise that resolves to `true` if the copy operation is successful, or `false` otherwise.
+ *
+ * @example
+ * // Copy plain text to clipboard
+ * copyToClipboard('Hello, World!').then((success) => {
+ *     console.log(success ? 'Copied successfully!' : 'Failed to copy.');
+ * });
+ *
+ * @example
+ * // Copy rich text (HTML element) to clipboard
+ * const element = document.getElementById('myElement');
+ * if (element) {
+ *     copyToClipboard(element).then((success) => {
+ *         console.log(success ? 'Copied successfully!' : 'Failed to copy.');
+ *     });
+ * }
+ */
+export declare function copyToClipboard(content: string | HTMLElement): Promise<boolean>;
+/**
+ * Formats a string by replacing placeholders `{index}` with corresponding arguments.
+ *
+ * This function replaces placeholders in the format `{0}`, `{1}`, etc., in the provided string
+ * with the corresponding values from the `args` array.
+ *
+ * @param str - The string containing placeholders.
+ * @param args - The values to replace the placeholders with.
+ * @returns A formatted string with the placeholders replaced by the corresponding arguments.
+ *
+ * @example
+ * const formatted = formatString('Hello, {0}!', 'World');
+ * console.log(formatted); // Output: "Hello, World!"
+ */
+export declare function formatString(str: string, ...args: any[]): string;
+/**
+ * Delays the execution of code for a specified number of milliseconds.
+ *
+ * This function returns a promise that resolves after the specified delay.
+ *
+ * @param milliseconds - The number of milliseconds to wait before resolving the promise. Default is 0.
+ * @returns A promise that resolves after the specified delay.
+ *
+ * @example
+ * delay(1000).then(() => console.log('1 second later'));
+ */
+export declare function delay(milliseconds?: number): Promise<void>;
+/**
+ * Sorts an array of objects or values based on a specified field or value.
+ *
+ * This function sorts an array of objects based on a specified field or directly sorts an array of values.
+ * It supports both ascending and descending orders and can handle date values.
+ *
+ * @typeParam T - The type of elements in the array.
+ * @param param - An object containing the array to sort, the field to sort by (optional),
+ *                whether to sort in descending order, and whether to sort as date values.
+ * @param param.array - The array of objects or values to sort.
+ * @param param.field - Optional. The field of the objects to sort by.
+ * @param param.desc - Optional. If true, sorts in descending order. Default is false (ascending).
+ * @param param.isDate - Optional. If true, sorts the values as dates.
+ * @returns The sorted array.
+ *
+ * @example
+ * const arr = [{ name: 'Alice' }, { name: 'Bob' }];
+ * const sortedArr = sort({ array: arr, field: 'name', desc: true });
+ * console.log(sortedArr); // Output: [{ name: 'Bob' }, { name: 'Alice' }]
+ */
+export declare function sort<T>({ array, field, desc, isDate }: {
+    array: T[];
+    field?: keyof T;
+    desc?: boolean;
+    isDate?: boolean;
+}): T[];
+/**
+ * Triggers a vibration effect on supported devices.
+ *
+ * This function uses the Vibration API to trigger a vibration effect. If the Vibration API is not
+ * supported or if permissions are not granted, the function will have no effect.
+ *
+ * @param value - A single number representing the duration of the vibration in milliseconds, or
+ *                an array of numbers representing vibration patterns.
+ *
+ * @example
+ * // Single vibration for 200 milliseconds
+ * vibrate(200);
+ *
+ * @example
+ * // Vibration pattern: 200ms on, 100ms off, 200ms on
+ * vibrate([200, 100, 200]);
+ */
+export declare function vibrate(value?: number | number[]): void;
+/**
+ * Plays a simple click effect using the vibration API (if supported).
+ *
+ * This function triggers a short vibration effect to simulate a click or feedback action on devices
+ * that support the Vibration API.
+ *
+ * @example
+ * playClickEffect(); // Triggers a short vibration effect.
+ */
+export declare function playClickEffect(): void;
+/**
+ * Converts an object into an array of its values, attaching a specified key to each value.
+ *
+ * This function takes an object and converts it into an array of its values, where each value is
+ * augmented with a new property specified by the `key` parameter. The property is set to the key
+ * of the original object.
+ *
+ * @param key - The property name to attach to each value.
+ * @param obj - The object to be converted to an array.
+ * @returns An array of values with the specified key attached.
+ *
+ * @example
+ * const obj = { a: { name: 'Alice' }, b: { name: 'Bob' } };
+ * const array = toArrayByKey('id', obj);
+ * console.log(array); // Output: [{ name: 'Alice', id: 'a' }, { name: 'Bob', id: 'b' }]
+ */
+export declare function toArrayByKey(key: string, obj?: Record<string, any>): any[];
+/**
+ * Converts a numeric string into its corresponding alphabets (0-9 => a-j).
+ *
+ * This function maps each digit in the provided number to its corresponding alphabet:
+ * - 0 => a, 1 => b, 2 => c, ... , 9 => j.
+ *
+ * @param num - The number to be converted to a string of alphabets.
+ * @returns A string representing the number converted to alphabets.
+ *
+ * @example
+ * const result = convertNumToAlphabets(123); // "bcd"
+ * console.log(result); // Output: "bcd"
+ */
+export declare function convertNumToAlphabets(num: number): string;
+/**
+ * Converts a length in inches to pixels based on a DPI of 96.
+ *
+ * This function converts inches to pixels assuming a screen DPI (Dots Per Inch) of 96.
+ * It is useful for calculating dimensions in pixels when working with different units of measurement.
+ *
+ * @param inches - The length in inches to be converted to pixels.
+ * @returns The length in pixels corresponding to the provided inches.
+ *
+ * @throws An error if the input is not a valid number or is negative.
+ *
+ * @example
+ * const pixels = inchToPixel(1); // 1 inch to pixels
+ * console.log(pixels); // Output: 96
+ */
+export declare function inchToPixel(inches: number): number;
+/**
+ * Converts a length in pixels to inches based on a DPI of 96.
+ *
+ * This function converts pixels to inches assuming a screen DPI (Dots Per Inch) of 96.
+ * It is useful for converting pixel measurements to physical dimensions.
+ *
+ * @param pixels - The length in pixels to be converted to inches.
+ * @returns The length in inches corresponding to the provided pixels.
+ *
+ * @throws An error if the input is not a valid number or is negative.
+ *
+ * @example
+ * const inches = pixelToInch(96); // 96 pixels to inches
+ * console.log(inches); // Output: 1
+ */
+export declare function pixelToInch(pixels: number): number;
+export declare function alphabetNanoid(length?: number, lowercase?: boolean): string;
+export declare function sanitizePhoneNumber(input: string): string;
+export declare function isChrome(): boolean;