yi-bi-ez-table 1.0.0

package/constants.js

@@ -0,0 +1,62 @@
+export const CALCULATED_REGEX = /\{(.+?)\}/g;
+export const SUM_REGEX = /sum\((.+?)\)/g; // sum()匹配
+export const GROUP_SUM_REGEX = /group_sum\((.+?)\)/g; // group_sum()匹配
+export const GET_SIZE_REGEX = /getSize\((.+?)\)/g;
+export const RANK_TYPES = [
+    { label: '全局降序排名', value: 'GLOBAL_RANK_DESC' },
+    { label: '全局升序排名', value: 'GLOBAL_RANK_ASC' },
+    { label: '分组升序排名', value: 'GROUP_RANK_ASC' },
+    { label: '分组降序排名', value: 'GROUP_RANK_DESC' },
+    { label: '自定义排名', value: 'CUSTOM_RANK' },
+];
+// 累加等一次性算好全部的计算度量
+export const ONCE_CALC_LIST = [
+    'GLOBAL_ACC',
+    'GROUP_ACC',
+    'MAX',
+    'MIN',
+    'GROUP_MAX',
+    'GROUP_MIN',
+    'AVG',
+    'AVG_NON_ZERO',
+    'GROUP_AVG',
+    'GROUP_AVG_NON_ZERO',
+    'GLOBAL_RANK_DESC',
+    'GLOBAL_RANK_ASC',
+    'GROUP_RANK_DESC',
+    'GROUP_RANK_ASC',
+    'CUSTOM_RANK',
+];
+// 合计已经算好的计算度量（data.current 中，如data.current['max' | 'avg' | 'sum']）
+export const SUMMARY_ONCE_CALC_ALERADY_LIST = [
+    'GLOBAL_ACC',
+    'GROUP_ACC',
+    'MAX',
+    'MIN',
+    'GROUP_MAX',
+    'GROUP_MIN',
+    'AVG',
+    'AVG_NON_ZERO',
+    'GROUP_AVG',
+    'GROUP_AVG_NON_ZERO',
+];
+// 合计一次性算好全部的计算度量
+// 不包括最大值/平均值等，因为这些在计算合计之前，已经在 data.current 上算好了
+// 不包括累加，因为累加取最大值 data.curren.max 就可以了
+export const SUMMARY_ONCE_CALC_LIST = [
+    'GLOBAL_RANK_DESC',
+    'GLOBAL_RANK_ASC',
+    'GROUP_RANK_DESC',
+    'GROUP_RANK_ASC',
+    'CUSTOM_RANK',
+];
+export const DEFAULT_FORMAT = {
+    // type: 'number',
+    type: 'default',
+    precision: 0,
+    quantityUnit: '个',
+    unitSuffix: '',
+    isThousandth: true,
+    progressColor: 'rgba(0, 0, 0, 0)',
+    hideZero: false,
+};

package/ez-agg-cunc-hander.js

