office-viewer 0.3.11 → 0.3.13

package/esm/node_modules/echarts/lib/model/Model.js

@@ -0,0 +1,134 @@
+import env from '../../../zrender/lib/core/env.js';
+import { enableClassExtend, enableClassCheck } from '../util/clazz.js';
+import { AreaStyleMixin } from './mixin/areaStyle.js';
+import TextStyleMixin from './mixin/textStyle.js';
+import { LineStyleMixin } from './mixin/lineStyle.js';
+import { ItemStyleMixin } from './mixin/itemStyle.js';
+import { merge, clone, mixin } from '../../../zrender/lib/core/util.js';
+
+var Model = /** @class */function () {
+  function Model(option, parentModel, ecModel) {
+    this.parentModel = parentModel;
+    this.ecModel = ecModel;
+    this.option = option;
+    // Simple optimization
+    // if (this.init) {
+    //     if (arguments.length <= 4) {
+    //         this.init(option, parentModel, ecModel, extraOpt);
+    //     }
+    //     else {
+    //         this.init.apply(this, arguments);
+    //     }
+    // }
+  }
+
+  Model.prototype.init = function (option, parentModel, ecModel) {
+  };
+  /**
+   * Merge the input option to me.
+   */
+  Model.prototype.mergeOption = function (option, ecModel) {
+    merge(this.option, option, true);
+  };
+  // `path` can be 'a.b.c', so the return value type have to be `ModelOption`
+  // TODO: TYPE strict key check?
+  // get(path: string | string[], ignoreParent?: boolean): ModelOption;
+  Model.prototype.get = function (path, ignoreParent) {
+    if (path == null) {
+      return this.option;
+    }
+    return this._doGet(this.parsePath(path), !ignoreParent && this.parentModel);
+  };
+  Model.prototype.getShallow = function (key, ignoreParent) {
+    var option = this.option;
+    var val = option == null ? option : option[key];
+    if (val == null && !ignoreParent) {
+      var parentModel = this.parentModel;
+      if (parentModel) {
+        // FIXME:TS do not know how to make it works
+        val = parentModel.getShallow(key);
+      }
+    }
+    return val;
+  };
+  // `path` can be 'a.b.c', so the return value type have to be `Model<ModelOption>`
+  // getModel(path: string | string[], parentModel?: Model): Model;
+  // TODO 'a.b.c' is deprecated
+  Model.prototype.getModel = function (path, parentModel) {
+    var hasPath = path != null;
+    var pathFinal = hasPath ? this.parsePath(path) : null;
+    var obj = hasPath ? this._doGet(pathFinal) : this.option;
+    parentModel = parentModel || this.parentModel && this.parentModel.getModel(this.resolveParentPath(pathFinal));
+    return new Model(obj, parentModel, this.ecModel);
+  };
+  /**
+   * If model has option
+   */
+  Model.prototype.isEmpty = function () {
+    return this.option == null;
+  };
+  Model.prototype.restoreData = function () {};
+  // Pending
+  Model.prototype.clone = function () {
+    var Ctor = this.constructor;
+    return new Ctor(clone(this.option));
+  };
+  // setReadOnly(properties): void {
+  // clazzUtil.setReadOnly(this, properties);
+  // }
+  // If path is null/undefined, return null/undefined.
+  Model.prototype.parsePath = function (path) {
+    if (typeof path === 'string') {
+      return path.split('.');
+    }
+    return path;
+  };
+  // Resolve path for parent. Perhaps useful when parent use a different property.
+  // Default to be a identity resolver.
+  // Can be modified to a different resolver.
+  Model.prototype.resolveParentPath = function (path) {
+    return path;
+  };
+  // FIXME:TS check whether put this method here
+  Model.prototype.isAnimationEnabled = function () {
+    if (!env.node && this.option) {
+      if (this.option.animation != null) {
+        return !!this.option.animation;
+      } else if (this.parentModel) {
+        return this.parentModel.isAnimationEnabled();
+      }
+    }
+  };
+  Model.prototype._doGet = function (pathArr, parentModel) {
+    var obj = this.option;
+    if (!pathArr) {
+      return obj;
+    }
+    for (var i = 0; i < pathArr.length; i++) {
+      // Ignore empty
+      if (!pathArr[i]) {
+        continue;
+      }
+      // obj could be number/string/... (like 0)
+      obj = obj && typeof obj === 'object' ? obj[pathArr[i]] : null;
+      if (obj == null) {
+        break;
+      }
+    }
+    if (obj == null && parentModel) {
+      obj = parentModel._doGet(this.resolveParentPath(pathArr), parentModel.parentModel);
+    }
+    return obj;
+  };
+  return Model;
+}();
+// Enable Model.extend.
+enableClassExtend(Model);
+enableClassCheck(Model);
+mixin(Model, LineStyleMixin);
+mixin(Model, ItemStyleMixin);
+mixin(Model, AreaStyleMixin);
+mixin(Model, TextStyleMixin);
+var Model$1 = Model;
+
+export { Model$1 as default };

