@creopse/utils 0.0.15 → 0.0.16

package/dist/helpers/functions/file.js

@@ -0,0 +1,210 @@
+import { MediaFileType } from '../../enums/media-file-type';
+/**
+ * Converts a number of bytes to a human-readable file size.
+ *
+ * @param {number} bytes - The number of bytes to convert.
+ * @param {boolean} si - Whether to use the SI units (1000) or binary units (1024).
+ * @param {number} dp - The number of decimal places to round the result to.
+ * @return {string} The human-readable file size.
+ */
+export function humanFileSize(bytes, si = false, dp = 1) {
+    const thresh = si ? 1000 : 1024;
+    if (Math.abs(bytes) < thresh) {
+        return bytes + ' B';
+    }
+    const units = si
+        ? ['kB', 'MB', 'GB', 'TB', 'PB', 'EB', 'ZB', 'YB']
+        : ['KiB', 'MiB', 'GiB', 'TiB', 'PiB', 'EiB', 'ZiB', 'YiB'];
+    let u = -1;
+    const r = 10 ** dp;
+    do {
+        bytes /= thresh;
+        ++u;
+    } while (Math.round(Math.abs(bytes) * r) / r >= thresh &&
+        u < units.length - 1);
+    return bytes.toFixed(dp) + ' ' + units[u];
+}
+/**
+ * Returns the filename from a given URL.
+ *
+ * @param {string} url - The URL from which to extract the filename.
+ * @return {string} The filename extracted from the URL.
+ */
+export function filenameFromUrl(url) {
+    return url.substring(url.lastIndexOf('/') + 1);
+}
+/**
+ * Converts a binary string to a Uint8Array.
+ *
+ * @param {string} binary - The binary string to convert.
+ * @returns {Uint8Array} The Uint8Array representation of the binary string.
+ */
+function binaryStringToUint8Array(binary) {
+    const binaryLength = binary.length;
+    const bytes = new Uint8Array(binaryLength);
+    for (let i = 0; i < binaryLength; i++) {
+        bytes[i] = binary.charCodeAt(i);
+    }
+    return bytes;
+}
+/**
+ * Convert binary string content to a JavaScript File object and optionally trigger a download.
+ *
+ * @param {string} binaryContent - The binary string content of the file.
+ * @param {string} fileName - The name for the generated file.
+ * @param {string} mimeType - The MIME type of the file.
+ * @param {boolean} download - Whether to trigger a download of the file.
+ * @returns {File} - The generated File object.
+ */
+export function binaryContentToFile(binaryContent, fileName = 'file.png', mimeType = 'image/png', download = false) {
+    // Convert the binary string to Uint8Array
+    const byteArray = binaryStringToUint8Array(binaryContent);
+    // Create a Blob from the Uint8Array
+    const blob = new Blob([byteArray], { type: mimeType });
+    // Create a File from the Blob
+    const file = new File([blob], fileName, { type: mimeType });
+    if (download) {
+        // If download is true, trigger a download of the file
+        const url = URL.createObjectURL(blob);
+        const a = document.createElement('a');
+        a.href = url;
+        a.download = fileName;
+        document.body.appendChild(a);
+        a.click();
+        setTimeout(() => {
+            document.body.removeChild(a);
+            window.URL.revokeObjectURL(url);
+        }, 0);
+    }
+    // Return the File object
+    return file;
+}
+/**
+ * Convert binary string content to a Data URL.
+ *
+ * @param {string} binaryContent - The binary string content of the file.
+ * @param {string} mimeType - The MIME type of the file.
+ * @returns {Promise<string>} - The Data URL representation of the file.
+ */
+export function binaryContentToDataURL(binaryContent, mimeType) {
+    // Convert the binary string to Uint8Array
+    const byteArray = binaryStringToUint8Array(binaryContent);
+    // Create a Blob from the Uint8Array
+    const blob = new Blob([byteArray], { type: mimeType });
+    // Create a FileReader to read the Blob as a Data URL
+    const reader = new FileReader();
+    return new Promise((resolve, reject) => {
+        reader.onloadend = () => {
+            resolve(reader.result);
+        };
+        reader.onerror = reject;
+        // Read the Blob as Data URL
+        reader.readAsDataURL(blob);
+    });
+}
+/**
+ * Convert a Blob to a Data URL.
+ *
+ * @param {Blob} blob - The Blob to convert.
+ * @returns {Promise<string>} - A promise that resolves to the Data URL.
+ */
+export function blobToDataURL(blob) {
+    return new Promise((resolve, reject) => {
+        const reader = new FileReader();
+        reader.onloadend = () => {
+            resolve(reader.result);
+        };
+        reader.onerror = reject;
+        reader.readAsDataURL(blob);
+    });
+}
+/**
+ * Determines the media file type based on the MIME type of the provided file.
+ *
+ * @param {File} file - The file whose type is to be determined.
+ * @returns {MediaFileType} - The determined media file type, which can be IMAGE, VIDEO, AUDIO, DOCUMENT, or OTHER.
+ */
+export function determineFileType(file) {
+    const mimeType = file.type.toLowerCase();
+    // Define MIME types and extensions for each MediaFileType
+    const imageMimes = [
+        'image/jpeg',
+        'image/png',
+        'image/gif',
+        'image/bmp',
+        'image/webp',
+        'image/svg+xml',
+    ];
+    const videoMimes = [
+        'video/mp4',
+        'video/mpeg',
+        'video/quicktime',
+        'video/x-ms-wmv',
+        'video/x-msvideo',
+        'video/x-flv',
+    ];
+    const audioMimes = [
+        'audio/mpeg',
+        'audio/wav',
+        'audio/x-wav',
+        'audio/ogg',
+        'audio/midi',
+        'audio/x-ms-wma',
+    ];
+    const documentMimes = [
+        'application/pdf',
+        'application/msword',
+        'application/vnd.openxmlformats-officedocument.wordprocessingml.document',
+        'application/vnd.ms-excel',
+        'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',
+        'application/vnd.ms-powerpoint',
+        'application/vnd.openxmlformats-officedocument.presentationml.presentation',
+        'text/plain',
+        'application/rtf',
+    ];
+    if (imageMimes.includes(mimeType)) {
+        return MediaFileType.IMAGE;
+    }
+    if (videoMimes.includes(mimeType)) {
+        return MediaFileType.VIDEO;
+    }
+    if (audioMimes.includes(mimeType)) {
+        return MediaFileType.AUDIO;
+    }
+    if (documentMimes.includes(mimeType)) {
+        return MediaFileType.DOCUMENT;
+    }
+    // If the MIME type doesn't match any of the above, return OTHER
+    return MediaFileType.OTHER;
+}
+/**
+ * Gets the file extension from a given path.
+ *
+ * @param {string} path - The path of the file.
+ * @returns {string} The file extension, or an empty string if none is found.
+ */
+export const getFileExtension = (path) => {
+    const base = path.split('/').pop() || '';
+    const lastDot = base.lastIndexOf('.');
+    if (lastDot <= 0 || lastDot === base.length - 1)
+        return '';
+    return base.slice(lastDot);
+};
+/**
+ * Downloads the given object as a JSON file with the specified name.
+ *
+ * @param {object} exportObj - The object to be exported as JSON.
+ * @param {string} exportName - The name of the exported file.
+ * @return {void} This function does not return a value.
+ */
+export function downloadObjectAsJson(exportObj, exportName) {
+    var dataStr = 'data:text/json;charset=utf-8,' +
+        encodeURIComponent(JSON.stringify(exportObj, null, 2));
+    var element = document.createElement('a');
+    element.setAttribute('href', dataStr);
+    element.setAttribute('download', exportName + '.json');
+    element.style.display = 'none';
+    document.body.appendChild(element);
+    element.click();
+    document.body.removeChild(element);
+}