@@ -0,0 +1,186 @@
+import { getCalcRowValue } from "./calc-measure/calc-measure-hander";
+import { recursionForParent } from "./calc-measure/utils";
+import { RANK_TYPES, SUMMARY_ONCE_CALC_ALERADY_LIST, SUMMARY_ONCE_CALC_LIST } from "./constants";
+import { calcCustomAgg } from "./ez-custom-agg-func/ez-custom-agg-func-hander";
+import { getFuncValue } from "./func";
+import { getSameLevelList } from "./utils";
+// export type TAggFunc = 'SUM' | 'MEDIAN' | 'AVG' | 'AVG_NON_ZERO' | 'MAX' | 'MIN' | 'COUNT' | 'DISTINC COUNT' | 'DISTINC_COUNT' | 'CUSTOM';
+// 合计方式
+const EzAggFuncHandler = {
+    'SUM': (params) => {
+        const { data, calcKey, aggRange } = params;
+        if (aggRange && aggRange !== 'GLOBAL') {
+            const list = getSameLevelList(data, aggRange);
+            return getFuncValue({
+                aggKey: 'SUM',
+                dataList: list,
+                header: { key: calcKey }
+            });
+        }
+        return data?.current?.sum[calcKey];
+    },
+    'MEDIAN': (params) => {
+        const { data, calcKey, dataList, aggRange } = params;
+        if (aggRange && aggRange !== 'GLOBAL') {
+            const list = getSameLevelList(data, aggRange);
+            return getFuncValue({
+                aggKey: 'MEDIAN',
+                dataList: list,
+                header: { key: calcKey }
+            });
+        }
+        const arr = [...dataList].sort();
+        const len = arr.length;
+        if (len % 2 === 1) {
+            return arr[(len - 1) / 2].data[calcKey];
+        }
+        return (arr[len / 2].data[calcKey] + arr[len / 2 - 1].data[calcKey]) / 2;
+    },
+    // 最大值
+    'MAX': (params) => {
+        const { calcKey, data, aggRange, dataList } = params;
+        if (aggRange && aggRange !== 'GLOBAL') {
+            const list = getSameLevelList(data, aggRange);
+            return getFuncValue({
+                aggKey: 'MAX',
+                dataList: list,
+                header: { key: calcKey }
+            });
+        }
+        if (!data) {
+            return getFuncValue({
+                aggKey: 'MAX',
+                dataList: dataList,
+                header: { key: calcKey }
+            });
+        }
+        return data?.current?.max[calcKey];
+    },
+    // 最小值
+    'MIN': (params) => {
+        const { calcKey, data, aggRange, dataList } = params;
+        if (aggRange && aggRange !== 'GLOBAL') {
+            const list = getSameLevelList(data, aggRange);
+            return getFuncValue({
+                aggKey: 'MIN',
+                dataList: list,
+                header: { key: calcKey }
+            });
+        }
+        if (!data) {
+            return getFuncValue({
+                aggKey: 'MIN',
+                dataList: dataList,
+                header: { key: calcKey }
+            });
+        }
+        return data?.current?.min[calcKey];
+    },
+    // 平均值
+    'AVG': (params) => {
+        const { calcKey, data, aggRange, dataList } = params;
+        if (aggRange && aggRange !== 'GLOBAL') {
+            const list = getSameLevelList(data, aggRange);
+            return getFuncValue({
+                aggKey: 'AVG',
+                dataList: list,
+                header: { key: calcKey }
+            });
+        }
+        if (!data) {
+            return getFuncValue({
+                aggKey: 'AVG',
+                dataList: dataList,
+                header: { key: calcKey }
+            });
+        }
+        return data?.current?.avg[calcKey];
+    },
+    // 平均值非零
+    'AVG_NON_ZERO': (params) => {
+        const { calcKey, data, aggRange, dataList } = params;
+        if (aggRange && aggRange !== 'GLOBAL') {
+            const list = getSameLevelList(data, aggRange);
+            return getFuncValue({
+                aggKey: 'AVG_NON_ZERO',
+                dataList: list,
+                header: { key: calcKey }
+            });
+        }
+        if (!data) {
+            return getFuncValue({
+                aggKey: 'AVG_NON_ZERO',
+                dataList: dataList,
+                header: { key: calcKey }
+            });
+        }
+        return data?.current?.avg_non_zero[calcKey];
+    },
+    // 计数
+    'COUNT': (params) => {
+        const { data, calcKey, dataList, aggRange } = params;
+        if (aggRange && aggRange !== 'GLOBAL') {
+            const list = getSameLevelList(data, aggRange);
+            return getFuncValue({
+                aggKey: 'COUNT',
+                dataList: list,
+                header: { key: calcKey }
+            });
+        }
+        return dataList.length;
+    },
+    // 非重复计数
+    'DISTINC_COUNT': (params) => {
+        const set = new Set();
+        const { calcKey, dataList } = params;
+        for (const item of dataList) {
+            set.add(item.data[calcKey]);
+        }
+        return set.size;
+    },
+    // 非重复计数（老）
+    'DISTINC COUNT': (params) => {
+        const set = new Set();
+        const { calcKey, dataList } = params;
+        for (const item of dataList) {
+            set.add(item.data[calcKey]);
+        }
+        return set.size;
+    },
+    // 计算值
+    'CUSTOM': (params) => {
+        const { header, header: { key, measureType, calcKeyList }, headerKeysDic, data, calcKey, dataList, tree, } = params;
+        if (SUMMARY_ONCE_CALC_ALERADY_LIST.includes(measureType)) {
+            recursionForParent(tree, data => {
+                // return calcCustomAgg({...params, data});
+                data.data[key] = calcCustomAgg({ ...params, data });
+            });
+            return;
+        }
+        if (SUMMARY_ONCE_CALC_LIST.includes(measureType)) {
+            calcCustomAgg(params);
+            return;
+        }
+        if (RANK_TYPES.some(item => item.value === measureType)) {
+            return;
+        }
+        // 'SUM', 'DIFFERENCE', 'DIVISION', 'RATE', 'RATIO', 'GROUP_RATIO'
+        return getCalcRowValue({
+            header,
+            headerKeysDic,
+            data,
+            dataList,
+        });
+    },
+    // 不显示合计
+    'NOT_SHOW': (params) => {
+        return null;
+    },
+};
+export function calcAgg(params) {
+    const { aggKey } = params;
+    if (EzAggFuncHandler[aggKey]) {
+        return EzAggFuncHandler[aggKey](params);
+    }
+    return 0;
+}

