zmdms-webui 1.9.4 → 1.9.6

package/dist/es/node_modules/exceljs/lib/stream/xlsx/workbook-reader.js

@@ -1,354 +0,0 @@
-import require$$0 from 'fs';
-import require$$0$1 from 'events';
-import { r as readableExports } from '../../../node_modules/readable-stream/readable.js';
-import require$$0$2 from 'stream';
-import '../../../../unzipper/unzip.js';
-import { t as tmpExports } from '../../../../tmp/lib/tmp.js';
-import { i as iterateStream$1 } from '../../utils/iterate-stream.js';
-import { p as parseSax$1 } from '../../utils/parse-sax.js';
-import { s as stylesXform } from '../../xlsx/xform/style/styles-xform.js';
-import { w as workbookXform } from '../../xlsx/xform/book/workbook-xform.js';
-import { r as relationshipsXform } from '../../xlsx/xform/core/relationships-xform.js';
-import { w as worksheetReader } from './worksheet-reader.js';
-import { h as hyperlinkReader } from './hyperlink-reader.js';
-import { __exports as unzip$1 } from '../../../../../_virtual/unzip.js';
-
-const fs = require$$0;
-const {EventEmitter} = require$$0$1;
-const {PassThrough, Readable} = readableExports;
-const nodeStream = require$$0$2;
-const unzip = unzip$1;
-const tmp = tmpExports;
-const iterateStream = iterateStream$1;
-const parseSax = parseSax$1;
-
-const StyleManager = stylesXform;
-const WorkbookXform = workbookXform;
-const RelationshipsXform = relationshipsXform;
-
-const WorksheetReader = worksheetReader;
-const HyperlinkReader = hyperlinkReader;
-
-tmp.setGracefulCleanup();
-
-class WorkbookReader extends EventEmitter {
-  constructor(input, options = {}) {
-    super();
-
-    this.input = input;
-
-    this.options = {
-      worksheets: 'emit',
-      sharedStrings: 'cache',
-      hyperlinks: 'ignore',
-      styles: 'ignore',
-      entries: 'ignore',
-      ...options,
-    };
-
-    this.styles = new StyleManager();
-    this.styles.init();
-  }
-
-  _getStream(input) {
-    if (input instanceof nodeStream.Readable || input instanceof Readable) {
-      return input;
-    }
-    if (typeof input === 'string') {
-      return fs.createReadStream(input);
-    }
-    throw new Error(`Could not recognise input: ${input}`);
-  }
-
-  async read(input, options) {
-    try {
-      for await (const {eventType, value} of this.parse(input, options)) {
-        switch (eventType) {
-          case 'shared-strings':
-            this.emit(eventType, value);
-            break;
-          case 'worksheet':
-            this.emit(eventType, value);
-            await value.read();
-            break;
-          case 'hyperlinks':
-            this.emit(eventType, value);
-            break;
-        }
-      }
-      this.emit('end');
-      this.emit('finished');
-    } catch (error) {
-      this.emit('error', error);
-    }
-  }
-
-  async *[Symbol.asyncIterator]() {
-    for await (const {eventType, value} of this.parse()) {
-      if (eventType === 'worksheet') {
-        yield value;
-      }
-    }
-  }
-
-  async *parse(input, options) {
-    if (options) this.options = options;
-    const stream = (this.stream = this._getStream(input || this.input));
-    const zip = unzip.Parse({forceStream: true});
-    stream.pipe(zip);
-
-    // worksheets, deferred for parsing after shared strings reading
-    const waitingWorkSheets = [];
-
-    for await (const entry of iterateStream(zip)) {
-      let match;
-      let sheetNo;
-      switch (entry.path) {
-        case '_rels/.rels':
-          break;
-        case 'xl/_rels/workbook.xml.rels':
-          await this._parseRels(entry);
-          break;
-        case 'xl/workbook.xml':
-          await this._parseWorkbook(entry);
-          break;
-        case 'xl/sharedStrings.xml':
-          yield* this._parseSharedStrings(entry);
-          break;
-        case 'xl/styles.xml':
-          await this._parseStyles(entry);
-          break;
-        default:
-          if (entry.path.match(/xl\/worksheets\/sheet\d+[.]xml/)) {
-            match = entry.path.match(/xl\/worksheets\/sheet(\d+)[.]xml/);
-            sheetNo = match[1];
-            if (this.sharedStrings && this.workbookRels) {
-              yield* this._parseWorksheet(iterateStream(entry), sheetNo);
-            } else {
-              // create temp file for each worksheet
-              await new Promise((resolve, reject) => {
-                tmp.file((err, path, fd, tempFileCleanupCallback) => {
-                  if (err) {
-                    return reject(err);
-                  }
-                  waitingWorkSheets.push({sheetNo, path, tempFileCleanupCallback});
-
-                  const tempStream = fs.createWriteStream(path);
-                  tempStream.on('error', reject);
-                  entry.pipe(tempStream);
-                  return tempStream.on('finish', () => {
-                    return resolve();
-                  });
-                });
-              });
-            }
-          } else if (entry.path.match(/xl\/worksheets\/_rels\/sheet\d+[.]xml.rels/)) {
-            match = entry.path.match(/xl\/worksheets\/_rels\/sheet(\d+)[.]xml.rels/);
-            sheetNo = match[1];
-            yield* this._parseHyperlinks(iterateStream(entry), sheetNo);
-          }
-          break;
-      }
-      entry.autodrain();
-    }
-
-    for (const {sheetNo, path, tempFileCleanupCallback} of waitingWorkSheets) {
-      let fileStream = fs.createReadStream(path);
-      // TODO: Remove once node v8 is deprecated
-      // Detect and upgrade old fileStreams
-      if (!fileStream[Symbol.asyncIterator]) {
-        fileStream = fileStream.pipe(new PassThrough());
-      }
-      yield* this._parseWorksheet(fileStream, sheetNo);
-      tempFileCleanupCallback();
-    }
-  }
-
-  _emitEntry(payload) {
-    if (this.options.entries === 'emit') {
-      this.emit('entry', payload);
-    }
-  }
-
-  async _parseRels(entry) {
-    const xform = new RelationshipsXform();
-    this.workbookRels = await xform.parseStream(iterateStream(entry));
-  }
-
-  async _parseWorkbook(entry) {
-    this._emitEntry({type: 'workbook'});
-
-    const workbook = new WorkbookXform();
-    await workbook.parseStream(iterateStream(entry));
-
-    this.properties = workbook.map.workbookPr;
-    this.model = workbook.model;
-  }
-
-  async *_parseSharedStrings(entry) {
-    this._emitEntry({type: 'shared-strings'});
-    switch (this.options.sharedStrings) {
-      case 'cache':
-        this.sharedStrings = [];
-        break;
-      case 'emit':
-        break;
-      default:
-        return;
-    }
-
-    let text = null;
-    let richText = [];
-    let index = 0;
-    let font = null;
-    for await (const events of parseSax(iterateStream(entry))) {
-      for (const {eventType, value} of events) {
-        if (eventType === 'opentag') {
-          const node = value;
-          switch (node.name) {
-            case 'b':
-              font = font || {};
-              font.bold = true;
-              break;
-            case 'charset':
-              font = font || {};
-              font.charset = parseInt(node.attributes.charset, 10);
-              break;
-            case 'color':
-              font = font || {};
-              font.color = {};
-              if (node.attributes.rgb) {
-                font.color.argb = node.attributes.argb;
-              }
-              if (node.attributes.val) {
-                font.color.argb = node.attributes.val;
-              }
-              if (node.attributes.theme) {
-                font.color.theme = node.attributes.theme;
-              }
-              break;
-            case 'family':
-              font = font || {};
-              font.family = parseInt(node.attributes.val, 10);
-              break;
-            case 'i':
-              font = font || {};
-              font.italic = true;
-              break;
-            case 'outline':
-              font = font || {};
-              font.outline = true;
-              break;
-            case 'rFont':
-              font = font || {};
-              font.name = node.value;
-              break;
-            case 'si':
-              font = null;
-              richText = [];
-              text = null;
-              break;
-            case 'sz':
-              font = font || {};
-              font.size = parseInt(node.attributes.val, 10);
-              break;
-            case 'strike':
-              break;
-            case 't':
-              text = null;
-              break;
-            case 'u':
-              font = font || {};
-              font.underline = true;
-              break;
-            case 'vertAlign':
-              font = font || {};
-              font.vertAlign = node.attributes.val;
-              break;
-          }
-        } else if (eventType === 'text') {
-          text = text ? text + value : value;
-        } else if (eventType === 'closetag') {
-          const node = value;
-          switch (node.name) {
-            case 'r':
-              richText.push({
-                font,
-                text,
-              });
-
-              font = null;
-              text = null;
-              break;
-            case 'si':
-              if (this.options.sharedStrings === 'cache') {
-                this.sharedStrings.push(richText.length ? {richText} : text);
-              } else if (this.options.sharedStrings === 'emit') {
-                yield {index: index++, text: richText.length ? {richText} : text};
-              }
-
-              richText = [];
-              font = null;
-              text = null;
-              break;
-          }
-        }
-      }
-    }
-  }
-
-  async _parseStyles(entry) {
-    this._emitEntry({type: 'styles'});
-    if (this.options.styles === 'cache') {
-      this.styles = new StyleManager();
-      await this.styles.parseStream(iterateStream(entry));
-    }
-  }
-
-  *_parseWorksheet(iterator, sheetNo) {
-    this._emitEntry({type: 'worksheet', id: sheetNo});
-    const worksheetReader = new WorksheetReader({
-      workbook: this,
-      id: sheetNo,
-      iterator,
-      options: this.options,
-    });
-
-    const matchingRel = (this.workbookRels || []).find(rel => rel.Target === `worksheets/sheet${sheetNo}.xml`);
-    const matchingSheet = matchingRel && (this.model.sheets || []).find(sheet => sheet.rId === matchingRel.Id);
-    if (matchingSheet) {
-      worksheetReader.id = matchingSheet.id;
-      worksheetReader.name = matchingSheet.name;
-      worksheetReader.state = matchingSheet.state;
-    }
-    if (this.options.worksheets === 'emit') {
-      yield {eventType: 'worksheet', value: worksheetReader};
-    }
-  }
-
-  *_parseHyperlinks(iterator, sheetNo) {
-    this._emitEntry({type: 'hyperlinks', id: sheetNo});
-    const hyperlinksReader = new HyperlinkReader({
-      workbook: this,
-      id: sheetNo,
-      iterator,
-      options: this.options,
-    });
-    if (this.options.hyperlinks === 'emit') {
-      yield {eventType: 'hyperlinks', value: hyperlinksReader};
-    }
-  }
-}
-
-// for reference - these are the valid values for options
-WorkbookReader.Options = {
-  worksheets: ['emit', 'ignore'],
-  sharedStrings: ['cache', 'emit', 'ignore'],
-  hyperlinks: ['cache', 'emit', 'ignore'],
-  styles: ['cache', 'ignore'],
-  entries: ['emit', 'ignore'],
-};
-
-var workbookReader = WorkbookReader;
-
-export { workbookReader as w };

