@smallwei/avue 3.8.2 → 3.8.3

package/es/plugin/export/_export2Excel.mjs

@@ -0,0 +1,141 @@
+// @ts-nocheck
+/* eslint-disable */
+import './_blob.mjs';
+const saveAs = window.saveAs;
+const XLSX = window.XLSX;
+function generateArray(table) {
+    const out = [];
+    const rows = table.querySelectorAll('tr');
+    const ranges = [];
+    for (let R = 0; R < rows.length; ++R) {
+        const outRow = [];
+        const row = rows[R];
+        const columns = row.querySelectorAll('td');
+        for (let C = 0; C < columns.length; ++C) {
+            const cell = columns[C];
+            let colspan = cell.getAttribute('colspan');
+            let rowspan = cell.getAttribute('rowspan');
+            let cellValue = cell.innerText;
+            if (cellValue !== '' && cellValue == +cellValue)
+                cellValue = +cellValue;
+            ranges.forEach(function (range) {
+                if (R >= range.s.r &&
+                    R <= range.e.r &&
+                    outRow.length >= range.s.c &&
+                    outRow.length <= range.e.c) {
+                    for (let i = 0; i <= range.e.c - range.s.c; ++i)
+                        outRow.push(null);
+                }
+            });
+            if (rowspan || colspan) {
+                rowspan = rowspan || 1;
+                colspan = colspan || 1;
+                ranges.push({
+                    s: { r: R, c: outRow.length },
+                    e: { r: R + rowspan - 1, c: outRow.length + colspan - 1 }
+                });
+            }
+            outRow.push(cellValue !== '' ? cellValue : null);
+            if (colspan)
+                for (let k = 0; k < colspan - 1; ++k)
+                    outRow.push(null);
+        }
+        out.push(outRow);
+    }
+    return [out, ranges];
+}
+function datenum(v, date1904) {
+    if (date1904)
+        v += 1462;
+    const epoch = Date.parse(v);
+    return (epoch - new Date(Date.UTC(1899, 11, 30))) / (24 * 60 * 60 * 1000);
+}
+function sheet_from_array_of_arrays(data) {
+    const ws = {};
+    const range = { s: { c: 10000000, r: 10000000 }, e: { c: 0, r: 0 } };
+    for (let R = 0; R != data.length; ++R) {
+        for (let C = 0; C != data[R].length; ++C) {
+            if (range.s.r > R)
+                range.s.r = R;
+            if (range.s.c > C)
+                range.s.c = C;
+            if (range.e.r < R)
+                range.e.r = R;
+            if (range.e.c < C)
+                range.e.c = C;
+            const cell = { v: data[R][C] };
+            if (cell.v == null)
+                continue;
+            const cell_ref = XLSX.utils.encode_cell({ c: C, r: R });
+            if (typeof cell.v === 'number')
+                cell.t = 'n';
+            else if (typeof cell.v === 'boolean')
+                cell.t = 'b';
+            else if (cell.v instanceof Date) {
+                cell.t = 'n';
+                cell.z = XLSX.SSF._table[14];
+                cell.v = datenum(cell.v, false);
+            }
+            else
+                cell.t = 's';
+            ws[cell_ref] = cell;
+        }
+    }
+    if (range.s.c < 10000000)
+        ws['!ref'] = XLSX.utils.encode_range(range);
+    return ws;
+}
+function Workbook() {
+    if (!(this instanceof Workbook))
+        return new Workbook();
+    this.SheetNames = [];
+    this.Sheets = {};
+}
+function s2ab(s) {
+    const buf = new ArrayBuffer(s.length);
+    const view = new Uint8Array(buf);
+    for (let i = 0; i != s.length; ++i)
+        view[i] = s.charCodeAt(i) & 0xff;
+    return buf;
+}
+export function export_table_to_excel(id) {
+    const theTable = document.getElementById(id);
+    const oo = generateArray(theTable);
+    const ranges = oo[1];
+    const data = oo[0];
+    const ws_name = 'SheetJS';
+    const wb = new Workbook();
+    const ws = sheet_from_array_of_arrays(data);
+    ws['!merges'] = ranges;
+    wb.SheetNames.push(ws_name);
+    wb.Sheets[ws_name] = ws;
+    const wbout = XLSX.write(wb, {
+        bookType: 'xlsx',
+        bookSST: false,
+        type: 'binary'
+    });
+    saveAs(new Blob([s2ab(wbout)], { type: 'application/octet-stream' }), 'test.xlsx');
+}
+export function export_json_to_excel(th, jsonData, defaultTitle, options = { merges: [], header: null }) {
+    const data = jsonData;
+    data.unshift(th);
+    if (options.header)
+        data.unshift([options.header]);
+    const ws_name = 'SheetJS';
+    const wb = new Workbook();
+    const ws = sheet_from_array_of_arrays(data);
+    let { merges = [] } = options;
+    if (typeof merges[0] == 'string' && merges.length == 2)
+        merges = [merges];
+    merges = merges.map((i) => (i instanceof Array ? { s: i[0], e: i[1] } : i));
+    ws['!merges'] = merges;
+    wb.SheetNames.push(ws_name);
+    wb.Sheets[ws_name] = ws;
+    const wbout = XLSX.write(wb, {
+        bookType: 'xlsx',
+        bookSST: false,
+        type: 'binary'
+    });
+    const title = defaultTitle || '列表';
+    saveAs(new Blob([s2ab(wbout)], { type: 'application/octet-stream' }), title + '.xlsx');
+}