package/ez-custom-agg-func/ez-custom-agg-func-hander.js

@@ -0,0 +1,71 @@
+import { getTopData } from "../calc-measure/utils";
+import { setTotalCustomRank, setTotalGloalRank, setTotalGroupRank } from "./utils";
+// 合计方式：计算值
+const EZCustomAggFuncHandler = {
+    'GLOBAL_ACC': (params) => {
+        const { data, calcKey, } = params;
+        return data.current?.max[calcKey];
+    },
+    'GROUP_ACC': (params) => {
+        const { data, calcKey, } = params;
+        return data.current?.max[calcKey];
+    },
+    'MAX': (params) => {
+        const { header: { calcKeyList }, data, } = params;
+        const topData = getTopData(data);
+        return topData.current?.max[calcKeyList[0]];
+    },
+    'MIN': (params) => {
+        const { header: { calcKeyList }, data, } = params;
+        const topData = getTopData(data);
+        return topData.current?.min[calcKeyList[0]];
+    },
+    'GROUP_MAX': (params) => {
+        const { header: { calcKeyList }, data, } = params;
+        return data.current?.max[calcKeyList[0]];
+    },
+    'GROUP_MIN': (params) => {
+        const { header: { calcKeyList }, data, } = params;
+        return data.current?.min[calcKeyList[0]];
+    },
+    'AVG': (params) => {
+        const { header: { calcKeyList }, data, } = params;
+        const topData = getTopData(data);
+        return topData.current?.avg[calcKeyList[0]];
+    },
+    'AVG_NON_ZERO': (params) => {
+        const { header: { calcKeyList }, data, } = params;
+        const topData = getTopData(data);
+        return topData.current?.avg_non_zero[calcKeyList[0]];
+    },
+    'GROUP_AVG': (params) => {
+        const { header: { calcKeyList }, data, } = params;
+        return data.current?.avg[calcKeyList[0]];
+    },
+    'GROUP_AVG_NON_ZERO': (params) => {
+        const { header: { calcKeyList }, data, } = params;
+        return data.current?.avg_non_zero[calcKeyList[0]];
+    },
+    'GLOBAL_RANK_DESC': (params) => {
+        setTotalGloalRank(params);
+    },
+    'GLOBAL_RANK_ASC': (params) => {
+        setTotalGloalRank(params);
+    },
+    'GROUP_RANK_DESC': (params) => {
+        setTotalGroupRank(params);
+    },
+    'GROUP_RANK_ASC': (params) => {
+        setTotalGroupRank(params);
+    },
+    'CUSTOM_RANK': (params) => {
+        setTotalCustomRank(params);
+    },
+};
+export function calcCustomAgg(params) {
+    const { header: { measureType }, } = params;
+    if (EZCustomAggFuncHandler[measureType]) {
+        return EZCustomAggFuncHandler[measureType](params);
+    }
+    return 0;
+}

package/ez-custom-agg-func/utils.js

@@ -0,0 +1,61 @@
+import { recursionForParent, setCustomRank } from "../calc-measure/utils";
+import { getSameLevelArrOfTotal } from "../utils";
+export function setTotalGloalRank(params) {
+    const { header: { key, measureType, calcKeyList }, tree, } = params;
+    const arr = getSameLevelArrOfTotal(tree);
+    arr.forEach(sameLevelList => {
+        const list = [...sameLevelList];
+        list.sort((a, b) => {
+            const aValue = a.data[calcKeyList[0]] || 0;
+            const bValue = b.data[calcKeyList[0]] || 0;
+            if (measureType === 'GLOBAL_RANK_DESC') {
+                return bValue - aValue;
+            }
+            return aValue - bValue;
+        });
+        list.forEach((item, index) => {
+            item.data[key] = index + 1;
+        });
+    });
+}
+export function setTotalGroupRank(params) {
+    const { header: { key, measureType, calcKeyList }, tree, } = params;
+    recursionForParent(tree, data => {
+        const children = [...data.children];
+        children.sort((a, b) => {
+            const aValue = a.data[calcKeyList[0]] || 0;
+            const bValue = b.data[calcKeyList[0]] || 0;
+            if (measureType === 'GROUP_RANK_DESC') {
+                return bValue - aValue;
+            }
+            return aValue - bValue;
+        });
+        children.forEach((item, index) => {
+            item.data[key] = index + 1;
+        });
+    });
+}
+export function setTotalCustomRank(params) {
+    const { header: { key, measureType, calcKeyList, computeParam, computeParam: { sortOrder, rankTarget, rankWay, rankDimList }, }, tree, } = params;
+    if (rankTarget === 'GLOBAL') {
+        const arr = getSameLevelArrOfTotal(tree);
+        arr.forEach(sameLevelList => {
+            setCustomRank(sortOrder, rankWay, sameLevelList, key, calcKeyList[0], computeParam?.measureList, computeParam?.rankDimList);
+        });
+    }
+    switch (rankTarget) {
+        case 'GLOBAL':
+            const arr = getSameLevelArrOfTotal(tree);
+            arr.forEach(sameLevelList => {
+                setCustomRank(sortOrder, rankWay, sameLevelList, key, calcKeyList[0], computeParam?.measureList, computeParam?.rankDimList);
+            });
+            break;
+        case 'GROUP':
+            recursionForParent(tree, data => {
+                setCustomRank(sortOrder, rankWay, data.children, key, calcKeyList[0], computeParam?.measureList, computeParam?.rankDimList);
+            });
+            break;
+        default:
+            break;
+    }
+}