package/dist/es/node_modules/exceljs/lib/stream/xlsx/workbook-writer.js

@@ -1,365 +0,0 @@
-import require$$0 from 'fs';
-import { a as archiver } from '../../../../archiver/index.js';
-import { s as streamBuf } from '../../utils/stream-buf.js';
-import { r as relType } from '../../xlsx/rel-type.js';
-import { s as stylesXform } from '../../xlsx/xform/style/styles-xform.js';
-import { s as sharedStrings } from '../../utils/shared-strings.js';
-import { d as definedNames } from '../../doc/defined-names.js';
-import { c as coreXform } from '../../xlsx/xform/core/core-xform.js';
-import { r as relationshipsXform } from '../../xlsx/xform/core/relationships-xform.js';
-import { c as contentTypesXform } from '../../xlsx/xform/core/content-types-xform.js';
-import { a as appXform } from '../../xlsx/xform/core/app-xform.js';
-import { w as workbookXform } from '../../xlsx/xform/book/workbook-xform.js';
-import { s as sharedStringsXform } from '../../xlsx/xform/strings/shared-strings-xform.js';
-import { w as worksheetWriter } from './worksheet-writer.js';
-import { t as theme1 } from '../../xlsx/xml/theme1.js';
-
-const fs = require$$0;
-const Archiver = archiver;
-
-const StreamBuf = streamBuf;
-
-const RelType = relType;
-const StylesXform = stylesXform;
-const SharedStrings = sharedStrings;
-const DefinedNames = definedNames;
-
-const CoreXform = coreXform;
-const RelationshipsXform = relationshipsXform;
-const ContentTypesXform = contentTypesXform;
-const AppXform = appXform;
-const WorkbookXform = workbookXform;
-const SharedStringsXform = sharedStringsXform;
-
-const WorksheetWriter = worksheetWriter;
-
-const theme1Xml = theme1;
-
-class WorkbookWriter {
-  constructor(options) {
-    options = options || {};
-
-    this.created = options.created || new Date();
-    this.modified = options.modified || this.created;
-    this.creator = options.creator || 'ExcelJS';
-    this.lastModifiedBy = options.lastModifiedBy || 'ExcelJS';
-    this.lastPrinted = options.lastPrinted;
-
-    // using shared strings creates a smaller xlsx file but may use more memory
-    this.useSharedStrings = options.useSharedStrings || false;
-    this.sharedStrings = new SharedStrings();
-
-    // style manager
-    this.styles = options.useStyles ? new StylesXform(true) : new StylesXform.Mock(true);
-
-    // defined names
-    this._definedNames = new DefinedNames();
-
-    this._worksheets = [];
-    this.views = [];
-
-    this.zipOptions = options.zip;
-
-    this.media = [];
-    this.commentRefs = [];
-
-    this.zip = Archiver('zip', this.zipOptions);
-    if (options.stream) {
-      this.stream = options.stream;
-    } else if (options.filename) {
-      this.stream = fs.createWriteStream(options.filename);
-    } else {
-      this.stream = new StreamBuf();
-    }
-    this.zip.pipe(this.stream);
-
-    // these bits can be added right now
-    this.promise = Promise.all([this.addThemes(), this.addOfficeRels()]);
-  }
-
-  get definedNames() {
-    return this._definedNames;
-  }
-
-  _openStream(path) {
-    const stream = new StreamBuf({bufSize: 65536, batch: true});
-    this.zip.append(stream, {name: path});
-    stream.on('finish', () => {
-      stream.emit('zipped');
-    });
-    return stream;
-  }
-
-  _commitWorksheets() {
-    const commitWorksheet = function(worksheet) {
-      if (!worksheet.committed) {
-        return new Promise(resolve => {
-          worksheet.stream.on('zipped', () => {
-            resolve();
-          });
-          worksheet.commit();
-        });
-      }
-      return Promise.resolve();
-    };
-    // if there are any uncommitted worksheets, commit them now and wait
-    const promises = this._worksheets.map(commitWorksheet);
-    if (promises.length) {
-      return Promise.all(promises);
-    }
-    return Promise.resolve();
-  }
-
-  async commit() {
-    // commit all worksheets, then add suplimentary files
-    await this.promise;
-    await this.addMedia();
-    await this._commitWorksheets();
-    await Promise.all([
-      this.addContentTypes(),
-      this.addApp(),
-      this.addCore(),
-      this.addSharedStrings(),
-      this.addStyles(),
-      this.addWorkbookRels(),
-    ]);
-    await this.addWorkbook();
-    return this._finalize();
-  }
-
-  get nextId() {
-    // find the next unique spot to add worksheet
-    let i;
-    for (i = 1; i < this._worksheets.length; i++) {
-      if (!this._worksheets[i]) {
-        return i;
-      }
-    }
-    return this._worksheets.length || 1;
-  }
-
-  addImage(image) {
-    const id = this.media.length;
-    const medium = Object.assign({}, image, {type: 'image', name: `image${id}.${image.extension}`});
-    this.media.push(medium);
-    return id;
-  }
-
-  getImage(id) {
-    return this.media[id];
-  }
-
-  addWorksheet(name, options) {
-    // it's possible to add a worksheet with different than default
-    // shared string handling
-    // in fact, it's even possible to switch it mid-sheet
-    options = options || {};
-    const useSharedStrings =
-      options.useSharedStrings !== undefined ? options.useSharedStrings : this.useSharedStrings;
-
-    if (options.tabColor) {
-      // eslint-disable-next-line no-console
-      console.trace('tabColor option has moved to { properties: tabColor: {...} }');
-      options.properties = Object.assign(
-        {
-          tabColor: options.tabColor,
-        },
-        options.properties
-      );
-    }
-
-    const id = this.nextId;
-    name = name || `sheet${id}`;
-
-    const worksheet = new WorksheetWriter({
-      id,
-      name,
-      workbook: this,
-      useSharedStrings,
-      properties: options.properties,
-      state: options.state,
-      pageSetup: options.pageSetup,
-      views: options.views,
-      autoFilter: options.autoFilter,
-      headerFooter: options.headerFooter,
-    });
-
-    this._worksheets[id] = worksheet;
-    return worksheet;
-  }
-
-  getWorksheet(id) {
-    if (id === undefined) {
-      return this._worksheets.find(() => true);
-    }
-    if (typeof id === 'number') {
-      return this._worksheets[id];
-    }
-    if (typeof id === 'string') {
-      return this._worksheets.find(worksheet => worksheet && worksheet.name === id);
-    }
-    return undefined;
-  }
-
-  addStyles() {
-    return new Promise(resolve => {
-      this.zip.append(this.styles.xml, {name: 'xl/styles.xml'});
-      resolve();
-    });
-  }
-
-  addThemes() {
-    return new Promise(resolve => {
-      this.zip.append(theme1Xml, {name: 'xl/theme/theme1.xml'});
-      resolve();
-    });
-  }
-
-  addOfficeRels() {
-    return new Promise(resolve => {
-      const xform = new RelationshipsXform();
-      const xml = xform.toXml([
-        {Id: 'rId1', Type: RelType.OfficeDocument, Target: 'xl/workbook.xml'},
-        {Id: 'rId2', Type: RelType.CoreProperties, Target: 'docProps/core.xml'},
-        {Id: 'rId3', Type: RelType.ExtenderProperties, Target: 'docProps/app.xml'},
-      ]);
-      this.zip.append(xml, {name: '/_rels/.rels'});
-      resolve();
-    });
-  }
-
-  addContentTypes() {
-    return new Promise(resolve => {
-      const model = {
-        worksheets: this._worksheets.filter(Boolean),
-        sharedStrings: this.sharedStrings,
-        commentRefs: this.commentRefs,
-        media: this.media,
-      };
-      const xform = new ContentTypesXform();
-      const xml = xform.toXml(model);
-      this.zip.append(xml, {name: '[Content_Types].xml'});
-      resolve();
-    });
-  }
-
-  addMedia() {
-    return Promise.all(
-      this.media.map(medium => {
-        if (medium.type === 'image') {
-          const filename = `xl/media/${medium.name}`;
-          if (medium.filename) {
-            return this.zip.file(medium.filename, {name: filename});
-          }
-          if (medium.buffer) {
-            return this.zip.append(medium.buffer, {name: filename});
-          }
-          if (medium.base64) {
-            const dataimg64 = medium.base64;
-            const content = dataimg64.substring(dataimg64.indexOf(',') + 1);
-            return this.zip.append(content, {name: filename, base64: true});
-          }
-        }
-        throw new Error('Unsupported media');
-      })
-    );
-  }
-
-  addApp() {
-    return new Promise(resolve => {
-      const model = {
-        worksheets: this._worksheets.filter(Boolean),
-      };
-      const xform = new AppXform();
-      const xml = xform.toXml(model);
-      this.zip.append(xml, {name: 'docProps/app.xml'});
-      resolve();
-    });
-  }
-
-  addCore() {
-    return new Promise(resolve => {
-      const coreXform = new CoreXform();
-      const xml = coreXform.toXml(this);
-      this.zip.append(xml, {name: 'docProps/core.xml'});
-      resolve();
-    });
-  }
-
-  addSharedStrings() {
-    if (this.sharedStrings.count) {
-      return new Promise(resolve => {
-        const sharedStringsXform = new SharedStringsXform();
-        const xml = sharedStringsXform.toXml(this.sharedStrings);
-        this.zip.append(xml, {name: '/xl/sharedStrings.xml'});
-        resolve();
-      });
-    }
-    return Promise.resolve();
-  }
-
-  addWorkbookRels() {
-    let count = 1;
-    const relationships = [
-      {Id: `rId${count++}`, Type: RelType.Styles, Target: 'styles.xml'},
-      {Id: `rId${count++}`, Type: RelType.Theme, Target: 'theme/theme1.xml'},
-    ];
-    if (this.sharedStrings.count) {
-      relationships.push({
-        Id: `rId${count++}`,
-        Type: RelType.SharedStrings,
-        Target: 'sharedStrings.xml',
-      });
-    }
-    this._worksheets.forEach(worksheet => {
-      if (worksheet) {
-        worksheet.rId = `rId${count++}`;
-        relationships.push({
-          Id: worksheet.rId,
-          Type: RelType.Worksheet,
-          Target: `worksheets/sheet${worksheet.id}.xml`,
-        });
-      }
-    });
-    return new Promise(resolve => {
-      const xform = new RelationshipsXform();
-      const xml = xform.toXml(relationships);
-      this.zip.append(xml, {name: '/xl/_rels/workbook.xml.rels'});
-      resolve();
-    });
-  }
-
-  addWorkbook() {
-    const {zip} = this;
-    const model = {
-      worksheets: this._worksheets.filter(Boolean),
-      definedNames: this._definedNames.model,
-      views: this.views,
-      properties: {},
-      calcProperties: {},
-    };
-
-    return new Promise(resolve => {
-      const xform = new WorkbookXform();
-      xform.prepare(model);
-      zip.append(xform.toXml(model), {name: '/xl/workbook.xml'});
-      resolve();
-    });
-  }
-
-  _finalize() {
-    return new Promise((resolve, reject) => {
-      this.stream.on('error', reject);
-      this.stream.on('finish', () => {
-        resolve(this);
-      });
-      this.zip.on('error', reject);
-
-      this.zip.finalize();
-    });
-  }
-}
-
-var workbookWriter = WorkbookWriter;
-
-export { workbookWriter as w };