@competer/primeng-table 0.0.0-stage → 14.2.0

package/esm2020/lib/utils/create-table-options.mjs

@@ -0,0 +1,37 @@
+import { DEFAULT_TABLE_OPTIONS } from '../interfaces';
+/**
+ * Deep merge two objects.
+ * Recursively copies properties from `source` into `target`,
+ * but ignores `undefined` values to preserve defaults.
+ */
+function deepMerge(target, source) {
+    for (const key in source) {
+        const value = source[key];
+        if (value === undefined) { // skip undefined values to keep defaults
+            continue;
+        }
+        if (value !== null && typeof value === "object" && !Array.isArray(value)) {
+            if (!target[key])
+                target[key] = {};
+            deepMerge(target[key], value);
+        }
+        else {
+            target[key] = value;
+        }
+    }
+    return target;
+}
+/**
+ * Create table options based on defaults, with optional overrides.
+ */
+export function createTableOptions(overrides = {}) {
+    const defaultsCopy = JSON.parse(JSON.stringify(DEFAULT_TABLE_OPTIONS)); // clone only data
+    const merged = deepMerge(defaultsCopy, overrides);
+    // Reasign function if they exist in override
+    if (overrides.rows?.style)
+        merged.rows.style = overrides.rows.style;
+    if (overrides.rows?.class)
+        merged.rows.class = overrides.rows.class;
+    return merged;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY3JlYXRlLXRhYmxlLW9wdGlvbnMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9lY3MtcHJpbWVuZy10YWJsZS9zcmMvbGliL3V0aWxzL2NyZWF0ZS10YWJsZS1vcHRpb25zLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxxQkFBcUIsRUFBaUIsTUFBTSxlQUFlLENBQUM7QUFFckU7Ozs7R0FJRztBQUNILFNBQVMsU0FBUyxDQUFJLE1BQVMsRUFBRSxNQUFrQjtJQUNqRCxLQUFLLE1BQU0sR0FBRyxJQUFJLE1BQU0sRUFBRTtRQUN4QixNQUFNLEtBQUssR0FBRyxNQUFNLENBQUMsR0FBRyxDQUFDLENBQUM7UUFFMUIsSUFBSSxLQUFLLEtBQUssU0FBUyxFQUFFLEVBQUUseUNBQXlDO1lBQ2xFLFNBQVM7U0FDVjtRQUVELElBQUksS0FBSyxLQUFLLElBQUksSUFBSSxPQUFPLEtBQUssS0FBSyxRQUFRLElBQUksQ0FBQyxLQUFLLENBQUMsT0FBTyxDQUFDLEtBQUssQ0FBQyxFQUFFO1lBQ3hFLElBQUksQ0FBQyxNQUFNLENBQUMsR0FBRyxDQUFDO2dCQUFHLE1BQWMsQ0FBQyxHQUFHLENBQUMsR0FBRyxFQUFFLENBQUM7WUFDNUMsU0FBUyxDQUFFLE1BQWMsQ0FBQyxHQUFHLENBQUMsRUFBRSxLQUFLLENBQUMsQ0FBQztTQUN4QzthQUFNO1lBQ0osTUFBYyxDQUFDLEdBQUcsQ0FBQyxHQUFHLEtBQUssQ0FBQztTQUM5QjtLQUNGO0lBQ0QsT0FBTyxNQUFNLENBQUM7QUFDaEIsQ0FBQztBQUVEOztHQUVHO0FBQ0gsTUFBTSxVQUFVLGtCQUFrQixDQUFDLFlBQW9DLEVBQUU7SUFDdkUsTUFBTSxZQUFZLEdBQUcsSUFBSSxDQUFDLEtBQUssQ0FBQyxJQUFJLENBQUMsU0FBUyxDQUFDLHFCQUFxQixDQUFDLENBQUMsQ0FBQyxDQUFDLGtCQUFrQjtJQUMxRixNQUFNLE1BQU0sR0FBRyxTQUFTLENBQUMsWUFBbUIsRUFBRSxTQUFTLENBQUMsQ0FBQztJQUV6RCw2Q0FBNkM7SUFDN0MsSUFBSSxTQUFTLENBQUMsSUFBSSxFQUFFLEtBQUs7UUFBRSxNQUFNLENBQUMsSUFBSSxDQUFDLEtBQUssR0FBRyxTQUFTLENBQUMsSUFBSSxDQUFDLEtBQUssQ0FBQztJQUNwRSxJQUFJLFNBQVMsQ0FBQyxJQUFJLEVBQUUsS0FBSztRQUFFLE1BQU0sQ0FBQyxJQUFJLENBQUMsS0FBSyxHQUFHLFNBQVMsQ0FBQyxJQUFJLENBQUMsS0FBSyxDQUFDO0lBRXBFLE9BQU8sTUFBdUIsQ0FBQztBQUNqQyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgREVGQVVMVF9UQUJMRV9PUFRJT05TLCBJVGFibGVPcHRpb25zIH0gZnJvbSAnLi4vaW50ZXJmYWNlcyc7XHJcblxyXG4vKipcclxuICogRGVlcCBtZXJnZSB0d28gb2JqZWN0cy5cclxuICogUmVjdXJzaXZlbHkgY29waWVzIHByb3BlcnRpZXMgZnJvbSBgc291cmNlYCBpbnRvIGB0YXJnZXRgLFxyXG4gKiBidXQgaWdub3JlcyBgdW5kZWZpbmVkYCB2YWx1ZXMgdG8gcHJlc2VydmUgZGVmYXVsdHMuXHJcbiAqL1xyXG5mdW5jdGlvbiBkZWVwTWVyZ2U8VD4odGFyZ2V0OiBULCBzb3VyY2U6IFBhcnRpYWw8VD4pOiBUIHtcclxuICBmb3IgKGNvbnN0IGtleSBpbiBzb3VyY2UpIHtcclxuICAgIGNvbnN0IHZhbHVlID0gc291cmNlW2tleV07XHJcblxyXG4gICAgaWYgKHZhbHVlID09PSB1bmRlZmluZWQpIHsgLy8gc2tpcCB1bmRlZmluZWQgdmFsdWVzIHRvIGtlZXAgZGVmYXVsdHNcclxuICAgICAgY29udGludWU7XHJcbiAgICB9XHJcblxyXG4gICAgaWYgKHZhbHVlICE9PSBudWxsICYmIHR5cGVvZiB2YWx1ZSA9PT0gXCJvYmplY3RcIiAmJiAhQXJyYXkuaXNBcnJheSh2YWx1ZSkpIHtcclxuICAgICAgaWYgKCF0YXJnZXRba2V5XSkgKHRhcmdldCBhcyBhbnkpW2tleV0gPSB7fTtcclxuICAgICAgZGVlcE1lcmdlKCh0YXJnZXQgYXMgYW55KVtrZXldLCB2YWx1ZSk7XHJcbiAgICB9IGVsc2Uge1xyXG4gICAgICAodGFyZ2V0IGFzIGFueSlba2V5XSA9IHZhbHVlO1xyXG4gICAgfVxyXG4gIH1cclxuICByZXR1cm4gdGFyZ2V0O1xyXG59XHJcblxyXG4vKipcclxuICogQ3JlYXRlIHRhYmxlIG9wdGlvbnMgYmFzZWQgb24gZGVmYXVsdHMsIHdpdGggb3B0aW9uYWwgb3ZlcnJpZGVzLlxyXG4gKi9cclxuZXhwb3J0IGZ1bmN0aW9uIGNyZWF0ZVRhYmxlT3B0aW9ucyhvdmVycmlkZXM6IFBhcnRpYWw8SVRhYmxlT3B0aW9ucz4gPSB7fSk6IElUYWJsZU9wdGlvbnMge1xyXG4gIGNvbnN0IGRlZmF1bHRzQ29weSA9IEpTT04ucGFyc2UoSlNPTi5zdHJpbmdpZnkoREVGQVVMVF9UQUJMRV9PUFRJT05TKSk7IC8vIGNsb25lIG9ubHkgZGF0YVxyXG4gIGNvbnN0IG1lcmdlZCA9IGRlZXBNZXJnZShkZWZhdWx0c0NvcHkgYXMgYW55LCBvdmVycmlkZXMpO1xyXG5cclxuICAvLyBSZWFzaWduIGZ1bmN0aW9uIGlmIHRoZXkgZXhpc3QgaW4gb3ZlcnJpZGVcclxuICBpZiAob3ZlcnJpZGVzLnJvd3M/LnN0eWxlKSBtZXJnZWQucm93cy5zdHlsZSA9IG92ZXJyaWRlcy5yb3dzLnN0eWxlO1xyXG4gIGlmIChvdmVycmlkZXMucm93cz8uY2xhc3MpIG1lcmdlZC5yb3dzLmNsYXNzID0gb3ZlcnJpZGVzLnJvd3MuY2xhc3M7XHJcblxyXG4gIHJldHVybiBtZXJnZWQgYXMgSVRhYmxlT3B0aW9ucztcclxufSJdfQ==

package/esm2020/lib/utils/data-align-horizontal-as-text.mjs

@@ -0,0 +1,23 @@
+import { DataAlignHorizontal } from "../enums";
+/**
+ * Converts a `DataAlignHorizontal` enum value to its corresponding CSS text alignment string.
+ *
+ * @param dataAlignHorizontal - The horizontal alignment enum value.
+ * @returns The CSS text alignment string ('left', 'center', or 'right').
+ *
+ * @remarks
+ * If an unknown value is provided, the function defaults to 'center'.
+ */
+export function dataAlignHorizontalAsText(dataAlignHorizontal) {
+    switch (dataAlignHorizontal) {
+        case DataAlignHorizontal.Left:
+            return 'left';
+        case DataAlignHorizontal.Center:
+            return 'center';
+        case DataAlignHorizontal.Right:
+            return 'right';
+        default:
+            return 'center';
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGF0YS1hbGlnbi1ob3Jpem9udGFsLWFzLXRleHQuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9lY3MtcHJpbWVuZy10YWJsZS9zcmMvbGliL3V0aWxzL2RhdGEtYWxpZ24taG9yaXpvbnRhbC1hcy10ZXh0LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxtQkFBbUIsRUFBRSxNQUFNLFVBQVUsQ0FBQztBQUUvQzs7Ozs7Ozs7R0FRRztBQUNILE1BQU0sVUFBVSx5QkFBeUIsQ0FBQyxtQkFBd0M7SUFDOUUsUUFBUSxtQkFBbUIsRUFBRTtRQUN6QixLQUFLLG1CQUFtQixDQUFDLElBQUk7WUFDekIsT0FBTyxNQUFNLENBQUM7UUFDbEIsS0FBSyxtQkFBbUIsQ0FBQyxNQUFNO1lBQzNCLE9BQU8sUUFBUSxDQUFDO1FBQ3BCLEtBQUssbUJBQW1CLENBQUMsS0FBSztZQUMxQixPQUFPLE9BQU8sQ0FBQztRQUNuQjtZQUNJLE9BQU8sUUFBUSxDQUFDO0tBQ3ZCO0FBQ0wsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IERhdGFBbGlnbkhvcml6b250YWwgfSBmcm9tIFwiLi4vZW51bXNcIjtcclxuXHJcbi8qKlxyXG4gKiBDb252ZXJ0cyBhIGBEYXRhQWxpZ25Ib3Jpem9udGFsYCBlbnVtIHZhbHVlIHRvIGl0cyBjb3JyZXNwb25kaW5nIENTUyB0ZXh0IGFsaWdubWVudCBzdHJpbmcuXHJcbiAqXHJcbiAqIEBwYXJhbSBkYXRhQWxpZ25Ib3Jpem9udGFsIC0gVGhlIGhvcml6b250YWwgYWxpZ25tZW50IGVudW0gdmFsdWUuXHJcbiAqIEByZXR1cm5zIFRoZSBDU1MgdGV4dCBhbGlnbm1lbnQgc3RyaW5nICgnbGVmdCcsICdjZW50ZXInLCBvciAncmlnaHQnKS5cclxuICpcclxuICogQHJlbWFya3NcclxuICogSWYgYW4gdW5rbm93biB2YWx1ZSBpcyBwcm92aWRlZCwgdGhlIGZ1bmN0aW9uIGRlZmF1bHRzIHRvICdjZW50ZXInLlxyXG4gKi9cclxuZXhwb3J0IGZ1bmN0aW9uIGRhdGFBbGlnbkhvcml6b250YWxBc1RleHQoZGF0YUFsaWduSG9yaXpvbnRhbDogRGF0YUFsaWduSG9yaXpvbnRhbCk6IHN0cmluZyB7XHJcbiAgICBzd2l0Y2ggKGRhdGFBbGlnbkhvcml6b250YWwpIHtcclxuICAgICAgICBjYXNlIERhdGFBbGlnbkhvcml6b250YWwuTGVmdDpcclxuICAgICAgICAgICAgcmV0dXJuICdsZWZ0JztcclxuICAgICAgICBjYXNlIERhdGFBbGlnbkhvcml6b250YWwuQ2VudGVyOlxyXG4gICAgICAgICAgICByZXR1cm4gJ2NlbnRlcic7XHJcbiAgICAgICAgY2FzZSBEYXRhQWxpZ25Ib3Jpem9udGFsLlJpZ2h0OlxyXG4gICAgICAgICAgICByZXR1cm4gJ3JpZ2h0JztcclxuICAgICAgICBkZWZhdWx0OlxyXG4gICAgICAgICAgICByZXR1cm4gJ2NlbnRlcic7XHJcbiAgICB9XHJcbn0iXX0=

package/esm2020/lib/utils/data-align-vertical-as-text.mjs

@@ -0,0 +1,23 @@
+import { DataAlignVertical } from "../enums";
+/**
+ * Converts a `DataAlignVertical` enum value to its corresponding CSS vertical alignment string.
+ *
+ * @param dataAlignVertical - The vertical alignment enum value.
+ * @returns The CSS vertical alignment string ('top', 'middle', or 'bottom').
+ *
+ * @remarks
+ * If an unknown value is provided, the function defaults to 'middle'.
+ */
+export function dataAlignVerticalAsText(dataAlignVertical) {
+    switch (dataAlignVertical) {
+        case DataAlignVertical.Top:
+            return 'top';
+        case DataAlignVertical.Middle:
+            return 'middle';
+        case DataAlignVertical.Bottom:
+            return 'bottom';
+        default:
+            return 'middle';
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGF0YS1hbGlnbi12ZXJ0aWNhbC1hcy10ZXh0LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvZWNzLXByaW1lbmctdGFibGUvc3JjL2xpYi91dGlscy9kYXRhLWFsaWduLXZlcnRpY2FsLWFzLXRleHQudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLGlCQUFpQixFQUFFLE1BQU0sVUFBVSxDQUFDO0FBRTdDOzs7Ozs7OztHQVFHO0FBQ0gsTUFBTSxVQUFVLHVCQUF1QixDQUFDLGlCQUFvQztJQUN4RSxRQUFRLGlCQUFpQixFQUFFO1FBQ3ZCLEtBQUssaUJBQWlCLENBQUMsR0FBRztZQUN0QixPQUFPLEtBQUssQ0FBQztRQUNqQixLQUFLLGlCQUFpQixDQUFDLE1BQU07WUFDekIsT0FBTyxRQUFRLENBQUM7UUFDcEIsS0FBSyxpQkFBaUIsQ0FBQyxNQUFNO1lBQ3pCLE9BQU8sUUFBUSxDQUFDO1FBQ3BCO1lBQ0ksT0FBTyxRQUFRLENBQUM7S0FDdkI7QUFDTCxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgRGF0YUFsaWduVmVydGljYWwgfSBmcm9tIFwiLi4vZW51bXNcIjtcclxuXHJcbi8qKlxyXG4gKiBDb252ZXJ0cyBhIGBEYXRhQWxpZ25WZXJ0aWNhbGAgZW51bSB2YWx1ZSB0byBpdHMgY29ycmVzcG9uZGluZyBDU1MgdmVydGljYWwgYWxpZ25tZW50IHN0cmluZy5cclxuICpcclxuICogQHBhcmFtIGRhdGFBbGlnblZlcnRpY2FsIC0gVGhlIHZlcnRpY2FsIGFsaWdubWVudCBlbnVtIHZhbHVlLlxyXG4gKiBAcmV0dXJucyBUaGUgQ1NTIHZlcnRpY2FsIGFsaWdubWVudCBzdHJpbmcgKCd0b3AnLCAnbWlkZGxlJywgb3IgJ2JvdHRvbScpLlxyXG4gKlxyXG4gKiBAcmVtYXJrc1xyXG4gKiBJZiBhbiB1bmtub3duIHZhbHVlIGlzIHByb3ZpZGVkLCB0aGUgZnVuY3Rpb24gZGVmYXVsdHMgdG8gJ21pZGRsZScuXHJcbiAqL1xyXG5leHBvcnQgZnVuY3Rpb24gZGF0YUFsaWduVmVydGljYWxBc1RleHQoZGF0YUFsaWduVmVydGljYWw6IERhdGFBbGlnblZlcnRpY2FsKTogc3RyaW5nIHtcclxuICAgIHN3aXRjaCAoZGF0YUFsaWduVmVydGljYWwpIHtcclxuICAgICAgICBjYXNlIERhdGFBbGlnblZlcnRpY2FsLlRvcDpcclxuICAgICAgICAgICAgcmV0dXJuICd0b3AnO1xyXG4gICAgICAgIGNhc2UgRGF0YUFsaWduVmVydGljYWwuTWlkZGxlOlxyXG4gICAgICAgICAgICByZXR1cm4gJ21pZGRsZSc7XHJcbiAgICAgICAgY2FzZSBEYXRhQWxpZ25WZXJ0aWNhbC5Cb3R0b206XHJcbiAgICAgICAgICAgIHJldHVybiAnYm90dG9tJztcclxuICAgICAgICBkZWZhdWx0OlxyXG4gICAgICAgICAgICByZXR1cm4gJ21pZGRsZSc7XHJcbiAgICB9XHJcbn0iXX0=

package/esm2020/lib/utils/data-type-as-text.mjs

@@ -0,0 +1,25 @@
+import { DataType } from "../enums";
+/**
+ * Converts a `DataType` enum value to its corresponding string representation.
+ *
+ * @param dataType - The data type enum value.
+ * @returns The string representation of the data type ('text', 'numeric', 'boolean', or 'date').
+ *
+ * @remarks
+ * If an unknown value is provided, the function defaults to 'text'.
+ */
+export function dataTypeAsText(dataType) {
+    switch (dataType) {
+        case DataType.Text:
+            return 'text';
+        case DataType.Numeric:
+            return 'numeric';
+        case DataType.Boolean:
+            return 'boolean';
+        case DataType.Date:
+            return 'date';
+        default:
+            return 'text';
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGF0YS10eXBlLWFzLXRleHQuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9lY3MtcHJpbWVuZy10YWJsZS9zcmMvbGliL3V0aWxzL2RhdGEtdHlwZS1hcy10ZXh0LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxRQUFRLEVBQUUsTUFBTSxVQUFVLENBQUM7QUFFcEM7Ozs7Ozs7O0dBUUc7QUFDSCxNQUFNLFVBQVUsY0FBYyxDQUFDLFFBQWtCO0lBQzdDLFFBQVEsUUFBUSxFQUFFO1FBQ2QsS0FBSyxRQUFRLENBQUMsSUFBSTtZQUNkLE9BQU8sTUFBTSxDQUFDO1FBQ2xCLEtBQUssUUFBUSxDQUFDLE9BQU87WUFDakIsT0FBTyxTQUFTLENBQUM7UUFDckIsS0FBSyxRQUFRLENBQUMsT0FBTztZQUNqQixPQUFPLFNBQVMsQ0FBQztRQUNyQixLQUFLLFFBQVEsQ0FBQyxJQUFJO1lBQ2QsT0FBTyxNQUFNLENBQUM7UUFDbEI7WUFDSSxPQUFPLE1BQU0sQ0FBQztLQUNyQjtBQUNMLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBEYXRhVHlwZSB9IGZyb20gXCIuLi9lbnVtc1wiO1xyXG5cclxuLyoqXHJcbiAqIENvbnZlcnRzIGEgYERhdGFUeXBlYCBlbnVtIHZhbHVlIHRvIGl0cyBjb3JyZXNwb25kaW5nIHN0cmluZyByZXByZXNlbnRhdGlvbi5cclxuICpcclxuICogQHBhcmFtIGRhdGFUeXBlIC0gVGhlIGRhdGEgdHlwZSBlbnVtIHZhbHVlLlxyXG4gKiBAcmV0dXJucyBUaGUgc3RyaW5nIHJlcHJlc2VudGF0aW9uIG9mIHRoZSBkYXRhIHR5cGUgKCd0ZXh0JywgJ251bWVyaWMnLCAnYm9vbGVhbicsIG9yICdkYXRlJykuXHJcbiAqXHJcbiAqIEByZW1hcmtzXHJcbiAqIElmIGFuIHVua25vd24gdmFsdWUgaXMgcHJvdmlkZWQsIHRoZSBmdW5jdGlvbiBkZWZhdWx0cyB0byAndGV4dCcuXHJcbiAqL1xyXG5leHBvcnQgZnVuY3Rpb24gZGF0YVR5cGVBc1RleHQoZGF0YVR5cGU6IERhdGFUeXBlKTogc3RyaW5nIHtcclxuICAgIHN3aXRjaCAoZGF0YVR5cGUpIHtcclxuICAgICAgICBjYXNlIERhdGFUeXBlLlRleHQ6XHJcbiAgICAgICAgICAgIHJldHVybiAndGV4dCc7XHJcbiAgICAgICAgY2FzZSBEYXRhVHlwZS5OdW1lcmljOlxyXG4gICAgICAgICAgICByZXR1cm4gJ251bWVyaWMnO1xyXG4gICAgICAgIGNhc2UgRGF0YVR5cGUuQm9vbGVhbjpcclxuICAgICAgICAgICAgcmV0dXJuICdib29sZWFuJztcclxuICAgICAgICBjYXNlIERhdGFUeXBlLkRhdGU6XHJcbiAgICAgICAgICAgIHJldHVybiAnZGF0ZSc7XHJcbiAgICAgICAgZGVmYXVsdDpcclxuICAgICAgICAgICAgcmV0dXJuICd0ZXh0JztcclxuICAgIH1cclxufSJdfQ==

package/esm2020/lib/utils/frozen-column-align-as-text.mjs

@@ -0,0 +1,21 @@
+import { FrozenColumnAlign } from "../enums";
+/**
+ * Converts a `FrozenColumnAlign` enum value to its corresponding CSS alignment string.
+ *
+ * @param frozenColumnAlign - The frozen column alignment enum value.
+ * @returns The CSS alignment string ('left' or 'right').
+ *
+ * @remarks
+ * If an unknown value is provided, the function defaults to 'left'.
+ */
+export function frozenColumnAlignAsText(frozenColumnAlign) {
+    switch (frozenColumnAlign) {
+        case FrozenColumnAlign.Left:
+            return 'left';
+        case FrozenColumnAlign.Right:
+            return 'right';
+        default:
+            return 'left';
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZnJvemVuLWNvbHVtbi1hbGlnbi1hcy10ZXh0LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvZWNzLXByaW1lbmctdGFibGUvc3JjL2xpYi91dGlscy9mcm96ZW4tY29sdW1uLWFsaWduLWFzLXRleHQudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLGlCQUFpQixFQUFFLE1BQU0sVUFBVSxDQUFDO0FBRTdDOzs7Ozs7OztHQVFHO0FBQ0gsTUFBTSxVQUFVLHVCQUF1QixDQUFDLGlCQUFvQztJQUMxRSxRQUFRLGlCQUFpQixFQUFFO1FBQ3pCLEtBQUssaUJBQWlCLENBQUMsSUFBSTtZQUN6QixPQUFPLE1BQU0sQ0FBQztRQUNoQixLQUFLLGlCQUFpQixDQUFDLEtBQUs7WUFDMUIsT0FBTyxPQUFPLENBQUM7UUFDakI7WUFDRSxPQUFPLE1BQU0sQ0FBQztLQUNqQjtBQUNILENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBGcm96ZW5Db2x1bW5BbGlnbiB9IGZyb20gXCIuLi9lbnVtc1wiO1xyXG5cclxuLyoqXHJcbiAqIENvbnZlcnRzIGEgYEZyb3plbkNvbHVtbkFsaWduYCBlbnVtIHZhbHVlIHRvIGl0cyBjb3JyZXNwb25kaW5nIENTUyBhbGlnbm1lbnQgc3RyaW5nLlxyXG4gKlxyXG4gKiBAcGFyYW0gZnJvemVuQ29sdW1uQWxpZ24gLSBUaGUgZnJvemVuIGNvbHVtbiBhbGlnbm1lbnQgZW51bSB2YWx1ZS5cclxuICogQHJldHVybnMgVGhlIENTUyBhbGlnbm1lbnQgc3RyaW5nICgnbGVmdCcgb3IgJ3JpZ2h0JykuXHJcbiAqXHJcbiAqIEByZW1hcmtzXHJcbiAqIElmIGFuIHVua25vd24gdmFsdWUgaXMgcHJvdmlkZWQsIHRoZSBmdW5jdGlvbiBkZWZhdWx0cyB0byAnbGVmdCcuXHJcbiAqL1xyXG5leHBvcnQgZnVuY3Rpb24gZnJvemVuQ29sdW1uQWxpZ25Bc1RleHQoZnJvemVuQ29sdW1uQWxpZ246IEZyb3plbkNvbHVtbkFsaWduKTogc3RyaW5nIHtcclxuICBzd2l0Y2ggKGZyb3plbkNvbHVtbkFsaWduKSB7XHJcbiAgICBjYXNlIEZyb3plbkNvbHVtbkFsaWduLkxlZnQ6XHJcbiAgICAgIHJldHVybiAnbGVmdCc7XHJcbiAgICBjYXNlIEZyb3plbkNvbHVtbkFsaWduLlJpZ2h0OlxyXG4gICAgICByZXR1cm4gJ3JpZ2h0JztcclxuICAgIGRlZmF1bHQ6XHJcbiAgICAgIHJldHVybiAnbGVmdCc7XHJcbiAgfVxyXG59Il19

package/esm2020/lib/utils/highlight-text.mjs

@@ -0,0 +1,36 @@
+import { DataType } from "../enums";
+/**
+ * Generates sanitized HTML (`SafeHtml`) with highlighted text based on a global search term.
+ *
+ * @remarks
+ * This utility safely creates HTML content where occurrences of the provided global search text
+ * within the cell value are wrapped in a `<span class="highlighted-text">` tag for visual emphasis.
+ * If the cell does not match the search text or is of type `Boolean`, the original value is returned as safe HTML.
+ *
+ * @param {any} cellValue - The cell's value that may contain the text to highlight.
+ * @param {IColumnMetadata} colMetadata - Metadata configuration of the column that defines its data type and filtering behavior.
+ * @param {string | null} globalSearchText - The search text to highlight if found within the cell's content.
+ * @param {DomSanitizer} sanitizer - Angular's sanitizer used to safely produce trusted HTML content.
+ * @returns {SafeHtml} A `SafeHtml` instance containing highlighted HTML when a match is found, or the original sanitized text otherwise.
+ */
+export function highlightText(cellValue, colMetadata, globalSearchText, sanitizer) {
+    if (colMetadata.dataType !== DataType.Boolean && globalSearchText !== null) { // Check if the column data type is not boolean and global search text is not null
+        const valueToUse = String(cellValue); // Convert cell value to string
+        if (colMetadata.canBeGlobalFiltered) { // Check if the column can be globally filtered
+            const searchLowerCase = globalSearchText.toUpperCase(); // Convert global search text to uppercase for case-insensitive comparison
+            const cellValueLowerCase = valueToUse.toUpperCase(); // Convert cell value to uppercase for case-insensitive comparison
+            if (cellValueLowerCase.includes(searchLowerCase)) { // Check if the cell value contains the search text
+                // Determine the start and end indices of the search text within the cell value
+                const startIndex = cellValueLowerCase.indexOf(searchLowerCase);
+                const endIndex = startIndex + globalSearchText.length;
+                // Extract the prefix, highlight, and suffix of the cell value
+                const prefix = valueToUse.substring(0, startIndex);
+                const highlight = valueToUse.substring(startIndex, endIndex);
+                const suffix = valueToUse.substring(endIndex);
+                return sanitizer.bypassSecurityTrustHtml(`${prefix}<span class="highlighted-text">${highlight}</span>${suffix}`); // Construct SafeHtml with highlighted text using the <mark> element
+            }
+        }
+    }
+    return sanitizer.bypassSecurityTrustHtml(String(cellValue)); // Return the original cell value if it doesn't meet the highlighting conditions
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/utils/index.mjs

@@ -0,0 +1,7 @@
+export * from "./create-table-options";
+export * from "./data-align-horizontal-as-text";
+export * from "./data-align-vertical-as-text";
+export * from "./data-type-as-text";
+export * from "./frozen-column-align-as-text";
+export * from "./highlight-text";
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9lY3MtcHJpbWVuZy10YWJsZS9zcmMvbGliL3V0aWxzL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMsd0JBQXdCLENBQUM7QUFDdkMsY0FBYyxpQ0FBaUMsQ0FBQztBQUNoRCxjQUFjLCtCQUErQixDQUFDO0FBQzlDLGNBQWMscUJBQXFCLENBQUM7QUFDcEMsY0FBYywrQkFBK0IsQ0FBQztBQUM5QyxjQUFjLGtCQUFrQixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSBcIi4vY3JlYXRlLXRhYmxlLW9wdGlvbnNcIjtcclxuZXhwb3J0ICogZnJvbSBcIi4vZGF0YS1hbGlnbi1ob3Jpem9udGFsLWFzLXRleHRcIjtcclxuZXhwb3J0ICogZnJvbSBcIi4vZGF0YS1hbGlnbi12ZXJ0aWNhbC1hcy10ZXh0XCI7XHJcbmV4cG9ydCAqIGZyb20gXCIuL2RhdGEtdHlwZS1hcy10ZXh0XCI7XHJcbmV4cG9ydCAqIGZyb20gXCIuL2Zyb3plbi1jb2x1bW4tYWxpZ24tYXMtdGV4dFwiO1xyXG5leHBvcnQgKiBmcm9tIFwiLi9oaWdobGlnaHQtdGV4dFwiOyJdfQ==

package/esm2020/lib/utils/tree-table-state.mjs

@@ -0,0 +1,239 @@
+export class TreeTableState {
+    constructor(options) {
+        this.options = options;
+        this.expanded = new Set();
+        this.nodes = new Map();
+        this.children = new Map();
+        this.totals = new Map();
+        this.pages = new Map();
+        this.entries = new WeakMap();
+        this.roots = [];
+        this.allRoots = [];
+        this.version = 0;
+        this.pending = new Set();
+        this.restoredPages = {};
+        this.visible = [];
+        this.loading = false;
+        this.page = 0;
+        this.pageSize = 10;
+        this.totalRecords = 0;
+        this.totalRecordsNotFiltered = 0;
+        if (!options.keyExpr?.trim() || !options.parentIdExpr?.trim() || !options.column?.trim()) {
+            throw new Error('Tree configuration requires keyExpr, parentIdExpr and column.');
+        }
+        if (!['all', 'onDemand', 'pagedChildren'].includes(this.mode)) {
+            throw new Error('Invalid tree loadMode.');
+        }
+        if (this.mode !== 'all' && !options.hasItemsExpr?.trim()) {
+            throw new Error('Remote tree loading requires hasItemsExpr.');
+        }
+    }
+    get mode() { return this.options.loadMode ?? 'onDemand'; }
+    get rootValue() { return this.options.rootValue === undefined ? 0 : this.options.rootValue; }
+    key(row) {
+        const key = row[this.options.keyExpr];
+        if ((typeof key !== 'string' && typeof key !== 'number') || key === '' ||
+            (typeof key === 'number' && !Number.isFinite(key))) {
+            throw new Error('Tree keys must be non-empty strings or finite numbers.');
+        }
+        return key;
+    }
+    restore(keys = [], pages = {}) {
+        this.expanded.clear();
+        keys.forEach(key => this.expanded.add(key));
+        this.restoredPages = { ...pages };
+    }
+    snapshotPages() {
+        return Object.fromEntries([...this.pages].map(([key, page]) => [JSON.stringify(key), page]));
+    }
+    depth(row) { return this.entries.get(row)?.depth ?? 0; }
+    isMore(row) { return !!this.entries.get(row)?.more; }
+    moreParent(row) { return this.entries.get(row)?.parent; }
+    isExpanded(row) { return this.expanded.has(this.key(row)); }
+    isLoading(row) { return this.pending.has(this.key(row)); }
+    hasChildren(row) {
+        if (this.mode === 'all')
+            return !!this.children.get(this.key(row))?.length;
+        return row[this.options.hasItemsExpr] === true;
+    }
+    cancel() { this.version++; this.loading = false; this.pending.clear(); }
+    async load(page, pageSize, fetch) {
+        const version = ++this.version;
+        this.loading = true;
+        this.pending.clear();
+        this.nodes.clear();
+        this.children.clear();
+        this.totals.clear();
+        this.pages.clear();
+        this.visible = [];
+        this.page = page;
+        this.pageSize = pageSize;
+        try {
+            const response = await fetch({ roots: true, parentId: this.rootValue, loadMode: this.mode, page, pageSize });
+            if (version !== this.version)
+                return false;
+            this.insert(response.data);
+            this.page = response.page;
+            this.totalRecords = response.totalRecords;
+            this.totalRecordsNotFiltered = response.totalRecordsNotFiltered;
+            if (this.mode === 'all') {
+                this.buildAll();
+                this.page = Math.min(Math.max(0, page), Math.max(0, Math.ceil(this.allRoots.length / pageSize) - 1));
+                this.roots = this.allRoots.slice(this.page * pageSize, (this.page + 1) * pageSize);
+            }
+            else {
+                this.roots = response.data.map(row => this.key(row));
+            }
+            response.ancestorKeys?.forEach(key => this.expanded.add(key));
+            const queue = [...this.roots];
+            for (let cursor = 0; cursor < queue.length; cursor++) {
+                const key = queue[cursor];
+                const row = this.nodes.get(key);
+                if (!this.expanded.has(key) || !this.hasChildren(row))
+                    continue;
+                if (this.mode !== 'all') {
+                    await this.fetchChildren(key, 0, fetch, version);
+                    const targetPage = this.restoredPages[JSON.stringify(key)] ?? 0;
+                    while (version === this.version && this.mode === 'pagedChildren' &&
+                        (this.pages.get(key) ?? 0) < targetPage && this.hasMore(key)) {
+                        await this.fetchChildren(key, (this.pages.get(key) ?? 0) + 1, fetch, version);
+                    }
+                }
+                if (version !== this.version)
+                    return false;
+                queue.push(...(this.children.get(key) ?? []));
+            }
+            this.restoredPages = {};
+            this.rebuild();
+            return true;
+        }
+        finally {
+            if (version === this.version)
+                this.loading = false;
+        }
+    }
+    async toggle(row, fetch) {
+        const key = this.key(row);
+        if (this.pending.has(key))
+            return;
+        if (this.expanded.delete(key)) {
+            this.rebuild();
+            return;
+        }
+        this.expanded.add(key);
+        const version = this.version;
+        try {
+            const queue = [key];
+            for (let cursor = 0; cursor < queue.length; cursor++) {
+                const current = queue[cursor];
+                if (this.mode !== 'all' && !this.children.has(current))
+                    await this.fetchChildren(current, 0, fetch, version);
+                if (version !== this.version)
+                    return;
+                for (const child of this.children.get(current) ?? []) {
+                    if (this.expanded.has(child) && this.hasChildren(this.nodes.get(child)))
+                        queue.push(child);
+                }
+            }
+            this.rebuild();
+        }
+        catch (error) {
+            if (version === this.version)
+                this.expanded.delete(key);
+            throw error;
+        }
+    }
+    async loadMore(row, fetch) {
+        const parent = this.moreParent(row);
+        if (parent === undefined || this.pending.has(parent))
+            return;
+        const version = this.version;
+        await this.fetchChildren(parent, (this.pages.get(parent) ?? 0) + 1, fetch, version);
+        if (version === this.version)
+            this.rebuild();
+    }
+    insert(rows) {
+        const keys = new Set();
+        for (const row of rows) {
+            const key = this.key(row);
+            if (keys.has(key) || this.nodes.has(key))
+                throw new Error('Duplicate tree key.');
+            keys.add(key);
+        }
+        for (const row of rows)
+            this.nodes.set(this.key(row), row);
+    }
+    buildAll() {
+        this.allRoots = [];
+        for (const [key, row] of this.nodes) {
+            const parent = row[this.options.parentIdExpr];
+            if (parent === this.rootValue)
+                this.allRoots.push(key);
+            else {
+                if (!this.nodes.has(parent))
+                    throw new Error('Missing tree parent.');
+                const siblings = this.children.get(parent) ?? [];
+                siblings.push(key);
+                this.children.set(parent, siblings);
+            }
+        }
+        const seen = new Set();
+        const queue = [...this.allRoots];
+        for (let cursor = 0; cursor < queue.length; cursor++) {
+            const key = queue[cursor];
+            if (seen.has(key))
+                throw new Error('Tree cycle.');
+            seen.add(key);
+            queue.push(...(this.children.get(key) ?? []));
+        }
+        if (seen.size !== this.nodes.size)
+            throw new Error('Tree cycle.');
+    }
+    async fetchChildren(key, page, fetch, version) {
+        this.pending.add(key);
+        try {
+            const response = await fetch({ roots: false, parentId: key, loadMode: this.mode, page, pageSize: this.pageSize });
+            if (version !== this.version)
+                return;
+            for (const row of response.data) {
+                if (row[this.options.parentIdExpr] !== key)
+                    throw new Error('Unexpected tree parent.');
+            }
+            this.insert(response.data);
+            this.children.set(key, [...(this.children.get(key) ?? []), ...response.data.map(row => this.key(row))]);
+            this.totals.set(key, response.totalRecords);
+            this.pages.set(key, response.page);
+            response.ancestorKeys?.forEach(ancestor => this.expanded.add(ancestor));
+        }
+        finally {
+            if (version === this.version)
+                this.pending.delete(key);
+        }
+    }
+    hasMore(key) {
+        return (this.children.get(key)?.length ?? 0) < (this.totals.get(key) ?? 0);
+    }
+    rebuild() {
+        this.entries = new WeakMap();
+        const result = [];
+        const stack = this.roots.map(key => ({ row: this.nodes.get(key), depth: 0 })).reverse();
+        while (stack.length) {
+            const entry = stack.pop();
+            this.entries.set(entry.row, entry);
+            result.push(entry.row);
+            if (entry.more)
+                continue;
+            const key = this.key(entry.row);
+            if (!this.expanded.has(key))
+                continue;
+            if (this.hasMore(key))
+                stack.push({ row: {}, depth: entry.depth + 1, parent: key, more: true });
+            const children = this.children.get(key) ?? [];
+            for (let index = children.length - 1; index >= 0; index--) {
+                stack.push({ row: this.nodes.get(children[index]), depth: entry.depth + 1, parent: key });
+            }
+        }
+        this.visible = result;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"tree-table-state.js","sourceRoot":"","sources":["../../../../../projects/ecs-primeng-table/src/lib/utils/tree-table-state.ts"],"names":[],"mappings":"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","sourcesContent":["export type TreeKey = string | number;\r\nexport type TreeRow = Record<string, unknown>;\r\nexport type TreeLoadMode = 'all' | 'onDemand' | 'pagedChildren';\r\n\r\nexport interface ITreeTableOptions {\r\n  keyExpr: string;\r\n  parentIdExpr: string;\r\n  rootValue?: TreeKey | null;\r\n  hasItemsExpr?: string;\r\n  column: string;\r\n  loadMode?: TreeLoadMode;\r\n}\r\n\r\nexport interface ITreeResponse {\r\n  data: TreeRow[];\r\n  page: number;\r\n  totalRecords: number;\r\n  totalRecordsNotFiltered: number;\r\n  ancestorKeys?: TreeKey[];\r\n}\r\n\r\nexport interface ITreeRequest {\r\n  roots: boolean;\r\n  parentId: TreeKey | null;\r\n  loadMode: TreeLoadMode;\r\n  page: number;\r\n  pageSize: number;\r\n}\r\n\r\ninterface TreeEntry {\r\n  row: TreeRow;\r\n  depth: number;\r\n  parent?: TreeKey;\r\n  more?: boolean;\r\n}\r\n\r\nexport class TreeTableState {\r\n  readonly expanded = new Set<TreeKey>();\r\n  private readonly nodes = new Map<TreeKey, TreeRow>();\r\n  private readonly children = new Map<TreeKey, TreeKey[]>();\r\n  private readonly totals = new Map<TreeKey, number>();\r\n  private readonly pages = new Map<TreeKey, number>();\r\n  private entries = new WeakMap<TreeRow, TreeEntry>();\r\n  private roots: TreeKey[] = [];\r\n  private allRoots: TreeKey[] = [];\r\n  private version = 0;\r\n  private readonly pending = new Set<TreeKey>();\r\n  private restoredPages: Record<string, number> = {};\r\n  visible: TreeRow[] = [];\r\n  loading = false;\r\n  page = 0;\r\n  pageSize = 10;\r\n  totalRecords = 0;\r\n  totalRecordsNotFiltered = 0;\r\n\r\n  constructor(readonly options: ITreeTableOptions) {\r\n    if (!options.keyExpr?.trim() || !options.parentIdExpr?.trim() || !options.column?.trim()) {\r\n      throw new Error('Tree configuration requires keyExpr, parentIdExpr and column.');\r\n    }\r\n    if (!['all', 'onDemand', 'pagedChildren'].includes(this.mode)) {\r\n      throw new Error('Invalid tree loadMode.');\r\n    }\r\n    if (this.mode !== 'all' && !options.hasItemsExpr?.trim()) {\r\n      throw new Error('Remote tree loading requires hasItemsExpr.');\r\n    }\r\n  }\r\n\r\n  get mode(): TreeLoadMode { return this.options.loadMode ?? 'onDemand'; }\r\n  get rootValue(): TreeKey | null { return this.options.rootValue === undefined ? 0 : this.options.rootValue; }\r\n\r\n  key(row: TreeRow): TreeKey {\r\n    const key = row[this.options.keyExpr];\r\n    if ((typeof key !== 'string' && typeof key !== 'number') || key === '' ||\r\n        (typeof key === 'number' && !Number.isFinite(key))) {\r\n      throw new Error('Tree keys must be non-empty strings or finite numbers.');\r\n    }\r\n    return key;\r\n  }\r\n\r\n  restore(keys: TreeKey[] = [], pages: Record<string, number> = {}): void {\r\n    this.expanded.clear();\r\n    keys.forEach(key => this.expanded.add(key));\r\n    this.restoredPages = { ...pages };\r\n  }\r\n\r\n  snapshotPages(): Record<string, number> {\r\n    return Object.fromEntries([...this.pages].map(([key, page]) => [JSON.stringify(key), page]));\r\n  }\r\n\r\n  depth(row: TreeRow): number { return this.entries.get(row)?.depth ?? 0; }\r\n  isMore(row: TreeRow): boolean { return !!this.entries.get(row)?.more; }\r\n  moreParent(row: TreeRow): TreeKey | undefined { return this.entries.get(row)?.parent; }\r\n  isExpanded(row: TreeRow): boolean { return this.expanded.has(this.key(row)); }\r\n  isLoading(row: TreeRow): boolean { return this.pending.has(this.key(row)); }\r\n  hasChildren(row: TreeRow): boolean {\r\n    if (this.mode === 'all') return !!this.children.get(this.key(row))?.length;\r\n    return row[this.options.hasItemsExpr!] === true;\r\n  }\r\n\r\n  cancel(): void { this.version++; this.loading = false; this.pending.clear(); }\r\n\r\n  async load(page: number, pageSize: number, fetch: (request: ITreeRequest) => Promise<ITreeResponse>): Promise<boolean> {\r\n    const version = ++this.version;\r\n    this.loading = true;\r\n    this.pending.clear();\r\n    this.nodes.clear(); this.children.clear(); this.totals.clear(); this.pages.clear();\r\n    this.visible = [];\r\n    this.page = page; this.pageSize = pageSize;\r\n    try {\r\n      const response = await fetch({ roots: true, parentId: this.rootValue, loadMode: this.mode, page, pageSize });\r\n      if (version !== this.version) return false;\r\n      this.insert(response.data);\r\n      this.page = response.page;\r\n      this.totalRecords = response.totalRecords;\r\n      this.totalRecordsNotFiltered = response.totalRecordsNotFiltered;\r\n      if (this.mode === 'all') {\r\n        this.buildAll();\r\n        this.page = Math.min(Math.max(0, page), Math.max(0, Math.ceil(this.allRoots.length / pageSize) - 1));\r\n        this.roots = this.allRoots.slice(this.page * pageSize, (this.page + 1) * pageSize);\r\n      } else {\r\n        this.roots = response.data.map(row => this.key(row));\r\n      }\r\n      response.ancestorKeys?.forEach(key => this.expanded.add(key));\r\n      const queue = [...this.roots];\r\n      for (let cursor = 0; cursor < queue.length; cursor++) {\r\n        const key = queue[cursor];\r\n        const row = this.nodes.get(key)!;\r\n        if (!this.expanded.has(key) || !this.hasChildren(row)) continue;\r\n        if (this.mode !== 'all') {\r\n          await this.fetchChildren(key, 0, fetch, version);\r\n          const targetPage = this.restoredPages[JSON.stringify(key)] ?? 0;\r\n          while (version === this.version && this.mode === 'pagedChildren' &&\r\n              (this.pages.get(key) ?? 0) < targetPage && this.hasMore(key)) {\r\n            await this.fetchChildren(key, (this.pages.get(key) ?? 0) + 1, fetch, version);\r\n          }\r\n        }\r\n        if (version !== this.version) return false;\r\n        queue.push(...(this.children.get(key) ?? []));\r\n      }\r\n      this.restoredPages = {};\r\n      this.rebuild();\r\n      return true;\r\n    } finally {\r\n      if (version === this.version) this.loading = false;\r\n    }\r\n  }\r\n\r\n  async toggle(row: TreeRow, fetch: (request: ITreeRequest) => Promise<ITreeResponse>): Promise<void> {\r\n    const key = this.key(row);\r\n    if (this.pending.has(key)) return;\r\n    if (this.expanded.delete(key)) { this.rebuild(); return; }\r\n    this.expanded.add(key);\r\n    const version = this.version;\r\n    try {\r\n      const queue = [key];\r\n      for (let cursor = 0; cursor < queue.length; cursor++) {\r\n        const current = queue[cursor];\r\n        if (this.mode !== 'all' && !this.children.has(current)) await this.fetchChildren(current, 0, fetch, version);\r\n        if (version !== this.version) return;\r\n        for (const child of this.children.get(current) ?? []) {\r\n          if (this.expanded.has(child) && this.hasChildren(this.nodes.get(child)!)) queue.push(child);\r\n        }\r\n      }\r\n      this.rebuild();\r\n    } catch (error) {\r\n      if (version === this.version) this.expanded.delete(key);\r\n      throw error;\r\n    }\r\n  }\r\n\r\n  async loadMore(row: TreeRow, fetch: (request: ITreeRequest) => Promise<ITreeResponse>): Promise<void> {\r\n    const parent = this.moreParent(row);\r\n    if (parent === undefined || this.pending.has(parent)) return;\r\n    const version = this.version;\r\n    await this.fetchChildren(parent, (this.pages.get(parent) ?? 0) + 1, fetch, version);\r\n    if (version === this.version) this.rebuild();\r\n  }\r\n\r\n  private insert(rows: TreeRow[]): void {\r\n    const keys = new Set<TreeKey>();\r\n    for (const row of rows) {\r\n      const key = this.key(row);\r\n      if (keys.has(key) || this.nodes.has(key)) throw new Error('Duplicate tree key.');\r\n      keys.add(key);\r\n    }\r\n    for (const row of rows) this.nodes.set(this.key(row), row);\r\n  }\r\n\r\n  private buildAll(): void {\r\n    this.allRoots = [];\r\n    for (const [key, row] of this.nodes) {\r\n      const parent = row[this.options.parentIdExpr];\r\n      if (parent === this.rootValue) this.allRoots.push(key);\r\n      else {\r\n        if (!this.nodes.has(parent as TreeKey)) throw new Error('Missing tree parent.');\r\n        const siblings = this.children.get(parent as TreeKey) ?? [];\r\n        siblings.push(key); this.children.set(parent as TreeKey, siblings);\r\n      }\r\n    }\r\n    const seen = new Set<TreeKey>();\r\n    const queue = [...this.allRoots];\r\n    for (let cursor = 0; cursor < queue.length; cursor++) {\r\n      const key = queue[cursor];\r\n      if (seen.has(key)) throw new Error('Tree cycle.');\r\n      seen.add(key); queue.push(...(this.children.get(key) ?? []));\r\n    }\r\n    if (seen.size !== this.nodes.size) throw new Error('Tree cycle.');\r\n  }\r\n\r\n  private async fetchChildren(key: TreeKey, page: number, fetch: (request: ITreeRequest) => Promise<ITreeResponse>, version: number): Promise<void> {\r\n    this.pending.add(key);\r\n    try {\r\n      const response = await fetch({ roots: false, parentId: key, loadMode: this.mode, page, pageSize: this.pageSize });\r\n      if (version !== this.version) return;\r\n      for (const row of response.data) {\r\n        if (row[this.options.parentIdExpr] !== key) throw new Error('Unexpected tree parent.');\r\n      }\r\n      this.insert(response.data);\r\n      this.children.set(key, [...(this.children.get(key) ?? []), ...response.data.map(row => this.key(row))]);\r\n      this.totals.set(key, response.totalRecords);\r\n      this.pages.set(key, response.page);\r\n      response.ancestorKeys?.forEach(ancestor => this.expanded.add(ancestor));\r\n    } finally {\r\n      if (version === this.version) this.pending.delete(key);\r\n    }\r\n  }\r\n\r\n  private hasMore(key: TreeKey): boolean {\r\n    return (this.children.get(key)?.length ?? 0) < (this.totals.get(key) ?? 0);\r\n  }\r\n\r\n  private rebuild(): void {\r\n    this.entries = new WeakMap();\r\n    const result: TreeRow[] = [];\r\n    const stack: TreeEntry[] = this.roots.map(key => ({ row: this.nodes.get(key)!, depth: 0 })).reverse();\r\n    while (stack.length) {\r\n      const entry = stack.pop()!;\r\n      this.entries.set(entry.row, entry); result.push(entry.row);\r\n      if (entry.more) continue;\r\n      const key = this.key(entry.row);\r\n      if (!this.expanded.has(key)) continue;\r\n      if (this.hasMore(key)) stack.push({ row: {}, depth: entry.depth + 1, parent: key, more: true });\r\n      const children = this.children.get(key) ?? [];\r\n      for (let index = children.length - 1; index >= 0; index--) {\r\n        stack.push({ row: this.nodes.get(children[index])!, depth: entry.depth + 1, parent: key });\r\n      }\r\n    }\r\n    this.visible = result;\r\n  }\r\n}"]}

package/esm2020/public-api.mjs

@@ -0,0 +1,19 @@
+/*
+ * Public API Surface of ecs-primeng-table
+ */
+// ENUMS
+export * from './lib/enums';
+// INTERFACES
+export * from './lib/interfaces/columns-metadata.interface';
+export * from './lib/interfaces/predefined-filter.interface';
+export * from './lib/interfaces/table-button.interface';
+export * from './lib/interfaces/table-options.interface';
+// UTILS
+export * from "./lib/utils/create-table-options";
+export * from './lib/utils/tree-table-state';
+// SERVICES
+export * from './lib/services';
+// COMPONENTS AND DEPENDENCIES
+export * from './lib/components/ecs-primeng-table/ecs-primeng-table';
+export * from './lib/components/ecs-primeng-table/ecs-primeng-table.service';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljLWFwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3Byb2plY3RzL2Vjcy1wcmltZW5nLXRhYmxlL3NyYy9wdWJsaWMtYXBpLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOztHQUVHO0FBQ0gsUUFBUTtBQUNSLGNBQWMsYUFBYSxDQUFDO0FBRTVCLGFBQWE7QUFDYixjQUFjLDZDQUE2QyxDQUFDO0FBQzVELGNBQWMsOENBQThDLENBQUM7QUFDN0QsY0FBYyx5Q0FBeUMsQ0FBQztBQUN4RCxjQUFjLDBDQUEwQyxDQUFDO0FBRXpELFFBQVE7QUFDUixjQUFjLGtDQUFrQyxDQUFDO0FBQ2pELGNBQWMsOEJBQThCLENBQUM7QUFFN0MsV0FBVztBQUNYLGNBQWMsZ0JBQWdCLENBQUM7QUFFL0IsOEJBQThCO0FBQzlCLGNBQWMsc0RBQXNELENBQUM7QUFDckUsY0FBYyw4REFBOEQsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qXHJcbiAqIFB1YmxpYyBBUEkgU3VyZmFjZSBvZiBlY3MtcHJpbWVuZy10YWJsZVxyXG4gKi9cclxuLy8gRU5VTVNcclxuZXhwb3J0ICogZnJvbSAnLi9saWIvZW51bXMnO1xyXG5cclxuLy8gSU5URVJGQUNFU1xyXG5leHBvcnQgKiBmcm9tICcuL2xpYi9pbnRlcmZhY2VzL2NvbHVtbnMtbWV0YWRhdGEuaW50ZXJmYWNlJztcclxuZXhwb3J0ICogZnJvbSAnLi9saWIvaW50ZXJmYWNlcy9wcmVkZWZpbmVkLWZpbHRlci5pbnRlcmZhY2UnO1xyXG5leHBvcnQgKiBmcm9tICcuL2xpYi9pbnRlcmZhY2VzL3RhYmxlLWJ1dHRvbi5pbnRlcmZhY2UnO1xyXG5leHBvcnQgKiBmcm9tICcuL2xpYi9pbnRlcmZhY2VzL3RhYmxlLW9wdGlvbnMuaW50ZXJmYWNlJztcclxuXHJcbi8vIFVUSUxTXHJcbmV4cG9ydCAqIGZyb20gXCIuL2xpYi91dGlscy9jcmVhdGUtdGFibGUtb3B0aW9uc1wiO1xyXG5leHBvcnQgKiBmcm9tICcuL2xpYi91dGlscy90cmVlLXRhYmxlLXN0YXRlJztcclxuXHJcbi8vIFNFUlZJQ0VTXHJcbmV4cG9ydCAqIGZyb20gJy4vbGliL3NlcnZpY2VzJztcclxuXHJcbi8vIENPTVBPTkVOVFMgQU5EIERFUEVOREVOQ0lFU1xyXG5leHBvcnQgKiBmcm9tICcuL2xpYi9jb21wb25lbnRzL2Vjcy1wcmltZW5nLXRhYmxlL2Vjcy1wcmltZW5nLXRhYmxlJztcclxuZXhwb3J0ICogZnJvbSAnLi9saWIvY29tcG9uZW50cy9lY3MtcHJpbWVuZy10YWJsZS9lY3MtcHJpbWVuZy10YWJsZS5zZXJ2aWNlJzsiXX0=