package/ezNumber.js

@@ -0,0 +1,82 @@
+import { DEFAULT_FORMAT } from "./constants";
+import { format as dateFormat, parseISO } from 'date-fns';
+import { getFormatUnit, formatNumber as customFormatNumber } from "./utils";
+import { formatPercent } from "./angular/formatPercent";
+import { formatNumber } from "./angular/formatNumber";
+export function ezNumber(num, format = 'number', digitsInfo = '1.0-2', defaultValue = '-', customFormat = null, isCondition = false) {
+    if (['IMAGE', 'LINK'].includes(format)) {
+        format = typeof num;
+    }
+    if (num === '允许空') {
+        return '';
+    }
+    if (isCondition && isNaN(num)) {
+        return num;
+    }
+    if (!format) {
+        format = 'number';
+    }
+    if (!digitsInfo) {
+        digitsInfo = '1.0-2';
+    }
+    format = format.toLowerCase();
+    if (format === 'date' || format === 'string') {
+        if (format === 'date' && num && num !== -Infinity && num !== Infinity && num !== '-' && num !== '无' && num !== '未定义') {
+            return dateFormat(typeof num === 'number' ? new Date(num) : parseISO(num), customFormat?.format || 'yyyy-MM-dd');
+        }
+        return num ?? defaultValue;
+    }
+    if (num === null || !isFinite(num)) {
+        return defaultValue;
+    }
+    if (format === null || format === undefined) {
+        format = 'number';
+    }
+    if (customFormat?.hideZero && num === 0) {
+        return '';
+    }
+    if (customFormat) {
+        const newFormat = customFormat || { ...DEFAULT_FORMAT };
+        let newNum = `${num}`;
+        if (newFormat.type === 'number' && newFormat.quantityUnit !== '个') {
+            newNum = getFormatUnit(newNum, newFormat.quantityUnit);
+        }
+        if (newFormat.type === 'percent') {
+            newNum = `${Number(newNum) * 100}`;
+        }
+        newNum = customFormatNumber(newNum, newFormat.precision, newFormat.isThousandth);
+        if (newFormat.type === 'percent') {
+            newNum += '%';
+        }
+        if (newFormat.unitSuffix) {
+            newNum += newFormat.unitSuffix;
+        }
+        return newNum;
+    }
+    if (format === 'percent') {
+        return formatPercent(num, 'zh-CN', digitsInfo);
+    }
+    if (format === 'thousand') {
+        return num < 1000 ?
+            formatNumber(num, 'zh-CN', digitsInfo) :
+            `${formatNumber(num / 1000, 'zh-CN', digitsInfo)}k`;
+    }
+    if (format === 'currency') {
+        const K = 1000;
+        const M = K * K;
+        const B = K * M;
+        if (num < K) {
+            return formatNumber(num, 'zh-CN', digitsInfo);
+        }
+        else if (num < M) {
+            return `${formatNumber(num / K, 'zh-CN', digitsInfo)}K`;
+        }
+        else if (num < B) {
+            return `${formatNumber(num / M, 'zh-CN', digitsInfo)}M`;
+        }
+        else {
+            return `${formatNumber(num / B, 'zh-CN', digitsInfo)}B`;
+        }
+    }
+    return formatNumber(num, 'zh-CN', digitsInfo);
+}

package/func.js