package/dist/helpers/functions/geo.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Calculates the distance between two points on the Earth's surface using the Haversine formula.
+ *
+ * @param {number} lat1 - The latitude of the first point.
+ * @param {number} lon1 - The longitude of the first point.
+ * @param {number} lat2 - The latitude of the second point.
+ * @param {number} lon2 - The longitude of the second point.
+ * @return {number} The distance between the two points in kilometers.
+ */
+export declare function getDistanceFromLatLonInKm(lat1: number, lon1: number, lat2: number, lon2: number): number;
+/**
+ * Converts degrees to radians.
+ *
+ * @param {number} deg - The angle in degrees.
+ * @returns {number} The angle in radians.
+ */
+export declare function deg2rad(deg: number): number;

package/dist/helpers/functions/geo.js

@@ -0,0 +1,31 @@
+/**
+ * Calculates the distance between two points on the Earth's surface using the Haversine formula.
+ *
+ * @param {number} lat1 - The latitude of the first point.
+ * @param {number} lon1 - The longitude of the first point.
+ * @param {number} lat2 - The latitude of the second point.
+ * @param {number} lon2 - The longitude of the second point.
+ * @return {number} The distance between the two points in kilometers.
+ */
+export function getDistanceFromLatLonInKm(lat1, lon1, lat2, lon2) {
+    var R = 6371;
+    var dLat = deg2rad(lat2 - lat1);
+    var dLon = deg2rad(lon2 - lon1);
+    var a = Math.sin(dLat / 2) * Math.sin(dLat / 2) +
+        Math.cos(deg2rad(lat1)) *
+            Math.cos(deg2rad(lat2)) *
+            Math.sin(dLon / 2) *
+            Math.sin(dLon / 2);
+    var c = 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1 - a));
+    var d = R * c;
+    return d;
+}
+/**
+ * Converts degrees to radians.
+ *
+ * @param {number} deg - The angle in degrees.
+ * @returns {number} The angle in radians.
+ */
+export function deg2rad(deg) {
+    return deg * (Math.PI / 180);
+}