package/es/plugin/export/_export2Excel.ts

@@ -0,0 +1,166 @@
+// @ts-nocheck
+/* eslint-disable */
+
+import './_blob';
+
+declare global {
+  interface Window {
+    saveAs: any;
+    XLSX: any;
+  }
+}
+
+const saveAs = window.saveAs;
+const XLSX = window.XLSX;
+
+function generateArray(table: HTMLElement) {
+  const out: any[] = [];
+  const rows = table.querySelectorAll('tr');
+  const ranges: any[] = [];
+  for (let R = 0; R < rows.length; ++R) {
+    const outRow: any[] = [];
+    const row = rows[R];
+    const columns = row.querySelectorAll('td');
+    for (let C = 0; C < columns.length; ++C) {
+      const cell = columns[C] as HTMLElement;
+      let colspan: any = cell.getAttribute('colspan');
+      let rowspan: any = cell.getAttribute('rowspan');
+      let cellValue: any = cell.innerText;
+      if (cellValue !== '' && cellValue == +cellValue) cellValue = +cellValue;
+
+      ranges.forEach(function (range) {
+        if (
+          R >= range.s.r &&
+          R <= range.e.r &&
+          outRow.length >= range.s.c &&
+          outRow.length <= range.e.c
+        ) {
+          for (let i = 0; i <= range.e.c - range.s.c; ++i) outRow.push(null);
+        }
+      });
+
+      if (rowspan || colspan) {
+        rowspan = rowspan || 1;
+        colspan = colspan || 1;
+        ranges.push({
+          s: { r: R, c: outRow.length },
+          e: { r: R + rowspan - 1, c: outRow.length + colspan - 1 }
+        });
+      }
+
+      outRow.push(cellValue !== '' ? cellValue : null);
+
+      if (colspan) for (let k = 0; k < colspan - 1; ++k) outRow.push(null);
+    }
+    out.push(outRow);
+  }
+  return [out, ranges];
+}
+
+function datenum(v: any, date1904: any) {
+  if (date1904) v += 1462;
+  const epoch = Date.parse(v);
+  return (epoch - new Date(Date.UTC(1899, 11, 30)) as any) / (24 * 60 * 60 * 1000);
+}
+
+function sheet_from_array_of_arrays(data: any[][]) {
+  const ws: Record<string, any> = {};
+  const range = { s: { c: 10000000, r: 10000000 }, e: { c: 0, r: 0 } };
+  for (let R = 0; R != data.length; ++R) {
+    for (let C = 0; C != data[R].length; ++C) {
+      if (range.s.r > R) range.s.r = R;
+      if (range.s.c > C) range.s.c = C;
+      if (range.e.r < R) range.e.r = R;
+      if (range.e.c < C) range.e.c = C;
+      const cell: any = { v: data[R][C] };
+      if (cell.v == null) continue;
+      const cell_ref = XLSX.utils.encode_cell({ c: C, r: R });
+
+      if (typeof cell.v === 'number') cell.t = 'n';
+      else if (typeof cell.v === 'boolean') cell.t = 'b';
+      else if (cell.v instanceof Date) {
+        cell.t = 'n';
+        cell.z = XLSX.SSF._table[14];
+        cell.v = datenum(cell.v, false);
+      } else cell.t = 's';
+
+      ws[cell_ref] = cell;
+    }
+  }
+  if (range.s.c < 10000000) ws['!ref'] = XLSX.utils.encode_range(range);
+  return ws;
+}
+
+function Workbook(this: any) {
+  if (!(this instanceof Workbook)) return new (Workbook as any)();
+  this.SheetNames = [];
+  this.Sheets = {};
+}
+
+function s2ab(s: string) {
+  const buf = new ArrayBuffer(s.length);
+  const view = new Uint8Array(buf);
+  for (let i = 0; i != s.length; ++i) view[i] = s.charCodeAt(i) & 0xff;
+  return buf;
+}
+
+export function export_table_to_excel(id: string) {
+  const theTable = document.getElementById(id)!;
+  const oo = generateArray(theTable);
+  const ranges = oo[1];
+  const data = oo[0];
+  const ws_name = 'SheetJS';
+
+  const wb: any = new (Workbook as any)();
+  const ws = sheet_from_array_of_arrays(data);
+
+  ws['!merges'] = ranges;
+
+  wb.SheetNames.push(ws_name);
+  wb.Sheets[ws_name] = ws;
+
+  const wbout = XLSX.write(wb, {
+    bookType: 'xlsx',
+    bookSST: false,
+    type: 'binary'
+  });
+
+  saveAs(
+    new Blob([s2ab(wbout)], { type: 'application/octet-stream' }),
+    'test.xlsx'
+  );
+}
+
+export function export_json_to_excel(
+  th: any[],
+  jsonData: any[][],
+  defaultTitle?: string,
+  options: { merges?: any[]; header?: string | null } = { merges: [], header: null }
+) {
+  const data = jsonData;
+  data.unshift(th);
+  if (options.header) data.unshift([options.header]);
+  const ws_name = 'SheetJS';
+
+  const wb: any = new (Workbook as any)();
+  const ws = sheet_from_array_of_arrays(data);
+
+  let { merges = [] } = options;
+  if (typeof merges[0] == 'string' && merges.length == 2) merges = [merges];
+  merges = merges.map((i: any) => (i instanceof Array ? { s: i[0], e: i[1] } : i));
+  ws['!merges'] = merges;
+
+  wb.SheetNames.push(ws_name);
+  wb.Sheets[ws_name] = ws;
+
+  const wbout = XLSX.write(wb, {
+    bookType: 'xlsx',
+    bookSST: false,
+    type: 'binary'
+  });
+  const title = defaultTitle || '列表';
+  saveAs(
+    new Blob([s2ab(wbout)], { type: 'application/octet-stream' }),
+    title + '.xlsx'
+  );
+}

