@cloudparker/moldex.js 0.0.50 → 0.0.52

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

@@ -0,0 +1,81 @@
+export declare const ACCEPT_IMAGE_FILES: 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?: 'image/webp' | 'image/jpeg' | 'image/png';
+    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>;

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

@@ -0,0 +1,194 @@
+import { readFileAsDataURL } from "./file-service";
+export const ACCEPT_IMAGE_FILES = ".png,.PNG,.jpg,.jpg,.jepg,.JPEG,.webp,.WEBP";
+/**
+ * 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;
+    }
+    // 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;
+    });
+}

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

@@ -1,74 +1,276 @@
-export declare const FILE_VIEWER_HOST = "https://viewer.cloudparker.com";
-export declare const CODE_FILE_EXTENTIONS: string[];
-export declare const ACCEPT_IMAGE_FILES: string;
+/**
+ * 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;
-export declare function openFilePicker(opt: {
-    accept?: string;
-    multiple?: boolean;
-}): Promise<File | File[]>;
-/**
- * Default quality 1.0
- * @param opt
- * @returns
- */
-export declare function resizeImage(opt: {
-    file: File;
-    width: number;
-    height?: number;
-    fileName?: string;
-    quality?: number;
-    type?: string;
-}): Promise<File>;
-export declare function downloadURI(uri: string, name: string): Promise<void>;
-export declare function downloadFile(file: File): Promise<void>;
-export declare function downloadBlob(blob: Blob, name: string): Promise<void>;
-export declare function fileToDataURL(file: File): Promise<string>;
-export declare function fileToText(file: File): Promise<string>;
-export declare function fileToBuffer(file: File): Promise<ArrayBuffer>;
-export declare function fileToImage(file: File): Promise<HTMLImageElement>;
-export declare function dataUrlToImage(base64: string): Promise<any>;
-export declare function stripBase64(data: string): string;
+/**
+ * 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 urlToBase64(url: string): Promise<string>;
-export declare function urlToFile(url: string, givenFileName?: string, givenMimeType?: string): Promise<File>;
-export declare function dataUrlToFile(url: string, givenFileName?: string, givenMimeType?: string): Promise<File>;
-export declare function bufferToFile(buffer: ArrayBuffer, filename: string, mimeType: string): Promise<File>;
-export declare function postData(url?: string, data?: {}): Promise<any>;
-export declare function fileNameAndExt(filename: string): {
-    name: string;
-    ext: string | undefined;
-};
-export declare function isValidateEmail(email: string): boolean;
-export declare function isValidURL(str: string): boolean;
-export declare function mailto({ to, body, subject }: {
+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;
+    body?: string;
+    subject?: string;
 }): void;
-export declare function copyText(str: string): void;
-export declare function copyRichText(node: HTMLElement): void;
-export declare function download(data: string, filename: string, type: 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;
-export declare function fileSizeString(size: number): string;
-export declare function delay(mills?: number): Promise<unknown>;
+/**
+ * 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?: string;
+    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;
-export declare function toArrayByKey(key: string, obj?: any): any[];
-export declare function convertNumToAlphabates(num: number): string;
-export declare function fetchText(url: string): Promise<string>;
+/**
+ * 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 number to a currency-formatted string.
+ *
+ * This function formats a given number as a currency string, using a specified currency symbol
+ * (default is '$'). It handles negative values by adding a '-' sign in front of the formatted value.
+ *
+ * @param value - The numeric value to format as currency.
+ * @param symbol - The currency symbol to use. Default is '$'.
+ * @returns A formatted string representing the currency value.
+ *
+ * @example
+ * const formattedValue = toCurrency(1234.56, '$');
+ * console.log(formattedValue); // Output: "$ 1234.56"
+ *
+ * @example
+ * const formattedNegative = toCurrency(-1234.56, '€');
+ * console.log(formattedNegative); // Output: "- € 1234.56"
+ */
 export declare function toCurrency(value?: number, symbol?: string): 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 isValidHexColor(hex: string): boolean;
-export declare function colorToHex(color: string): string;
-export declare function rgbToHex(r: number, g: number, b: number): string;