package/dist/helpers/functions/image.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Compresses an image file.
+ *
+ * @param {File} file - The image file to compress.
+ * @param {Object} options - Optional parameters for compression.
+ * @param {number} options.maxSizeMB - The maximum size of the compressed image file in megabytes (default is 1MB).
+ * @param {number} options.maxWidthOrHeight - The maximum width or height of the compressed image file in pixels (default is 1920).
+ * @return {Promise<File>} The compressed image file.
+ */
+export declare function compressImage(file: File, { maxSizeMB, maxWidthOrHeight, }?: {
+    maxSizeMB?: number;
+    maxWidthOrHeight?: number;
+}): Promise<File>;
+/**
+ * Loads the metadata of an image from the specified URL.
+ *
+ * @param {string} url - The URL of the image.
+ * @return {Promise<HTMLImageElement>} A promise that resolves with the loaded image.
+ */
+export declare function loadImageMeta(url: string): Promise<HTMLImageElement>;

package/dist/helpers/functions/image.js

@@ -0,0 +1,44 @@
+import imageCompression from 'browser-image-compression';
+/**
+ * Compresses an image file.
+ *
+ * @param {File} file - The image file to compress.
+ * @param {Object} options - Optional parameters for compression.
+ * @param {number} options.maxSizeMB - The maximum size of the compressed image file in megabytes (default is 1MB).
+ * @param {number} options.maxWidthOrHeight - The maximum width or height of the compressed image file in pixels (default is 1920).
+ * @return {Promise<File>} The compressed image file.
+ */
+export async function compressImage(file, { maxSizeMB = 1, maxWidthOrHeight = 1920, } = {}) {
+    const extensions = ['jpeg', 'jpg', 'png', 'gif', 'webp'];
+    const fileExt = file.name.split('.').pop();
+    const options = {
+        maxSizeMB: maxSizeMB,
+        maxWidthOrHeight: maxWidthOrHeight,
+    };
+    let result = file;
+    if (fileExt != null && extensions.includes(fileExt.toLowerCase())) {
+        try {
+            result = await imageCompression(file, options);
+        }
+        catch (error) {
+            console.log(error);
+        }
+    }
+    if (result instanceof Blob)
+        return new File([result], file.name);
+    return result;
+}
+/**
+ * Loads the metadata of an image from the specified URL.
+ *
+ * @param {string} url - The URL of the image.
+ * @return {Promise<HTMLImageElement>} A promise that resolves with the loaded image.
+ */
+export function loadImageMeta(url) {
+    return new Promise((resolve, reject) => {
+        const img = new Image();
+        img.onload = () => resolve(img);
+        img.onerror = reject;
+        img.src = url;
+    });
+}

package/dist/helpers/functions/index.d.ts

