@smallwei/avue 3.8.5 → 3.8.6

package/es/src/plugin/export/_blob.mjs

@@ -0,0 +1,151 @@
+/*! Avue.js v3.8.6 | (c) 2017-2026 Smallwei | Released under the MIT License. */
+// @ts-nocheck
+/* eslint-disable */
+/* Blob.js
+ * A Blob implementation.
+ * 2014-05-27
+ *
+ * By Eli Grey, http://eligrey.com
+ * By Devin Samarin, https://github.com/eboyjr
+ * License: X11/MIT
+ *   See LICENSE.md
+ */
+(function (view) {
+    view.URL = view.URL || view.webkitURL;
+    if (view.Blob && view.URL) {
+        try {
+            new Blob();
+            return;
+        }
+        catch (e) { }
+    }
+    const BlobBuilder = view.BlobBuilder ||
+        view.WebKitBlobBuilder ||
+        view.MozBlobBuilder ||
+        (function (view) {
+            const get_class = function (object) {
+                return Object.prototype.toString
+                    .call(object)
+                    .match(/^\[object\s(.*)\]$/)[1];
+            }, FakeBlobBuilder = function BlobBuilder() {
+                this.data = [];
+            }, FakeBlob = function Blob(data, type, encoding) {
+                this.data = data;
+                this.size = data.length;
+                this.type = type;
+                this.encoding = encoding;
+            }, FBB_proto = FakeBlobBuilder.prototype, FB_proto = FakeBlob.prototype, FileReaderSync = view.FileReaderSync, FileException = function (type) {
+                this.code = this[(this.name = type)];
+            }, file_ex_codes = ('NOT_FOUND_ERR SECURITY_ERR ABORT_ERR NOT_READABLE_ERR ENCODING_ERR ' +
+                'NO_MODIFICATION_ALLOWED_ERR INVALID_STATE_ERR SYNTAX_ERR').split(' '), file_ex_code = file_ex_codes.length, real_URL = view.URL || view.webkitURL || view, real_create_object_URL = real_URL.createObjectURL, real_revoke_object_URL = real_URL.revokeObjectURL, URL = real_URL, btoa = view.btoa, atob = view.atob, ArrayBuffer = view.ArrayBuffer, Uint8Array = view.Uint8Array;
+            FakeBlob.fake = FB_proto.fake = true;
+            while (file_ex_code--) {
+                FileException.prototype[file_ex_codes[file_ex_code]] = file_ex_code + 1;
+            }
+            if (!real_URL.createObjectURL) {
+                URL = view.URL = {};
+            }
+            URL.createObjectURL = function (blob) {
+                let type = blob.type;
+                let data_URI_header;
+                if (type === null) {
+                    type = 'application/octet-stream';
+                }
+                if (blob instanceof FakeBlob) {
+                    data_URI_header = 'data:' + type;
+                    if (blob.encoding === 'base64') {
+                        return data_URI_header + ';base64,' + blob.data;
+                    }
+                    else if (blob.encoding === 'URI') {
+                        return data_URI_header + ',' + decodeURIComponent(blob.data);
+                    }
+                    if (btoa) {
+                        return data_URI_header + ';base64,' + btoa(blob.data);
+                    }
+                    else {
+                        return data_URI_header + ',' + encodeURIComponent(blob.data);
+                    }
+                }
+                else if (real_create_object_URL) {
+                    return real_create_object_URL.call(real_URL, blob);
+                }
+            };
+            URL.revokeObjectURL = function (object_URL) {
+                if (object_URL.substring(0, 5) !== 'data:' && real_revoke_object_URL) {
+                    real_revoke_object_URL.call(real_URL, object_URL);
+                }
+            };
+            FBB_proto.append = function (data) {
+                const bb = this.data;
+                if (Uint8Array &&
+                    (data instanceof ArrayBuffer || data instanceof Uint8Array)) {
+                    let str = '', buf = new Uint8Array(data), i = 0, buf_len = buf.length;
+                    for (; i < buf_len; i++) {
+                        str += String.fromCharCode(buf[i]);
+                    }
+                    bb.push(str);
+                }
+                else if (get_class(data) === 'Blob' || get_class(data) === 'File') {
+                    if (FileReaderSync) {
+                        const fr = new FileReaderSync();
+                        bb.push(fr.readAsBinaryString(data));
+                    }
+                    else {
+                        throw new FileException('NOT_READABLE_ERR');
+                    }
+                }
+                else if (data instanceof FakeBlob) {
+                    if (data.encoding === 'base64' && atob) {
+                        bb.push(atob(data.data));
+                    }
+                    else if (data.encoding === 'URI') {
+                        bb.push(decodeURIComponent(data.data));
+                    }
+                    else if (data.encoding === 'raw') {
+                        bb.push(data.data);
+                    }
+                }
+                else {
+                    if (typeof data !== 'string') {
+                        data += '';
+                    }
+                    bb.push(unescape(encodeURIComponent(data)));
+                }
+            };
+            FBB_proto.getBlob = function (type) {
+                if (!arguments.length) {
+                    type = null;
+                }
+                return new FakeBlob(this.data.join(''), type, 'raw');
+            };
+            FBB_proto.toString = function () {
+                return '[object BlobBuilder]';
+            };
+            FB_proto.slice = function (start, end, type) {
+                const args = arguments.length;
+                if (args < 3) {
+                    type = null;
+                }
+                return new FakeBlob(this.data.slice(start, args > 1 ? end : this.data.length), type, this.encoding);
+            };
+            FB_proto.toString = function () {
+                return '[object Blob]';
+            };
+            FB_proto.close = function () {
+                this.size = this.data.length = 0;
+            };
+            return FakeBlobBuilder;
+        })(view);
+    view.Blob = function Blob(blobParts, options) {
+        const type = options ? options.type || '' : '';
+        const builder = new BlobBuilder();
+        if (blobParts) {
+            for (let i = 0, len = blobParts.length; i < len; i++) {
+                builder.append(blobParts[i]);
+            }
+        }
+        return builder.getBlob(type);
+    };
+})(((typeof self !== 'undefined' && self) ||
+    (typeof window !== 'undefined' && window) ||
+    globalThis));

