@decaf-ts/for-angular 0.0.10 → 0.0.11

package/dist/lib/esm2022/helpers/utils.mjs

@@ -0,0 +1,415 @@
+import { isDevMode } from '@angular/core';
+import { InjectableRegistryImp } from '@decaf-ts/injectable-decorators';
+import { Primitives } from '@decaf-ts/decorator-validation';
+import { getLogger } from '../for-angular.module';
+let injectableRegistry;
+/**
+ * @description Retrieves the singleton instance of the injectables registry
+ * @summary This function implements the singleton pattern for the InjectablesRegistry.
+ * It returns the existing registry instance if one exists, or creates a new instance
+ * if none exists. The registry is used to store and retrieve injectable dependencies
+ * throughout the application.
+ *
+ * @return {InjectablesRegistry} The singleton injectables registry instance
+ *
+ * @function getInjectablesRegistry
+ * @memberOf module:for-angular
+ */
+export function getInjectablesRegistry() {
+    if (!injectableRegistry)
+        injectableRegistry = new InjectableRegistryImp();
+    return injectableRegistry;
+}
+/**
+ * @description Determines if the application is running in development mode
+ * @summary This function checks whether the application is currently running in a development
+ * environment. It uses Angular's isDevMode() function and also checks the window context
+ * and hostname against the provided context parameter. This is useful for enabling
+ * development-specific features or logging.
+ *
+ * @param {string} [context='localhost'] - The context string to check against the current environment
+ * @return {boolean} True if the application is running in development mode, false otherwise
+ *
+ * @function isDevelopmentMode
+ * @memberOf module:for-angular
+ */
+export function isDevelopmentMode(context = 'localhost') {
+    if (!context)
+        return isDevMode();
+    const win = getWindow();
+    return (isDevMode() ||
+        win?.['env']?.['CONTEXT'].toLowerCase() !== context.toLowerCase() ||
+        win?.['location']?.hostname?.includes(context));
+}
+/**
+ * @description Dispatches a custom event to the document window
+ * @summary This function creates and dispatches a custom event to the browser window.
+ * It's useful for cross-component communication or for triggering application-wide events.
+ * The function allows specifying the event name, detail data, and additional event properties.
+ *
+ * @param {string} name - The name of the custom event to dispatch
+ * @param {unknown} detail - The data to include in the event's detail property
+ * @param {object} [props] - Optional additional properties for the custom event
+ * @return {void}
+ *
+ * @function windowEventEmitter
+ * @memberOf module:for-angular
+ */
+export function windowEventEmitter(name, detail, props) {
+    const data = Object.assign({
+        bubbles: true,
+        composed: true,
+        cancelable: false,
+        detail: detail,
+    }, props || {});
+    getWindow().dispatchEvent(new CustomEvent(name, data));
+}
+/**
+ * @description Retrieves a property from the window's document object
+ * @summary This function provides a safe way to access properties on the window's document object.
+ * It uses the getWindowDocument function to get a reference to the document, then accesses
+ * the specified property. This is useful for browser environment interactions that need
+ * to access document properties.
+ *
+ * @param {string} key - The name of the property to retrieve from the document object
+ * @return {any} The value of the specified property, or undefined if the document or property doesn't exist
+ *
+ * @function getOnWindowDocument
+ * @memberOf module:for-angular
+ */
+export function getOnWindowDocument(key) {
+    const doc = getWindowDocument()?.[key];
+    return doc instanceof Document ?
+        doc : undefined;
+}
+/**
+ * @description Retrieves the document object from the window
+ * @summary This function provides a safe way to access the document object from the window.
+ * It uses the getOnWindow function to retrieve the 'document' property from the window object.
+ * This is useful for browser environment interactions that need access to the document.
+ *
+ * @return {Document | undefined} The window's document object, or undefined if it doesn't exist
+ *
+ * @function getWindowDocument
+ * @memberOf module:for-angular
+ */
+export function getWindowDocument() {
+    return getOnWindow('document');
+}
+/**
+ * @description Retrieves a property from the window object
+ * @summary This function provides a safe way to access properties on the window object.
+ * It uses the getWindow function to get a reference to the window, then accesses
+ * the specified property. This is useful for browser environment interactions that need
+ * to access window properties or APIs.
+ *
+ * @param {string} key - The name of the property to retrieve from the window object
+ * @return {unknown | undefined} The value of the specified property, or undefined if the window or property doesn't exist
+ *
+ * @function getOnWindow
+ * @memberOf module:for-angular
+ */
+export function getOnWindow(key) {
+    return getWindow()?.[key];
+}
+/**
+ * @description Sets a property on the window object
+ * @summary This function provides a way to set properties on the window object.
+ * It uses the getWindow function to get a reference to the window, then sets
+ * the specified property to the provided value. This is useful for storing
+ * global data or functions that need to be accessible across the application.
+ *
+ * @param {string} key - The name of the property to set on the window object
+ * @param {any} value - The value to assign to the property
+ * @return {void}
+ *
+ * @function setOnWindow
+ * @memberOf module:for-angular
+ */
+export function setOnWindow(key, value) {
+    getWindow()[key] = value;
+}
+/**
+ * @description Retrieves the global window object
+ * @summary This function provides a safe way to access the global window object.
+ * It uses globalThis to ensure compatibility across different JavaScript environments.
+ * This is the core function used by other window-related utility functions to
+ * access the window object.
+ *
+ * @return {Window} The global window object
+ *
+ * @function getWindow
+ * @memberOf module:for-angular
+ */
+export function getWindow() {
+    return globalThis?.['window'];
+}
+/**
+ * @description Retrieves the width of the browser window
+ * @summary This function provides a convenient way to get the current width of the browser window.
+ * It uses the getOnWindow function to access the 'innerWidth' property of the window object.
+ * This is useful for responsive design implementations and viewport-based calculations.
+ *
+ * @return {number | undefined} The current width of the browser window in pixels
+ *
+ * @function getWindowWidth
+ * @memberOf module:for-angular
+ */
+export function getWindowWidth() {
+    return getOnWindow('innerWidth') || 0;
+}
+/**
+ * @description Checks if a value is  not undefined
+ * @summary This utility function determines whether a given value is not undefined.
+ * It's a simple wrapper that makes code more readable when checking for defined values.
+ * The function is particularly useful for checking StringOrBoolean properties that might be undefined.
+ *
+ * @param {StringOrBoolean | undefined} prop - The property to check
+ * @return {boolean} True if the property is not undefined, false otherwise
+ *
+ * @function isNotUndefined
+ * @memberOf module:for-angular
+ */
+export function isNotUndefined(prop) {
+    return (prop !== undefined);
+}
+/**
+ * @description Generates a locale string from a class name or instance
+ * @summary This utility function converts a class name or instance into a locale string
+ * that can be used for internationalization purposes. It handles different input types
+ * (string, function, or object) and applies formatting rules to generate a consistent
+ * locale identifier. For short names (less than 3 parts), it reverses the dot-separated
+ * string. For longer names, it uses the last part as a prefix and joins the rest with
+ * underscores.
+ *
+ * @param {string|FunctionLike|object} instance - The input to generate the locale from (class name, constructor, or instance)
+ * @param {string} [suffix] - Optional string to append to the instance name before processing
+ * @return {string} A formatted locale string derived from the input
+ *
+ * @function getLocaleFromClassName
+ * @memberOf module:for-angular
+ */
+export function getLocaleFromClassName(instance, suffix) {
+    if (typeof instance !== 'string')
+        instance =
+            instance.name || instance?.constructor?.name;
+    let name = instance;
+    if (suffix)
+        name = `${instance}${suffix.charAt(0).toUpperCase() + suffix.slice(1)}`;
+    name = name
+        .replace(/_|-/g, '')
+        .replace(/(?:^\w|[A-Z]|\b\w)/g, (word, index) => {
+        if (index > 1)
+            word = '.' + word;
+        return word.toLowerCase();
+    })
+        .split('.');
+    if (name.length < 3)
+        return name.reverse().join('.');
+    const preffix = name[name.length - 1];
+    name.pop();
+    name = name.join('_');
+    return `${preffix}.${name}`;
+}
+/**
+ * @description Generates a localized string by combining locale and phrase
+ * @summary This utility function creates a properly formatted locale string by combining
+ * a locale identifier with a phrase. It handles edge cases such as empty phrases,
+ * missing locales, and phrases that already include the locale prefix. This function
+ * is useful for ensuring consistent formatting of localized strings throughout the application.
+ *
+ * @param {string} locale - The locale identifier (e.g., 'en', 'fr')
+ * @param {string | undefined} phrase - The phrase to localize
+ * @return {string} The formatted locale string, or empty string if phrase is undefined
+ *
+ * @function generateLocaleFromString
+ * @memberOf module:for-angular
+ */
+export function generateLocaleFromString(locale, phrase) {
+    if (!phrase)
+        return '';
+    if (!locale || phrase.includes(`${locale}.`))
+        return phrase;
+    return `${locale}.${phrase}`;
+}
+/**
+ * @description Retrieves the current locale language
+ * @summary This utility function gets the current locale language based on the user's browser settings.
+ * It provides a consistent way to access the user's language preference throughout the application.
+ * The function returns the browser's navigator.language value, defaulting to 'en' if not available.
+ *
+ * @return {string} The current locale language (e.g., 'en', 'fr')
+ *
+ * @function getLocaleLanguage
+ * @memberOf module:for-angular
+ */
+export function getLocaleLanguage() {
+    const win = getWindow();
+    return win.navigator.language || "en";
+    // return win?.[WINDOW_KEYS.LANGUAGE_SELECTED] || (win.navigator.language || '').split('-')[0] || "en";
+}
+/**
+ * @description Generates a random string or number of specified length
+ * @summary This utility function creates a random string of a specified length.
+ * It can generate either alphanumeric strings (including uppercase and lowercase letters)
+ * or numeric-only strings. This is useful for creating random IDs, temporary passwords,
+ * or other random identifiers throughout the application.
+ *
+ * @param {number} [length=8] - The length of the random value to generate
+ * @param {boolean} [onlyNumbers=false] - Whether to generate only numeric characters
+ * @return {string} A randomly generated string of the specified length and character set
+ *
+ * @function generateRandomValue
+ * @memberOf module:for-angular
+ */
+export function generateRandomValue(length = 8, onlyNumbers = false) {
+    const chars = onlyNumbers
+        ? '0123456789'
+        : 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
+    let result = '';
+    for (let i = 0; i < length; i++)
+        result += chars.charAt(Math.floor(Math.random() * chars.length));
+    return result;
+}
+/**
+ * Converts a string representation of a boolean or a boolean value to a boolean type.
+ *
+ * @export
+ * @param {('true' | 'false' | boolean)} prop - The value to convert. Can be the string 'true', 'false', or a boolean.
+ * @returns {boolean} The boolean representation of the input value. Returns true if the input is the string 'true' or boolean true, false otherwise.
+ */
+export function stringToBoolean(prop) {
+    if (typeof prop === 'string')
+        prop = prop.toLowerCase() === 'true' ? true : false;
+    return prop;
+}
+/**
+ * Checks if a value is a valid Date object
+ *
+ * @param {(string | Date | number)} date - The value to check. Can be a Date object, a timestamp number, or a date string
+ * @return {boolean} Returns true if the value is a valid Date object (not NaN), otherwise false
+ */
+export function isValidDate(date) {
+    try {
+        return (date instanceof Date && !isNaN(date)) || (() => {
+            const testRegex = new RegExp(/^\d{4}-\d{2}-\d{2}$/).test(date);
+            if (typeof date !== Primitives.STRING || !date?.includes('T') && !testRegex)
+                return false;
+            date = date.split('T')[0];
+            if (!new RegExp(/^\d{4}-\d{2}-\d{2}$/).test(date))
+                return false;
+            return !!(new Date(date));
+        })();
+    }
+    catch (error) {
+        getLogger(isValidDate).error(error);
+        return false;
+    }
+}
+/**
+ * Formats a date into a localized string representation
+ *
+ * @param {(string | Date | number)} date - The date to format. Can be a Date object, a timestamp number, or a date string
+ * @param {string} [locale] - The locale to use for formatting. If not provided, the system's locale will be used
+ * @return {(Date | string)} A formatted date string in the format DD/MM/YYYY according to the specified locale,
+ *                           or the original input as a string if the date is invalid
+ */
+export function formatDate(date, locale) {
+    if (!locale)
+        locale = getLocaleLanguage();
+    if (typeof date === 'string' || typeof date === 'number')
+        date = new Date(typeof date === 'string' ? date.replace(/\//g, '-') : date);
+    if (!isValidDate(date))
+        return `${date}`;
+    const r = date.toLocaleString(locale, {
+        year: "numeric",
+        day: "2-digit",
+        month: '2-digit'
+    });
+    return r;
+}
+/**
+ * Attempts to parse a date string, Date object, or number into a valid Date object
+ *
+ * @param {(string | Date | number)} date - The date to parse. Can be a Date object, a timestamp number,
+ *                                         or a date string in the format "DD/MM/YYYY HH:MM:SS:MS"
+ * @return {(Date | null)} A valid Date object if parsing is successful, or null if the date is invalid
+ *                         or doesn't match the expected format
+ */
+export function parseToValidDate(date) {
+    if (isValidDate(date))
+        return date;
+    if (!`${date}`.includes('/'))
+        return null;
+    const [dateString, timeString] = date.split(' ');
+    const [day, month, year] = dateString.split('/').map(Number);
+    const [hours, minutes, seconds, milliseconds] = timeString.split(':').map(Number);
+    date = new Date(year, month - 1, day, hours, minutes, seconds, milliseconds);
+    if (!isValidDate(date)) {
+        console.warn('parseToValidDate - Invalid date format', date);
+        return null;
+    }
+    return date;
+}
+/**
+ * Maps an item object using a provided mapper object and optional additional properties.
+ *
+ * @param {KeyValue} item - The source object to be mapped.
+ * @param {KeyValue} mapper - An object that defines the mapping rules. Keys represent the new property names,
+ *                            and values represent the path to the corresponding values in the source object.
+ * @param {KeyValue} [props] - Optional additional properties to be included in the mapped object.
+ * @returns {KeyValue} A new object with properties mapped according to the mapper object and including any additional properties.
+ */
+export function itemMapper(item, mapper, props) {
+    return Object.entries(mapper).reduce((accum, [key, value]) => {
+        const arrayValue = value.split('.');
+        if (!value) {
+            accum[key] = value;
+        }
+        else {
+            if (arrayValue.length === 1) {
+                accum[key] = item?.[value] || value;
+            }
+            else {
+                let val;
+                for (const _value of arrayValue)
+                    val = !val
+                        ? item[_value]
+                        : (typeof val === 'string' ? JSON.parse(val) : val)[_value];
+                if (isValidDate(new Date(val)))
+                    val = `${formatDate(val)}`;
+                accum[key] = val === null || val === undefined ? value : val;
+            }
+        }
+        return Object.assign({}, props || {}, accum);
+    }, {});
+}
+/**
+ * Maps an array of data objects using a provided mapper object.
+ *
+ * @template T - The type of the resulting mapped items.
+ * @param {any[]} data - The array of data objects to be mapped.
+ * @param {KeyValue} mapper - An object that defines the mapping rules.
+ * @param {KeyValue} [props] - Additional properties to be included in the mapped items.
+ *
+ * @returns {T[]} - The array of mapped items. If an item in the original array does not have any non-null values after mapping,
+ * the original item is returned instead.
+ */
+export function dataMapper(data, mapper, props) {
+    if (!data || !data.length)
+        return [];
+    return data.reduce((accum, curr) => {
+        const item = itemMapper(curr, mapper, props);
+        const hasValues = [...new Set(Object.values(item))].filter((value) => value).length >
+            0;
+        // caso o item filtrado não possua nenhum valor, passar o objeto original
+        accum.push(hasValues ? item : curr);
+        return accum;
+    }, []);
+}
+export function removeFocusTrap() {
+    const doc = getWindowDocument();
+    if (doc?.activeElement)
+        doc.activeElement?.blur();
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"utils.js","sourceRoot":"","sources":["../../../../src/lib/helpers/utils.ts"],"names":[],"mappings":"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","sourcesContent":["import { isDevMode } from '@angular/core';\nimport { InjectableRegistryImp, InjectablesRegistry } from '@decaf-ts/injectable-decorators';\nimport { Primitives } from '@decaf-ts/decorator-validation';\nimport { KeyValue, StringOrBoolean, } from '../engine/types';\nimport { FunctionLike } from '../engine/types';\nimport { getLogger } from '../for-angular.module';\n\nlet injectableRegistry: InjectablesRegistry;\n\n/**\n * @description Retrieves the singleton instance of the injectables registry\n * @summary This function implements the singleton pattern for the InjectablesRegistry.\n * It returns the existing registry instance if one exists, or creates a new instance\n * if none exists. The registry is used to store and retrieve injectable dependencies\n * throughout the application.\n *\n * @return {InjectablesRegistry} The singleton injectables registry instance\n *\n * @function getInjectablesRegistry\n * @memberOf module:for-angular\n */\nexport function getInjectablesRegistry(): InjectablesRegistry {\n  if (!injectableRegistry)\n    injectableRegistry = new InjectableRegistryImp();\n  return injectableRegistry;\n}\n\n/**\n * @description Determines if the application is running in development mode\n * @summary This function checks whether the application is currently running in a development\n * environment. It uses Angular's isDevMode() function and also checks the window context\n * and hostname against the provided context parameter. This is useful for enabling\n * development-specific features or logging.\n *\n * @param {string} [context='localhost'] - The context string to check against the current environment\n * @return {boolean} True if the application is running in development mode, false otherwise\n *\n * @function isDevelopmentMode\n * @memberOf module:for-angular\n */\nexport function isDevelopmentMode(context: string = 'localhost'): boolean {\n  if (!context)\n    return isDevMode();\n  const win = getWindow();\n  return (\n    isDevMode() ||\n    win?.['env']?.['CONTEXT'].toLowerCase() !== context.toLowerCase() ||\n    win?.['location']?.hostname?.includes(context)\n  );\n}\n\n/**\n * @description Dispatches a custom event to the document window\n * @summary This function creates and dispatches a custom event to the browser window.\n * It's useful for cross-component communication or for triggering application-wide events.\n * The function allows specifying the event name, detail data, and additional event properties.\n *\n * @param {string} name - The name of the custom event to dispatch\n * @param {unknown} detail - The data to include in the event's detail property\n * @param {object} [props] - Optional additional properties for the custom event\n * @return {void}\n *\n * @function windowEventEmitter\n * @memberOf module:for-angular\n */\nexport function windowEventEmitter(\n  name: string,\n  detail: unknown,\n  props?: object\n): void {\n  const data = Object.assign(\n    {\n      bubbles: true,\n      composed: true,\n      cancelable: false,\n      detail: detail,\n    },\n    props || {}\n  );\n  (getWindow() as Window).dispatchEvent(new CustomEvent(name, data));\n}\n/**\n * @description Retrieves a property from the window's document object\n * @summary This function provides a safe way to access properties on the window's document object.\n * It uses the getWindowDocument function to get a reference to the document, then accesses\n * the specified property. This is useful for browser environment interactions that need\n * to access document properties.\n *\n * @param {string} key - The name of the property to retrieve from the document object\n * @return {any} The value of the specified property, or undefined if the document or property doesn't exist\n *\n * @function getOnWindowDocument\n * @memberOf module:for-angular\n */\nexport function getOnWindowDocument(key: string): Document | undefined {\n  const doc = getWindowDocument()?.[key as keyof Document];\n  return doc instanceof Document ?\n    doc : undefined;\n}\n\n/**\n * @description Retrieves the document object from the window\n * @summary This function provides a safe way to access the document object from the window.\n * It uses the getOnWindow function to retrieve the 'document' property from the window object.\n * This is useful for browser environment interactions that need access to the document.\n *\n * @return {Document | undefined} The window's document object, or undefined if it doesn't exist\n *\n * @function getWindowDocument\n * @memberOf module:for-angular\n */\nexport function getWindowDocument(): Document | undefined {\n  return getOnWindow('document') as Document;\n}\n\n/**\n * @description Retrieves a property from the window object\n * @summary This function provides a safe way to access properties on the window object.\n * It uses the getWindow function to get a reference to the window, then accesses\n * the specified property. This is useful for browser environment interactions that need\n * to access window properties or APIs.\n *\n * @param {string} key - The name of the property to retrieve from the window object\n * @return {unknown | undefined} The value of the specified property, or undefined if the window or property doesn't exist\n *\n * @function getOnWindow\n * @memberOf module:for-angular\n */\nexport function getOnWindow(key: string): unknown | undefined {\n  return getWindow()?.[key];\n}\n\n/**\n * @description Sets a property on the window object\n * @summary This function provides a way to set properties on the window object.\n * It uses the getWindow function to get a reference to the window, then sets\n * the specified property to the provided value. This is useful for storing\n * global data or functions that need to be accessible across the application.\n *\n * @param {string} key - The name of the property to set on the window object\n * @param {any} value - The value to assign to the property\n * @return {void}\n *\n * @function setOnWindow\n * @memberOf module:for-angular\n */\nexport function setOnWindow(key: string, value: unknown): void {\n  getWindow()[key] = value;\n}\n\n/**\n * @description Retrieves the global window object\n * @summary This function provides a safe way to access the global window object.\n * It uses globalThis to ensure compatibility across different JavaScript environments.\n * This is the core function used by other window-related utility functions to\n * access the window object.\n *\n * @return {Window} The global window object\n *\n * @function getWindow\n * @memberOf module:for-angular\n */\nexport function getWindow(): Window & KeyValue {\n  return (globalThis as KeyValue)?.['window'] as Window & KeyValue;\n}\n\n/**\n * @description Retrieves the width of the browser window\n * @summary This function provides a convenient way to get the current width of the browser window.\n * It uses the getOnWindow function to access the 'innerWidth' property of the window object.\n * This is useful for responsive design implementations and viewport-based calculations.\n *\n * @return {number | undefined} The current width of the browser window in pixels\n *\n * @function getWindowWidth\n * @memberOf module:for-angular\n */\nexport function getWindowWidth(): number {\n  return getOnWindow('innerWidth') as number || 0;\n}\n\n/**\n * @description Checks if a value is  not undefined\n * @summary This utility function determines whether a given value is not undefined.\n * It's a simple wrapper that makes code more readable when checking for defined values.\n * The function is particularly useful for checking StringOrBoolean properties that might be undefined.\n *\n * @param {StringOrBoolean | undefined} prop - The property to check\n * @return {boolean} True if the property is not undefined, false otherwise\n *\n * @function isNotUndefined\n * @memberOf module:for-angular\n */\nexport function isNotUndefined(prop: StringOrBoolean | undefined): boolean {\n  return (prop !== undefined) as boolean;\n}\n\n/**\n * @description Generates a locale string from a class name or instance\n * @summary This utility function converts a class name or instance into a locale string\n * that can be used for internationalization purposes. It handles different input types\n * (string, function, or object) and applies formatting rules to generate a consistent\n * locale identifier. For short names (less than 3 parts), it reverses the dot-separated\n * string. For longer names, it uses the last part as a prefix and joins the rest with\n * underscores.\n *\n * @param {string|FunctionLike|object} instance - The input to generate the locale from (class name, constructor, or instance)\n * @param {string} [suffix] - Optional string to append to the instance name before processing\n * @return {string} A formatted locale string derived from the input\n *\n * @function getLocaleFromClassName\n * @memberOf module:for-angular\n */\nexport function getLocaleFromClassName(\n  instance: string | FunctionLike | object,\n  suffix?: string\n): string {\n  if (typeof instance !== 'string')\n    instance =\n      (instance as FunctionLike).name || (instance as object)?.constructor?.name;\n\n  let name: string | string[] = instance;\n\n  if (suffix) name = `${instance}${suffix.charAt(0).toUpperCase() + suffix.slice(1)}`;\n\n  name = name\n    .replace(/_|-/g, '')\n    .replace(/(?:^\\w|[A-Z]|\\b\\w)/g, (word: string, index: number) => {\n      if (index > 1) word = '.' + word;\n      return word.toLowerCase();\n    })\n    .split('.');\n\n  if (name.length < 3)\n    return name.reverse().join('.');\n\n  const preffix = name[name.length - 1];\n  name.pop();\n  name = name.join('_');\n  return `${preffix}.${name}`;\n\n\n}\n\n/**\n * @description Generates a localized string by combining locale and phrase\n * @summary This utility function creates a properly formatted locale string by combining\n * a locale identifier with a phrase. It handles edge cases such as empty phrases,\n * missing locales, and phrases that already include the locale prefix. This function\n * is useful for ensuring consistent formatting of localized strings throughout the application.\n *\n * @param {string} locale - The locale identifier (e.g., 'en', 'fr')\n * @param {string | undefined} phrase - The phrase to localize\n * @return {string} The formatted locale string, or empty string if phrase is undefined\n *\n * @function generateLocaleFromString\n * @memberOf module:for-angular\n */\nexport function generateLocaleFromString(\n  locale: string,\n  phrase: string | undefined\n): string {\n  if (!phrase) return '';\n  if (!locale || phrase.includes(`${locale}.`)) return phrase;\n  return `${locale}.${phrase}`;\n}\n\n\n/**\n * @description Retrieves the current locale language\n * @summary This utility function gets the current locale language based on the user's browser settings.\n * It provides a consistent way to access the user's language preference throughout the application.\n * The function returns the browser's navigator.language value, defaulting to 'en' if not available.\n *\n * @return {string} The current locale language (e.g., 'en', 'fr')\n *\n * @function getLocaleLanguage\n * @memberOf module:for-angular\n */\nexport function getLocaleLanguage(): string {\n  const win = getWindow();\n  return (win as Window).navigator.language || \"en\";\n  // return win?.[WINDOW_KEYS.LANGUAGE_SELECTED] || (win.navigator.language || '').split('-')[0] || \"en\";\n}\n\n\n\n/**\n * @description Generates a random string or number of specified length\n * @summary This utility function creates a random string of a specified length.\n * It can generate either alphanumeric strings (including uppercase and lowercase letters)\n * or numeric-only strings. This is useful for creating random IDs, temporary passwords,\n * or other random identifiers throughout the application.\n *\n * @param {number} [length=8] - The length of the random value to generate\n * @param {boolean} [onlyNumbers=false] - Whether to generate only numeric characters\n * @return {string} A randomly generated string of the specified length and character set\n *\n * @function generateRandomValue\n * @memberOf module:for-angular\n */\nexport function generateRandomValue(length: number = 8, onlyNumbers: boolean = false): string {\n  const chars = onlyNumbers\n    ? '0123456789'\n    : 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';\n  let result = '';\n  for (let i = 0; i < length; i++)\n    result += chars.charAt(Math.floor(Math.random() * chars.length));\n\n  return result;\n}\n\n\n/**\n * Converts a string representation of a boolean or a boolean value to a boolean type.\n *\n * @export\n * @param {('true' | 'false' | boolean)} prop - The value to convert. Can be the string 'true', 'false', or a boolean.\n * @returns {boolean} The boolean representation of the input value. Returns true if the input is the string 'true' or boolean true, false otherwise.\n */\nexport function stringToBoolean(prop: 'true' | 'false' | boolean): boolean {\n  if(typeof prop === 'string')\n    prop = prop.toLowerCase() === 'true' ? true : false;\n  return prop;\n}\n\n\n/**\n * Checks if a value is a valid Date object\n *\n * @param {(string | Date | number)} date - The value to check. Can be a Date object, a timestamp number, or a date string\n * @return {boolean} Returns true if the value is a valid Date object (not NaN), otherwise false\n */\nexport function isValidDate(date: string | Date | number): boolean {\n  try {\n    return (date instanceof Date && !isNaN(date as unknown as number)) || (() => {\n      const testRegex = new RegExp(/^\\d{4}-\\d{2}-\\d{2}$/).test(date as string)\n      if(typeof date !== Primitives.STRING || !(date as string)?.includes('T') && !testRegex)\n         return false;\n\n     date = (date as string).split('T')[0];\n    if(!new RegExp(/^\\d{4}-\\d{2}-\\d{2}$/).test(date))\n      return false;\n\n    return !!(new Date(date));\n   })();\n  } catch(error: unknown) {\n    getLogger(isValidDate).error(error as Error | string);\n    return false;\n  }\n}\n\n/**\n * Formats a date into a localized string representation\n *\n * @param {(string | Date | number)} date - The date to format. Can be a Date object, a timestamp number, or a date string\n * @param {string} [locale] - The locale to use for formatting. If not provided, the system's locale will be used\n * @return {(Date | string)} A formatted date string in the format DD/MM/YYYY according to the specified locale,\n *                           or the original input as a string if the date is invalid\n */\nexport function formatDate(date: string | Date | number, locale?: string | undefined): Date | string {\n\n  if(!locale)\n    locale = getLocaleLanguage();\n\n  if(typeof date === 'string' || typeof date === 'number')\n    date = new Date(typeof date === 'string' ? date.replace(/\\//g, '-') : date);\n\n  if(!isValidDate(date))\n    return `${date}` as string;\n  const r = date.toLocaleString(locale, {\n      year: \"numeric\",\n      day: \"2-digit\",\n      month: '2-digit'\n  });\n\n\n  return r;\n}\n\n/**\n * Attempts to parse a date string, Date object, or number into a valid Date object\n *\n * @param {(string | Date | number)} date - The date to parse. Can be a Date object, a timestamp number,\n *                                         or a date string in the format \"DD/MM/YYYY HH:MM:SS:MS\"\n * @return {(Date | null)} A valid Date object if parsing is successful, or null if the date is invalid\n *                         or doesn't match the expected format\n */\nexport function parseToValidDate(date: string | Date | number): Date | null {\n  if(isValidDate(date))\n    return date as Date;\n\n  if(!`${date}`.includes('/'))\n    return null;\n\n  const [dateString, timeString] = (date as string).split(' ');\n  const [day, month, year] = dateString.split('/').map(Number);\n  const [hours, minutes, seconds, milliseconds] = timeString.split(':').map(Number);\n  date = new Date(year, month - 1, day, hours, minutes, seconds, milliseconds);\n\n  if(!isValidDate(date)) {\n    console.warn('parseToValidDate - Invalid date format', date);\n    return null;\n  }\n\n  return date;\n}\n\n\n/**\n * Maps an item object using a provided mapper object and optional additional properties.\n *\n * @param {KeyValue} item - The source object to be mapped.\n * @param {KeyValue} mapper - An object that defines the mapping rules. Keys represent the new property names,\n *                            and values represent the path to the corresponding values in the source object.\n * @param {KeyValue} [props] - Optional additional properties to be included in the mapped object.\n * @returns {KeyValue} A new object with properties mapped according to the mapper object and including any additional properties.\n */\nexport function itemMapper(item: KeyValue, mapper: KeyValue, props?: KeyValue): KeyValue {\n  return Object.entries(mapper).reduce((accum: KeyValue, [key, value]) => {\n    const arrayValue = (value as string).split('.');\n    if (!value) {\n      accum[key] = value;\n    } else {\n      if (arrayValue.length === 1) {\n        accum[key] = item?.[value as string] || value;\n      } else {\n        let val;\n\n        for (const _value of arrayValue)\n          val = !val\n            ? item[_value]\n            : (typeof val === 'string' ? JSON.parse(val) : val)[_value];\n\n        if (isValidDate(new Date(val))) val = `${formatDate(val)}`;\n\n        accum[key] = val === null || val === undefined ? value : val;\n      }\n    }\n    return Object.assign({}, props || {}, accum);\n  }, {});\n}\n\n/**\n * Maps an array of data objects using a provided mapper object.\n *\n * @template T - The type of the resulting mapped items.\n * @param {any[]} data - The array of data objects to be mapped.\n * @param {KeyValue} mapper - An object that defines the mapping rules.\n * @param {KeyValue} [props] - Additional properties to be included in the mapped items.\n *\n * @returns {T[]} - The array of mapped items. If an item in the original array does not have any non-null values after mapping,\n * the original item is returned instead.\n */\nexport function dataMapper<T>(data: T[], mapper: KeyValue, props?: KeyValue): T[] {\n  if (!data || !data.length) return [];\n  return data.reduce((accum: T[], curr) => {\n    const item = itemMapper(curr as KeyValue, mapper, props) as T;\n    const hasValues =\n      [...new Set(Object.values(item as T[]))].filter((value) => value).length >\n      0;\n    // caso o item filtrado não possua nenhum valor, passar o objeto original\n    accum.push(hasValues ? item : curr);\n    return accum;\n  }, []);\n}\n\n\nexport function removeFocusTrap(): void {\n  const doc = getWindowDocument();\n  if(doc?.activeElement)\n    (doc.activeElement as HTMLElement)?.blur();\n}\n"]}

package/dist/lib/esm2022/interfaces.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW50ZXJmYWNlcy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9saWIvaW50ZXJmYWNlcy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgRm9ybUdyb3VwIH0gZnJvbSAnQGFuZ3VsYXIvZm9ybXMnO1xuaW1wb3J0IHsgRWxlbWVudFJlZiB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuXG4vKipcbiAqIEBkZXNjcmlwdGlvbiBJbnRlcmZhY2UgZm9yIGNvbXBvbmVudHMgdGhhdCBob2xkIGFuIEVsZW1lbnRSZWZcbiAqIEBzdW1tYXJ5IERlZmluZXMgYSBjb21wb25lbnQgaG9sZGVyIGludGVyZmFjZSB0aGF0IHByb3ZpZGVzIGFjY2VzcyB0byB0aGUgdW5kZXJseWluZyBET00gZWxlbWVudCB0aHJvdWdoIEVsZW1lbnRSZWZcbiAqIEBpbnRlcmZhY2UgQ29tcG9uZW50SG9sZGVyXG4gKiBAbWVtYmVyT2YgbW9kdWxlOmZvci1hbmd1bGFyXG4gKi9cbmV4cG9ydCBpbnRlcmZhY2UgQ29tcG9uZW50SG9sZGVyIHtcbiAgLyoqXG4gICAqIEBkZXNjcmlwdGlvbiBSZWZlcmVuY2UgdG8gdGhlIGNvbXBvbmVudCdzIERPTSBlbGVtZW50XG4gICAqIEBwcm9wZXJ0eSB7RWxlbWVudFJlZn0gY29tcG9uZW50IC0gVGhlIEVsZW1lbnRSZWYgaW5zdGFuY2UgcHJvdmlkaW5nIGFjY2VzcyB0byB0aGUgbmF0aXZlIERPTSBlbGVtZW50XG4gICAqL1xuICBjb21wb25lbnQ6IEVsZW1lbnRSZWY7XG59XG5cbi8qKlxuICogQGRlc2NyaXB0aW9uIEludGVyZmFjZSBmb3IgZm9ybSBjb21wb25lbnRzIHRoYXQgaG9sZCBib3RoIGFuIEVsZW1lbnRSZWYgYW5kIGEgRm9ybUdyb3VwXG4gKiBAc3VtbWFyeSBFeHRlbmRzIENvbXBvbmVudEhvbGRlciB0byBpbmNsdWRlIGEgRm9ybUdyb3VwIGZvciBmb3JtIGhhbmRsaW5nIGNhcGFiaWxpdGllc1xuICogQGludGVyZmFjZSBGb3JtRWxlbWVudFxuICogQG1lbWJlck9mIG1vZHVsZTpmb3ItYW5ndWxhclxuICovXG5leHBvcnQgaW50ZXJmYWNlIEZvcm1FbGVtZW50IGV4dGVuZHMgQ29tcG9uZW50SG9sZGVyIHtcbiAgLyoqXG4gICAqIEBkZXNjcmlwdGlvbiBUaGUgQW5ndWxhciBGb3JtR3JvdXAgYXNzb2NpYXRlZCB3aXRoIHRoaXMgZm9ybSBlbGVtZW50XG4gICAqIEBwcm9wZXJ0eSB7Rm9ybUdyb3VwfHVuZGVmaW5lZH0gZm9ybUdyb3VwIC0gVGhlIGZvcm0gZ3JvdXAgaW5zdGFuY2UgZm9yIG1hbmFnaW5nIGZvcm0gY29udHJvbHMgYW5kIHZhbGlkYXRpb25cbiAgICovXG4gIGZvcm1Hcm91cDogRm9ybUdyb3VwIHwgdW5kZWZpbmVkO1xufVxuIl19

package/dist/lib/esm2022/public-apis.mjs

@@ -0,0 +1,14 @@
+import '@decaf-ts/ui-decorators';
+export * from './components';
+export * from './engine';
+export * from './directives';
+export * from './helpers';
+export * from './for-angular.module';
+/**
+ * @description Angular integration for the Decaf framework
+ * @summary This module provides Angular components and services for integrating with the Decaf framework.
+ * It includes components for rendering models, CRUD operations, and form handling, as well as
+ * rendering engines and utility functions to facilitate Angular application development with Decaf.
+ * @module for-angular
+ */
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljLWFwaXMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvbGliL3B1YmxpYy1hcGlzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8seUJBQXlCLENBQUM7QUFDakMsY0FBYyxjQUFjLENBQUM7QUFDN0IsY0FBYyxVQUFVLENBQUM7QUFDekIsY0FBYyxjQUFjLENBQUM7QUFDN0IsY0FBYyxXQUFXLENBQUM7QUFDMUIsY0FBYyxzQkFBc0IsQ0FBQztBQUNyQzs7Ozs7O0dBTUciLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgJ0BkZWNhZi10cy91aS1kZWNvcmF0b3JzJztcbmV4cG9ydCAqIGZyb20gJy4vY29tcG9uZW50cyc7XG5leHBvcnQgKiBmcm9tICcuL2VuZ2luZSc7XG5leHBvcnQgKiBmcm9tICcuL2RpcmVjdGl2ZXMnO1xuZXhwb3J0ICogZnJvbSAnLi9oZWxwZXJzJztcbmV4cG9ydCAqIGZyb20gJy4vZm9yLWFuZ3VsYXIubW9kdWxlJztcbi8qKlxuICogQGRlc2NyaXB0aW9uIEFuZ3VsYXIgaW50ZWdyYXRpb24gZm9yIHRoZSBEZWNhZiBmcmFtZXdvcmtcbiAqIEBzdW1tYXJ5IFRoaXMgbW9kdWxlIHByb3ZpZGVzIEFuZ3VsYXIgY29tcG9uZW50cyBhbmQgc2VydmljZXMgZm9yIGludGVncmF0aW5nIHdpdGggdGhlIERlY2FmIGZyYW1ld29yay5cbiAqIEl0IGluY2x1ZGVzIGNvbXBvbmVudHMgZm9yIHJlbmRlcmluZyBtb2RlbHMsIENSVUQgb3BlcmF0aW9ucywgYW5kIGZvcm0gaGFuZGxpbmcsIGFzIHdlbGwgYXNcbiAqIHJlbmRlcmluZyBlbmdpbmVzIGFuZCB1dGlsaXR5IGZ1bmN0aW9ucyB0byBmYWNpbGl0YXRlIEFuZ3VsYXIgYXBwbGljYXRpb24gZGV2ZWxvcG1lbnQgd2l0aCBEZWNhZi5cbiAqIEBtb2R1bGUgZm9yLWFuZ3VsYXJcbiAqL1xuIl19