@@ -0,0 +1,70 @@
+const func = {
+    'SUM': (params) => {
+        const { dataList, header } = params;
+        return dataList.reduce((total, item) => total + (item.data[header.key] || 0), 0);
+    },
+    'MEDIAN': (params) => {
+        const { dataList, header: { key } } = params;
+        const arr = [...dataList].sort((a, b) => (a.data[key] || 0) - (b.data[key] || 0));
+        const len = arr.length;
+        if (len % 2 === 1) {
+            return arr[(len - 1) / 2].data[key];
+        }
+        return (arr[len / 2].data[key] + arr[len / 2 - 1].data[key]) / 2;
+    },
+    'MAX': (params) => {
+        const { dataList, header } = params;
+        let max = -Infinity;
+        for (const item of dataList) {
+            max = Math.max(max, item.data[header.key] || 0);
+        }
+        return max;
+    },
+    'MIN': (params) => {
+        const { dataList, header } = params;
+        let min = Infinity;
+        for (const item of dataList) {
+            min = Math.min(min, item.data[header.key] || 0);
+        }
+        return min;
+    },
+    'AVG': (params) => {
+        const { dataList, header } = params;
+        const sum = dataList.reduce((total, item) => total + (item.data[header.key] || 0), 0);
+        return sum / dataList.length;
+    },
+    // 平均值非零
+    'AVG_NON_ZERO': (params) => {
+        const { dataList, header } = params;
+        let sum = 0;
+        let leng = 0;
+        for (const item of dataList) {
+            if (item.data[header.key]) {
+                sum += item.data[header.key];
+                leng++;
+            }
+        }
+        return sum / leng;
+    },
+    // 计数
+    'COUNT': (params) => {
+        const { dataList, header } = params;
+        return dataList.length;
+    },
+    // 非重复计数
+    'DISTINC_COUNT': (params) => {
+        const { dataList, header: { key } } = params;
+        const set = new Set();
+        for (const item of dataList) {
+            set.add(item.data[key]);
+        }
+        return set.size;
+    },
+};
+export function getFuncValue(params) {
+    const { aggKey } = params;
+    if (func[aggKey]) {
+        return func[aggKey](params);
+    }
+    return 0;
+}

package/index.js

@@ -0,0 +1,3 @@
+import {EZTable} from "table-core.js";
+
+module.exports = EZTable;

package/interface.js

@@ -0,0 +1,2 @@
+;
+export {};

package/package.json

@@ -0,0 +1,16 @@
+{
+  "name": "yi-bi-ez-table",
+  "version": "1.0.0",
+  "description": "yi-bi table",
+  "license": "ISC",
+  "author": "yi-bi",
+  "type": "commonjs",
+  "main": "index.js",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "dependencies": {
+    "bignumber.js": "^9.3.1",
+    "lodash": "^4.17.21"
+  }
+}

package/prisma/seed.js

@@ -0,0 +1,70 @@
+// import { PrismaClient, Prisma } from '@prisma/client'
+//
+// const prisma = new PrismaClient()
+//
+// const userData: Prisma.UserCreateInput[] = [
+//   {
+//     name: 'Alice',
+//     email: 'alice@prisma.io',
+//     posts: {
+//       create: [
+//         {
+//           title: 'Join the Prisma Slack',
+//           content: 'https://slack.prisma.io',
+//           published: true,
+//         },
+//       ],
+//     },
+//   },
+//   {
+//     name: 'Nilu',
+//     email: 'nilu@prisma.io',
+//     posts: {
+//       create: [
+//         {
+//           title: 'Follow Prisma on Twitter',
+//           content: 'https://www.twitter.com/prisma',
+//           published: true,
+//         },
+//       ],
+//     },
+//   },
+//   {
+//     name: 'Mahmoud',
+//     email: 'mahmoud@prisma.io',
+//     posts: {
+//       create: [
+//         {
+//           title: 'Ask a question about Prisma on GitHub',
+//           content: 'https://www.github.com/prisma/prisma/discussions',
+//           published: true,
+//         },
+//         {
+//           title: 'Prisma on YouTube',
+//           content: 'https://pris.ly/youtube',
+//         },
+//       ],
+//     },
+//   },
+// ]
+//
+// async function main() {
+//   console.log(`Start seeding ...`)
+//   for (const u of userData) {
+//     const user = await prisma.user.create({
+//       data: u,
+//     })
+//     console.log(`Created user with id: ${user.id}`)
+//   }
+//   console.log(`Seeding finished.`)
+// }
+//
+// main()
+//   .then(async () => {
+//     await prisma.$disconnect()
+//   })
+//   .catch(async (e) => {
+//     console.error(e)
+//     await prisma.$disconnect()
+//     process.exit(1)
+//   })