ocpview-plus 0.0.1

package/src/method/index.js

@@ -0,0 +1,8 @@
+import caseMethod from './case/case.js';
+import commonMethod from './const/const.js';
+import query from './config/queryconfig.js';
+export default {
+    caseMethod,
+    commonMethod,
+    query   
+};

package/src/static/excel/exportexcel.js

@@ -0,0 +1,627 @@
+/* eslint-disable */
+import * as XLSX from "xlsx"
+import * as XLSXS from "xlsx-style-vite"
+import {saveAs} from 'file-saver'
+
+(function (view) {
+    "use strict";
+
+    view.URL = view.URL || view.webkitURL;
+
+    if (view.Blob && view.URL) {
+        try {
+            new Blob;
+            return;
+        } catch (e) {}
+    }
+
+    // Internally we use a BlobBuilder implementation to base Blob off of
+    // in order to support older browsers that only have BlobBuilder
+    var BlobBuilder = view.BlobBuilder || view.WebKitBlobBuilder || view.MozBlobBuilder || (function(view) {
+            var
+                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) {
+                var
+                    type = blob.type
+                    , 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/*, endings*/) {
+                var bb = this.data;
+                // decode data to a binary string
+                if (Uint8Array && (data instanceof ArrayBuffer || data instanceof Uint8Array)) {
+                    var
+                        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) {
+                        var fr = new FileReaderSync;
+                        bb.push(fr.readAsBinaryString(data));
+                    } else {
+                        // async FileReader won't work as BlobBuilder is sync
+                        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 += ""; // convert unsupported types to strings
+                    }
+                    // decode UTF-16 to binary string
+                    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) {
+                var 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) {
+        var type = options ? (options.type || "") : "";
+        var builder = new BlobBuilder();
+        if (blobParts) {
+            for (var i = 0, len = blobParts.length; i < len; i++) {
+                builder.append(blobParts[i]);
+            }
+        }
+        return builder.getBlob(type);
+    };
+}(typeof self !== "undefined" && self || typeof window !== "undefined" && window || this.content || this));
+
+function generateArray(table) {
+    var out = [];
+    var rows = table.querySelectorAll('tr');
+    var ranges = [];
+    for (var R = 0; R < rows.length; ++R) {
+        var outRow = [];
+        var row = rows[R];
+        var columns = row.querySelectorAll('td');
+        for (var C = 0; C < columns.length; ++C) {
+            var cell = columns[C];
+            var colspan = cell.getAttribute('colspan');
+            var rowspan = cell.getAttribute('rowspan');
+            var cellValue = cell.innerText;
+            if (cellValue !== "" && cellValue == +cellValue) cellValue = +cellValue;
+
+            //Skip ranges
+            ranges.forEach(function (range) {
+                if (R >= range.s.r && R <= range.e.r && outRow.length >= range.s.c && outRow.length <= range.e.c) {
+                    for (var i = 0; i <= range.e.c - range.s.c; ++i) outRow.push(null);
+                }
+            });
+
+            //Handle Row Span
+            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}});
+            }
+            ;
+
+            //Handle Value
+            outRow.push(cellValue !== "" ? cellValue : null);
+
+            //Handle Colspan
+            if (colspan) for (var k = 0; k < colspan - 1; ++k) outRow.push(null);
+        }
+        out.push(outRow);
+    }
+    return [out, ranges];
+};
+
+function datenum(v, date1904) {
+    if (date1904) v += 1462;
+    var epoch = Date.parse(v);
+    return (epoch - new Date(Date.UTC(1899, 11, 30))) / (24 * 60 * 60 * 1000);
+}
+
+function sheet_from_array_of_arrays(data, opts) {
+    var ws = {};
+    var range = {s: {c: 10000000, r: 10000000}, e: {c: 0, r: 0}};
+    for (var R = 0; R != data.length; ++R) {
+        for (var 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;
+            var cell = {v: data[R][C]};
+            if (cell.v == null) continue;
+            var 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) {
+    var buf = new ArrayBuffer(s.length);
+    var view = new Uint8Array(buf);
+    for (var i = 0; i != s.length; ++i) view[i] = s.charCodeAt(i) & 0xFF;
+    return buf;
+}
+
+export function export_table_to_excel(id) {
+    var theTable = document.getElementById(id);
+    console.log('a')
+    var oo = generateArray(theTable);
+    var ranges = oo[1];
+
+    /* original data */
+    var data = oo[0];
+    var ws_name = "SheetJS";
+    console.log(data);
+
+    var wb = new Workbook(), ws = sheet_from_array_of_arrays(data);
+
+    /* add ranges to worksheet */
+    // ws['!cols'] = ['apple', 'banan'];
+    ws['!merges'] = ranges;
+
+    /* add worksheet to workbook */
+    wb.SheetNames.push(ws_name);
+    wb.Sheets[ws_name] = ws;
+
+    var wbout = XLSX.write(wb, {bookType: 'xlsx', bookSST: false, type: 'binary'});
+
+    saveAs(new Blob([s2ab(wbout)], {type: "application/octet-stream"}), "test.xlsx")
+}
+
+function formatJson(names,jsonData) {
+   return jsonData.map(v => names.map(j =>v[j]));
+}
+
+export function exportExcel(config, jsonData, sheetName, defaultTitle) {
+     /* original data */
+     var th = [];
+     var names = [];
+     config.forEach(el => {
+         if (el.label) {
+             th.push(el.label);
+         } else {
+             th.push(el.name);
+         }
+         names.push(el.name);
+     })
+
+     var data = formatJson(names,jsonData);
+     data.unshift(th);
+     var ws_name = "SheetJS";
+     if (sheetName) {
+         ws_name = sheetName;
+     }
+     var wb = new Workbook(), ws = sheet_from_array_of_arrays(data);
+
+     /* add worksheet to workbook */
+     wb.SheetNames.push(ws_name);
+     wb.Sheets[ws_name] = ws;
+
+     var wbout = XLSX.write(wb, {bookType: 'xlsx', bookSST: false, type: 'binary'});
+     var title = defaultTitle || '列表'
+     saveAs(new Blob([s2ab(wbout)], {type: "application/octet-stream"}), title + ".xlsx")
+}
+
+export function exportMultiSheetExcel(obj, defaultTitle) {
+    var wb = new Workbook();
+    var th = [];
+    var names = [];
+    var ws_name = "";
+    obj.forEach((tmp, index) => {
+        th = [];
+        names = [];
+        tmp.config.forEach(el => {
+            if (el.label) {
+                th.push(el.label);
+            } else {
+                th.push(el.name);
+            }
+            names.push(el.name);
+        });
+        
+        var data = formatJson(names,tmp.data);
+        data.unshift(th);
+        ws_name = "SheetJS" + index;
+        if (tmp.sheetName) {
+            ws_name = tmp.sheetName;
+        }
+        wb.SheetNames.push(ws_name);
+        wb.Sheets[ws_name] = sheet_from_array_of_arrays(data);
+    });
+    var wbout = XLSX.write(wb, {bookType: 'xlsx', bookSST: false, type: 'binary'});
+    var title = defaultTitle || '列表';
+    saveAs(new Blob([s2ab(wbout)], {type: "application/octet-stream"}), title + ".xlsx");
+}
+
+function getExcelCellConfig(config) {
+  let pro = {};
+  pro.alignment = {
+      vertical: 'center',
+      wrapText: true
+  };
+  if (config.type === 'NumberBox') {
+      pro.alignment.horizontal = 'right';
+      if (config.format && config.format.length > 1) {
+          let numType = config.format[0];
+          let precisionNum = config.format[1];
+          let excelstyle = '0';
+          if (numType === 'n' || numType === 'p') {
+              excelstyle = '0';
+          } else if (numType === 'c') {
+              excelstyle  = '¥#,##0';
+          }
+          let tempStyle = '';
+          if (Number(precisionNum) > 0) {
+              for (let i = 0; i < Number(precisionNum); i++) {
+                  tempStyle = tempStyle + '0';
+              }
+          }
+          if (tempStyle) {
+              excelstyle = excelstyle + '.'+ tempStyle;
+          }
+          if (numType === 'p') {
+              excelstyle = excelstyle + '%';
+          }
+          pro.numFmt = excelstyle;
+      }
+      pro.t = 'n';
+  } else if (config.type === 'DataBox') {
+      pro.alignment.horizontal = 'center';
+      let excelstyle = 'yyyy年m月d日';
+      if (config.vtype === 'datetime') {
+          excelstyle = 'yyyy年m月d日 h:mm:ss';
+      }
+      pro.numFmt = excelstyle;
+      pro.t = 'd';
+  } else {
+      pro.alignment.horizontal = 'left';
+      pro.numFmt='@';
+      pro.t = 's';
+  }
+  return pro;
+}
+ 
+
+function getHeadPro(names, heads, excelData, mergelist) {
+  let sIndex = 0;
+  for (let i=0;i<heads.length;i++) {
+      let temp = new Array(names.length).fill('');
+      sIndex = 0;
+     
+      let preFsIndes = '';
+      for (let j=0;j<heads[i].length;j++) {
+          if (heads[i][j].fIndex || heads[i][j].fIndex === 0) {
+              let findex = i- 1;
+              let fsIndex = heads[findex][heads[i][j].fIndex].sIndex;
+              if (preFsIndes !== fsIndex) {
+                  sIndex = fsIndex;
+                  preFsIndes = fsIndex;
+              }
+          }
+          temp[sIndex] = heads[i][j].label;
+          heads[i][j].sIndex = sIndex;
+          let tempMerge = {};
+          tempMerge.s = {};
+          tempMerge.s.r = i;
+          tempMerge.s.c = sIndex;
+          tempMerge.e = {};
+          tempMerge.e.r = tempMerge.s.r;
+          sIndex = sIndex  + heads[i][j].num;
+          if (heads[i][j].num === 1) {
+              if (i === 0) {
+                  tempMerge.e.r =  heads.length -1;
+                  tempMerge.e.c = tempMerge.s.c;
+              }
+          } else {
+              tempMerge.e.c = sIndex - 1;
+          }
+          if (i !== heads.length -1) {
+              mergelist.push(tempMerge);
+          }
+      }
+      excelData.push(temp);
+  }
+}
+function getExportConfig (config, head, n, names, fIndex) {
+  if (config instanceof Array) {
+      config.forEach(el => {
+          getExportConfig(el,head, n, names, fIndex);
+      });
+  } else {
+      if (config.visible !== false) {
+          let obj = {};
+          obj.label = config.label;
+          obj.num = 1;
+          let childRenNum = 0;
+          let tempIndex = head[n].length;
+          if (config.children && config.children.length > 0) {
+              config.children.forEach(el => {
+                  let num  = getExportConfig(el, head, n+1, names, tempIndex);
+                  childRenNum = childRenNum + num;
+              });  
+              obj.num = childRenNum;
+          } else {
+              if (config.name) {
+                  obj.name = config.name;
+                  let width = 100;
+                  if (config.width) {
+                      if (config.width > 100) {
+                          width =  config.width;
+                      }
+                  } else if (config.maxWidth) {
+                      if (config.maxWidth > 100) {
+                          width =  config.maxWidth;
+                      }
+                  } else if (config.minWidth) {
+                      if (config.minWidth > 100) {
+                          width =  config.minWidth;
+                      }
+                  }
+                  obj.width = width;
+                  obj.excelPro = getExcelCellConfig(config);
+                  names.push(obj);
+              }
+          }
+          if (fIndex||fIndex === 0) {
+              if (n !== 0) {
+                  obj.fIndex = fIndex;
+              } 
+          }
+          head[n].push(obj); 
+          return obj.num;
+      } else {
+          return 0;
+      }
+  }
+}
+
+export function exportExcelStyle(config, data, headNum, filename) {
+  let head = [];
+  for (let i=0;i<headNum; i++) {
+    head.push([]);
+  }
+  let num = 0;
+  let names = [];       
+  getExportConfig(config,head,num,names);
+  let mergeslist = [];
+  // 需要导出的数据
+  let excelData = [];
+  getHeadPro(names, head, excelData, mergeslist);
+  let widthCol = [];
+  names.forEach(el => {
+    widthCol.push({wpx: el.width});
+  });
+  data.forEach(el => {
+    let temp = [];
+    names.forEach(el2 => {
+      if (el2.excelPro.t === 'n') {
+        temp.push(Number(el[el2.name]));
+      } else if (el2.excelPro.t === 'd') {
+        let value = datenum(new Date(el[el2.name]));
+        temp.push(value);
+        el2.excelPro.t = 'n';
+      } else {
+        temp.push(el[el2.name]);
+      }
+    })
+    excelData.push(temp);
+  });
+  let namesNum = names.length;
+ 
+   
+  let defaultHeadCellStyle = {
+     // 字体
+     font: {
+      name: '宋体',
+      sz: 9,
+      bold: true
+    },
+    border: {
+      top: {
+        style: 'thin'
+      },
+      bottom: {
+        style: 'thin'
+      },
+      left: {
+        style: 'thin'
+      },
+      right: {
+        style: 'thin'
+      }
+    },
+    alignment: {
+      horizontal: 'center',
+      vertical: 'center',
+      wrapText: true
+    }
+  }
+  let defaultCellStyle = {
+    // 字体
+    font: {
+     name: '宋体',
+     sz: 9
+   },
+   border: {
+     top: {
+       style: 'thin'
+     },
+     bottom: {
+       style: 'thin'
+     },
+     left: {
+       style: 'thin'
+     },
+     right: {
+       style: 'thin'
+     }
+   }
+ };
+
+  // 导出的excel文件名
+  let tempfilename = 'example.xlsx'
+  if (filename) {
+    tempfilename = filename;
+   }
+ 
+  // Excel第一个sheet的名称
+  const ws_name = 'Sheet1'
+  const wb = XLSX.utils.book_new();
+  const ws = XLSX.utils.aoa_to_sheet(excelData)
+  XLSX.utils.book_append_sheet(wb, ws, ws_name) // 将数据添加到工作薄
+ 
+ 
+  // 设置标题行单元格合并
+  // s即start, e即end, r即row, c即column
+  // 合并从--0行0列开始,到0行3列
+  if (mergeslist.length > 0) {
+    ws['!merges'] = mergeslist
+  }
+  let x=0;
+  // 可以遍历全部单元格,进行样式设置
+  for (let i in ws) {
+    if (i === '!merges' || i === '!ref' || i === '!cols') continue;
+    ws[i].s = defaultHeadCellStyle
+    if (x < namesNum*headNum) {
+      ws[i].s = defaultHeadCellStyle
+    } else {
+      let pro =Object.assign({},{},defaultCellStyle);
+      let num = x%namesNum;
+      Object.assign(pro,names[num].excelPro);
+      ws[i].s = pro
+    }
+    x++;
+
+  }
+ 
+  // 设置单元格宽度
+  ws['!cols'] = widthCol;
+ 
+
+  // 导出Excel, 注意这里用到的是XLSXS对象
+  let wbout = XLSXS.write(wb, {
+    bookType: 'xlsx',
+    bookSST: false,
+    type: 'binary'
+  })
+  saveAs(
+    new Blob([s2ab(wbout)], {
+      type: 'application/octet-stream'
+    }),
+    tempfilename
+  )
+}
+