package/esm/node_modules/echarts/lib/model/OptionManager.js

@@ -0,0 +1,319 @@
+import { normalizeToArray } from '../util/model.js';
+import { each, isTypedArray, setAsPrimitive, clone, map, isArray, isObject } from '../../../zrender/lib/core/util.js';
+import { error } from '../util/log.js';
+
+var QUERY_REG = /^(min|max)?(.+)$/;
+// Key: mainType
+// type FakeComponentsMap = HashMap<(MappingExistingItem & { subType: string })[]>;
+/**
+ * TERM EXPLANATIONS:
+ * See `ECOption` and `ECUnitOption` in `src/util/types.ts`.
+ */
+var OptionManager = /** @class */function () {
+  // timeline.notMerge is not supported in ec3. Firstly there is rearly
+  // case that notMerge is needed. Secondly supporting 'notMerge' requires
+  // rawOption cloned and backuped when timeline changed, which does no
+  // good to performance. What's more, that both timeline and setOption
+  // method supply 'notMerge' brings complex and some problems.
+  // Consider this case:
+  // (step1) chart.setOption({timeline: {notMerge: false}, ...}, false);
+  // (step2) chart.setOption({timeline: {notMerge: true}, ...}, false);
+  function OptionManager(api) {
+    this._timelineOptions = [];
+    this._mediaList = [];
+    /**
+     * -1, means default.
+     * empty means no media.
+     */
+    this._currentMediaIndices = [];
+    this._api = api;
+  }
+  OptionManager.prototype.setOption = function (rawOption, optionPreprocessorFuncs, opt) {
+    if (rawOption) {
+      // That set dat primitive is dangerous if user reuse the data when setOption again.
+      each(normalizeToArray(rawOption.series), function (series) {
+        series && series.data && isTypedArray(series.data) && setAsPrimitive(series.data);
+      });
+      each(normalizeToArray(rawOption.dataset), function (dataset) {
+        dataset && dataset.source && isTypedArray(dataset.source) && setAsPrimitive(dataset.source);
+      });
+    }
+    // Caution: some series modify option data, if do not clone,
+    // it should ensure that the repeat modify correctly
+    // (create a new object when modify itself).
+    rawOption = clone(rawOption);
+    // FIXME
+    // If some property is set in timeline options or media option but
+    // not set in baseOption, a warning should be given.
+    var optionBackup = this._optionBackup;
+    var newParsedOption = parseRawOption(rawOption, optionPreprocessorFuncs, !optionBackup);
+    this._newBaseOption = newParsedOption.baseOption;
+    // For setOption at second time (using merge mode);
+    if (optionBackup) {
+      // FIXME
+      // the restore merge solution is essentially incorrect.
+      // the mapping can not be 100% consistent with ecModel, which probably brings
+      // potential bug!
+      // The first merge is delayed, because in most cases, users do not call `setOption` twice.
+      // let fakeCmptsMap = this._fakeCmptsMap;
+      // if (!fakeCmptsMap) {
+      //     fakeCmptsMap = this._fakeCmptsMap = createHashMap();
+      //     mergeToBackupOption(fakeCmptsMap, null, optionBackup.baseOption, null);
+      // }
+      // mergeToBackupOption(
+      //     fakeCmptsMap, optionBackup.baseOption, newParsedOption.baseOption, opt
+      // );
+      // For simplicity, timeline options and media options do not support merge,
+      // that is, if you `setOption` twice and both has timeline options, the latter
+      // timeline options will not be merged to the former, but just substitute them.
+      if (newParsedOption.timelineOptions.length) {
+        optionBackup.timelineOptions = newParsedOption.timelineOptions;
+      }
+      if (newParsedOption.mediaList.length) {
+        optionBackup.mediaList = newParsedOption.mediaList;
+      }
+      if (newParsedOption.mediaDefault) {
+        optionBackup.mediaDefault = newParsedOption.mediaDefault;
+      }
+    } else {
+      this._optionBackup = newParsedOption;
+    }
+  };
+  OptionManager.prototype.mountOption = function (isRecreate) {
+    var optionBackup = this._optionBackup;
+    this._timelineOptions = optionBackup.timelineOptions;
+    this._mediaList = optionBackup.mediaList;
+    this._mediaDefault = optionBackup.mediaDefault;
+    this._currentMediaIndices = [];
+    return clone(isRecreate
+    // this._optionBackup.baseOption, which is created at the first `setOption`
+    // called, and is merged into every new option by inner method `mergeToBackupOption`
+    // each time `setOption` called, can be only used in `isRecreate`, because
+    // its reliability is under suspicion. In other cases option merge is
+    // performed by `model.mergeOption`.
+    ? optionBackup.baseOption : this._newBaseOption);
+  };
+  OptionManager.prototype.getTimelineOption = function (ecModel) {
+    var option;
+    var timelineOptions = this._timelineOptions;
+    if (timelineOptions.length) {
+      // getTimelineOption can only be called after ecModel inited,
+      // so we can get currentIndex from timelineModel.
+      var timelineModel = ecModel.getComponent('timeline');
+      if (timelineModel) {
+        option = clone(
+        // FIXME:TS as TimelineModel or quivlant interface
+        timelineOptions[timelineModel.getCurrentIndex()]);
+      }
+    }
+    return option;
+  };
+  OptionManager.prototype.getMediaOption = function (ecModel) {
+    var ecWidth = this._api.getWidth();
+    var ecHeight = this._api.getHeight();
+    var mediaList = this._mediaList;
+    var mediaDefault = this._mediaDefault;
+    var indices = [];
+    var result = [];
+    // No media defined.
+    if (!mediaList.length && !mediaDefault) {
+      return result;
+    }
+    // Multi media may be applied, the latter defined media has higher priority.
+    for (var i = 0, len = mediaList.length; i < len; i++) {
+      if (applyMediaQuery(mediaList[i].query, ecWidth, ecHeight)) {
+        indices.push(i);
+      }
+    }
+    // FIXME
+    // Whether mediaDefault should force users to provide? Otherwise
+    // the change by media query can not be recorvered.
+    if (!indices.length && mediaDefault) {
+      indices = [-1];
+    }
+    if (indices.length && !indicesEquals(indices, this._currentMediaIndices)) {
+      result = map(indices, function (index) {
+        return clone(index === -1 ? mediaDefault.option : mediaList[index].option);
+      });
+    }
+    // Otherwise return nothing.
+    this._currentMediaIndices = indices;
+    return result;
+  };
+  return OptionManager;
+}();
+/**
+ * [RAW_OPTION_PATTERNS]
+ * (Note: "series: []" represents all other props in `ECUnitOption`)
+ *
+ * (1) No prop "baseOption" declared:
+ * Root option is used as "baseOption" (except prop "options" and "media").
+ * ```js
+ * option = {
+ *     series: [],
+ *     timeline: {},
+ *     options: [],
+ * };
+ * option = {
+ *     series: [],
+ *     media: {},
+ * };
+ * option = {
+ *     series: [],
+ *     timeline: {},
+ *     options: [],
+ *     media: {},
+ * }
+ * ```
+ *
+ * (2) Prop "baseOption" declared:
+ * If "baseOption" declared, `ECUnitOption` props can only be declared
+ * inside "baseOption" except prop "timeline" (compat ec2).
+ * ```js
+ * option = {
+ *     baseOption: {
+ *         timeline: {},
+ *         series: [],
+ *     },
+ *     options: []
+ * };
+ * option = {
+ *     baseOption: {
+ *         series: [],
+ *     },
+ *     media: []
+ * };
+ * option = {
+ *     baseOption: {
+ *         timeline: {},
+ *         series: [],
+ *     },
+ *     options: []
+ *     media: []
+ * };
+ * option = {
+ *     // ec3 compat ec2: allow (only) `timeline` declared
+ *     // outside baseOption. Keep this setting for compat.
+ *     timeline: {},
+ *     baseOption: {
+ *         series: [],
+ *     },
+ *     options: [],
+ *     media: []
+ * };
+ * ```
+ */
+function parseRawOption(
+// `rawOption` May be modified
+rawOption, optionPreprocessorFuncs, isNew) {
+  var mediaList = [];
+  var mediaDefault;
+  var baseOption;
+  var declaredBaseOption = rawOption.baseOption;
+  // Compatible with ec2, [RAW_OPTION_PATTERNS] above.
+  var timelineOnRoot = rawOption.timeline;
+  var timelineOptionsOnRoot = rawOption.options;
+  var mediaOnRoot = rawOption.media;
+  var hasMedia = !!rawOption.media;
+  var hasTimeline = !!(timelineOptionsOnRoot || timelineOnRoot || declaredBaseOption && declaredBaseOption.timeline);
+  if (declaredBaseOption) {
+    baseOption = declaredBaseOption;
+    // For merge option.
+    if (!baseOption.timeline) {
+      baseOption.timeline = timelineOnRoot;
+    }
+  }
+  // For convenience, enable to use the root option as the `baseOption`:
+  // `{ ...normalOptionProps, media: [{ ... }, { ... }] }`
+  else {
+    if (hasTimeline || hasMedia) {
+      rawOption.options = rawOption.media = null;
+    }
+    baseOption = rawOption;
+  }
+  if (hasMedia) {
+    if (isArray(mediaOnRoot)) {
+      each(mediaOnRoot, function (singleMedia) {
+        if (process.env.NODE_ENV !== 'production') {
+          // Real case of wrong config.
+          if (singleMedia && !singleMedia.option && isObject(singleMedia.query) && isObject(singleMedia.query.option)) {
+            error('Illegal media option. Must be like { media: [ { query: {}, option: {} } ] }');
+          }
+        }
+        if (singleMedia && singleMedia.option) {
+          if (singleMedia.query) {
+            mediaList.push(singleMedia);
+          } else if (!mediaDefault) {
+            // Use the first media default.
+            mediaDefault = singleMedia;
+          }
+        }
+      });
+    } else {
+      if (process.env.NODE_ENV !== 'production') {
+        // Real case of wrong config.
+        error('Illegal media option. Must be an array. Like { media: [ {...}, {...} ] }');
+      }
+    }
+  }
+  doPreprocess(baseOption);
+  each(timelineOptionsOnRoot, function (option) {
+    return doPreprocess(option);
+  });
+  each(mediaList, function (media) {
+    return doPreprocess(media.option);
+  });
+  function doPreprocess(option) {
+    each(optionPreprocessorFuncs, function (preProcess) {
+      preProcess(option, isNew);
+    });
+  }
+  return {
+    baseOption: baseOption,
+    timelineOptions: timelineOptionsOnRoot || [],
+    mediaDefault: mediaDefault,
+    mediaList: mediaList
+  };
+}
+/**
+ * @see <http://www.w3.org/TR/css3-mediaqueries/#media1>
+ * Support: width, height, aspectRatio
+ * Can use max or min as prefix.
+ */
+function applyMediaQuery(query, ecWidth, ecHeight) {
+  var realMap = {
+    width: ecWidth,
+    height: ecHeight,
+    aspectratio: ecWidth / ecHeight // lower case for convenience.
+  };
+
+  var applicable = true;
+  each(query, function (value, attr) {
+    var matched = attr.match(QUERY_REG);
+    if (!matched || !matched[1] || !matched[2]) {
+      return;
+    }
+    var operator = matched[1];
+    var realAttr = matched[2].toLowerCase();
+    if (!compare(realMap[realAttr], value, operator)) {
+      applicable = false;
+    }
+  });
+  return applicable;
+}
+function compare(real, expect, operator) {
+  if (operator === 'min') {
+    return real >= expect;
+  } else if (operator === 'max') {
+    return real <= expect;
+  } else {
+    // Equals
+    return real === expect;
+  }
+}
+function indicesEquals(indices1, indices2) {
+  // indices is always order by asc and has only finite number.
+  return indices1.join(',') === indices2.join(',');
+}
+
+export { OptionManager as default };