@angular-generic-table/core 5.0.0-rc.2 → 5.0.0-rc.20

package/esm2020/lib/pipes/sort-class.pipe.mjs

@@ -0,0 +1,40 @@
+import { Pipe } from '@angular/core';
+import * as i0 from "@angular/core";
+export class SortClassPipe {
+    transform(sortOrder, key, context = 'class') {
+        const sortIndex = sortOrder
+            ? sortOrder.findIndex((s) => s.key === key)
+            : -1;
+        if (context === 'aria') {
+            if (sortIndex === -1 || !sortOrder) {
+                return null;
+            }
+            else {
+                return `${sortOrder[sortIndex].order}ending`;
+            }
+        }
+        else if (context === 'class') {
+            if (sortIndex === -1 || !sortOrder) {
+                return '';
+            }
+            else {
+                return `gt-sort-${sortOrder[sortIndex].order}`;
+            }
+        }
+        else {
+            return (sortOrder && sortOrder?.length === 1) || sortIndex < 0
+                ? null
+                : sortIndex + 1 + '';
+        }
+    }
+}
+SortClassPipe.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.1.1", ngImport: i0, type: SortClassPipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe });
+SortClassPipe.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "15.1.1", ngImport: i0, type: SortClassPipe, isStandalone: true, name: "sortClass" });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.1.1", ngImport: i0, type: SortClassPipe, decorators: [{
+            type: Pipe,
+            args: [{
+                    name: 'sortClass',
+                    standalone: true,
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/utilities/utilities.mjs

@@ -0,0 +1,186 @@
+export let dashed;
+dashed = (s) => s.replace(/[A-Z]/g, (m) => '-' + m.toLowerCase());
+export let capitalize;
+capitalize = (s) => (s.charAt(0).toUpperCase() + s.slice(1))
+    .replace(/_/g, ' ')
+    .replace(/([A-Z][a-z]+)/g, ' $1')
+    .replace(/([A-Z]{2,})/g, ' $1')
+    .replace(/\s{2,}/g, ' ')
+    .trim();
+export let chunk;
+chunk = (array, chunkSize) => {
+    if (chunkSize < 0) {
+        throw new Error('Invalid chunk size');
+    }
+    if (chunkSize === 0 && !chunkSize) {
+        return [array];
+    }
+    const CHUNK = [];
+    for (let i = 0, len = array.length; i < len; i += chunkSize) {
+        CHUNK.push(array.slice(i, i + chunkSize));
+    }
+    return CHUNK;
+};
+export let search;
+search = (text, caseSensitive, data, config) => {
+    if (config.columns) {
+        const searchColumns = Object.keys(config.columns).filter(
+        // @ts-ignore
+        (key) => config.columns &&
+            !config.columns[key]?.hidden &&
+            config.columns[key]?.search !== false);
+        const FILTERED = [];
+        for (let i = 0; i < data.length; i++) {
+            const row = data[i];
+            const match = Object.entries(row)
+                .filter(([key, value]) => searchColumns.indexOf(key) !== -1)
+                .reduce((acc, [key, value], index) => {
+                const search = config?.columns[key]?.search;
+                // if search is a function...
+                if (typeof search === 'function') {
+                    // ...use search function to return value to search
+                    value = search(row, key, value);
+                }
+                return (acc +
+                    (index === 0 ? '' : ' ? ') +
+                    (caseSensitive ? value + '' : (value + '').toLowerCase()));
+            }, '')
+                .indexOf(caseSensitive ? text : text.toLowerCase()) !== -1;
+            if (match) {
+                FILTERED[FILTERED.length] = row;
+            }
+        }
+        return FILTERED;
+    }
+    else {
+        return data;
+    }
+};
+export let calculate = (data, config) => {
+    const CALCULATIONS = {};
+    const COLUMN_CALCULATIONS = {};
+    let CALCULATED = Object.entries(config.footer?.columns || {})
+        .filter(([columnName, calculations]) => Object.values(calculations || {}).filter((value) => value !== false)
+        .length >= 0)
+        .reduce((acc, [columnName, calculations], index) => {
+        acc[columnName] = Object.entries(calculations || {})
+            .filter(([calculation, value]) => value !== false)
+            .reduce((acc, [calculation, value]) => {
+            if (COLUMN_CALCULATIONS[columnName]) {
+                COLUMN_CALCULATIONS[columnName].push(calculation);
+            }
+            else if (value === true) {
+                COLUMN_CALCULATIONS[columnName] = [calculation];
+            }
+            CALCULATIONS[calculation] = true;
+            if (typeof value === 'function') {
+                value = value(data, columnName);
+            }
+            acc[calculation] = value === true ? 0 : value;
+            return acc;
+        }, {});
+        return acc;
+    }, {});
+    if (Object.keys(CALCULATED).length > 0) {
+        for (let i = 0; i < data.length; i++) {
+            Object.entries(COLUMN_CALCULATIONS).forEach(([column, calculations]) => {
+                if (calculations.indexOf('sum') > -1) {
+                    CALCULATED[column].sum += data[i][column];
+                }
+                if (calculations.indexOf('avg') > -1 &&
+                    calculations.indexOf('sum') === -1) {
+                    if (CALCULATED[column].sum === undefined) {
+                        CALCULATED[column].sum = 0;
+                    }
+                    CALCULATED[column].sum += data[i][column];
+                }
+                if (calculations.indexOf('max') > -1 &&
+                    (!CALCULATED[column].max || +data[i][column] > CALCULATED[column].max)) {
+                    CALCULATED[column].max = +data[i][column];
+                }
+                if (calculations.indexOf('min') > -1 &&
+                    (!CALCULATED[column].min || +data[i][column] < CALCULATED[column].min)) {
+                    CALCULATED[column].min = +data[i][column];
+                }
+            });
+        }
+        Object.entries(COLUMN_CALCULATIONS).forEach(([column, calculations]) => {
+            if (calculations.indexOf('avg') !== -1) {
+                CALCULATED[column].avg = CALCULATED[column]?.sum / data.length;
+                // if sum is not part of calculations config...
+                if (calculations.indexOf('sum') === -1 && CALCULATED[column].sum) {
+                    // ...remove it
+                    delete CALCULATED[column].sum;
+                }
+            }
+            if (calculations.indexOf('count') !== -1) {
+                CALCULATED[column].count = data.length;
+            }
+        });
+    }
+    return {
+        calculated: CALCULATED,
+        calculations: Object.keys(CALCULATIONS).sort((a, b) => (config.footer?.rowOrder?.indexOf(a) || 0) -
+            (config.footer?.rowOrder?.indexOf(b) || 0)),
+        calculatedColumnsCount: Object.keys(CALCULATED).length || 0,
+    };
+};
+/** sortOnMultipleKeys
+ * @description Sort data on multiple keys
+ * @param {GtSortOrder} keys - array with sort config objects to sort on, data will be sorted according to array order
+ * @returns sort function
+ */
+export const sortOnMultipleKeys = (keys) => {
+    const order = keys.map((key) => (key.order === 'desc' ? -1 : 1));
+    return (a, b) => {
+        for (let i = 0; i < keys.length; i++) {
+            const o = keys[i].key;
+            if (a[o] === b[o])
+                return 0;
+            if (a[o] === null)
+                return 1;
+            if (b[o] === null)
+                return -1;
+            if (a[o] > b[o])
+                return order[i];
+            if (a[o] < b[o])
+                return -order[i];
+        }
+        return 0;
+    };
+};
+/** parseSortOrderParams
+ * @description Convert sort order query param to array with sort config objects
+ * @param sortParams - Query param string where each sort config object is separated by comma and order is indicated by + (ascending) or - (descending), e.g. _'name,-age'_
+ * @returns GtSortOrder - Array with sort config objects
+ */
+export const parseSortOrderParams = (sortParams) => {
+    const sortParamsArray = sortParams.split(',');
+    return sortParamsArray.map((sortParam) => {
+        const [key, order] = sortParam.split(':');
+        return {
+            key: key.replace(/^[+-]/, ''),
+            order: order === 'desc' ? 'desc' : 'asc',
+        };
+    });
+};
+/** sortOrderConfigToParam
+ * @description Convert sort config object to string that can be used as query param when sorting is implemented server side
+ * @param sortConfig - Sort config object
+ * @returns string - Query param string where order is indicated by + (ascending) or - (descending), e.g. _'-name'_
+ */
+export const sortOrderConfigToParam = (sortConfig) => {
+    const order = sortConfig.order === 'desc' ? '-' : '+';
+    return `${order}${sortConfig.key}`;
+};
+/** sortOrderToParams
+ * @description Convert sort order array to string that can be used as query param when sorting is implemented server side
+ * @param sortOrder - Array with sort config objects
+ * @returns string - Query param string where each sort config object is separated by comma and order is indicated by + (ascending) or - (descending), e.g. _'name,-age'_
+ */
+export const sortOrderToParams = (sortOrder) => {
+    return sortOrder
+        .map((sortConfig) => sortOrderConfigToParam(sortConfig))
+        .join(',');
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"utilities.js","sourceRoot":"","sources":["../../../../../projects/core/src/lib/utilities/utilities.ts"],"names":[],"mappings":"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","sourcesContent":["import { TableRow } from '../models/table-row.interface';\nimport { TableConfig } from '../models/table-config.interface';\nimport { GtSortConfig, GtSortOrder } from '../models/table-sort.interface';\nimport { GtSortEvent } from '../models/table-events.interface';\nexport let dashed: (s: string) => string;\ndashed = (s: string) => s.replace(/[A-Z]/g, (m) => '-' + m.toLowerCase());\n\nexport let capitalize: (s: string) => string;\ncapitalize = (s) =>\n  (s.charAt(0).toUpperCase() + s.slice(1))\n    .replace(/_/g, ' ')\n    .replace(/([A-Z][a-z]+)/g, ' $1')\n    .replace(/([A-Z]{2,})/g, ' $1')\n    .replace(/\\s{2,}/g, ' ')\n    .trim();\n\nexport let chunk: (\n  array: Array<any>,\n  chunkSize: number\n) => Array<Array<TableRow>>;\nchunk = (array, chunkSize) => {\n  if (chunkSize < 0) {\n    throw new Error('Invalid chunk size');\n  }\n  if (chunkSize === 0 && !chunkSize) {\n    return [array];\n  }\n  const CHUNK = [];\n  for (let i = 0, len = array.length; i < len; i += chunkSize) {\n    CHUNK.push(array.slice(i, i + chunkSize));\n  }\n  return CHUNK;\n};\n\nexport let search: (\n  text: string,\n  caseSensitive: boolean,\n  data: Array<TableRow>,\n  config: TableConfig\n) => TableRow[];\nsearch = (\n  text: string,\n  caseSensitive: boolean,\n  data: Array<TableRow>,\n  config: TableConfig\n) => {\n  if (config.columns) {\n    const searchColumns = Object.keys(config.columns).filter(\n      // @ts-ignore\n      (key) =>\n        config.columns &&\n        !config.columns[key]?.hidden &&\n        config.columns[key]?.search !== false\n    );\n\n    const FILTERED = [];\n    for (let i = 0; i < data.length; i++) {\n      const row = data[i];\n      const match =\n        Object.entries(row)\n          .filter(([key, value]) => searchColumns.indexOf(key) !== -1)\n          .reduce((acc, [key, value], index): string => {\n            const search = config?.columns![key]?.search;\n            // if search is a function...\n            if (typeof search === 'function') {\n              // ...use search function to return value to search\n              value = search(row, key, value);\n            }\n            return (\n              acc +\n              (index === 0 ? '' : ' ? ') +\n              (caseSensitive ? value + '' : (value + '').toLowerCase())\n            );\n          }, '')\n          .indexOf(caseSensitive ? text : text.toLowerCase()) !== -1;\n      if (match) {\n        FILTERED[FILTERED.length] = row;\n      }\n    }\n    return FILTERED;\n  } else {\n    return data;\n  }\n};\n\nexport let calculate = (data: Array<TableRow>, config: TableConfig) => {\n  const CALCULATIONS: { [key: string]: boolean } = {};\n  const COLUMN_CALCULATIONS: { [key: string]: Array<string> } = {};\n  let CALCULATED = Object.entries(config.footer?.columns || {})\n    .filter(\n      ([columnName, calculations]) =>\n        Object.values(calculations || {}).filter((value) => value !== false)\n          .length >= 0\n    )\n    .reduce((acc: any, [columnName, calculations], index) => {\n      acc[columnName] = Object.entries(calculations || {})\n        .filter(([calculation, value]) => value !== false)\n        .reduce((acc: any, [calculation, value]) => {\n          if (COLUMN_CALCULATIONS[columnName]) {\n            COLUMN_CALCULATIONS[columnName].push(calculation);\n          } else if (value === true) {\n            COLUMN_CALCULATIONS[columnName] = [calculation];\n          }\n          CALCULATIONS[calculation] = true;\n          if (typeof value === 'function') {\n            value = value(data, columnName);\n          }\n          acc[calculation] = value === true ? 0 : value;\n          return acc;\n        }, {});\n      return acc;\n    }, {});\n  if (Object.keys(CALCULATED).length > 0) {\n    for (let i = 0; i < data.length; i++) {\n      Object.entries(COLUMN_CALCULATIONS).forEach(([column, calculations]) => {\n        if (calculations.indexOf('sum') > -1) {\n          CALCULATED[column].sum += data[i][column];\n        }\n        if (\n          calculations.indexOf('avg') > -1 &&\n          calculations.indexOf('sum') === -1\n        ) {\n          if (CALCULATED[column].sum === undefined) {\n            CALCULATED[column].sum = 0;\n          }\n          CALCULATED[column].sum += data[i][column];\n        }\n        if (\n          calculations.indexOf('max') > -1 &&\n          (!CALCULATED[column].max || +data[i][column] > CALCULATED[column].max)\n        ) {\n          CALCULATED[column].max = +data[i][column];\n        }\n        if (\n          calculations.indexOf('min') > -1 &&\n          (!CALCULATED[column].min || +data[i][column] < CALCULATED[column].min)\n        ) {\n          CALCULATED[column].min = +data[i][column];\n        }\n      });\n    }\n    Object.entries(COLUMN_CALCULATIONS).forEach(([column, calculations]) => {\n      if (calculations.indexOf('avg') !== -1) {\n        CALCULATED[column].avg = CALCULATED[column]?.sum / data.length;\n        // if sum is not part of calculations config...\n        if (calculations.indexOf('sum') === -1 && CALCULATED[column].sum) {\n          // ...remove it\n          delete CALCULATED[column].sum;\n        }\n      }\n      if (calculations.indexOf('count') !== -1) {\n        CALCULATED[column].count = data.length;\n      }\n    });\n  }\n  return {\n    calculated: CALCULATED,\n    calculations: Object.keys(CALCULATIONS).sort(\n      (a, b) =>\n        (config.footer?.rowOrder?.indexOf(a) || 0) -\n        (config.footer?.rowOrder?.indexOf(b) || 0)\n    ),\n    calculatedColumnsCount: Object.keys(CALCULATED).length || 0,\n  };\n};\n\n/** sortOnMultipleKeys\n * @description Sort data on multiple keys\n * @param {GtSortOrder} keys - array with sort config objects to sort on, data will be sorted according to array order\n * @returns sort function\n */\nexport const sortOnMultipleKeys = (\n  keys: GtSortOrder\n): ((a: TableRow, b: TableRow) => number) => {\n  const order = keys.map((key) => (key.order === 'desc' ? -1 : 1));\n  return (a, b) => {\n    for (let i = 0; i < keys.length; i++) {\n      const o = keys[i].key;\n      if (a[o] === b[o]) return 0;\n      if (a[o] === null) return 1;\n      if (b[o] === null) return -1;\n      if (a[o] > b[o]) return order[i];\n      if (a[o] < b[o]) return -order[i];\n    }\n    return 0;\n  };\n};\n\n/** parseSortOrderParams\n * @description Convert sort order query param to array with sort config objects\n * @param sortParams - Query param string where each sort config object is separated by comma and order is indicated by + (ascending) or - (descending), e.g. _'name,-age'_\n * @returns GtSortOrder - Array with sort config objects\n */\nexport const parseSortOrderParams = (sortParams: string): GtSortOrder => {\n  const sortParamsArray = sortParams.split(',');\n  return sortParamsArray.map((sortParam) => {\n    const [key, order] = sortParam.split(':');\n    return {\n      key: key.replace(/^[+-]/, ''),\n      order: order === 'desc' ? 'desc' : 'asc',\n    };\n  });\n};\n\n/** sortOrderConfigToParam\n * @description Convert sort config object to string that can be used as query param when sorting is implemented server side\n * @param sortConfig - Sort config object\n * @returns string - Query param string where order is indicated by + (ascending) or - (descending), e.g. _'-name'_\n */\nexport const sortOrderConfigToParam = (\n  sortConfig: GtSortEvent | GtSortConfig\n): string => {\n  const order = sortConfig.order === 'desc' ? '-' : '+';\n  return `${order}${sortConfig.key}`;\n};\n\n/** sortOrderToParams\n * @description Convert sort order array to string that can be used as query param when sorting is implemented server side\n * @param sortOrder - Array with sort config objects\n * @returns string - Query param string where each sort config object is separated by comma and order is indicated by + (ascending) or - (descending), e.g. _'name,-age'_\n */\nexport const sortOrderToParams = (sortOrder: GtSortOrder): string => {\n  return sortOrder\n    .map((sortConfig) => sortOrderConfigToParam(sortConfig))\n    .join(',');\n};\n"]}

package/esm2020/public-api.mjs

@@ -0,0 +1,24 @@
+/*
+ * Public API Surface of core
+ */
+export * from './lib/core.service';
+export * from './lib/core.component';
+export * from './lib/core.module';
+export * from './lib/gt-delta/gt-delta.component';
+export * from './lib/pagination/pagination.component';
+export * from './lib/pagination/pagination.module';
+export * from './lib/models/table-config.interface';
+export * from './lib/models/table-column.interface';
+export * from './lib/models/table-info.interface';
+export * from './lib/models/table-row.interface';
+export * from './lib/models/table-sort.interface';
+export * from './lib/models/table-meta.interface';
+export * from './lib/models/table-events.interface';
+export * from './lib/models/gt-pagination';
+export * from './lib/utilities/utilities';
+export * from './lib/pipes/capital-case.pipe';
+export * from './lib/pipes/dash-case.pipe';
+export * from './lib/pipes/dynamic.pipe';
+export * from './lib/pipes/highlight.pipe';
+export * from './lib/pipes/sort-class.pipe';
+//# sourceMappingURL=data:application/json;base64,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