@solar-angular/platform-browser 1.0.0

package/esm2022/spreadsheet.service.mjs

@@ -0,0 +1,282 @@
+import { DatePipe, DOCUMENT } from '@angular/common';
+import { inject, Injectable } from '@angular/core';
+import { defer, firstValueFrom, map, shareReplay } from 'rxjs';
+import { ResourceLoader } from './resource-loader';
+import * as i0 from "@angular/core";
+const EXCEL_COL_ALIAS = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ';
+const NUMBER_PATTERN = /[0-9]/g;
+const CHAR_PATTERN = /[a-zA-Z]/g;
+export class SpreadsheetService {
+    constructor() {
+        this.document = inject(DOCUMENT);
+        this.resourceLoader = inject(ResourceLoader);
+        this.datePipe = new DatePipe('zh-CN');
+        // ExcelJS 对象，用时异步自动加载
+        this.excel = defer(() => Promise.all([
+            this.resourceLoader.loadScript('https://img.omofresh.com/js/aieyes-exceljs-o_1_8_10.min.js'), // 修改过的 https://www.npmjs.com/package/aieyes-exceljs-o
+            this.resourceLoader.loadStylesheet('https://img.omofresh.com/css/exceljs.min.css'), // aieyes-exceljs-o 中定义的
+        ])).pipe(map(() => ExcelJS), shareReplay(1));
+    }
+    /**
+     * 根据当前的单元格找到下一列的地址
+     * 采用倒序进位法，这样就不需要递归了
+     */
+    nextColOfCell(cell) {
+        // 先把字母和数字分开，字母是列，数字是行，倒序排列
+        const args = cell.match(CHAR_PATTERN).reverse();
+        let needAppend = false;
+        for (let i = 0; i < args.length; i++) {
+            const arg = args[i];
+            if (arg !== 'Z') {
+                const idx = EXCEL_COL_ALIAS.indexOf(arg);
+                args[i] = EXCEL_COL_ALIAS[idx + 1];
+                break;
+            }
+            else {
+                args[i] = 'A';
+                if (i === args.length - 1) { // 说明是最后一个了，需要补A
+                    needAppend = true;
+                }
+            }
+        }
+        if (needAppend) {
+            args.push('A');
+        }
+        return args.reverse().join(''); // 最终的结果，反转再合并
+    }
+    /**
+     * 获取单元格的行
+     */
+    rowOfCell(cell) {
+        return cell.match(NUMBER_PATTERN).join('');
+    }
+    /**
+     * 获取单元格的列
+     */
+    colOfCell(cell) {
+        return cell.match(CHAR_PATTERN).join('');
+    }
+    /**
+     * 单元格的列号
+     * 当作26进制计算列的编号
+     */
+    colNumberOfCell(cell) {
+        let col = 0;
+        cell.match(CHAR_PATTERN).reverse().forEach((c, i) => {
+            if (i == 0) {
+                // 个位
+                col += EXCEL_COL_ALIAS.indexOf(c) + 1;
+            }
+            else {
+                // 十位以上
+                col += (EXCEL_COL_ALIAS.indexOf(c) + 1) * i * 26;
+            }
+        });
+        return col;
+    }
+    async parseDomTable(table, _opts) {
+        const excel = await firstValueFrom(this.excel);
+        return excel.TableParser.utils.parseDomTable(table, _opts);
+    }
+    /**
+     * 只导出一个table, 内容放在第一个sheet上
+     */
+    async exportDomTableById(tableId, fileName, _opts) {
+        const table = this.document.getElementById(tableId);
+        const excel = await firstValueFrom(this.excel);
+        const wb = new excel.Workbook();
+        const ws = wb.addWorksheet(fileName);
+        const re = await this.exportDomTable(wb, ws, table, null, null, _opts);
+        await this.saveAsFile(re.wb, fileName);
+    }
+    /**
+     * 导出多个table, 内容放在多个sheet上
+     */
+    async exportDomTableSheets(tableIds, sheetNames, fileName, _opts) {
+        const excel = await firstValueFrom(this.excel);
+        let wb = new excel.Workbook();
+        for (let index = 0; index < tableIds.length; index++) {
+            const table = this.document.getElementById(tableIds[index]);
+            const sheetName = sheetNames[index];
+            const ws = wb.addWorksheet(sheetName);
+            const re = await this.exportDomTable(wb, ws, table, null, null, _opts);
+            wb = re.wb;
+        }
+        await this.saveAsFile(wb, fileName);
+    }
+    /**
+     * 在一页中导出多个table, 每个table默认间隔1列
+     */
+    async exportDomTableParallel(tableIds, fileName, gap = 1, _opts) {
+        const excel = await firstValueFrom(this.excel);
+        let wb = new excel.Workbook();
+        const ws = wb.addWorksheet(fileName);
+        let cursor = 'A'; // 从第一列开始导出，并列几个table
+        for (const tableId of tableIds) {
+            const table = this.document.getElementById(tableId);
+            const re = await this.exportDomTable(wb, ws, table, cursor, null, _opts);
+            const lastCol = re.cols[re.cols.length - 1];
+            cursor = this.nextColOfCell(lastCol);
+            for (let k = 0; k < gap; k++) {
+                cursor = this.nextColOfCell(cursor);
+            }
+            wb = re.wb;
+        }
+        await this.saveAsFile(wb, fileName);
+    }
+    /**
+     * 在一页中垂直导出多个table
+     */
+    async exportDomTableVertical(tableIds, fileName, gap = 0, _opts) {
+        let rowOffset = 0;
+        const excel = await firstValueFrom(this.excel);
+        let wb = new excel.Workbook();
+        const ws = wb.addWorksheet(fileName);
+        for (const tableId of tableIds) {
+            const table = this.document.getElementById(tableId);
+            const re = await this.exportDomTable(wb, ws, table, null, rowOffset, _opts);
+            rowOffset += re.rows.length + gap;
+            wb = re.wb;
+        }
+        await this.saveAsFile(wb, fileName);
+    }
+    /**
+     * 导出dom table
+     * colCursor: 标记起始列
+     * rowOffset: 偏移的行数
+     * @return 返回最后一列的列名
+     */
+    async exportDomTable(wb, ws, table, colCursor, rowOffset, _opts) {
+        if (!_opts) {
+            _opts = { cellDates: true, dateNF: 'yyyy/M/d' }; // 默认的日期格式
+        }
+        else {
+            _opts.cellDates = true;
+        }
+        const ref = await this.parseDomTable(table, _opts);
+        let colOffset = 0; // colCursor偏移量，默认为0
+        if (colCursor) {
+            const c = ws.getColumn(colCursor);
+            colOffset = c.number - 1;
+        }
+        rowOffset = rowOffset || 0; // rowOffset默认为0
+        const cellMap = {};
+        Object.keys(ref).sort().forEach(cellAlias => {
+            if (!cellAlias.startsWith('!')) {
+                let rowNum = this.rowOfCell(cellAlias);
+                rowNum = String(parseInt(rowNum, 10) + rowOffset);
+                const colNum = this.colNumberOfCell(cellAlias);
+                const col = ws.getColumn(colOffset + colNum); // 根据偏移量找出所在的列
+                const finalCell = col.letter + rowNum;
+                cellMap[finalCell] = ref[cellAlias];
+            }
+        });
+        const colSet = new Set();
+        Object.keys(cellMap).forEach(k => {
+            colSet.add(this.colOfCell(k));
+        });
+        let cols = Array.from(colSet);
+        // 因为excel的列都是连续的，如果导出table存在跨列的话这里面可能却少某一列，所以需要补充缺少的列名保证这一段是连续的
+        let cursor = cols[0];
+        for (let i = 0; i < ref['!cols'].length - 1; i++) {
+            const next = this.nextColOfCell(cursor);
+            colSet.add(next);
+            cursor = next;
+        }
+        cols = Array.from(colSet).sort((a, b) => {
+            if (a.length === b.length) {
+                return a.localeCompare(b);
+            }
+            else if (a.length > b.length) {
+                return 1;
+            }
+            else if (b.length > a.length) {
+                return -1;
+            }
+            return -1;
+        });
+        // 赋值
+        Object.keys(cellMap).forEach(alias => {
+            const cell = ws.getCell(alias);
+            const cellConfig = cellMap[alias];
+            if (cellConfig.t === 'd') { // 日期格式需格式化后显示，换言之转为了字符串
+                cell.value = this.datePipe.transform(cellConfig.v, cellConfig.z);
+            }
+            else {
+                cell.value = cellConfig.v;
+            }
+            // 默认就有边框的
+            if (cellConfig.style.bordered) { // 表示需要加边框
+                cell.style.border = {
+                    top: { style: 'thin' },
+                    left: { style: 'thin' },
+                    bottom: { style: 'thin' },
+                    right: { style: 'thin' }
+                };
+            }
+            // 默认内容垂直居中，左右居中不一定
+            cell.style.alignment = {
+                horizontal: cellConfig.style.align,
+                vertical: 'middle',
+                wrapText: true
+            };
+            // 字体默认为宋体
+            cell.style.font = {
+                bold: cellConfig.style.bold,
+                name: '宋体',
+                size: cellConfig.style.pound // 字号
+            };
+            // 背景色/前景色
+            if (cellConfig.style.background) {
+                cell.fill = {
+                    type: 'pattern',
+                    pattern: 'solid',
+                    fgColor: { argb: cellConfig.style.background }, // 实际上fgColor是理解上的背景色，而不是前景色，不知道excel怎么定义的
+                    // bgColor: {argb: 'ffd8e6de'}
+                };
+            }
+        });
+        // 设置每行的高度
+        ref['!rows'].forEach((rowConfig, rowIndex) => {
+            const row = ws.getRow(rowIndex + rowOffset + 1);
+            row.height = rowConfig.height;
+        });
+        // 设置列宽
+        ref['!cols'].forEach((colConfig, colIndex) => {
+            const colAlias = cols[colIndex];
+            const col = ws.getColumn(colAlias);
+            if (colConfig.width) {
+                col.width = colConfig.width;
+            }
+        });
+        // 合并单元格, 由于不一定有，所以要判断一下
+        ref['!merges']?.forEach(mergeParam => {
+            const s = mergeParam['s'];
+            const e = mergeParam['e'];
+            const startCell = ws.getCell(rowOffset + s.r + 1, colOffset + s.c + 1);
+            const endCell = ws.getCell(rowOffset + e.r + 1, colOffset + e.c + 1);
+            ws.mergeCells([startCell.address, endCell.address]);
+        });
+        return { wb, cols, rows: ref['!rows'] };
+    }
+    /**
+     * 保存Workbook到磁盘上
+     */
+    async saveAsFile(wb, fileName) {
+        const excelData = await wb.xlsx.writeBuffer();
+        const blob = new Blob([excelData], { type: "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet" /* MediaType.Xlsx */ });
+        const anchor = document.createElement('a');
+        anchor.href = URL.createObjectURL(blob);
+        anchor.download = fileName + '.xlsx';
+        anchor.click();
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: SpreadsheetService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: SpreadsheetService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: SpreadsheetService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"spreadsheet.service.js","sourceRoot":"","sources":["../../../packages/platform-browser/src/spreadsheet.service.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,iBAAiB,CAAC;AACrD,OAAO,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAEnD,OAAO,EAAE,KAAK,EAAE,cAAc,EAAE,GAAG,EAAE,WAAW,EAAE,MAAM,MAAM,CAAC;AAC/D,OAAO,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;;AAKnD,MAAM,eAAe,GAAG,4BAA4B,CAAC;AACrD,MAAM,cAAc,GAAG,QAAQ,CAAC;AAChC,MAAM,YAAY,GAAG,WAAW,CAAC;AAKjC,MAAM,OAAO,kBAAkB;IAH/B;QAImB,aAAQ,GAAa,MAAM,CAAC,QAAQ,CAAC,CAAC;QACtC,mBAAc,GAAG,MAAM,CAAC,cAAc,CAAC,CAAC;QACxC,aAAQ,GAAG,IAAI,QAAQ,CAAC,OAAO,CAAC,CAAC;QAElD,sBAAsB;QACL,UAAK,GAAG,KAAK,CAAC,GAAG,EAAE,CAAC,OAAO,CAAC,GAAG,CAAC;YAC/C,IAAI,CAAC,cAAc,CAAC,UAAU,CAAC,4DAA4D,CAAC,EAAE,sDAAsD;YACpJ,IAAI,CAAC,cAAc,CAAC,cAAc,CAAC,8CAA8C,CAAC,EAAE,wBAAwB;SAC7G,CAAC,CAAC,CAAC,IAAI,CACN,GAAG,CAAC,GAAG,EAAE,CAAC,OAAO,CAAC,EAClB,WAAW,CAAC,CAAC,CAAC,CACf,CAAC;KA2QH;IAzQC;;;OAGG;IACK,aAAa,CAAC,IAAY;QAChC,2BAA2B;QAC3B,MAAM,IAAI,GAAG,IAAI,CAAC,KAAK,CAAC,YAAY,CAAE,CAAC,OAAO,EAAE,CAAC;QACjD,IAAI,UAAU,GAAG,KAAK,CAAC;QACvB,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,IAAI,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;YACrC,MAAM,GAAG,GAAG,IAAI,CAAC,CAAC,CAAC,CAAC;YACpB,IAAI,GAAG,KAAK,GAAG,EAAE,CAAC;gBAChB,MAAM,GAAG,GAAG,eAAe,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC;gBACzC,IAAI,CAAC,CAAC,CAAC,GAAG,eAAe,CAAC,GAAG,GAAG,CAAC,CAAC,CAAC;gBACnC,MAAM;YACR,CAAC;iBAAM,CAAC;gBACN,IAAI,CAAC,CAAC,CAAC,GAAG,GAAG,CAAC;gBACd,IAAI,CAAC,KAAK,IAAI,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC,CAAI,gBAAgB;oBAC9C,UAAU,GAAG,IAAI,CAAC;gBACpB,CAAC;YACH,CAAC;QACH,CAAC;QACD,IAAI,UAAU,EAAE,CAAC;YACf,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;QACjB,CAAC;QACD,OAAO,IAAI,CAAC,OAAO,EAAE,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC,CAAI,cAAc;IACnD,CAAC;IAED;;OAEG;IACK,SAAS,CAAC,IAAY;QAC5B,OAAO,IAAI,CAAC,KAAK,CAAC,cAAc,CAAE,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;IAC9C,CAAC;IAED;;OAEG;IACK,SAAS,CAAC,IAAY;QAC5B,OAAO,IAAI,CAAC,KAAK,CAAC,YAAY,CAAE,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;IAC5C,CAAC;IAED;;;OAGG;IACK,eAAe,CAAC,IAAY;QAClC,IAAI,GAAG,GAAG,CAAC,CAAC;QACZ,IAAI,CAAC,KAAK,CAAC,YAAY,CAAE,CAAC,OAAO,EAAE,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE;YACnD,IAAI,CAAC,IAAI,CAAC,EAAE,CAAC;gBACX,KAAK;gBACL,GAAG,IAAI,eAAe,CAAC,OAAO,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC;YACxC,CAAC;iBAAM,CAAC;gBACN,OAAO;gBACP,GAAG,IAAI,CAAC,eAAe,CAAC,OAAO,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,GAAG,EAAE,CAAC;YACnD,CAAC;QACH,CAAC,CAAC,CAAC;QACH,OAAO,GAAG,CAAC;IACb,CAAC;IAEO,KAAK,CAAC,aAAa,CAAC,KAAkB,EAAE,KAAW;QACzD,MAAM,KAAK,GAAG,MAAM,cAAc,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;QAC/C,OAAO,KAAK,CAAC,WAAW,CAAC,KAAK,CAAC,aAAa,CAAC,KAAK,EAAE,KAAK,CAAC,CAAC;IAC7D,CAAC;IAED;;OAEG;IACH,KAAK,CAAC,kBAAkB,CAAC,OAAe,EAAE,QAAgB,EAAE,KAAW;QACrE,MAAM,KAAK,GAAG,IAAI,CAAC,QAAQ,CAAC,cAAc,CAAC,OAAO,CAAE,CAAC;QACrD,MAAM,KAAK,GAAG,MAAM,cAAc,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;QAC/C,MAAM,EAAE,GAAG,IAAI,KAAK,CAAC,QAAQ,EAAE,CAAC;QAChC,MAAM,EAAE,GAAG,EAAE,CAAC,YAAY,CAAC,QAAQ,CAAC,CAAC;QACrC,MAAM,EAAE,GAAG,MAAM,IAAI,CAAC,cAAc,CAAC,EAAE,EAAE,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,IAAI,EAAE,KAAK,CAAC,CAAC;QACvE,MAAM,IAAI,CAAC,UAAU,CAAC,EAAE,CAAC,EAAE,EAAE,QAAQ,CAAC,CAAC;IACzC,CAAC;IAED;;OAEG;IACH,KAAK,CAAC,oBAAoB,CAAC,QAAkB,EAAE,UAAoB,EAAE,QAAgB,EAAE,KAAW;QAChG,MAAM,KAAK,GAAG,MAAM,cAAc,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;QAC/C,IAAI,EAAE,GAAG,IAAI,KAAK,CAAC,QAAQ,EAAE,CAAC;QAE9B,KAAK,IAAI,KAAK,GAAG,CAAC,EAAE,KAAK,GAAG,QAAQ,CAAC,MAAM,EAAE,KAAK,EAAE,EAAE,CAAC;YACrD,MAAM,KAAK,GAAG,IAAI,CAAC,QAAQ,CAAC,cAAc,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAE,CAAC;YAC7D,MAAM,SAAS,GAAG,UAAU,CAAC,KAAK,CAAC,CAAC;YACpC,MAAM,EAAE,GAAG,EAAE,CAAC,YAAY,CAAC,SAAS,CAAC,CAAC;YACtC,MAAM,EAAE,GAAG,MAAM,IAAI,CAAC,cAAc,CAAC,EAAE,EAAE,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,IAAI,EAAE,KAAK,CAAC,CAAC;YACvE,EAAE,GAAG,EAAE,CAAC,EAAE,CAAC;QACb,CAAC;QAED,MAAM,IAAI,CAAC,UAAU,CAAC,EAAE,EAAE,QAAQ,CAAC,CAAC;IACtC,CAAC;IAED;;OAEG;IACH,KAAK,CAAC,sBAAsB,CAAC,QAAkB,EAAE,QAAgB,EAAE,GAAG,GAAG,CAAC,EAAE,KAAW;QACrF,MAAM,KAAK,GAAG,MAAM,cAAc,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;QAE/C,IAAI,EAAE,GAAG,IAAI,KAAK,CAAC,QAAQ,EAAE,CAAC;QAC9B,MAAM,EAAE,GAAG,EAAE,CAAC,YAAY,CAAC,QAAQ,CAAC,CAAC;QACrC,IAAI,MAAM,GAAG,GAAG,CAAC,CAAI,qBAAqB;QAE1C,KAAK,MAAM,OAAO,IAAI,QAAQ,EAAE,CAAC;YAC/B,MAAM,KAAK,GAAG,IAAI,CAAC,QAAQ,CAAC,cAAc,CAAC,OAAO,CAAE,CAAC;YACrD,MAAM,EAAE,GAAG,MAAM,IAAI,CAAC,cAAc,CAAC,EAAE,EAAE,EAAE,EAAE,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,KAAK,CAAC,CAAC;YACzE,MAAM,OAAO,GAAG,EAAE,CAAC,IAAI,CAAC,EAAE,CAAC,IAAI,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC;YAC5C,MAAM,GAAG,IAAI,CAAC,aAAa,CAAC,OAAO,CAAC,CAAC;YACrC,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,GAAG,EAAE,CAAC,EAAE,EAAE,CAAC;gBAC7B,MAAM,GAAG,IAAI,CAAC,aAAa,CAAC,MAAM,CAAC,CAAC;YACtC,CAAC;YACD,EAAE,GAAG,EAAE,CAAC,EAAE,CAAC;QACb,CAAC;QAED,MAAM,IAAI,CAAC,UAAU,CAAC,EAAE,EAAE,QAAQ,CAAC,CAAC;IACtC,CAAC;IAED;;OAEG;IACH,KAAK,CAAC,sBAAsB,CAAC,QAAkB,EAAE,QAAgB,EAAE,GAAG,GAAG,CAAC,EAAE,KAAW;QACrF,IAAI,SAAS,GAAG,CAAC,CAAC;QAClB,MAAM,KAAK,GAAG,MAAM,cAAc,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;QAC/C,IAAI,EAAE,GAAG,IAAI,KAAK,CAAC,QAAQ,EAAE,CAAC;QAC9B,MAAM,EAAE,GAAG,EAAE,CAAC,YAAY,CAAC,QAAQ,CAAC,CAAC;QAErC,KAAK,MAAM,OAAO,IAAI,QAAQ,EAAE,CAAC;YAC/B,MAAM,KAAK,GAAG,IAAI,CAAC,QAAQ,CAAC,cAAc,CAAC,OAAO,CAAE,CAAC;YACrD,MAAM,EAAE,GAAG,MAAM,IAAI,CAAC,cAAc,CAAC,EAAE,EAAE,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,SAAS,EAAE,KAAK,CAAC,CAAC;YAC5E,SAAS,IAAI,EAAE,CAAC,IAAI,CAAC,MAAM,GAAG,GAAG,CAAC;YAClC,EAAE,GAAG,EAAE,CAAC,EAAE,CAAC;QACb,CAAC;QAED,MAAM,IAAI,CAAC,UAAU,CAAC,EAAE,EAAE,QAAQ,CAAC,CAAC;IACtC,CAAC;IAED;;;;;OAKG;IACK,KAAK,CAAC,cAAc,CAAC,EAAO,EAAE,EAAO,EAAE,KAAkB,EAAE,SAAyB,EAAE,SAAyB,EAAE,KAAW;QAClI,IAAI,CAAC,KAAK,EAAE,CAAC;YACX,KAAK,GAAG,EAAE,SAAS,EAAE,IAAI,EAAE,MAAM,EAAE,UAAU,EAAE,CAAC,CAAI,UAAU;QAChE,CAAC;aAAM,CAAC;YACN,KAAK,CAAC,SAAS,GAAG,IAAI,CAAC;QACzB,CAAC;QAED,MAAM,GAAG,GAAG,MAAM,IAAI,CAAC,aAAa,CAAC,KAAK,EAAE,KAAK,CAAC,CAAC;QACnD,IAAI,SAAS,GAAG,CAAC,CAAC,CAAI,oBAAoB;QAC1C,IAAI,SAAS,EAAE,CAAC;YACd,MAAM,CAAC,GAAG,EAAE,CAAC,SAAS,CAAC,SAAS,CAAC,CAAC;YAClC,SAAS,GAAG,CAAC,CAAC,MAAM,GAAG,CAAC,CAAC;QAC3B,CAAC;QACD,SAAS,GAAG,SAAS,IAAI,CAAC,CAAC,CAAG,gBAAgB;QAC9C,MAAM,OAAO,GAAwB,EAAE,CAAC;QACxC,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,CAAC,OAAO,CAAC,SAAS,CAAC,EAAE;YAC1C,IAAI,CAAC,SAAS,CAAC,UAAU,CAAC,GAAG,CAAC,EAAE,CAAC;gBAC/B,IAAI,MAAM,GAAG,IAAI,CAAC,SAAS,CAAC,SAAS,CAAC,CAAC;gBACvC,MAAM,GAAG,MAAM,CAAC,QAAQ,CAAC,MAAM,EAAE,EAAE,CAAC,GAAG,SAAS,CAAC,CAAC;gBAClD,MAAM,MAAM,GAAG,IAAI,CAAC,eAAe,CAAC,SAAS,CAAC,CAAC;gBAC/C,MAAM,GAAG,GAAG,EAAE,CAAC,SAAS,CAAC,SAAS,GAAG,MAAM,CAAC,CAAC,CAAC,cAAc;gBAC5D,MAAM,SAAS,GAAG,GAAG,CAAC,MAAM,GAAG,MAAM,CAAC;gBACtC,OAAO,CAAC,SAAS,CAAC,GAAG,GAAG,CAAC,SAAS,CAAC,CAAC;YACtC,CAAC;QACH,CAAC,CAAC,CAAC;QACH,MAAM,MAAM,GAAG,IAAI,GAAG,EAAU,CAAC;QACjC,MAAM,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE;YAC/B,MAAM,CAAC,GAAG,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,CAAC;QAChC,CAAC,CAAC,CAAC;QACH,IAAI,IAAI,GAAG,KAAK,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;QAC9B,gEAAgE;QAChE,IAAI,MAAM,GAAG,IAAI,CAAC,CAAC,CAAC,CAAC;QACrB,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,GAAG,CAAC,OAAO,CAAC,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC;YACjD,MAAM,IAAI,GAAG,IAAI,CAAC,aAAa,CAAC,MAAM,CAAC,CAAC;YACxC,MAAM,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;YACjB,MAAM,GAAG,IAAI,CAAC;QAChB,CAAC;QACD,IAAI,GAAG,KAAK,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,IAAI,CAAC,CAAC,CAAS,EAAE,CAAS,EAAE,EAAE;YACtD,IAAI,CAAC,CAAC,MAAM,KAAK,CAAC,CAAC,MAAM,EAAE,CAAC;gBAC1B,OAAO,CAAC,CAAC,aAAa,CAAC,CAAC,CAAC,CAAC;YAC5B,CAAC;iBAAM,IAAI,CAAC,CAAC,MAAM,GAAG,CAAC,CAAC,MAAM,EAAE,CAAC;gBAC/B,OAAO,CAAC,CAAC;YACX,CAAC;iBAAM,IAAI,CAAC,CAAC,MAAM,GAAG,CAAC,CAAC,MAAM,EAAE,CAAC;gBAC/B,OAAO,CAAC,CAAC,CAAC;YACZ,CAAC;YACD,OAAO,CAAC,CAAC,CAAC;QACZ,CAAC,CAAC,CAAC;QACH,KAAK;QACL,MAAM,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC,OAAO,CAAC,KAAK,CAAC,EAAE;YACnC,MAAM,IAAI,GAAG,EAAE,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC;YAC/B,MAAM,UAAU,GAAG,OAAO,CAAC,KAAK,CAAC,CAAC;YAClC,IAAI,UAAU,CAAC,CAAC,KAAK,GAAG,EAAE,CAAC,CAAG,wBAAwB;gBACpD,IAAI,CAAC,KAAK,GAAG,IAAI,CAAC,QAAQ,CAAC,SAAS,CAAC,UAAU,CAAC,CAAC,EAAE,UAAU,CAAC,CAAC,CAAC,CAAC;YACnE,CAAC;iBAAM,CAAC;gBACN,IAAI,CAAC,KAAK,GAAG,UAAU,CAAC,CAAC,CAAC;YAC5B,CAAC;YACD,UAAU;YACV,IAAI,UAAU,CAAC,KAAK,CAAC,QAAQ,EAAE,CAAC,CAAI,UAAU;gBAC5C,IAAI,CAAC,KAAK,CAAC,MAAM,GAAG;oBAClB,GAAG,EAAE,EAAE,KAAK,EAAE,MAAM,EAAE;oBACtB,IAAI,EAAE,EAAE,KAAK,EAAE,MAAM,EAAE;oBACvB,MAAM,EAAE,EAAE,KAAK,EAAE,MAAM,EAAE;oBACzB,KAAK,EAAE,EAAE,KAAK,EAAE,MAAM,EAAE;iBACzB,CAAC;YACJ,CAAC;YACD,mBAAmB;YACnB,IAAI,CAAC,KAAK,CAAC,SAAS,GAAG;gBACrB,UAAU,EAAE,UAAU,CAAC,KAAK,CAAC,KAAK;gBAClC,QAAQ,EAAE,QAAQ;gBAClB,QAAQ,EAAE,IAAI;aACf,CAAC;YACF,UAAU;YACV,IAAI,CAAC,KAAK,CAAC,IAAI,GAAG;gBAChB,IAAI,EAAE,UAAU,CAAC,KAAK,CAAC,IAAI;gBAC3B,IAAI,EAAE,IAAI;gBACV,IAAI,EAAE,UAAU,CAAC,KAAK,CAAC,KAAK,CAAC,KAAK;aACnC,CAAC;YACF,UAAU;YACV,IAAI,UAAU,CAAC,KAAK,CAAC,UAAU,EAAE,CAAC;gBAChC,IAAI,CAAC,IAAI,GAAG;oBACV,IAAI,EAAE,SAAS;oBACf,OAAO,EAAE,OAAO;oBAChB,OAAO,EAAE,EAAE,IAAI,EAAE,UAAU,CAAC,KAAK,CAAC,UAAU,EAAE,EAAK,0CAA0C;oBAC7F,8BAA8B;iBACxB,CAAC;YACX,CAAC;QACH,CAAC,CAAC,CAAC;QACH,UAAU;QACT,GAAG,CAAC,OAAO,CAAW,CAAC,OAAO,CAAC,CAAC,SAAS,EAAE,QAAQ,EAAE,EAAE;YACtD,MAAM,GAAG,GAAG,EAAE,CAAC,MAAM,CAAC,QAAQ,GAAG,SAAS,GAAG,CAAC,CAAC,CAAC;YAChD,GAAG,CAAC,MAAM,GAAG,SAAS,CAAC,MAAM,CAAC;QAChC,CAAC,CAAC,CAAC;QACH,OAAO;QACN,GAAG,CAAC,OAAO,CAAW,CAAC,OAAO,CAAC,CAAC,SAAS,EAAE,QAAQ,EAAE,EAAE;YACtD,MAAM,QAAQ,GAAG,IAAI,CAAC,QAAQ,CAAC,CAAC;YAChC,MAAM,GAAG,GAAG,EAAE,CAAC,SAAS,CAAC,QAAQ,CAAC,CAAC;YACnC,IAAI,SAAS,CAAC,KAAK,EAAE,CAAC;gBACpB,GAAG,CAAC,KAAK,GAAG,SAAS,CAAC,KAAK,CAAC;YAC9B,CAAC;QACH,CAAC,CAAC,CAAC;QACH,wBAAwB;QACvB,GAAG,CAAC,SAAS,CAAkB,EAAE,OAAO,CAAC,UAAU,CAAC,EAAE;YACrD,MAAM,CAAC,GAAG,UAAU,CAAC,GAAG,CAAC,CAAC;YAC1B,MAAM,CAAC,GAAG,UAAU,CAAC,GAAG,CAAC,CAAC;YAC1B,MAAM,SAAS,GAAG,EAAE,CAAC,OAAO,CAAC,SAAS,GAAG,CAAC,CAAC,CAAC,GAAG,CAAC,EAAE,SAAS,GAAG,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC;YACvE,MAAM,OAAO,GAAG,EAAE,CAAC,OAAO,CAAC,SAAS,GAAG,CAAC,CAAC,CAAC,GAAG,CAAC,EAAE,SAAS,GAAG,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC;YACrE,EAAE,CAAC,UAAU,CAAC,CAAC,SAAS,CAAC,OAAO,EAAE,OAAO,CAAC,OAAO,CAAC,CAAC,CAAC;QACtD,CAAC,CAAC,CAAC;QACH,OAAO,EAAE,EAAE,EAAE,IAAI,EAAE,IAAI,EAAE,GAAG,CAAC,OAAO,CAAC,EAAE,CAAC;IAC1C,CAAC;IAED;;OAEG;IACK,KAAK,CAAC,UAAU,CAAC,EAAO,EAAE,QAAgB;QAChD,MAAM,SAAS,GAAG,MAAM,EAAE,CAAC,IAAI,CAAC,WAAW,EAAE,CAAC;QAC9C,MAAM,IAAI,GAAG,IAAI,IAAI,CAAC,CAAC,SAAS,CAAC,EAAE,EAAE,IAAI,0FAAgB,EAAE,CAAC,CAAC;QAC7D,MAAM,MAAM,GAAG,QAAQ,CAAC,aAAa,CAAC,GAAG,CAAC,CAAC;QAC3C,MAAM,CAAC,IAAI,GAAG,GAAG,CAAC,eAAe,CAAC,IAAI,CAAC,CAAC;QACxC,MAAM,CAAC,QAAQ,GAAG,QAAQ,GAAG,OAAO,CAAC;QACrC,MAAM,CAAC,KAAK,EAAE,CAAC;IACjB,CAAC;+GAtRU,kBAAkB;mHAAlB,kBAAkB,cAFjB,MAAM;;4FAEP,kBAAkB;kBAH9B,UAAU;mBAAC;oBACV,UAAU,EAAE,MAAM;iBACnB","sourcesContent":["import { DatePipe, DOCUMENT } from '@angular/common';\nimport { inject, Injectable } from '@angular/core';\nimport { MediaType } from '@solar-kit/core';\nimport { defer, firstValueFrom, map, shareReplay } from 'rxjs';\nimport { ResourceLoader } from './resource-loader';\n// 不默认集成exceljs了，需要的时候注入XlsxService动态加载，因为不是每个地方都需要导出excel\n// import {TableParser, Workbook} from 'aieyes-exceljs-o';\ndeclare let ExcelJS: any;   // from exceljs\n\nconst EXCEL_COL_ALIAS = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ';\nconst NUMBER_PATTERN = /[0-9]/g;\nconst CHAR_PATTERN = /[a-zA-Z]/g;\n\n@Injectable({\n  providedIn: 'root'\n})\nexport class SpreadsheetService {\n  private readonly document: Document = inject(DOCUMENT);\n  private readonly resourceLoader = inject(ResourceLoader);\n  private readonly datePipe = new DatePipe('zh-CN');\n\n  // ExcelJS 对象，用时异步自动加载\n  private readonly excel = defer(() => Promise.all([\n    this.resourceLoader.loadScript('https://img.omofresh.com/js/aieyes-exceljs-o_1_8_10.min.js'), // 修改过的 https://www.npmjs.com/package/aieyes-exceljs-o\n    this.resourceLoader.loadStylesheet('https://img.omofresh.com/css/exceljs.min.css'), // aieyes-exceljs-o 中定义的\n  ])).pipe(\n    map(() => ExcelJS),\n    shareReplay(1)\n  );\n\n  /**\n   * 根据当前的单元格找到下一列的地址\n   * 采用倒序进位法，这样就不需要递归了\n   */\n  private nextColOfCell(cell: string) {\n    // 先把字母和数字分开，字母是列，数字是行，倒序排列\n    const args = cell.match(CHAR_PATTERN)!.reverse();\n    let needAppend = false;\n    for (let i = 0; i < args.length; i++) {\n      const arg = args[i];\n      if (arg !== 'Z') {\n        const idx = EXCEL_COL_ALIAS.indexOf(arg);\n        args[i] = EXCEL_COL_ALIAS[idx + 1];\n        break;\n      } else {\n        args[i] = 'A';\n        if (i === args.length - 1) {    // 说明是最后一个了，需要补A\n          needAppend = true;\n        }\n      }\n    }\n    if (needAppend) {\n      args.push('A');\n    }\n    return args.reverse().join('');    // 最终的结果，反转再合并\n  }\n\n  /**\n   * 获取单元格的行\n   */\n  private rowOfCell(cell: string) {\n    return cell.match(NUMBER_PATTERN)!.join('');\n  }\n\n  /**\n   * 获取单元格的列\n   */\n  private colOfCell(cell: string) {\n    return cell.match(CHAR_PATTERN)!.join('');\n  }\n\n  /**\n   * 单元格的列号\n   * 当作26进制计算列的编号\n   */\n  private colNumberOfCell(cell: string) {\n    let col = 0;\n    cell.match(CHAR_PATTERN)!.reverse().forEach((c, i) => {\n      if (i == 0) {\n        // 个位\n        col += EXCEL_COL_ALIAS.indexOf(c) + 1;\n      } else {\n        // 十位以上\n        col += (EXCEL_COL_ALIAS.indexOf(c) + 1) * i * 26;\n      }\n    });\n    return col;\n  }\n\n  private async parseDomTable(table: HTMLElement, _opts?: any) {\n    const excel = await firstValueFrom(this.excel);\n    return excel.TableParser.utils.parseDomTable(table, _opts);\n  }\n\n  /**\n   * 只导出一个table, 内容放在第一个sheet上\n   */\n  async exportDomTableById(tableId: string, fileName: string, _opts?: any) {\n    const table = this.document.getElementById(tableId)!;\n    const excel = await firstValueFrom(this.excel);\n    const wb = new excel.Workbook();\n    const ws = wb.addWorksheet(fileName);\n    const re = await this.exportDomTable(wb, ws, table, null, null, _opts);\n    await this.saveAsFile(re.wb, fileName);\n  }\n\n  /**\n   * 导出多个table, 内容放在多个sheet上\n   */\n  async exportDomTableSheets(tableIds: string[], sheetNames: string[], fileName: string, _opts?: any) {\n    const excel = await firstValueFrom(this.excel);\n    let wb = new excel.Workbook();\n\n    for (let index = 0; index < tableIds.length; index++) {\n      const table = this.document.getElementById(tableIds[index])!;\n      const sheetName = sheetNames[index];\n      const ws = wb.addWorksheet(sheetName);\n      const re = await this.exportDomTable(wb, ws, table, null, null, _opts);\n      wb = re.wb;\n    }\n\n    await this.saveAsFile(wb, fileName);\n  }\n\n  /**\n   * 在一页中导出多个table, 每个table默认间隔1列\n   */\n  async exportDomTableParallel(tableIds: string[], fileName: string, gap = 1, _opts?: any) {\n    const excel = await firstValueFrom(this.excel);\n\n    let wb = new excel.Workbook();\n    const ws = wb.addWorksheet(fileName);\n    let cursor = 'A';    // 从第一列开始导出，并列几个table\n\n    for (const tableId of tableIds) {\n      const table = this.document.getElementById(tableId)!;\n      const re = await this.exportDomTable(wb, ws, table, cursor, null, _opts);\n      const lastCol = re.cols[re.cols.length - 1];\n      cursor = this.nextColOfCell(lastCol);\n      for (let k = 0; k < gap; k++) {\n        cursor = this.nextColOfCell(cursor);\n      }\n      wb = re.wb;\n    }\n\n    await this.saveAsFile(wb, fileName);\n  }\n\n  /**\n   * 在一页中垂直导出多个table\n   */\n  async exportDomTableVertical(tableIds: string[], fileName: string, gap = 0, _opts?: any) {\n    let rowOffset = 0;\n    const excel = await firstValueFrom(this.excel);\n    let wb = new excel.Workbook();\n    const ws = wb.addWorksheet(fileName);\n\n    for (const tableId of tableIds) {\n      const table = this.document.getElementById(tableId)!;\n      const re = await this.exportDomTable(wb, ws, table, null, rowOffset, _opts);\n      rowOffset += re.rows.length + gap;\n      wb = re.wb;\n    }\n\n    await this.saveAsFile(wb, fileName);\n  }\n\n  /**\n   * 导出dom table\n   * colCursor: 标记起始列\n   * rowOffset: 偏移的行数\n   * @return 返回最后一列的列名\n   */\n  private async exportDomTable(wb: any, ws: any, table: HTMLElement, colCursor?: string | null, rowOffset?: number | null, _opts?: any) {\n    if (!_opts) {\n      _opts = { cellDates: true, dateNF: 'yyyy/M/d' };    // 默认的日期格式\n    } else {\n      _opts.cellDates = true;\n    }\n\n    const ref = await this.parseDomTable(table, _opts);\n    let colOffset = 0;    // colCursor偏移量，默认为0\n    if (colCursor) {\n      const c = ws.getColumn(colCursor);\n      colOffset = c.number - 1;\n    }\n    rowOffset = rowOffset || 0;   // rowOffset默认为0\n    const cellMap: Record<string, any> = {};\n    Object.keys(ref).sort().forEach(cellAlias => {\n      if (!cellAlias.startsWith('!')) {\n        let rowNum = this.rowOfCell(cellAlias);\n        rowNum = String(parseInt(rowNum, 10) + rowOffset);\n        const colNum = this.colNumberOfCell(cellAlias);\n        const col = ws.getColumn(colOffset + colNum); // 根据偏移量找出所在的列\n        const finalCell = col.letter + rowNum;\n        cellMap[finalCell] = ref[cellAlias];\n      }\n    });\n    const colSet = new Set<string>();\n    Object.keys(cellMap).forEach(k => {\n      colSet.add(this.colOfCell(k));\n    });\n    let cols = Array.from(colSet);\n    // 因为excel的列都是连续的，如果导出table存在跨列的话这里面可能却少某一列，所以需要补充缺少的列名保证这一段是连续的\n    let cursor = cols[0];\n    for (let i = 0; i < ref['!cols'].length - 1; i++) {\n      const next = this.nextColOfCell(cursor);\n      colSet.add(next);\n      cursor = next;\n    }\n    cols = Array.from(colSet).sort((a: string, b: string) => {\n      if (a.length === b.length) {\n        return a.localeCompare(b);\n      } else if (a.length > b.length) {\n        return 1;\n      } else if (b.length > a.length) {\n        return -1;\n      }\n      return -1;\n    });\n    // 赋值\n    Object.keys(cellMap).forEach(alias => {\n      const cell = ws.getCell(alias);\n      const cellConfig = cellMap[alias];\n      if (cellConfig.t === 'd') {   // 日期格式需格式化后显示，换言之转为了字符串\n        cell.value = this.datePipe.transform(cellConfig.v, cellConfig.z);\n      } else {\n        cell.value = cellConfig.v;\n      }\n      // 默认就有边框的\n      if (cellConfig.style.bordered) {    // 表示需要加边框\n        cell.style.border = {\n          top: { style: 'thin' },\n          left: { style: 'thin' },\n          bottom: { style: 'thin' },\n          right: { style: 'thin' }\n        };\n      }\n      // 默认内容垂直居中，左右居中不一定\n      cell.style.alignment = {\n        horizontal: cellConfig.style.align,\n        vertical: 'middle',\n        wrapText: true\n      };\n      // 字体默认为宋体\n      cell.style.font = {\n        bold: cellConfig.style.bold,\n        name: '宋体',\n        size: cellConfig.style.pound // 字号\n      };\n      // 背景色/前景色\n      if (cellConfig.style.background) {\n        cell.fill = {\n          type: 'pattern',\n          pattern: 'solid',\n          fgColor: { argb: cellConfig.style.background },    // 实际上fgColor是理解上的背景色，而不是前景色，不知道excel怎么定义的\n          // bgColor: {argb: 'ffd8e6de'}\n        } as any;\n      }\n    });\n    // 设置每行的高度\n    (ref['!rows'] as any[]).forEach((rowConfig, rowIndex) => {\n      const row = ws.getRow(rowIndex + rowOffset + 1);\n      row.height = rowConfig.height;\n    });\n    // 设置列宽\n    (ref['!cols'] as any[]).forEach((colConfig, colIndex) => {\n      const colAlias = cols[colIndex];\n      const col = ws.getColumn(colAlias);\n      if (colConfig.width) {\n        col.width = colConfig.width;\n      }\n    });\n    // 合并单元格, 由于不一定有，所以要判断一下\n    (ref['!merges'] as any[] | null)?.forEach(mergeParam => {\n      const s = mergeParam['s'];\n      const e = mergeParam['e'];\n      const startCell = ws.getCell(rowOffset + s.r + 1, colOffset + s.c + 1);\n      const endCell = ws.getCell(rowOffset + e.r + 1, colOffset + e.c + 1);\n      ws.mergeCells([startCell.address, endCell.address]);\n    });\n    return { wb, cols, rows: ref['!rows'] };\n  }\n\n  /**\n   * 保存Workbook到磁盘上\n   */\n  private async saveAsFile(wb: any, fileName: string) {\n    const excelData = await wb.xlsx.writeBuffer();\n    const blob = new Blob([excelData], { type: MediaType.Xlsx });\n    const anchor = document.createElement('a');\n    anchor.href = URL.createObjectURL(blob);\n    anchor.download = fileName + '.xlsx';\n    anchor.click();\n  }\n}\n"]}

package/esm2022/storage/index.mjs

@@ -0,0 +1,3 @@
+export * from './local-storage';
+export * from './session-storage';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9wYWNrYWdlcy9wbGF0Zm9ybS1icm93c2VyL3NyYy9zdG9yYWdlL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMsaUJBQWlCLENBQUE7QUFDL0IsY0FBYyxtQkFBbUIsQ0FBQSIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vbG9jYWwtc3RvcmFnZSdcbmV4cG9ydCAqIGZyb20gJy4vc2Vzc2lvbi1zdG9yYWdlJ1xuIl19

package/esm2022/storage/local-storage.mjs

@@ -0,0 +1,40 @@
+import { DOCUMENT } from '@angular/common';
+import { inject, Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+export class LocalStorage {
+    constructor() {
+        this.storage = inject(DOCUMENT).defaultView.localStorage;
+    }
+    /**
+     * 保存数据
+     * @param key 键名
+     * @param value 数据
+     */
+    set(key, value) {
+        this.storage.setItem(key, JSON.stringify(value));
+    }
+    /**
+     * 获取数据
+     * @param key 键名
+     */
+    get(key) {
+        const data = this.storage.getItem(key);
+        return data ? JSON.parse(data) : null;
+    }
+    /**
+     * 移除数据
+     * @param key 键名
+     */
+    remove(key) {
+        this.storage.removeItem(key);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: LocalStorage, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: LocalStorage, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: LocalStorage, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/storage/session-storage.mjs

@@ -0,0 +1,41 @@
+import { DOCUMENT } from '@angular/common';
+import { inject, Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+export class SessionStorage {
+    constructor() {
+        this.storage = inject(DOCUMENT).defaultView.sessionStorage;
+    }
+    /**
+     * 保存数据
+     * @param key 键名
+     * @param value 数据
+     */
+    set(key, value) {
+        this.storage.setItem(key, JSON.stringify(value));
+    }
+    /**
+     * 获取数据
+     * @param key 键名
+     * @param defaults 默认值
+     */
+    get(key) {
+        const data = this.storage.getItem(key);
+        return data ? JSON.parse(data) : null;
+    }
+    /**
+     * 移除数据
+     * @param key 键名
+     */
+    remove(key) {
+        this.storage.removeItem(key);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: SessionStorage, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: SessionStorage, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: SessionStorage, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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