package/es/src/plugin/export/_export2Excel.mjs

@@ -0,0 +1,143 @@
+/*! Avue.js v3.8.6 | (c) 2017-2026 Smallwei | Released under the MIT License. */
+import './_blob.mjs';
+
+// @ts-nocheck
+/* eslint-disable */
+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) {
+    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);
+            }
+            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;
+}
+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');
+}
+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');
+}
+
+export { export_json_to_excel, export_table_to_excel };

package/es/src/plugin/export/index.mjs

@@ -0,0 +1,267 @@
+/*! Avue.js v3.8.6 | (c) 2017-2026 Smallwei | Released under the MIT License. */
+import { isJson, downFile, validData } from '../../utils/util.mjs';
+import packages from '../../core/packages.mjs';
+import dayjs from '../../../_virtual/dayjs.min.mjs';
+
+/* eslint-disable */
+const XLSX = window.XLSX;
+var $Export = {
+    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);
+        });
+    }
+};
+
+export { $Export as default };

package/es/src/plugin/logs/index.mjs

@@ -0,0 +1,46 @@
+/*! Avue.js v3.8.6 | (c) 2017-2026 Smallwei | Released under the MIT License. */
+const log = {};
+function typeColor(type = 'default') {
+    let color = '';
+    switch (type) {
+        case 'default':
+            color = '#35495E';
+            break;
+        case 'primary':
+            color = '#3488ff';
+            break;
+        case 'success':
+            color = '#43B883';
+            break;
+        case 'warning':
+            color = '#e6a23c';
+            break;
+        case 'danger':
+            color = '#f56c6c';
+            break;
+    }
+    return color;
+}
+log.capsule = function (title, info, type = 'primary') {
+    console.log(`%c ${title} %c ${info} %c`, 'background:#35495E; padding: 1px; border-radius: 3px 0 0 3px; color: #fff;', `background:${typeColor(type)}; padding: 1px; border-radius: 0 3px 3px 0;  color: #fff;`, 'background:transparent');
+};
+log.colorful = function (textArr) {
+    console.log(`%c${textArr.map((t) => t.text || '').join('%c')}`, ...textArr.map((t) => `color: ${typeColor(t.type)};`));
+};
+log.default = function (text) {
+    log.colorful([{ text }]);
+};
+log.primary = function (text) {
+    log.colorful([{ text, type: 'primary' }]);
+};
+log.success = function (text) {
+    log.colorful([{ text, type: 'success' }]);
+};
+log.warning = function (text) {
+    log.colorful([{ text, type: 'warning' }]);
+};
+log.danger = function (text) {
+    log.colorful([{ text, type: 'danger' }]);
+};
+
+export { log as default };