@@ -0,0 +1,13 @@
+export * from './string';
+export * from './number';
+export * from './array';
+export * from './color';
+export * from './object';
+export * from './file';
+export * from './image';
+export * from './url';
+export * from './browser';
+export * from './time';
+export * from './geo';
+export * from './misc';
+export * from './svg';

package/dist/helpers/functions/index.js

@@ -0,0 +1,13 @@
+export * from './string';
+export * from './number';
+export * from './array';
+export * from './color';
+export * from './object';
+export * from './file';
+export * from './image';
+export * from './url';
+export * from './browser';
+export * from './time';
+export * from './geo';
+export * from './misc';
+export * from './svg';

package/dist/helpers/functions/misc.d.ts

@@ -0,0 +1,55 @@
+/**
+ * Formats the given duration in seconds into a string representation of time.
+ *
+ * @param {number} duration - The duration in seconds to be formatted.
+ * @param {Object} options - Optional parameters for formatting.
+ * @param {string} options.separator - The separator used between hours, minutes, and seconds. Defaults to ':'.
+ * @return {string} - The formatted time string.
+ */
+export declare function formatTimeFromSeconds(duration: number, { separator }?: {
+    separator?: string | undefined;
+}): string;
+/**
+ * Generates a password with the specified length and character options.
+ *
+ * @param {number} length - The length of the password to be generated. Default is 10.
+ * @param {object} options - The character options for the password. Default is { letters: true, numbers: true, symbols: false }.
+ * @param {boolean} options.letters - Specifies whether to include letters in the password. Default is true.
+ * @param {boolean} options.numbers - Specifies whether to include numbers in the password. Default is true.
+ * @param {boolean} options.symbols - Specifies whether to include symbols in the password. Default is false.
+ * @return {string} The generated password.
+ */
+export declare function genPassword(length?: number, { letters, numbers, symbols }?: {
+    letters?: boolean | undefined;
+    numbers?: boolean | undefined;
+    symbols?: boolean | undefined;
+}): string;
+/**
+ * Parses an INI string and returns an object containing the key-value pairs.
+ *
+ * @param {string} iniString - The INI string to parse.
+ * @return {{ [key: string]: string }} - An object containing the key-value pairs parsed from the INI string.
+ */
+export declare function parseINIString(iniString: string): {
+    [key: string]: string;
+};
+/**
+ * Generates a custom ID of the specified length.
+ *
+ * @param {number} length - The length of the ID to be generated.
+ * @return {string} The custom ID.
+ */
+export declare function generateCustomId(length: number): string;
+/**
+ * Sanitizes an ID by removing any characters that are not a letter, number, slash, or dash and replacing any slashes with dashes.
+ *
+ * @param {string} id - The ID to be sanitized.
+ * @return {string} The sanitized ID.
+ */
+export declare function sanitizeId(id: string): string;
+/**
+ * Scrolls to the element with the specified ID, with a smooth animation.
+ *
+ * @param {string} id - The ID of the element to scroll to.
+ */
+export declare function slideToId(id: string): void;

package/dist/helpers/functions/misc.js

