@one-grid-core/angular 0.2.1 → 0.4.0

package/esm2022/lib/helpers/one-column-def.helper.mjs

@@ -50,4 +50,19 @@ export function resolveOneColumDefParams(prop, params) {
 export function resolveOneValueGetterParams(prop, params) {
     return typeof prop === 'function' ? prop(params) : prop;
 }
-//# sourceMappingURL=data:application/json;base64,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
+/**
+ * Run a column's `valueGetter` for one row.
+ *
+ * Was `CellValueGetterPipe`, which existed only to call this resolver from a
+ * service. The pipe added a module declaration and an indirection for a
+ * template use that never existed.
+ */
+export function resolveCellValueGetter(data, node, column, context) {
+    return resolveOneValueGetterParams(column?.valueGetter, {
+        data,
+        rowIndex: node?.rowIndex,
+        node,
+        context,
+    });
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/helpers/one-csv.helper.mjs

@@ -0,0 +1,58 @@
+/**
+ * The columns an export can say anything about: those that read a row —
+ * through a field or a valueGetter. Action columns have neither, and the
+ * row-number column reads state the data does not hold; both are skipped.
+ */
+export function exportableColumns(columns) {
+    return (columns ?? []).filter(column => (column.field && column.field !== '_oneRowNumber') || column.valueGetter);
+}
+/**
+ * Serialize rows to RFC 4180 CSV.
+ *
+ * Each cell goes through the same value pipeline the grid renders with:
+ * `valueGetter` when declared, the field otherwise, then `valueFormatter` —
+ * so the file says what the screen says. Null and undefined export as empty
+ * cells, before the formatter, exactly as the grid leaves them to the
+ * placeholder.
+ */
+export function buildCsv(nodes, columns, context = null, options = {}) {
+    const separator = options.columnSeparator ?? ',';
+    const exportable = exportableColumns(columns);
+    const lines = [];
+    if (options.includeHeaders ?? true) {
+        lines.push(exportable.map(column => escapeCsvCell(column.headerName ?? column.field ?? '', separator)).join(separator));
+    }
+    nodes?.forEach((node, rowIndex) => {
+        const cells = exportable.map(column => {
+            let value = column.valueGetter
+                ? column.valueGetter({ data: node.data, rowIndex, node, context })
+                : node.data?.[column.field];
+            if (value === null || value === undefined)
+                return '';
+            if (column.valueFormatter) {
+                value = column.valueFormatter({
+                    value,
+                    data: node.data,
+                    node,
+                    rowIndex,
+                    field: column.field,
+                    columnDef: column,
+                    context,
+                });
+            }
+            return escapeCsvCell(value, separator);
+        });
+        lines.push(cells.join(separator));
+    });
+    // CRLF is what RFC 4180 asks for, and what spreadsheet apps expect.
+    return lines.join('\r\n');
+}
+/** Quote a cell when it holds the separator, a quote, or a line break. */
+function escapeCsvCell(value, separator) {
+    const text = `${value}`;
+    if (text.includes(separator) || text.includes('"') || text.includes('\n') || text.includes('\r')) {
+        return `"${text.replace(/"/g, '""')}"`;
+    }
+    return text;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/helpers/one-filter.helper.mjs

@@ -47,13 +47,23 @@ export function matchesAdvancedFilters(node, filters) {
         const val = (node.data[filter.field] ?? '').toString().toLowerCase();
         const results = filter.conditions.map(condition => {
             const cmp = (condition.value ?? '').toString().toLowerCase();
+            const cmpTo = (condition.valueTo ?? '').toString().toLowerCase();
             switch (condition.operator) {
                 case 'equals': return val === cmp;
+                case 'notEqual': return val !== cmp;
                 case 'contains': return val.includes(cmp);
+                case 'notContains': return !val.includes(cmp);
                 case 'startsWith': return val.startsWith(cmp);
                 case 'endsWith': return val.endsWith(cmp);
                 case 'greaterThan': return compare(val, cmp) > 0;
+                case 'greaterThanOrEqual': return compare(val, cmp) >= 0;
                 case 'lessThan': return compare(val, cmp) < 0;
+                case 'lessThanOrEqual': return compare(val, cmp) <= 0;
+                case 'inRange': return compare(val, cmp) >= 0 && compare(val, cmpTo) <= 0;
+                // `val` has already been through `?? ''`, so null and undefined land
+                // here as the empty string. 0 stringifies to '0' and does not.
+                case 'blank': return val === '';
+                case 'notBlank': return val !== '';
                 default: return true; // Unknown operator = ignore
             }
         });
@@ -108,4 +118,4 @@ export function matchesQuickFilter(node, quick, fields) {
         return value.toString().toLowerCase().includes(quick);
     });
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"one-filter.helper.js","sourceRoot":"","sources":["../../../../../projects/one-grid/src/lib/helpers/one-filter.helper.ts"],"names":[],"mappings":"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","sourcesContent":["import { OneRowNode } from \"../core/instants/one-row-node.class\";\nimport { OneFilterModel } from \"../core/models/one-filter.model\";\n\n/**\n * Recursively filters a tree and updates each node's UI state.\n *\n * Rules:\n * - A node is visible if it matches the filters or has a matching descendant.\n * - While a filter is active, a node is expanded iff it has a matching\n *   descendant, so the hit is revealed.\n *\n * Overwriting `expanded` is only correct *while filtering*. This runs from\n * `applyFilters`, which every `setRowData` / `updateRowData` calls, so doing it\n * unconditionally force-expanded every parent on each data update: it made\n * `groupDefaultExpanded` inert for tree data and collapsed expanded\n * master-detail rows (they have no children, so `childMatch` is false).\n *\n * @returns True if the current node or any descendant matches.\n */\nexport function filterTreeNode<T = any>(node: OneRowNode<T>, filters: OneFilterModel[] | null, quick: string, fields?: readonly string[]): boolean {\n\n  const filtering = isFilterActive(filters, quick);\n\n  // Check whether the current node matches all active filters.\n  const selfMatch = matchesAdvancedFilters(node, filters) && matchesQuickFilter(node, quick, fields);\n\n  // Recursively determine whether any child matches.\n  const childMatch = node.children?.some(child => filterTreeNode(child, filters, quick, fields)) ?? false;\n\n  // Keep the node visible when it or any descendant matches.\n  node.visible = selfMatch || childMatch;\n\n  if (filtering) {\n\n    // Expand parents to reveal matching descendants.\n    node.expanded = childMatch;\n  }\n\n  return node.visible;\n}\n\n/**\n * Whether anything is actually filtering right now. A model entry with no\n * conditions matches everything, so it does not count as active.\n */\nexport function isFilterActive(filters: OneFilterModel[] | null, quick: string): boolean {\n\n  if (quick) return true;\n\n  return !!filters?.some(filter => filter?.conditions?.length > 0);\n}\n\n/**\n * Apply advanced per-column filters\n */\nexport function matchesAdvancedFilters<T = any>(node: OneRowNode<T>, filters: OneFilterModel[] | null): boolean {\n\n  if (!filters || filters.length === 0) return true;\n\n  return filters.every(filter => {\n\n    const val = (node.data[filter.field as keyof T] ?? '').toString().toLowerCase();\n\n    const results = filter.conditions.map(condition => {\n\n      const cmp = (condition.value ?? '').toString().toLowerCase();\n\n      switch (condition.operator) {\n\n        case 'equals': return val === cmp;\n\n        case 'contains': return val.includes(cmp);\n\n        case 'startsWith': return val.startsWith(cmp);\n\n        case 'endsWith': return val.endsWith(cmp);\n\n        case 'greaterThan': return compare(val, cmp) > 0;\n\n        case 'lessThan': return compare(val, cmp) < 0;\n\n        default: return true; // Unknown operator = ignore\n      }\n    });\n\n    return filter.logicOperator === 'AND' ? results.every(Boolean) : results.some(Boolean);\n  });\n}\n\n/**\n * Order two already-lowercased cell values.\n *\n * Numeric when both sides parse as numbers, lexicographic otherwise. This used\n * to be `+val > +cmp` unconditionally, so anything non-numeric compared NaN\n * against NaN — always false. A date column filtered with `greaterThan` matched\n * nothing at all rather than reporting a problem, and ISO dates happen to sort\n * correctly as strings, which is what the fallback gives them.\n */\nfunction compare(val: string, cmp: string): number {\n\n  const left = Number(val);\n  const right = Number(cmp);\n\n  const numeric = val !== '' && cmp !== '' && !Number.isNaN(left) && !Number.isNaN(right);\n\n  if (numeric) return left === right ? 0 : left < right ? -1 : 1;\n\n  return val === cmp ? 0 : val < cmp ? -1 : 1;\n}\n\n/**\n * Apply the quick filter to one row.\n *\n * Searches the fields the grid actually shows, when it is told what they are.\n * It used to walk `Object.values(node.data)`, which had three consequences, all\n * of them wrong:\n *\n * - a property with no column was searchable, so a user could match rows on\n *   data the grid never displayed;\n * - a nested object stringified to `[object Object]`, so typing `object`\n *   matched every row holding one;\n * - in a tree, `children` did the same, so most parents matched most queries.\n *\n * Non-primitive values are skipped regardless, so the `[object Object]` haystack\n * cannot come back through a declared column either.\n */\nexport function matchesQuickFilter<T = any>(node: OneRowNode<T>, quick: string, fields?: readonly string[]): boolean {\n\n  if (!quick) return true;\n\n  const data = node.data as Record<string, unknown>;\n\n  const values = fields?.length ? fields.map(field => data?.[field]) : Object.values(data ?? {});\n\n  return values.some(value => {\n\n    if (value === null || value === undefined) return false;\n\n    // Objects, arrays and functions have no useful text form. Skipping them is\n    // what keeps `[object Object]` out of the search.\n    if (typeof value === 'object' || typeof value === 'function') return false;\n\n    return value.toString().toLowerCase().includes(quick);\n  });\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"one-filter.helper.js","sourceRoot":"","sources":["../../../../../projects/one-grid/src/lib/helpers/one-filter.helper.ts"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;GAeG;AACH,MAAM,UAAU,cAAc,CAAU,IAAmB,EAAE,OAAgC,EAAE,KAAa,EAAE,MAA0B;IAEtI,MAAM,SAAS,GAAG,cAAc,CAAC,OAAO,EAAE,KAAK,CAAC,CAAC;IAEjD,6DAA6D;IAC7D,MAAM,SAAS,GAAG,sBAAsB,CAAC,IAAI,EAAE,OAAO,CAAC,IAAI,kBAAkB,CAAC,IAAI,EAAE,KAAK,EAAE,MAAM,CAAC,CAAC;IAEnG,mDAAmD;IACnD,MAAM,UAAU,GAAG,IAAI,CAAC,QAAQ,EAAE,IAAI,CAAC,KAAK,CAAC,EAAE,CAAC,cAAc,CAAC,KAAK,EAAE,OAAO,EAAE,KAAK,EAAE,MAAM,CAAC,CAAC,IAAI,KAAK,CAAC;IAExG,2DAA2D;IAC3D,IAAI,CAAC,OAAO,GAAG,SAAS,IAAI,UAAU,CAAC;IAEvC,IAAI,SAAS,EAAE,CAAC;QAEd,iDAAiD;QACjD,IAAI,CAAC,QAAQ,GAAG,UAAU,CAAC;IAC7B,CAAC;IAED,OAAO,IAAI,CAAC,OAAO,CAAC;AACtB,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,cAAc,CAAC,OAAgC,EAAE,KAAa;IAE5E,IAAI,KAAK;QAAE,OAAO,IAAI,CAAC;IAEvB,OAAO,CAAC,CAAC,OAAO,EAAE,IAAI,CAAC,MAAM,CAAC,EAAE,CAAC,MAAM,EAAE,UAAU,EAAE,MAAM,GAAG,CAAC,CAAC,CAAC;AACnE,CAAC;AAED;;GAEG;AACH,MAAM,UAAU,sBAAsB,CAAU,IAAmB,EAAE,OAAgC;IAEnG,IAAI,CAAC,OAAO,IAAI,OAAO,CAAC,MAAM,KAAK,CAAC;QAAE,OAAO,IAAI,CAAC;IAElD,OAAO,OAAO,CAAC,KAAK,CAAC,MAAM,CAAC,EAAE;QAE5B,MAAM,GAAG,GAAG,CAAC,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,KAAgB,CAAC,IAAI,EAAE,CAAC,CAAC,QAAQ,EAAE,CAAC,WAAW,EAAE,CAAC;QAEhF,MAAM,OAAO,GAAG,MAAM,CAAC,UAAU,CAAC,GAAG,CAAC,SAAS,CAAC,EAAE;YAEhD,MAAM,GAAG,GAAG,CAAC,SAAS,CAAC,KAAK,IAAI,EAAE,CAAC,CAAC,QAAQ,EAAE,CAAC,WAAW,EAAE,CAAC;YAC7D,MAAM,KAAK,GAAG,CAAC,SAAS,CAAC,OAAO,IAAI,EAAE,CAAC,CAAC,QAAQ,EAAE,CAAC,WAAW,EAAE,CAAC;YAEjE,QAAQ,SAAS,CAAC,QAAQ,EAAE,CAAC;gBAE3B,KAAK,QAAQ,CAAC,CAAC,OAAO,GAAG,KAAK,GAAG,CAAC;gBAElC,KAAK,UAAU,CAAC,CAAC,OAAO,GAAG,KAAK,GAAG,CAAC;gBAEpC,KAAK,UAAU,CAAC,CAAC,OAAO,GAAG,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC;gBAE1C,KAAK,aAAa,CAAC,CAAC,OAAO,CAAC,GAAG,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC;gBAE9C,KAAK,YAAY,CAAC,CAAC,OAAO,GAAG,CAAC,UAAU,CAAC,GAAG,CAAC,CAAC;gBAE9C,KAAK,UAAU,CAAC,CAAC,OAAO,GAAG,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC;gBAE1C,KAAK,aAAa,CAAC,CAAC,OAAO,OAAO,CAAC,GAAG,EAAE,GAAG,CAAC,GAAG,CAAC,CAAC;gBAEjD,KAAK,oBAAoB,CAAC,CAAC,OAAO,OAAO,CAAC,GAAG,EAAE,GAAG,CAAC,IAAI,CAAC,CAAC;gBAEzD,KAAK,UAAU,CAAC,CAAC,OAAO,OAAO,CAAC,GAAG,EAAE,GAAG,CAAC,GAAG,CAAC,CAAC;gBAE9C,KAAK,iBAAiB,CAAC,CAAC,OAAO,OAAO,CAAC,GAAG,EAAE,GAAG,CAAC,IAAI,CAAC,CAAC;gBAEtD,KAAK,SAAS,CAAC,CAAC,OAAO,OAAO,CAAC,GAAG,EAAE,GAAG,CAAC,IAAI,CAAC,IAAI,OAAO,CAAC,GAAG,EAAE,KAAK,CAAC,IAAI,CAAC,CAAC;gBAE1E,qEAAqE;gBACrE,+DAA+D;gBAC/D,KAAK,OAAO,CAAC,CAAC,OAAO,GAAG,KAAK,EAAE,CAAC;gBAEhC,KAAK,UAAU,CAAC,CAAC,OAAO,GAAG,KAAK,EAAE,CAAC;gBAEnC,OAAO,CAAC,CAAC,OAAO,IAAI,CAAC,CAAC,4BAA4B;YACpD,CAAC;QACH,CAAC,CAAC,CAAC;QAEH,OAAO,MAAM,CAAC,aAAa,KAAK,KAAK,CAAC,CAAC,CAAC,OAAO,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;IACzF,CAAC,CAAC,CAAC;AACL,CAAC;AAED;;;;;;;;GAQG;AACH,SAAS,OAAO,CAAC,GAAW,EAAE,GAAW;IAEvC,MAAM,IAAI,GAAG,MAAM,CAAC,GAAG,CAAC,CAAC;IACzB,MAAM,KAAK,GAAG,MAAM,CAAC,GAAG,CAAC,CAAC;IAE1B,MAAM,OAAO,GAAG,GAAG,KAAK,EAAE,IAAI,GAAG,KAAK,EAAE,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;IAExF,IAAI,OAAO;QAAE,OAAO,IAAI,KAAK,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI,GAAG,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;IAE/D,OAAO,GAAG,KAAK,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,GAAG,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;AAC9C,CAAC;AAED;;;;;;;;;;;;;;;GAeG;AACH,MAAM,UAAU,kBAAkB,CAAU,IAAmB,EAAE,KAAa,EAAE,MAA0B;IAExG,IAAI,CAAC,KAAK;QAAE,OAAO,IAAI,CAAC;IAExB,MAAM,IAAI,GAAG,IAAI,CAAC,IAA+B,CAAC;IAElD,MAAM,MAAM,GAAG,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC,MAAM,CAAC,GAAG,CAAC,KAAK,CAAC,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,MAAM,CAAC,IAAI,IAAI,EAAE,CAAC,CAAC;IAE/F,OAAO,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,EAAE;QAEzB,IAAI,KAAK,KAAK,IAAI,IAAI,KAAK,KAAK,SAAS;YAAE,OAAO,KAAK,CAAC;QAExD,2EAA2E;QAC3E,kDAAkD;QAClD,IAAI,OAAO,KAAK,KAAK,QAAQ,IAAI,OAAO,KAAK,KAAK,UAAU;YAAE,OAAO,KAAK,CAAC;QAE3E,OAAO,KAAK,CAAC,QAAQ,EAAE,CAAC,WAAW,EAAE,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC;IACxD,CAAC,CAAC,CAAC;AACL,CAAC","sourcesContent":["import { OneRowNode } from \"../core/instants/one-row-node.class\";\nimport { OneFilterModel } from \"../core/models/one-filter.model\";\n\n/**\n * Recursively filters a tree and updates each node's UI state.\n *\n * Rules:\n * - A node is visible if it matches the filters or has a matching descendant.\n * - While a filter is active, a node is expanded iff it has a matching\n *   descendant, so the hit is revealed.\n *\n * Overwriting `expanded` is only correct *while filtering*. This runs from\n * `applyFilters`, which every `setRowData` / `updateRowData` calls, so doing it\n * unconditionally force-expanded every parent on each data update: it made\n * `groupDefaultExpanded` inert for tree data and collapsed expanded\n * master-detail rows (they have no children, so `childMatch` is false).\n *\n * @returns True if the current node or any descendant matches.\n */\nexport function filterTreeNode<T = any>(node: OneRowNode<T>, filters: OneFilterModel[] | null, quick: string, fields?: readonly string[]): boolean {\n\n  const filtering = isFilterActive(filters, quick);\n\n  // Check whether the current node matches all active filters.\n  const selfMatch = matchesAdvancedFilters(node, filters) && matchesQuickFilter(node, quick, fields);\n\n  // Recursively determine whether any child matches.\n  const childMatch = node.children?.some(child => filterTreeNode(child, filters, quick, fields)) ?? false;\n\n  // Keep the node visible when it or any descendant matches.\n  node.visible = selfMatch || childMatch;\n\n  if (filtering) {\n\n    // Expand parents to reveal matching descendants.\n    node.expanded = childMatch;\n  }\n\n  return node.visible;\n}\n\n/**\n * Whether anything is actually filtering right now. A model entry with no\n * conditions matches everything, so it does not count as active.\n */\nexport function isFilterActive(filters: OneFilterModel[] | null, quick: string): boolean {\n\n  if (quick) return true;\n\n  return !!filters?.some(filter => filter?.conditions?.length > 0);\n}\n\n/**\n * Apply advanced per-column filters\n */\nexport function matchesAdvancedFilters<T = any>(node: OneRowNode<T>, filters: OneFilterModel[] | null): boolean {\n\n  if (!filters || filters.length === 0) return true;\n\n  return filters.every(filter => {\n\n    const val = (node.data[filter.field as keyof T] ?? '').toString().toLowerCase();\n\n    const results = filter.conditions.map(condition => {\n\n      const cmp = (condition.value ?? '').toString().toLowerCase();\n      const cmpTo = (condition.valueTo ?? '').toString().toLowerCase();\n\n      switch (condition.operator) {\n\n        case 'equals': return val === cmp;\n\n        case 'notEqual': return val !== cmp;\n\n        case 'contains': return val.includes(cmp);\n\n        case 'notContains': return !val.includes(cmp);\n\n        case 'startsWith': return val.startsWith(cmp);\n\n        case 'endsWith': return val.endsWith(cmp);\n\n        case 'greaterThan': return compare(val, cmp) > 0;\n\n        case 'greaterThanOrEqual': return compare(val, cmp) >= 0;\n\n        case 'lessThan': return compare(val, cmp) < 0;\n\n        case 'lessThanOrEqual': return compare(val, cmp) <= 0;\n\n        case 'inRange': return compare(val, cmp) >= 0 && compare(val, cmpTo) <= 0;\n\n        // `val` has already been through `?? ''`, so null and undefined land\n        // here as the empty string. 0 stringifies to '0' and does not.\n        case 'blank': return val === '';\n\n        case 'notBlank': return val !== '';\n\n        default: return true; // Unknown operator = ignore\n      }\n    });\n\n    return filter.logicOperator === 'AND' ? results.every(Boolean) : results.some(Boolean);\n  });\n}\n\n/**\n * Order two already-lowercased cell values.\n *\n * Numeric when both sides parse as numbers, lexicographic otherwise. This used\n * to be `+val > +cmp` unconditionally, so anything non-numeric compared NaN\n * against NaN — always false. A date column filtered with `greaterThan` matched\n * nothing at all rather than reporting a problem, and ISO dates happen to sort\n * correctly as strings, which is what the fallback gives them.\n */\nfunction compare(val: string, cmp: string): number {\n\n  const left = Number(val);\n  const right = Number(cmp);\n\n  const numeric = val !== '' && cmp !== '' && !Number.isNaN(left) && !Number.isNaN(right);\n\n  if (numeric) return left === right ? 0 : left < right ? -1 : 1;\n\n  return val === cmp ? 0 : val < cmp ? -1 : 1;\n}\n\n/**\n * Apply the quick filter to one row.\n *\n * Searches the fields the grid actually shows, when it is told what they are.\n * It used to walk `Object.values(node.data)`, which had three consequences, all\n * of them wrong:\n *\n * - a property with no column was searchable, so a user could match rows on\n *   data the grid never displayed;\n * - a nested object stringified to `[object Object]`, so typing `object`\n *   matched every row holding one;\n * - in a tree, `children` did the same, so most parents matched most queries.\n *\n * Non-primitive values are skipped regardless, so the `[object Object]` haystack\n * cannot come back through a declared column either.\n */\nexport function matchesQuickFilter<T = any>(node: OneRowNode<T>, quick: string, fields?: readonly string[]): boolean {\n\n  if (!quick) return true;\n\n  const data = node.data as Record<string, unknown>;\n\n  const values = fields?.length ? fields.map(field => data?.[field]) : Object.values(data ?? {});\n\n  return values.some(value => {\n\n    if (value === null || value === undefined) return false;\n\n    // Objects, arrays and functions have no useful text form. Skipping them is\n    // what keeps `[object Object]` out of the search.\n    if (typeof value === 'object' || typeof value === 'function') return false;\n\n    return value.toString().toLowerCase().includes(quick);\n  });\n}\n"]}

package/esm2022/lib/helpers/one-row-grouping.helper.mjs

@@ -0,0 +1,103 @@
+/** Marks a synthetic group row, so anything can tell it from real data. */
+export const ONE_GROUP_FLAG = '__oneGroup';
+/** Stable id for a group row: its value path. Survives every rebuild. */
+export const ONE_GROUP_ID_FIELD = '__oneGroupId';
+/** The label the auto group column shows for a group row. */
+export const ONE_GROUP_VALUE_FIELD = '__oneGroupValue';
+/** Where a group row keeps its children, for the tree pipeline to recurse. */
+export const ONE_GROUP_CHILDREN_FIELD = '__oneGroupChildren';
+/** What a group of rows with no value in the grouped field is labelled. */
+export const ONE_GROUP_BLANK_LABEL = '(Blank)';
+/** The `rowGroup` fields of a column set, in definition order. */
+export function rowGroupFields(columns) {
+    return (columns ?? [])
+        .filter(column => column.rowGroup && column.field)
+        .map(column => column.field);
+}
+/** The `aggFunc` columns of a column set. */
+export function aggColumns(columns) {
+    return (columns ?? [])
+        .filter(column => column.aggFunc && column.field)
+        .map(column => ({ field: column.field, aggFunc: column.aggFunc }));
+}
+/**
+ * Fold flat rows into a tree of synthetic group rows, one level per group
+ * field, in first-appearance order. Each group row carries:
+ *
+ * - the marker, id and label fields above;
+ * - its own grouped field's value, so sorting and filtering read it naturally;
+ * - one aggregated value per `aggFunc` column, computed over the group's
+ *   leaves (not its child groups), stored under the column's own field so the
+ *   ordinary cell pipeline renders it.
+ *
+ * Pure: the input rows are referenced, never mutated.
+ */
+export function buildGroupedRows(rows, groupFields, aggregations = []) {
+    if (!groupFields?.length)
+        return [...(rows ?? [])];
+    return groupLevel(rows ?? [], groupFields, 0, aggregations, 'og-group');
+}
+function groupLevel(rows, groupFields, level, aggregations, idPrefix) {
+    const field = groupFields[level];
+    // Insertion-ordered buckets, keyed by the value's string form. The raw
+    // value is kept as well, so the group row exposes the real value under the
+    // grouped field, not its stringification.
+    const buckets = new Map();
+    for (const row of rows) {
+        const value = row?.[field];
+        const key = value === null || value === undefined || value === '' ? ONE_GROUP_BLANK_LABEL : String(value);
+        const bucket = buckets.get(key);
+        if (bucket) {
+            bucket.rows.push(row);
+        }
+        else {
+            buckets.set(key, { value, rows: [row] });
+        }
+    }
+    return [...buckets.entries()].map(([key, bucket]) => {
+        const id = `${idPrefix}:${key}`;
+        const children = level + 1 < groupFields.length
+            ? groupLevel(bucket.rows, groupFields, level + 1, aggregations, id)
+            : bucket.rows;
+        const groupRow = {
+            [ONE_GROUP_FLAG]: true,
+            [ONE_GROUP_ID_FIELD]: id,
+            [ONE_GROUP_VALUE_FIELD]: key,
+            [field]: bucket.value,
+            [ONE_GROUP_CHILDREN_FIELD]: children,
+        };
+        // Aggregates always read the original leaves, so a two-level group's
+        // parent is not averaging averages.
+        for (const aggregation of aggregations) {
+            groupRow[aggregation.field] = aggregate(bucket.rows, aggregation.field, aggregation.aggFunc);
+        }
+        return groupRow;
+    });
+}
+/** Apply one aggregation over a set of leaf rows. */
+export function aggregate(rows, field, aggFunc) {
+    const values = rows
+        .map(row => row?.[field])
+        .filter(value => value !== null && value !== undefined);
+    if (typeof aggFunc === 'function') {
+        return aggFunc({ values, rows: rows, field });
+    }
+    switch (aggFunc) {
+        case 'count': return values.length;
+        case 'first': return values.length ? values[0] : null;
+        case 'last': return values.length ? values[values.length - 1] : null;
+    }
+    // The numeric aggregates ignore what does not parse, so one stray string in
+    // a column does not turn the whole group's total into NaN.
+    const numbers = values.map(Number).filter(Number.isFinite);
+    if (!numbers.length)
+        return null;
+    switch (aggFunc) {
+        case 'sum': return numbers.reduce((total, value) => total + value, 0);
+        case 'min': return Math.min(...numbers);
+        case 'max': return Math.max(...numbers);
+        case 'avg': return numbers.reduce((total, value) => total + value, 0) / numbers.length;
+        default: return null;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"one-row-grouping.helper.js","sourceRoot":"","sources":["../../../../../projects/one-grid/src/lib/helpers/one-row-grouping.helper.ts"],"names":[],"mappings":"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","sourcesContent":["import { OneAggFunc, OneAggFuncParams, OneColumnDef } from \"../core/models/one-column-def-types.model\";\n\n/** Marks a synthetic group row, so anything can tell it from real data. */\nexport const ONE_GROUP_FLAG = '__oneGroup';\n\n/** Stable id for a group row: its value path. Survives every rebuild. */\nexport const ONE_GROUP_ID_FIELD = '__oneGroupId';\n\n/** The label the auto group column shows for a group row. */\nexport const ONE_GROUP_VALUE_FIELD = '__oneGroupValue';\n\n/** Where a group row keeps its children, for the tree pipeline to recurse. */\nexport const ONE_GROUP_CHILDREN_FIELD = '__oneGroupChildren';\n\n/** What a group of rows with no value in the grouped field is labelled. */\nexport const ONE_GROUP_BLANK_LABEL = '(Blank)';\n\n/** One column's aggregation, captured from the column definitions. */\nexport interface OneAggColumn<T = any> {\n  field: string;\n  aggFunc: OneAggFunc<T>;\n}\n\n/** The `rowGroup` fields of a column set, in definition order. */\nexport function rowGroupFields<T>(columns: readonly OneColumnDef<T>[]): string[] {\n\n  return (columns ?? [])\n    .filter(column => column.rowGroup && column.field)\n    .map(column => column.field as string);\n}\n\n/** The `aggFunc` columns of a column set. */\nexport function aggColumns<T>(columns: readonly OneColumnDef<T>[]): OneAggColumn<T>[] {\n\n  return (columns ?? [])\n    .filter(column => column.aggFunc && column.field)\n    .map(column => ({ field: column.field as string, aggFunc: column.aggFunc }));\n}\n\n/**\n * Fold flat rows into a tree of synthetic group rows, one level per group\n * field, in first-appearance order. Each group row carries:\n *\n * - the marker, id and label fields above;\n * - its own grouped field's value, so sorting and filtering read it naturally;\n * - one aggregated value per `aggFunc` column, computed over the group's\n *   leaves (not its child groups), stored under the column's own field so the\n *   ordinary cell pipeline renders it.\n *\n * Pure: the input rows are referenced, never mutated.\n */\nexport function buildGroupedRows<T>(\n  rows: readonly T[],\n  groupFields: readonly string[],\n  aggregations: readonly OneAggColumn<T>[] = [],\n): any[] {\n\n  if (!groupFields?.length) return [...(rows ?? [])];\n\n  return groupLevel(rows ?? [], groupFields, 0, aggregations, 'og-group');\n}\n\nfunction groupLevel<T>(\n  rows: readonly T[],\n  groupFields: readonly string[],\n  level: number,\n  aggregations: readonly OneAggColumn<T>[],\n  idPrefix: string,\n): any[] {\n\n  const field = groupFields[level];\n\n  // Insertion-ordered buckets, keyed by the value's string form. The raw\n  // value is kept as well, so the group row exposes the real value under the\n  // grouped field, not its stringification.\n  const buckets = new Map<string, { value: unknown; rows: T[] }>();\n\n  for (const row of rows) {\n\n    const value = (row as Record<string, unknown>)?.[field];\n    const key = value === null || value === undefined || value === '' ? ONE_GROUP_BLANK_LABEL : String(value);\n\n    const bucket = buckets.get(key);\n\n    if (bucket) {\n\n      bucket.rows.push(row);\n\n    } else {\n\n      buckets.set(key, { value, rows: [row] });\n    }\n  }\n\n  return [...buckets.entries()].map(([key, bucket]) => {\n\n    const id = `${idPrefix}:${key}`;\n\n    const children = level + 1 < groupFields.length\n      ? groupLevel(bucket.rows, groupFields, level + 1, aggregations, id)\n      : bucket.rows;\n\n    const groupRow: Record<string, unknown> = {\n      [ONE_GROUP_FLAG]: true,\n      [ONE_GROUP_ID_FIELD]: id,\n      [ONE_GROUP_VALUE_FIELD]: key,\n      [field]: bucket.value,\n      [ONE_GROUP_CHILDREN_FIELD]: children,\n    };\n\n    // Aggregates always read the original leaves, so a two-level group's\n    // parent is not averaging averages.\n    for (const aggregation of aggregations) {\n\n      groupRow[aggregation.field] = aggregate(bucket.rows, aggregation.field, aggregation.aggFunc);\n    }\n\n    return groupRow;\n  });\n}\n\n/** Apply one aggregation over a set of leaf rows. */\nexport function aggregate<T>(rows: readonly T[], field: string, aggFunc: OneAggFunc<T>): any {\n\n  const values = rows\n    .map(row => (row as Record<string, unknown>)?.[field])\n    .filter(value => value !== null && value !== undefined);\n\n  if (typeof aggFunc === 'function') {\n\n    return aggFunc({ values, rows: rows as T[], field } as OneAggFuncParams<T>);\n  }\n\n  switch (aggFunc) {\n\n    case 'count': return values.length;\n\n    case 'first': return values.length ? values[0] : null;\n\n    case 'last': return values.length ? values[values.length - 1] : null;\n  }\n\n  // The numeric aggregates ignore what does not parse, so one stray string in\n  // a column does not turn the whole group's total into NaN.\n  const numbers = values.map(Number).filter(Number.isFinite);\n\n  if (!numbers.length) return null;\n\n  switch (aggFunc) {\n\n    case 'sum': return numbers.reduce((total, value) => total + value, 0);\n\n    case 'min': return Math.min(...numbers);\n\n    case 'max': return Math.max(...numbers);\n\n    case 'avg': return numbers.reduce((total, value) => total + value, 0) / numbers.length;\n\n    default: return null;\n  }\n}\n"]}

package/esm2022/lib/index.mjs

@@ -1,4 +1,6 @@
 export * from './helpers/one-column-def.helper';
+export * from './helpers/one-csv.helper';
+export * from './helpers/one-row-grouping.helper';
 export * from './helpers/one-validation.helper';
 export * from './core/instants/one-grid-api.class';
 export * from './core/instants/one-row-node.class';
@@ -23,4 +25,4 @@ export * from './components/one-grid/one-grid.component';
 export * from './components/one-grid-status/one-grid-status.component';
 export * from './components/one-grid-cell-currency/one-grid-cell-currency.component';
 export * from './one-grid.module';
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/one-grid.module.mjs

@@ -1,133 +1,43 @@
 import { NgModule } from '@angular/core';
-import { CommonModule } from '@angular/common';
 import { OneGridComponent } from './components/one-grid/one-grid.component';
-import { OneGridHeaderComponent } from './components/one-grid-header/one-grid-header.component';
-import { OneGridBodyComponent } from './components/one-grid-body/one-grid-body.component';
-import { OneGridCheckboxComponent } from './components/one-grid-checkbox/one-grid-checkbox.component';
-import { FormsModule, ReactiveFormsModule } from '@angular/forms';
-import { OneGridRowActionComponent } from './components/one-grid-row-action/one-grid-row-action.component';
-import { OneGridPaginationComponent } from './components/one-grid-pagination/one-grid-pagination.component';
-import { OneGridCheckboxHeaderComponent } from './components/one-grid-checkbox-header/one-grid-checkbox-header.component';
 import { OneGridStatusComponent } from './components/one-grid-status/one-grid-status.component';
-import { CellFieldValueEmptyPipe } from './core/pipes/cell-field-value-empty.pipe';
-import { CellValueGetterPipe } from './core/pipes/cell-value-getter.pipe';
-import { CellFieldValuePipe } from './core/pipes/cell-field-value.pipe';
-import { OneGridCellGroupRendererComponent } from './components/one-grid-cell-group-renderer/one-grid-cell-group-renderer.component';
-import { CellActionButtonVisiblePipe } from './core/pipes/cell-action-button-visible.pipe';
-import { CellEditablePipe } from './core/pipes/cell-editable.pipe';
-import { CellInvalidPipe } from './core/pipes/cell-invalid.pipe';
-import { CellSelectedPipe } from './core/pipes/cell-selected.pipe';
-import { CellActionButtonEnablePipe } from './core/pipes/cell-action-button-enable.pipe';
-import { CellNumberValuePipe } from './core/pipes/cell-number-value.pipe';
-import { CellFieldPipe } from './core/pipes/cell-field.pipe';
-import { CellLevelPaddingPipe } from './core/pipes/cell-level-padding.pipe';
-import { ColumnSortStatePipe } from './core/pipes/column-sort-state.pipe';
-import { HeaderCheckboxDisabledPipe } from './core/pipes/header-checkbox-disabled.pipe';
-import { HeaderCheckboxCheckedPipe } from './core/pipes/header-checkbox-checked.pipe';
-import { HeaderCheckboxIndeterminatePipe } from './core/pipes/header-checkbox-indeterminate.pipe';
-import { CellStateRendererPipe } from './core/pipes/cell-state-renderer.pipe';
-import { CellStateGroupRendererPipe } from './core/pipes/cell-state-group-renderer.pipe';
-import { OneCellInputValidatorDirective } from './core/directives/one-cell-input-validator.directive';
-import { ScrollingModule } from '@angular/cdk/scrolling';
-import { OneCellRendererComponentDirective } from './core/directives/one-cell-renderer-component.directive';
-import { OneCellTextExpandDirective } from './core/directives/one-cell-text-expand.directive';
 import { OneGridCellCurrencyComponent } from './components/one-grid-cell-currency/one-grid-cell-currency.component';
-import { LucideAngularModule, icons } from 'lucide-angular';
-import { OneGridRowDragHandleComponent } from './components/one-grid-row-drag-handle/one-grid-row-drag-handle.component';
-import { CellKeyPipe } from './core/pipes/cell-key.pipe';
-import { OneGridCellOptionMenuComponent } from './components/one-grid-cell-option-menu/one-grid-cell-option-menu.component';
 import * as i0 from "@angular/core";
-import * as i1 from "lucide-angular";
+/**
+ * Compatibility shim.
+ *
+ * Every component, directive and pipe in the library is standalone, so this
+ * module declares nothing — it exists so `imports: [OneGridModule]` keeps
+ * working for anyone already on it. New code can import `OneGridComponent`
+ * directly instead.
+ *
+ * Icons no longer need registering here: each component that draws one
+ * provides the eight the grid uses, so they travel with the component whichever
+ * way it is imported.
+ */
 export class OneGridModule {
     static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: OneGridModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
-    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "17.3.12", ngImport: i0, type: OneGridModule, declarations: [OneGridComponent,
-            OneGridHeaderComponent,
-            OneGridBodyComponent,
-            OneGridCheckboxComponent,
-            OneGridCheckboxHeaderComponent,
-            OneGridRowActionComponent,
-            OneGridPaginationComponent,
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "17.3.12", ngImport: i0, type: OneGridModule, imports: [OneGridComponent,
             OneGridStatusComponent,
-            OneGridCellGroupRendererComponent,
-            CellFieldValueEmptyPipe,
-            CellValueGetterPipe,
-            CellFieldValuePipe,
-            CellActionButtonVisiblePipe,
-            CellEditablePipe,
-            CellInvalidPipe,
-            CellSelectedPipe,
-            CellActionButtonEnablePipe,
-            CellNumberValuePipe,
-            CellFieldPipe,
-            CellKeyPipe,
-            CellLevelPaddingPipe,
-            ColumnSortStatePipe,
-            HeaderCheckboxDisabledPipe,
-            HeaderCheckboxCheckedPipe,
-            HeaderCheckboxIndeterminatePipe,
-            CellStateRendererPipe,
-            CellStateGroupRendererPipe,
-            OneCellInputValidatorDirective,
-            OneCellRendererComponentDirective,
-            OneCellTextExpandDirective,
-            OneGridCellCurrencyComponent,
-            OneGridCellOptionMenuComponent,
-            OneGridRowDragHandleComponent], imports: [CommonModule,
-            FormsModule,
-            ScrollingModule,
-            ReactiveFormsModule, i1.LucideAngularModule], exports: [OneGridComponent] }); }
-    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: OneGridModule, imports: [CommonModule,
-            FormsModule,
-            ScrollingModule,
-            ReactiveFormsModule,
-            LucideAngularModule.pick(icons)] }); }
+            OneGridCellCurrencyComponent], exports: [OneGridComponent,
+            OneGridStatusComponent,
+            OneGridCellCurrencyComponent] }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: OneGridModule, imports: [OneGridComponent,
+            OneGridCellCurrencyComponent] }); }
 }
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: OneGridModule, decorators: [{
             type: NgModule,
             args: [{
-                    declarations: [
+                    imports: [
                         OneGridComponent,
-                        OneGridHeaderComponent,
-                        OneGridBodyComponent,
-                        OneGridCheckboxComponent,
-                        OneGridCheckboxHeaderComponent,
-                        OneGridRowActionComponent,
-                        OneGridPaginationComponent,
                         OneGridStatusComponent,
-                        OneGridCellGroupRendererComponent,
-                        CellFieldValueEmptyPipe,
-                        CellValueGetterPipe,
-                        CellFieldValuePipe,
-                        CellActionButtonVisiblePipe,
-                        CellEditablePipe,
-                        CellInvalidPipe,
-                        CellSelectedPipe,
-                        CellActionButtonEnablePipe,
-                        CellNumberValuePipe,
-                        CellFieldPipe,
-                        CellKeyPipe,
-                        CellLevelPaddingPipe,
-                        ColumnSortStatePipe,
-                        HeaderCheckboxDisabledPipe,
-                        HeaderCheckboxCheckedPipe,
-                        HeaderCheckboxIndeterminatePipe,
-                        CellStateRendererPipe,
-                        CellStateGroupRendererPipe,
-                        OneCellInputValidatorDirective,
-                        OneCellRendererComponentDirective,
-                        OneCellTextExpandDirective,
                         OneGridCellCurrencyComponent,
-                        OneGridCellOptionMenuComponent,
-                        OneGridRowDragHandleComponent
                     ],
-                    imports: [
-                        CommonModule,
-                        FormsModule,
-                        ScrollingModule,
-                        ReactiveFormsModule,
-                        LucideAngularModule.pick(icons),
+                    exports: [
+                        OneGridComponent,
+                        OneGridStatusComponent,
+                        OneGridCellCurrencyComponent,
                     ],
-                    exports: [OneGridComponent]
                 }]
         }] });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"one-grid.module.js","sourceRoot":"","sources":["../../../../projects/one-grid/src/lib/one-grid.module.ts"],"names":[],"mappings":"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","sourcesContent":["import { NgModule } from '@angular/core';\nimport { CommonModule } from '@angular/common';\nimport { OneGridComponent } from './components/one-grid/one-grid.component';\nimport { OneGridHeaderComponent } from './components/one-grid-header/one-grid-header.component';\nimport { OneGridBodyComponent } from './components/one-grid-body/one-grid-body.component';\nimport { OneGridCheckboxComponent } from './components/one-grid-checkbox/one-grid-checkbox.component';\nimport { FormsModule, ReactiveFormsModule } from '@angular/forms';\nimport { OneGridRowActionComponent } from './components/one-grid-row-action/one-grid-row-action.component';\nimport { OneGridPaginationComponent } from './components/one-grid-pagination/one-grid-pagination.component';\nimport { OneGridCheckboxHeaderComponent } from './components/one-grid-checkbox-header/one-grid-checkbox-header.component';\nimport { OneGridStatusComponent } from './components/one-grid-status/one-grid-status.component';\nimport { CellFieldValueEmptyPipe } from './core/pipes/cell-field-value-empty.pipe';\nimport { CellValueGetterPipe } from './core/pipes/cell-value-getter.pipe';\nimport { CellFieldValuePipe } from './core/pipes/cell-field-value.pipe';\nimport { OneGridCellGroupRendererComponent } from './components/one-grid-cell-group-renderer/one-grid-cell-group-renderer.component';\nimport { CellActionButtonVisiblePipe } from './core/pipes/cell-action-button-visible.pipe';\nimport { CellEditablePipe } from './core/pipes/cell-editable.pipe';\nimport { CellInvalidPipe } from './core/pipes/cell-invalid.pipe';\nimport { CellSelectedPipe } from './core/pipes/cell-selected.pipe';\nimport { CellActionButtonEnablePipe } from './core/pipes/cell-action-button-enable.pipe';\nimport { CellNumberValuePipe } from './core/pipes/cell-number-value.pipe';\nimport { CellFieldPipe } from './core/pipes/cell-field.pipe';\nimport { CellLevelPaddingPipe } from './core/pipes/cell-level-padding.pipe';\nimport { ColumnSortStatePipe } from './core/pipes/column-sort-state.pipe';\nimport { HeaderCheckboxDisabledPipe } from './core/pipes/header-checkbox-disabled.pipe';\nimport { HeaderCheckboxCheckedPipe } from './core/pipes/header-checkbox-checked.pipe';\nimport { HeaderCheckboxIndeterminatePipe } from './core/pipes/header-checkbox-indeterminate.pipe';\nimport { CellStateRendererPipe } from './core/pipes/cell-state-renderer.pipe';\nimport { CellStateGroupRendererPipe } from './core/pipes/cell-state-group-renderer.pipe';\nimport { OneCellInputValidatorDirective } from './core/directives/one-cell-input-validator.directive';\nimport { ScrollingModule } from '@angular/cdk/scrolling';\nimport { OneCellRendererComponentDirective } from './core/directives/one-cell-renderer-component.directive';\nimport { OneCellTextExpandDirective } from './core/directives/one-cell-text-expand.directive';\nimport { OneGridCellCurrencyComponent } from './components/one-grid-cell-currency/one-grid-cell-currency.component';\nimport { LucideAngularModule, icons } from 'lucide-angular';\nimport { OneGridRowDragHandleComponent } from './components/one-grid-row-drag-handle/one-grid-row-drag-handle.component';\nimport { CellKeyPipe } from './core/pipes/cell-key.pipe';\nimport { OneGridCellOptionMenuComponent } from './components/one-grid-cell-option-menu/one-grid-cell-option-menu.component';\n\n@NgModule({\n  declarations: [\n    OneGridComponent,\n    OneGridHeaderComponent,\n    OneGridBodyComponent,\n    OneGridCheckboxComponent,\n    OneGridCheckboxHeaderComponent,\n    OneGridRowActionComponent,\n    OneGridPaginationComponent,\n    OneGridStatusComponent,\n    OneGridCellGroupRendererComponent,\n    CellFieldValueEmptyPipe,\n    CellValueGetterPipe,\n    CellFieldValuePipe,\n    CellActionButtonVisiblePipe,\n    CellEditablePipe,\n    CellInvalidPipe,\n    CellSelectedPipe,\n    CellActionButtonEnablePipe,\n    CellNumberValuePipe,\n    CellFieldPipe,\n    CellKeyPipe,\n    CellLevelPaddingPipe,\n    ColumnSortStatePipe,\n    HeaderCheckboxDisabledPipe,\n    HeaderCheckboxCheckedPipe,\n    HeaderCheckboxIndeterminatePipe,\n    CellStateRendererPipe,\n    CellStateGroupRendererPipe,\n    OneCellInputValidatorDirective,\n    OneCellRendererComponentDirective,\n    OneCellTextExpandDirective,\n    OneGridCellCurrencyComponent,\n    OneGridCellOptionMenuComponent,\n    OneGridRowDragHandleComponent\n  ],\n  imports: [\n    CommonModule,\n    FormsModule,\n    ScrollingModule,\n    ReactiveFormsModule,\n    LucideAngularModule.pick(icons),\n  ],\n  exports: [OneGridComponent]\n})\nexport class OneGridModule { }\n"]}
+//# sourceMappingURL=data:application/json;base64,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