package/es/plugin/export/index.mjs

@@ -0,0 +1,263 @@
+/* eslint-disable */
+import { isJson, downFile, validData } from '../../utils/util.mjs';
+import packages from '../../core/packages.mjs';
+import dayjs from 'dayjs';
+const XLSX = window.XLSX;
+export default {
+    buildHeader(revealList) {
+        const excelHeader = [];
+        this.getHeader(revealList, excelHeader, 0, 0);
+        const max = Math.max(...excelHeader.map((a) => a.length));
+        excelHeader
+            .filter((e) => e.length < max)
+            .forEach((e) => this.pushRowSpanPlaceHolder(e, max - e.length));
+        return excelHeader;
+    },
+    getHeader(headers, excelHeader, deep, perOffset) {
+        let offset = 0;
+        let cur = excelHeader[deep];
+        if (!cur) {
+            cur = excelHeader[deep] = [];
+        }
+        this.pushRowSpanPlaceHolder(cur, perOffset - cur.length);
+        for (let i = 0; i < headers.length; i++) {
+            const head = headers[i];
+            cur.push(head.label);
+            if (head.hasOwnProperty('children') && Array.isArray(head.children) && head.children.length > 0) {
+                const childOffset = this.getHeader(head.children, excelHeader, deep + 1, cur.length - 1);
+                this.pushColSpanPlaceHolder(cur, childOffset - 1);
+                offset += childOffset;
+            }
+            else {
+                offset++;
+            }
+        }
+        return offset;
+    },
+    pushRowSpanPlaceHolder(arr, count) {
+        for (let i = 0; i < count; i++) {
+            arr.push('!$ROW_SPAN_PLACEHOLDER');
+        }
+    },
+    pushColSpanPlaceHolder(arr, count) {
+        for (let i = 0; i < count; i++) {
+            arr.push('!$COL_SPAN_PLACEHOLDER');
+        }
+    },
+    doMerges(arr) {
+        const deep = arr.length;
+        const merges = [];
+        for (let y = 0; y < deep; y++) {
+            const row = arr[y];
+            let colSpan = 0;
+            for (let x = 0; x < row.length; x++) {
+                if (row[x] === '!$COL_SPAN_PLACEHOLDER') {
+                    row[x] = undefined;
+                    if (x + 1 === row.length) {
+                        merges.push({ s: { r: y, c: x - colSpan - 1 }, e: { r: y, c: x } });
+                    }
+                    colSpan++;
+                }
+                else if (colSpan > 0 && x > colSpan) {
+                    merges.push({ s: { r: y, c: x - colSpan - 1 }, e: { r: y, c: x - 1 } });
+                    colSpan = 0;
+                }
+                else {
+                    colSpan = 0;
+                }
+            }
+        }
+        const colLength = arr[0].length;
+        for (let x = 0; x < colLength; x++) {
+            let rowSpan = 0;
+            for (let y = 0; y < deep; y++) {
+                if (arr[y][x] === '!$ROW_SPAN_PLACEHOLDER') {
+                    arr[y][x] = undefined;
+                    if (y + 1 === deep) {
+                        merges.push({ s: { r: y - rowSpan, c: x }, e: { r: y, c: x } });
+                    }
+                    rowSpan++;
+                }
+                else if (rowSpan > 0 && y > rowSpan) {
+                    merges.push({ s: { r: y - rowSpan - 1, c: x }, e: { r: y - 1, c: x } });
+                    rowSpan = 0;
+                }
+                else {
+                    rowSpan = 0;
+                }
+            }
+        }
+        return merges;
+    },
+    aoa_to_sheet(data, headerRows) {
+        const ws = {};
+        const range = { s: { c: 10000000, r: 10000000 }, e: { c: 0, r: 0 } };
+        for (let R = 0; R !== data.length; ++R) {
+            for (let C = 0; C !== data[R].length; ++C) {
+                if (range.s.r > R) {
+                    range.s.r = R;
+                }
+                if (range.s.c > C) {
+                    range.s.c = C;
+                }
+                if (range.e.r < R) {
+                    range.e.r = R;
+                }
+                if (range.e.c < C) {
+                    range.e.c = C;
+                }
+                const cell = {
+                    v: validData(data[R][C], ''),
+                    s: {
+                        font: { name: '宋体', sz: 11, color: { auto: 1, rgb: '000000' }, bold: true },
+                        alignment: {
+                            wrapText: 1,
+                            horizontal: 'center',
+                            vertical: 'center',
+                            indent: 0
+                        }
+                    }
+                };
+                if (R < headerRows) {
+                    cell.s.border = {
+                        top: { style: 'thin', color: { rgb: 'EBEEF5' } },
+                        left: { style: 'thin', color: { rgb: 'EBEEF5' } },
+                        bottom: { style: 'thin', color: { rgb: 'EBEEF5' } },
+                        right: { style: 'thin', color: { rgb: 'EBEEF5' } }
+                    };
+                    cell.s.fill = {
+                        patternType: 'solid',
+                        fgColor: { theme: 3, tint: 0.3999755851924192, rgb: 'F5F7FA' },
+                        bgColor: { theme: 7, tint: 0.3999755851924192, rgb: 'F5F7FA' }
+                    };
+                }
+                const cell_ref = XLSX.utils.encode_cell({ c: C, r: R });
+                if (typeof cell.v === 'number') {
+                    cell.t = 'n';
+                }
+                else if (typeof cell.v === 'boolean') {
+                    cell.t = 'b';
+                }
+                else {
+                    cell.t = 's';
+                }
+                ws[cell_ref] = cell;
+            }
+        }
+        if (range.s.c < 10000000) {
+            ws['!ref'] = XLSX.utils.encode_range(range);
+        }
+        return ws;
+    },
+    s2ab(s) {
+        const buf = new ArrayBuffer(s.length);
+        const view = new Uint8Array(buf);
+        for (let i = 0; i !== s.length; ++i) {
+            view[i] = s.charCodeAt(i) & 0xff;
+        }
+        return buf;
+    },
+    excel(params) {
+        if (!window.XLSX) {
+            packages.logs('xlsx');
+            return;
+        }
+        return new Promise((resolve) => {
+            const _params = {
+                prop: []
+            };
+            _params.header = this.buildHeader(params.columns);
+            _params.title = params.title || dayjs().format('YYYY-MM-DD HH:mm:ss');
+            const callback = (list) => {
+                list.forEach((ele) => {
+                    if (ele.children && ele.children instanceof Array) {
+                        callback(ele.children);
+                    }
+                    else {
+                        _params.prop.push(ele.prop);
+                    }
+                });
+            };
+            callback(params.columns);
+            _params.data = params.data.map((row) => _params.prop.map((prop) => {
+                let data = row[prop];
+                if (isJson(data))
+                    data = JSON.stringify(data);
+                return data;
+            }));
+            const headerRows = _params.header.length;
+            _params.header.push(..._params.data, []);
+            const merges = this.doMerges(_params.header);
+            const ws = this.aoa_to_sheet(_params.header, headerRows);
+            ws['!merges'] = merges;
+            ws['!freeze'] = {
+                xSplit: '1',
+                ySplit: '' + headerRows,
+                topLeftCell: 'B' + (headerRows + 1),
+                activePane: 'bottomRight',
+                state: 'frozen'
+            };
+            ws['!cols'] = [{ wpx: 165 }];
+            const workbook = {
+                SheetNames: ['Sheet1'],
+                Sheets: {}
+            };
+            workbook.Sheets.Sheet1 = ws;
+            const wopts = {
+                bookType: 'xlsx',
+                bookSST: false,
+                type: 'binary',
+                cellStyles: true
+            };
+            const wbout = XLSX.write(workbook, wopts);
+            const blob = new Blob([this.s2ab(wbout)], { type: 'application/octet-stream' });
+            downFile(blob, _params.title + '.xlsx');
+            resolve();
+        });
+    },
+    xlsx(file) {
+        if (!window.saveAs || !window.XLSX) {
+            packages.logs('file-saver');
+            packages.logs('xlsx');
+            return;
+        }
+        const xlsx = window.XLSX;
+        return new Promise((resolve) => {
+            const reader = new FileReader();
+            const fixdata = (data) => {
+                let o = '';
+                let l = 0;
+                const w = 10240;
+                for (; l < data.byteLength / w; ++l) {
+                    o += String.fromCharCode.apply(null, Array.from(new Uint8Array(data.slice(l * w, l * w + w))));
+                }
+                o += String.fromCharCode.apply(null, Array.from(new Uint8Array(data.slice(l * w))));
+                return o;
+            };
+            const getHeaderRow = (sheet) => {
+                const headers = [];
+                const range = xlsx.utils.decode_range(sheet['!ref']);
+                const R = range.s.r;
+                for (let C = range.s.c; C <= range.e.c; ++C) {
+                    const cell = sheet[xlsx.utils.encode_cell({ c: C, r: R })];
+                    let hdr = 'UNKNOWN ' + C;
+                    if (cell && cell.t)
+                        hdr = xlsx.utils.format_cell(cell);
+                    headers.push(hdr);
+                }
+                return headers;
+            };
+            reader.onload = (e) => {
+                const data = e.target.result;
+                const fixedData = fixdata(data);
+                const workbook = xlsx.read(btoa(fixedData), { type: 'base64' });
+                const firstSheetName = workbook.SheetNames[0];
+                const worksheet = workbook.Sheets[firstSheetName];
+                const header = getHeaderRow(worksheet);
+                const results = xlsx.utils.sheet_to_json(worksheet);
+                resolve({ header, results });
+            };
+            reader.readAsArrayBuffer(file);
+        });
+    }
+};