@@ -0,0 +1,125 @@
+import _ from 'lodash';
+import { strPadLeft } from './string';
+/**
+ * Formats the given duration in seconds into a string representation of time.
+ *
+ * @param {number} duration - The duration in seconds to be formatted.
+ * @param {Object} options - Optional parameters for formatting.
+ * @param {string} options.separator - The separator used between hours, minutes, and seconds. Defaults to ':'.
+ * @return {string} - The formatted time string.
+ */
+export function formatTimeFromSeconds(duration, { separator = ':' } = {}) {
+    var hrs = ~~(duration / 3600);
+    var mins = ~~((duration % 3600) / 60);
+    var secs = ~~duration % 60;
+    var ret = '';
+    if (hrs > 0) {
+        ret +=
+            '' + strPadLeft(String(hrs), '0', 2) + separator + (mins < 10 ? '00' : '');
+    }
+    ret +=
+        '' + strPadLeft(String(mins), '0', 2) + separator + (secs < 10 ? '00' : '');
+    ret += '' + strPadLeft(String(secs), '0', 2);
+    return ret;
+}
+/**
+ * Generates a password with the specified length and character options.
+ *
+ * @param {number} length - The length of the password to be generated. Default is 10.
+ * @param {object} options - The character options for the password. Default is { letters: true, numbers: true, symbols: false }.
+ * @param {boolean} options.letters - Specifies whether to include letters in the password. Default is true.
+ * @param {boolean} options.numbers - Specifies whether to include numbers in the password. Default is true.
+ * @param {boolean} options.symbols - Specifies whether to include symbols in the password. Default is false.
+ * @return {string} The generated password.
+ */
+export function genPassword(length = 10, { letters = true, numbers = true, symbols = false } = {}) {
+    if (!letters && !numbers && !symbols)
+        return '';
+    let base = [], password = '';
+    const numbersBase = '0123456789'.split(''), symbolsBase = '!@#$%^&*()'.split(''), lettersBase = 'abcdefghijklmnopqrstuvwxyz'.split('');
+    if (letters)
+        base.push(...lettersBase);
+    if (numbers)
+        base.push(...numbersBase);
+    if (symbols)
+        base.push(...symbolsBase);
+    base = _.shuffle(base);
+    for (let i = 0; i < length; i++) {
+        const randomNumber = Math.floor(Math.random() * base.length);
+        const char = lettersBase.includes(base[randomNumber]) &&
+            Math.floor(Math.random() * 2) === 0
+            ? base[randomNumber].toUpperCase()
+            : base[randomNumber];
+        password += char;
+    }
+    return password;
+}
+/**
+ * Parses an INI string and returns an object containing the key-value pairs.
+ *
+ * @param {string} iniString - The INI string to parse.
+ * @return {{ [key: string]: string }} - An object containing the key-value pairs parsed from the INI string.
+ */
+export function parseINIString(iniString) {
+    const lines = iniString.split('\n');
+    const result = {};
+    let currentSection = null;
+    for (const line of lines) {
+        // eslint-disable-next-line no-useless-escape
+        const section = line.match(/^\s*\[([^\[\]]+)\]\s*$/);
+        if (section) {
+            currentSection = section[1];
+            continue;
+        }
+        const keyValue = line.match(/^\s*([^=]+?)\s*=\s*(.+?)\s*$/);
+        if (keyValue) {
+            const key = keyValue[1];
+            const value = keyValue[2];
+            if (currentSection) {
+                result[`${currentSection}.${key}`] = value;
+            }
+            else {
+                result[key] = value;
+            }
+        }
+    }
+    return result;
+}
+/**
+ * Generates a custom ID of the specified length.
+ *
+ * @param {number} length - The length of the ID to be generated.
+ * @return {string} The custom ID.
+ */
+export function generateCustomId(length) {
+    const chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
+    let result = '';
+    for (let i = 0; i < length; i++) {
+        const randomIndex = Math.floor(Math.random() * chars.length);
+        result += chars.charAt(randomIndex);
+    }
+    return result;
+}
+/**
+ * Sanitizes an ID by removing any characters that are not a letter, number, slash, or dash and replacing any slashes with dashes.
+ *
+ * @param {string} id - The ID to be sanitized.
+ * @return {string} The sanitized ID.
+ */
+export function sanitizeId(id) {
+    return id.replace(/[^a-z0-9\/-]/g, '').replace(/\//g, '-');
+}
+/**
+ * Scrolls to the element with the specified ID, with a smooth animation.
+ *
+ * @param {string} id - The ID of the element to scroll to.
+ */
+export function slideToId(id) {
+    const element = document.getElementById(id);
+    if (element) {
+        element.scrollIntoView({ behavior: 'smooth', block: 'start' });
+    }
+    else {
+        console.error(`Element with ID "${id}" not found.`);
+    }
+}

package/dist/helpers/functions/number.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Generates a random integer between the provided minimum and maximum values (inclusive).
+ *
+ * @param {number} min - The minimum value for the random integer.
+ * @param {number} max - The maximum value for the random integer.
+ * @return {number} The randomly generated integer.
+ */
+export declare function getRandomInteger(min: number, max: number): number;
+/**
+ * Abbreviates a number by adding a suffix representing the magnitude.
+ *
+ * @param {number} number - The number to be abbreviated.
+ * @return {string|number} The abbreviated number with the magnitude suffix.
+ */
+export declare function abbreviateNumber(number: number): string | number;

package/dist/helpers/functions/number.js

@@ -0,0 +1,26 @@
+/**
+ * Generates a random integer between the provided minimum and maximum values (inclusive).
+ *
+ * @param {number} min - The minimum value for the random integer.
+ * @param {number} max - The maximum value for the random integer.
+ * @return {number} The randomly generated integer.
+ */
+export function getRandomInteger(min, max) {
+    return Math.floor(Math.random() * (max - min + 1)) + min;
+}
+/**
+ * Abbreviates a number by adding a suffix representing the magnitude.
+ *
+ * @param {number} number - The number to be abbreviated.
+ * @return {string|number} The abbreviated number with the magnitude suffix.
+ */
+export function abbreviateNumber(number) {
+    var SI_SYMBOL = ['', 'k', 'M', 'G', 'T', 'P', 'E'];
+    var tier = (Math.log10(Math.abs(number)) / 3) | 0;
+    if (tier == 0)
+        return number;
+    var suffix = SI_SYMBOL[tier];
+    var scale = Math.pow(10, tier * 3);
+    var scaled = number / scale;
+    return scaled.toFixed(1) + suffix;
+}

package/dist/helpers/functions/object.d.ts

@@ -0,0 +1,79 @@
+/**
+ * Checks if the given value is an object and not an array or null.
+ *
+ * @param {any} value - The value to check.
+ * @return {boolean} Returns true if the value is an object and not an array or null, false otherwise.
+ */
+export declare function isRealObject(value: any): boolean;
+/**
+ * Determines if a given string is a valid JSON string representing an object.
+ *
+ * @param {string} str - The string to be checked.
+ * @return {boolean} Returns true if the string is a valid JSON string of an object, false otherwise.
+ */
+export declare const isStringifiedObject: (str: string) => boolean;
+/**
+ * Recursively flattens a nested object into a single-level object with
+ * dot-separated property names.
+ *
+ * @example
+ * const obj = {
+ *   a: {
+ *     b: {
+ *       c: 1
+ *     }
+ *   }
+ * }
+ * const flattened = flattenObject(obj) // { 'a.b.c': 1 }
+ *
+ * @param {object} obj The object to flatten.
+ * @param {string} [prefix=''] The prefix to use for the flattened property names.
+ * @returns {object} The flattened object.
+ */
+export declare const flattenObject: (obj: any, prefix?: string) => Record<string, any>;
+/**
+ * Recursively unflattens a single-level object with dot-separated property
+ * names into a nested object.
+ *
+ * @example
+ * const obj = { 'a.b.c': 1 }
+ * const unflattened = unflattenObject(obj) // { a: { b: { c: 1 } } }
+ *
+ * @param {object} obj The object to unflatten.
+ * @returns {object} The unflattened object.
+ */
+export declare const unflattenObject: (obj: Record<string, any>) => any;
+/**
+ * Renames a key in an object.
+ *
+ * @param {Object} obj - The object that contains the key to rename.
+ * @param {string} oldKey - The old key name.
+ * @param {string} newKey - The new key name.
+ */
+export declare const renameKey: (obj: Record<string, any>, oldKey: string, newKey: string) => void;
+/**
+ * Creates a new object with a specified key renamed, leaving the original object unchanged.
+ *
+ * @param {Record<string, any>} obj - The original object containing the key to rename.
+ * @param {string} oldKey - The name of the key to rename.
+ * @param {string} newKey - The new name for the key.
+ * @returns {Record<string, any>} A new object with the key renamed.
+ */
+export declare const renameKeyImmutable: (obj: Record<string, any>, oldKey: string, newKey: string) => Record<string, any>;
+/**
+ * Omits the specified keys from the given object.
+ *
+ * @param {T} obj The object to omit keys from.
+ * @param {K[]} keys The keys to omit.
+ * @returns {Omit<T, K>} A new object with the specified keys omitted.
+ */
+export declare const omitKeys: <T, K extends keyof T>(obj: T, keys: K[]) => Omit<T, K>;
+/**
+ * Checks if the given object is empty.
+ *
+ * An object is considered empty if it is an object instance (i.e. `obj.constructor === Object`), and if it has no own enumerable property (i.e. `Object.keys(obj).length === 0`).
+ *
+ * @param {any} obj - The object to check.
+ * @returns {boolean} Returns true if the object is empty, false otherwise.
+ */
+export declare const isObjectEmpty: (obj: any) => boolean;