/*!
 * Mars3D平台插件,原生JS下的项目widget模块化设计功能模块
 * 版本信息：v3.1.17, hash值: 90d3bc1335d8a33b2b81
 * 编译日期：2021-12-20 13:39:27
 * 版权所有：Copyright by 火星科技 http://mars3d.cn
 * 
 */
(function webpackUniversalModuleDefinition(root, factory) {
	if(typeof exports === 'object' && typeof module === 'object')
		module.exports = factory(require("mars3d"));
	else if(typeof define === 'function' && define.amd)
		define("mars3dWidget", ["mars3d"], factory);
	else if(typeof exports === 'object')
		exports["mars3dWidget"] = factory(require("mars3d"));
	else
		root["mars3dWidget"] = factory(root["mars3d"]);
})(window, function(__WEBPACK_EXTERNAL_MODULE__0__) {
return /******/ (function(modules) { // webpackBootstrap
/******/ 	// The module cache
/******/ 	var installedModules = {};
/******/
/******/ 	// The require function
/******/ 	function __webpack_require__(moduleId) {
/******/
/******/ 		// Check if module is in cache
/******/ 		if(installedModules[moduleId]) {
/******/ 			return installedModules[moduleId].exports;
/******/ 		}
/******/ 		// Create a new module (and put it into the cache)
/******/ 		var module = installedModules[moduleId] = {
/******/ 			i: moduleId,
/******/ 			l: false,
/******/ 			exports: {}
/******/ 		};
/******/
/******/ 		// Execute the module function
/******/ 		modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);
/******/
/******/ 		// Flag the module as loaded
/******/ 		module.l = true;
/******/
/******/ 		// Return the exports of the module
/******/ 		return module.exports;
/******/ 	}
/******/
/******/
/******/ 	// expose the modules object (__webpack_modules__)
/******/ 	__webpack_require__.m = modules;
/******/
/******/ 	// expose the module cache
/******/ 	__webpack_require__.c = installedModules;
/******/
/******/ 	// define getter function for harmony exports
/******/ 	__webpack_require__.d = function(exports, name, getter) {
/******/ 		if(!__webpack_require__.o(exports, name)) {
/******/ 			Object.defineProperty(exports, name, { enumerable: true, get: getter });
/******/ 		}
/******/ 	};
/******/
/******/ 	// define __esModule on exports
/******/ 	__webpack_require__.r = function(exports) {
/******/ 		if(typeof Symbol !== 'undefined' && Symbol.toStringTag) {
/******/ 			Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
/******/ 		}
/******/ 		Object.defineProperty(exports, '__esModule', { value: true });
/******/ 	};
/******/
/******/ 	// create a fake namespace object
/******/ 	// mode & 1: value is a module id, require it
/******/ 	// mode & 2: merge all properties of value into the ns
/******/ 	// mode & 4: return value when already ns object
/******/ 	// mode & 8|1: behave like require
/******/ 	__webpack_require__.t = function(value, mode) {
/******/ 		if(mode & 1) value = __webpack_require__(value);
/******/ 		if(mode & 8) return value;
/******/ 		if((mode & 4) && typeof value === 'object' && value && value.__esModule) return value;
/******/ 		var ns = Object.create(null);
/******/ 		__webpack_require__.r(ns);
/******/ 		Object.defineProperty(ns, 'default', { enumerable: true, value: value });
/******/ 		if(mode & 2 && typeof value != 'string') for(var key in value) __webpack_require__.d(ns, key, function(key) { return value[key]; }.bind(null, key));
/******/ 		return ns;
/******/ 	};
/******/
/******/ 	// getDefaultExport function for compatibility with non-harmony modules
/******/ 	__webpack_require__.n = function(module) {
/******/ 		var getter = module && module.__esModule ?
/******/ 			function getDefault() { return module['default']; } :
/******/ 			function getModuleExports() { return module; };
/******/ 		__webpack_require__.d(getter, 'a', getter);
/******/ 		return getter;
/******/ 	};
/******/
/******/ 	// Object.prototype.hasOwnProperty.call
/******/ 	__webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };
/******/
/******/ 	// __webpack_public_path__
/******/ 	__webpack_require__.p = "";
/******/
/******/
/******/ 	// Load entry module and return exports
/******/ 	return __webpack_require__(__webpack_require__.s = 11);
/******/ })
/************************************************************************/
/******/ ([
/* 0 */
/***/ (function(module, exports) {

module.exports = __WEBPACK_EXTERNAL_MODULE__0__;

/***/ }),
/* 1 */
/***/ (function(module, exports) {

function _typeof(obj) {
  "@babel/helpers - typeof";

  if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") {
    module.exports = _typeof = function _typeof(obj) {
      return typeof obj;
    };

    module.exports["default"] = module.exports, module.exports.__esModule = true;
  } else {
    module.exports = _typeof = function _typeof(obj) {
      return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj;
    };

    module.exports["default"] = module.exports, module.exports.__esModule = true;
  }

  return _typeof(obj);
}

module.exports = _typeof;
module.exports["default"] = module.exports, module.exports.__esModule = true;

/***/ }),
/* 2 */
/***/ (function(module, exports) {

function _defineProperty(obj, key, value) {
  if (key in obj) {
    Object.defineProperty(obj, key, {
      value: value,
      enumerable: true,
      configurable: true,
      writable: true
    });
  } else {
    obj[key] = value;
  }

  return obj;
}

module.exports = _defineProperty;
module.exports["default"] = module.exports, module.exports.__esModule = true;

/***/ }),
/* 3 */
/***/ (function(module, exports) {

function _getPrototypeOf(o) {
  module.exports = _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) {
    return o.__proto__ || Object.getPrototypeOf(o);
  };
  module.exports["default"] = module.exports, module.exports.__esModule = true;
  return _getPrototypeOf(o);
}

module.exports = _getPrototypeOf;
module.exports["default"] = module.exports, module.exports.__esModule = true;

/***/ }),
/* 4 */
/***/ (function(module, exports) {

function _classCallCheck(instance, Constructor) {
  if (!(instance instanceof Constructor)) {
    throw new TypeError("Cannot call a class as a function");
  }
}

module.exports = _classCallCheck;
module.exports["default"] = module.exports, module.exports.__esModule = true;

/***/ }),
/* 5 */
/***/ (function(module, exports) {

function _defineProperties(target, props) {
  for (var i = 0; i < props.length; i++) {
    var descriptor = props[i];
    descriptor.enumerable = descriptor.enumerable || false;
    descriptor.configurable = true;
    if ("value" in descriptor) descriptor.writable = true;
    Object.defineProperty(target, descriptor.key, descriptor);
  }
}

function _createClass(Constructor, protoProps, staticProps) {
  if (protoProps) _defineProperties(Constructor.prototype, protoProps);
  if (staticProps) _defineProperties(Constructor, staticProps);
  return Constructor;
}

module.exports = _createClass;
module.exports["default"] = module.exports, module.exports.__esModule = true;

/***/ }),
/* 6 */
/***/ (function(module, exports, __webpack_require__) {

var setPrototypeOf = __webpack_require__(9);

function _inherits(subClass, superClass) {
  if (typeof superClass !== "function" && superClass !== null) {
    throw new TypeError("Super expression must either be null or a function");
  }

  subClass.prototype = Object.create(superClass && superClass.prototype, {
    constructor: {
      value: subClass,
      writable: true,
      configurable: true
    }
  });
  if (superClass) setPrototypeOf(subClass, superClass);
}

module.exports = _inherits;
module.exports["default"] = module.exports, module.exports.__esModule = true;

/***/ }),
/* 7 */
/***/ (function(module, exports, __webpack_require__) {

var _typeof = __webpack_require__(1)["default"];

var assertThisInitialized = __webpack_require__(10);

function _possibleConstructorReturn(self, call) {
  if (call && (_typeof(call) === "object" || typeof call === "function")) {
    return call;
  } else if (call !== void 0) {
    throw new TypeError("Derived constructors may only return object or undefined");
  }

  return assertThisInitialized(self);
}

module.exports = _possibleConstructorReturn;
module.exports["default"] = module.exports, module.exports.__esModule = true;

/***/ }),
/* 8 */
/***/ (function(module, exports, __webpack_require__) {

// extracted by mini-css-extract-plugin

/***/ }),
/* 9 */
/***/ (function(module, exports) {

function _setPrototypeOf(o, p) {
  module.exports = _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) {
    o.__proto__ = p;
    return o;
  };

  module.exports["default"] = module.exports, module.exports.__esModule = true;
  return _setPrototypeOf(o, p);
}

module.exports = _setPrototypeOf;
module.exports["default"] = module.exports, module.exports.__esModule = true;

/***/ }),
/* 10 */
/***/ (function(module, exports) {

function _assertThisInitialized(self) {
  if (self === void 0) {
    throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
  }

  return self;
}

module.exports = _assertThisInitialized;
module.exports["default"] = module.exports, module.exports.__esModule = true;

/***/ }),
/* 11 */
/***/ (function(module, __webpack_exports__, __webpack_require__) {

"use strict";
// ESM COMPAT FLAG
__webpack_require__.r(__webpack_exports__);

// EXPORTS
__webpack_require__.d(__webpack_exports__, "widget", function() { return /* reexport */ widgetManager_namespaceObject; });

// NAMESPACE OBJECT: ./src/widget/widgetManager.js
var widgetManager_namespaceObject = {};
__webpack_require__.r(widgetManager_namespaceObject);
__webpack_require__.d(widgetManager_namespaceObject, "init", function() { return init; });
__webpack_require__.d(widgetManager_namespaceObject, "getDefWindowOptions", function() { return getDefWindowOptions; });
__webpack_require__.d(widgetManager_namespaceObject, "activate", function() { return activate; });
__webpack_require__.d(widgetManager_namespaceObject, "getWidget", function() { return getWidget; });
__webpack_require__.d(widgetManager_namespaceObject, "getClass", function() { return getClass; });
__webpack_require__.d(widgetManager_namespaceObject, "isActivate", function() { return isActivate; });
__webpack_require__.d(widgetManager_namespaceObject, "disable", function() { return disable; });
__webpack_require__.d(widgetManager_namespaceObject, "disableAll", function() { return disableAll; });
__webpack_require__.d(widgetManager_namespaceObject, "disableGroup", function() { return disableGroup; });
__webpack_require__.d(widgetManager_namespaceObject, "eachWidget", function() { return eachWidget; });
__webpack_require__.d(widgetManager_namespaceObject, "bindClass", function() { return bindClass; });
__webpack_require__.d(widgetManager_namespaceObject, "removeDebugeBar", function() { return removeDebugeBar; });
__webpack_require__.d(widgetManager_namespaceObject, "getCacheVersion", function() { return getCacheVersion; });
__webpack_require__.d(widgetManager_namespaceObject, "getBasePath", function() { return getBasePath; });
__webpack_require__.d(widgetManager_namespaceObject, "destroy", function() { return destroy; });
__webpack_require__.d(widgetManager_namespaceObject, "eventTarget", function() { return eventTarget; });
__webpack_require__.d(widgetManager_namespaceObject, "on", function() { return on; });
__webpack_require__.d(widgetManager_namespaceObject, "off", function() { return off; });
__webpack_require__.d(widgetManager_namespaceObject, "fire", function() { return fire; });
__webpack_require__.d(widgetManager_namespaceObject, "once", function() { return once; });
__webpack_require__.d(widgetManager_namespaceObject, "listens", function() { return listens; });

// EXTERNAL MODULE: external "mars3d"
var external_mars3d_ = __webpack_require__(0);

// EXTERNAL MODULE: ./src/theme/widget.scss
var widget = __webpack_require__(8);

// EXTERNAL MODULE: ./node_modules/_@babel_runtime@7.15.3@@babel/runtime/helpers/typeof.js
var helpers_typeof = __webpack_require__(1);
var typeof_default = /*#__PURE__*/__webpack_require__.n(helpers_typeof);

// EXTERNAL MODULE: ./node_modules/_@babel_runtime@7.15.3@@babel/runtime/helpers/defineProperty.js
var defineProperty = __webpack_require__(2);
var defineProperty_default = /*#__PURE__*/__webpack_require__.n(defineProperty);

// CONCATENATED MODULE: ./src/widget/loader.js
// cssExpr 用于判断资源是否是css
var cssExpr = new RegExp("\\.css");
var nHead = document.head || document.getElementsByTagName("head")[0]; // `onload` 在WebKit < 535.23， Firefox < 9.0 不被支持

var isOldWebKit = +navigator.userAgent.replace(/.*(?:AppleWebKit|AndroidWebKit)\/?(\d+).*/i, "$1") < 536; // 判断对应的node节点是否已经载入完成

function isReady(node) {
  return node.readyState === "complete" || node.readyState === "loaded";
} // loadCss 用于载入css资源


function loadCss(url, setting, callback) {
  var node = document.createElement("link");
  node.rel = "stylesheet";
  addOnload(node, callback, "css");
  node.async = true;
  node.href = url;
  nHead.appendChild(node);
} // loadJs 用于载入js资源


function loadJs(url, setting, callback) {
  var node = document.createElement("script");
  node.charset = "utf-8";
  addOnload(node, callback, "js");
  node.async = !setting.sync;
  node.src = url;
  nHead.appendChild(node);
} // 在老的webkit中，因不支持load事件，这里用轮询sheet来保证


function pollCss(node, callback) {
  var isLoaded;

  if (node.sheet) {
    isLoaded = true;
  }

  setTimeout(function () {
    if (isLoaded) {
      // 在这里callback 是为了让样式有足够的时间渲染
      callback();
    } else {
      pollCss(node, callback);
    }
  }, 20);
} // 用于给指定的节点绑定onload回调
// 监听元素载入完成事件


function addOnload(node, callback, type) {
  var supportOnload = ("onload" in node);
  var isCSS = type === "css"; // 对老的webkit和老的firefox的兼容

  if (isCSS && (isOldWebKit || !supportOnload)) {
    setTimeout(function () {
      pollCss(node, callback);
    }, 1);
    return;
  }

  if (supportOnload) {
    node.onload = onload;

    node.onerror = function (e) {
      node.onerror = null; //window._cdnFallback(node);
      // eslint-disable-next-line no-console

      if (type == "css") {
        console.error("该css文件不存在：" + node.href, e);
      } // eslint-disable-next-line no-console
      else {
        console.error("该js文件不存在：" + node.src, e);
      }

      onload();
    };
  } else {
    node.onreadystatechange = function () {
      if (isReady(node)) {
        onload();
      }
    };
  }

  function onload() {
    // 执行一次后清除，防止重复执行
    node.onload = node.onreadystatechange = null;
    node = null;
    callback();
  }
} // 资源下载入口，根绝文件类型的不同，调用loadCss或者loadJs


function loadItem(url, list, setting, callback) {
  // 如果加载的url为空，就直接成功返回
  if (!url) {
    setTimeout(function () {
      onFinishLoading();
    });
    return;
  }

  if (cssExpr.test(url)) {
    loadCss(url, setting, onFinishLoading);
  } else {
    loadJs(url, setting, onFinishLoading);
  } // 每次资源下载完成后，检验是否结束整个list下载过程
  // 若已经完成所有下载，执行回调函数


  function onFinishLoading() {
    var urlIndex = list.indexOf(url);

    if (urlIndex > -1) {
      list.splice(urlIndex, 1);
    }

    if (list.length === 0) {
      callback();
    }
  }
}

function doInit(list, setting, callback) {
  var cb = function cb() {
    callback && callback();
  };

  list = Array.prototype.slice.call(list || []);

  if (list.length === 0) {
    cb();
    return;
  }

  for (var i = 0, len = list.length; i < len; i++) {
    loadItem(list[i], list, setting, cb);
  }
} // 判断当前页面是否加载完
// 加载完，立刻执行下载
// 未加载完，等待页面load事件以后再进行下载


function ready(node, callback) {
  if (isReady(node)) {
    callback();
  } else {
    // 1500ms 以后，直接开始下载资源文件，不再等待load事件
    var timeLeft = 1500;
    var isExecute = false;
    window.addEventListener("load", function () {
      if (!isExecute) {
        callback();
        isExecute = true;
      }
    });
    setTimeout(function () {
      if (!isExecute) {
        callback();
        isExecute = true;
      }
    }, timeLeft);
  }
} // 暴露出去的Loader
// 提供async, sync两个函数
// async 用作异步下载执行用，不阻塞页面渲染
// sync  用作异步下载，顺序执行，保证下载的js按照数组顺序执行


var Loader = {
  async: function async(list, callback) {
    ready(document, function () {
      doInit(list, {}, callback);
    });
  },
  sync: function sync(list, callback) {
    ready(document, function () {
      doInit(list, {
        sync: true
      }, callback);
    });
  }
}; //window.Loader = Loader;


// CONCATENATED MODULE: ./src/widget/WidgetEventType.js
/**
 * widget事件类型枚举, mars3d.widget.EventType
 * 【需要引入  mars3d-widget 插件库】
 *  @enum {String}
 */
var WidgetEventType = {
  /**
   * 在实例初始化之后、创建之前执行
   */
  beforeCreate: "beforeCreate",

  /**
   * 实例创建后执行
   */
  created: "created",

  /**
   * 在activat挂载开始之前调用
   */
  beforeActivate: "beforeActivate",

  /**
   * activate方法调用后
   */
  activated: "activated",

  /**
   *view弹窗构造完成后后调用
   */
  openView: "openView",

  /**
   * 实例销毁之前调用
   */
  beforeDisable: "beforeDisable",

  /**
   *实例销毁完成调用
   */
  disabled: "disabled",

  /**
   *加载完成 未做任何其他处理前
   */
  loadBefore: "loadBefore",

  /**
   *加载完成，执行所有内部处理后
   */
  load: "load"
};

// CONCATENATED MODULE: ./src/widget/widgetManager.js



function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) { symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); } keys.push.apply(keys, symbols); } return keys; }

function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { defineProperty_default()(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }

/**
 * widget模块化框架，公共处理类
 * 【需要引入  mars3d-widget 插件库】
 * @module widget
 */



var jQuery = window.jQuery; //内部参数

var thismap;
var basePath = "";
var widgetsdata = [];
var defoptions;
var widgetManager_cacheVersion;
var isdebuger;
var removeKeys = ["_class"];
/**
 * 初始化widget管理器，在构造完成map后调用一次即可。
 *
 * @param {Map} map 地图对象
 * @param {Object} [widgetcfg={}] 全局配置(一般存放在widget.json)，包括：
 * @param {BaseWidget.widgetOptions} [widgetcfg.defaultOptions] 所有widget的默认参数值，可以系统内所有widget相同配置统一在此处传入，额外的个性化的再配置到各widget中。
 * @param {BaseWidget.widgetOptions[]} [widgetcfg.openAtStart] 默认自启动并不可释放的插件，其中autoDisable和openAtStart固定，设置无效。
 * @param {BaseWidget.widgetOptions[]} [widgetcfg.widgets] 所有插件配置，传入后后续激活时，只用传入uri即可。
 * @param {String} [widgetcfg.version] 加载资源时，附加的参数，主要为了清理浏览器缓存，可选值："time"（实时时间戳）或固定的字符串值，每次发布新版本换下固定值。
 * @param {Boolean} [widgetcfg.debugger] 是否显示插件测试栏，true时会在地图下侧显示所有插件测试按钮，方便测试。
 *
 * @param {String} [_basePath=''] widgets目录所在的主路径(统一前缀), 如果widgets目录不在主页面一起或存在路由时，可以传入自定义主目录，值为 widgets目录相对于当前html页面的相对路径。
 * @return {void}  无
 * @example
let widgetCfg ={
  "version": "20220120",
  "defaultOptions": {
    "style": "dark",
    "windowOptions": {
      "skin": "layer-mars-dialog animation-scale-up",
      "position": {
        "top": 50,
        "right": 10
      },
      "maxmin": false,
      "resize": true
    },
    "autoReset": false,
    "autoDisable": true,
    "disableOther": true
  },
  "openAtStart": [
    {
      "name": "放大缩小按钮",
      "uri": "widgets/toolButton/zoom.js"
    }
  ],
  "widgets": [
    {
      "name": "模板-div弹窗",
      "uri": "widgets/_example_divwin/widget.js"
    },
    {
      "name": "模板-append模板",
      "uri": "widgets/_example_append/widget.js"
    }
  ]
}
mars3d.widget.init(map, widgetCfg, './')
 */

function init(map) {
  var widgetcfg = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};

  var _basePath = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : "";

  thismap = map;
  widgetsdata = [];
  defoptions = external_mars3d_["Util"].merge({
    windowOptions: {
      position: "rt",
      maxmin: false,
      resize: true
    },
    autoDisable: true,
    disableOther: true
  }, widgetcfg.defaultOptions);
  widgetManager_cacheVersion = widgetcfg.version;

  if (widgetManager_cacheVersion == "time") {
    widgetManager_cacheVersion = new Date().getTime();
  } //将自启动的加入


  var arrtemp = widgetcfg.openAtStart;

  if (arrtemp && arrtemp.length > 0) {
    for (var i = 0; i < arrtemp.length; i++) {
      var item = arrtemp[i];

      if (!item.hasOwnProperty("uri") || item.uri == "") {
        // eslint-disable-next-line no-console
        console.error("widget未配置uri", item);
        continue;
      }

      if (item.hasOwnProperty("visible") && !item.visible) {
        continue;
      }

      item.autoDisable = false;
      item.openAtStart = true;
      item._nodebug = true;
      bindDefOptions(item);
      item._firstConfigBak = _objectSpread({}, item);
      widgetsdata.push(item);
    }
  } //显示测试栏
  //为了方便测试，所有widget会在页面下侧生成一排按钮，每个按钮对应一个widget，单击后激活对应widget


  isdebuger = widgetcfg["debugger"];

  if (isdebuger) {
    var inhtml = '<div id="widget-testbar" class="mars3d-widgetbar animation-slide-bottom no-print-view" > ' + '     <div style="height: 30px; line-height:30px;"><b style="color: #4db3ff;">widget测试栏</b>&nbsp;&nbsp;<button  id="widget-testbar-remove"  type="button" class="btn btn-link btn-xs">关闭</button> </div>' + '     <button id="widget-testbar-disableAll" type="button" class="btn btn-info" ><i class="fa fa-globe"></i>漫游</button>' + "</div>";
    jQuery("body").append(inhtml);
    jQuery("#widget-testbar-remove").click(function (e) {
      removeDebugeBar();
    });
    jQuery("#widget-testbar-disableAll").click(function (e) {
      disableAll();
    });
  } //将配置的加入


  arrtemp = widgetcfg.widgets;

  if (arrtemp && arrtemp.length > 0) {
    for (var _i = 0; _i < arrtemp.length; _i++) {
      var _item = arrtemp[_i];

      if (_item.type == "group") {
        var _inhtml = ' <div class="btn-group dropup">  <button type="button" class="btn btn-primary dropdown-toggle" data-toggle="dropdown" aria-expanded="false"><i class="fa fa-align-justify"></i>' + _item.name + ' <span class="caret"></span></button> <ul class="dropdown-menu">';

        for (var j = 0; j < _item.children.length; j++) {
          var childItem = _item.children[j];

          if (!childItem.hasOwnProperty("uri") || childItem.uri == "") {
            // eslint-disable-next-line no-console
            console.error("widget未配置uri", childItem);
            continue;
          }

          _inhtml += ' <li data-widget="' + childItem.uri + '" class="widget-btn" ><a href="#"><i class="fa fa-star"></i>' + childItem.name + "</a></li>";
          bindDefOptions(childItem);
          childItem._firstConfigBak = _objectSpread({}, childItem);
          widgetsdata.push(childItem); //将配置的加入
        }

        _inhtml += "</ul></div>";

        if (isdebuger && !_item._nodebug) {
          jQuery("#widget-testbar").append(_inhtml);
        }
      } else {
        if (!_item.hasOwnProperty("uri") || _item.uri == "") {
          // eslint-disable-next-line no-console
          console.error("widget未配置uri", _item);
          continue;
        } //显示测试栏


        if (isdebuger && !_item._nodebug) {
          var _inhtml2 = '<button type="button" class="btn btn-primary widget-btn" data-widget="' + _item.uri + '"  > <i class="fa fa-globe"></i>' + _item.name + " </button>";

          jQuery("#widget-testbar").append(_inhtml2);
        }

        bindDefOptions(_item);
        _item._firstConfigBak = _objectSpread({}, _item);
        widgetsdata.push(_item); //将配置的加入
      }
    }

    if (isdebuger) {
      jQuery("#widget-testbar .widget-btn").each(function () {
        jQuery(this).click(function (e) {
          var uri = jQuery(this).attr("data-widget");

          if (uri == null || uri == "") {
            return;
          }

          if (isActivate(uri)) {
            disable(uri);
          } else {
            activate(uri);
          }
        });
      });
    }
  }

  for (var _i2 = 0; _i2 < widgetsdata.length; _i2++) {
    var _item2 = widgetsdata[_i2];

    if (_item2.openAtStart || _item2.createAtStart) {
      _arrLoadWidget.push(_item2);
    }
  }

  jQuery(window).resize(function () {
    for (var _i3 = 0; _i3 < widgetsdata.length; _i3++) {
      var _item3 = widgetsdata[_i3];

      if (_item3._class) {
        _item3._class.indexResize(); //BaseWidget: indexResize

      }
    }
  });

  if (isdebuger) {
    var hash = getLocationParam();

    if (hash) {
      activate(hash);
    }
  }

  loadWidgetJs();
}
/**
 * 获取默认init时中传入配置的 windowOptions 参数
 * @return {Object} windowOptions参数默认值
 * @see BaseWidget.widgetOptions
 */

function getDefWindowOptions() {
  return external_mars3d_["Util"].clone(defoptions.windowOptions, removeKeys);
}

function getLocationParam() {
  var param = window.location.toString();

  if (param.indexOf("#") === -1) {
    return "";
  }

  param = param.split("#");

  if (param && param.length > 0) {
    return param[1];
  }
}

function bindDefOptions(item) {
  //赋默认值至options（跳过已存在设置值）
  if (defoptions) {
    for (var aa in defoptions) {
      if (aa == "windowOptions") {//for (var jj in defoptions['windowOptions']) {
        //    if (!item['windowOptions'].hasOwnProperty(jj)) {
        //        item['windowOptions'][jj] = defoptions['windowOptions'][jj];
        //    }
        //}
      } else if (!item.hasOwnProperty(aa)) {
        item[aa] = defoptions[aa];
      }
    }
  } //赋值内部使用属性


  item.path = getFilePath(basePath + item.uri);
  item.name = item.name || item.label; //兼容name和label命名
}
/**
 * 激活指定 widget模块
 *
 * @param {String|BaseWidget.widgetOptions} item 指widget模块的uri 或 指模块的配置参数,当有配置参数时，参数优先级是：
 * 【activate方法传入的配置 > init方法传入的配置(widget.json) > widget.js内部配置的】
 * @param {Map} [item.map] 当单页面简单场景没有init时，也可以传入map来使用单个widget
 * @param {Boolean} [noDisableOther=false]  不释放其他已激活的widget
 * @return {BaseWidget.widgetOptions}  指widget模块对象
 * @example
//常用方式，直接使用uri
mars3d.widget.activate("widgets/bookmark/widget.js");

//使用对象，可以传入更多参数，具体参数参看配置项手册，。
mars3d.widget.activate({
  name:"视角书签"
  uri: "widgets/bookmark/widget.js",
  autoDisable: true,
  testdata:'测试数据1987', //传数据进widget内部，widget内部使用this.config.testdata获取到传的数据
});
 */


function activate(item, noDisableOther) {
  if (thismap == null && item.map) {
    init(item.map, {}, item.basePath);
  } //参数是字符串id或uri时


  if (typeof item === "string") {
    item = {
      uri: item
    };

    if (noDisableOther != null) {
      //是否释放其他已激活的widget
      item.disableOther = !noDisableOther;
    }
  } else {
    if (item.uri == null) {
      // eslint-disable-next-line no-console
      console.error("activate激活widget时需要uri参数！", item);
    }
  }

  var thisItem;

  for (var i = 0; i < widgetsdata.length; i++) {
    var othitem = widgetsdata[i];

    if (item.uri == othitem.uri || othitem.id && item.uri == othitem.id) {
      thisItem = othitem;

      if (thisItem.isloading) {
        return thisItem;
      } //激活了正在loading的widget 防止快速双击了菜单
      //赋值


      for (var aa in item) {
        if (aa == "uri") {
          continue;
        }

        thisItem[aa] = item[aa];
      }

      break;
    }
  }

  if (thisItem == null) {
    bindDefOptions(item);
    thisItem = item; //非config中配置的，外部传入，首次激活

    if (!item._firstConfigBak) {
      item._firstConfigBak = _objectSpread({}, item);
    }

    widgetsdata.push(item);
  }

  if (isdebuger) {
    // eslint-disable-next-line no-console
    console.log("开始激活widget：" + thisItem.uri);
    window.location.hash = "#" + thisItem.uri;
  } //兼容之前历史版本的错误命名时的属性名称


  if (thisItem.hasOwnProperty("disableOhter") && !thisItem.hasOwnProperty("disableOther")) {
    thisItem.disableOther = thisItem.disableOhter;
  } //释放其他已激活的widget


  if (thisItem.disableOther) {
    disableAll(thisItem.uri, thisItem.group);
  } else {
    disableGroup(thisItem.group, thisItem.uri);
  } //激活本widget


  if (thisItem._class) {
    if (thisItem._class.isActivate) {
      //已激活时
      if (thisItem._class.update) {
        //刷新
        thisItem._class.update();
      } else {
        //重启
        _reStart(thisItem);
      }
    } else {
      thisItem._class.activateBase(); // BaseWidget: activateBase

    }
  } else {
    for (var _i4 = 0; _i4 < _arrLoadWidget.length; _i4++) {
      if (_arrLoadWidget[_i4].uri == thisItem.uri) {
        //如果已在加载列表中的直接跳出
        return _arrLoadWidget[_i4];
      }
    }

    _arrLoadWidget.push(thisItem);

    if (_arrLoadWidget.length == 1) {
      loadWidgetJs();
    }
  }

  return thisItem;
}
var timetemp; //重启

function _reStart(thisItem) {
  clearInterval(timetemp);

  thisItem._class.disableBase();

  timetemp = setInterval(function () {
    if (thisItem._class.isActivate) {
      return;
    }

    thisItem._class.activateBase();

    clearInterval(timetemp);
  }, 200);
}
/**
 * 获取指定的widget配置信息
 *
 * @param {String} uri widget的uri 或 id
 * @return {BaseWidget.widgetOptions} widget配置信息
 */


function getWidget(uri) {
  for (var i = 0; i < widgetsdata.length; i++) {
    var item = widgetsdata[i];

    if (uri == item.uri || uri == item.id) {
      return item;
    }
  }
}
/**
 * 获取指定的widget 对应的实例化对象
 *
 * @param {String} uri widget的uri 或 id
 * @return {BaseWidget} widget对应的实例化对象
 */

function getClass(uri) {
  var item = getWidget(uri);

  if (item) {
    return item._class;
  } else {
    return null;
  }
}
/**
 * 获取widget的当前激活状态
 *
 * @param {String} uri widget的uri 或 id
 * @return {Boolean} 是否激活
 */

function isActivate(uri) {
  var _class = getClass(uri);

  if (_class == null) {
    return false;
  }

  return _class.isActivate;
}
/**
 * 释放指定的widget
 *
 * @param {String} uri widget的uri 或 id
 * @return {Boolean} 是否成功调用了释放
 */

function disable(uri) {
  if (uri == null) {
    return false;
  }

  if ((typeof id === "undefined" ? "undefined" : typeof_default()(id)) === "object") {
    uri = uri.uri;
  }

  for (var i = 0; i < widgetsdata.length; i++) {
    var item = widgetsdata[i];

    if (item._class && (uri == item.uri || uri == item.id)) {
      item._class.disableBase();

      return true;
    }
  }

  return false;
}
/**
 * 关闭释放所有widget
 *
 * @export
 * @param {String|Boolean} [nodisable]  指定不释放的widget的uri或id 或 传true值强制释放所有widget(默认autoDisable为false的widet不会释放)
 * @param {String} [group] 指定强制释放的group名(默认autoDisable为false的widet不会释放)，传入group值后会强制释放所有同group组的widget
 * @return {void}  无
 */

function disableAll(nodisable, group) {
  for (var i = 0; i < widgetsdata.length; i++) {
    var item = widgetsdata[i];

    if (group && item.group == group) {//同组别的全部释放
    } else {
      if (nodisable !== true && !item.autoDisable) {
        continue;
      }
    } //指定不释放的跳过


    if (nodisable && (nodisable == item.uri || nodisable == item.id)) {
      continue;
    }

    if (item._class) {
      item._class.disableBase(); //BaseWidget: disableBase

    }
  }
}
/**
 * 关闭释放同组widget
 *
 * @param {String} group 指定强制释放的group名
 * @param {String} [nodisable]  指定不释放的widget的uri或id
 * @return {void}  无
 */

function disableGroup(group, nodisable) {
  if (group == null) {
    return;
  }

  for (var i = 0; i < widgetsdata.length; i++) {
    var item = widgetsdata[i];

    if (item.group == group) {
      //指定不释放的跳过
      if (nodisable && (nodisable == item.uri || nodisable == item.id)) {
        continue;
      }

      if (item._class) {
        item._class.disableBase(); ////BaseWidget: disableBase

      }
    }
  }
}
/**
 * 遍历所有widget
 * @param {Function} method 回调方法
 * @return {void}  无
 */

function eachWidget(method) {
  for (var i = 0; i < widgetsdata.length; i++) {
    var item = widgetsdata[i];
    method(item);
  }
}
var _arrLoadWidget = [];
var widgetManager_loadItem;
var isloading;

function loadWidgetJs() {
  if (_arrLoadWidget.length == 0) {
    return;
  }

  if (isloading) {
    setTimeout(loadWidgetJs, 500);
    return;
  }

  isloading = true;
  widgetManager_loadItem = _arrLoadWidget[0];
  widgetManager_loadItem.isloading = true;
  var _uri = widgetManager_loadItem.uri;

  if (widgetManager_cacheVersion) {
    if (_uri.indexOf("?") == -1) {
      _uri += "?cache=" + widgetManager_cacheVersion;
    } else {
      _uri += "&cache=" + widgetManager_cacheVersion;
    }
  }

  if (window.NProgress) {
    window.NProgress.start();
  }

  fire(WidgetEventType.loadBefore, {
    sourceTarget: widgetManager_loadItem
  });
  Loader.async([basePath + _uri], function () {
    isloading = false;
    widgetManager_loadItem.isloading = false;

    if (window.NProgress) {
      window.NProgress.done(true);
    }

    _arrLoadWidget.shift();

    loadWidgetJs();
  });
}
/**
 * 绑定类到当前对应js的widget中。
 *
 * @param {BaseWidget} _class 定义的BaseWidget子类
 * @return {Object} 实例化后的对象
 */


function bindClass(_class) {
  fire(WidgetEventType.load, {
    sourceTarget: _class
  });

  if (widgetManager_loadItem == null) {
    var _jspath = getThisJSPath();

    for (var i = 0; i < widgetsdata.length; i++) {
      var item = widgetsdata[i];

      if (_jspath.endsWith(item.uri)) {
        item.isloading = false;
        item._class = new _class(thismap, item);

        item._class.activateBase(); // BaseWidget: activateBase


        return item._class;
      }
    }
  } else {
    widgetManager_loadItem.isloading = false;
    widgetManager_loadItem._class = new _class(thismap, widgetManager_loadItem);

    widgetManager_loadItem._class.activateBase(); // BaseWidget: activateBase


    return widgetManager_loadItem._class;
  }
}

function getThisJSPath() {
  var jsPath;
  var js = document.scripts;

  for (var i = js.length - 1; i >= 0; i--) {
    jsPath = js[i].src;

    if (jsPath == null || jsPath == "") {
      continue;
    }

    if (jsPath.indexOf("widgets") == -1) {
      continue;
    } //jsPath = jsPath.substring(0, jsPath.lastIndexOf("/") + 1);


    return jsPath;
  }

  return "";
} //获取路径


function getFilePath(file) {
  var pos = file.lastIndexOf("/");
  return file.substring(0, pos + 1);
}
/**
 * 移除Widget测试栏（当有开启debugger时）
 * @return {void}  无
 */


function removeDebugeBar() {
  jQuery("#widget-testbar").remove();
}
/**
 * 获取配置的version配置参数，用于附加清除浏览器缓存
 * @return {String} 配置的version参数
 */

function getCacheVersion() {
  return widgetManager_cacheVersion;
}
/**
 * 获取init方法传入的主目录配置参数
 * @return {String} 主目录配置参数
 */

function getBasePath() {
  return basePath;
}
/**
 * 销毁对象
 * @return {void}  无
 */

function destroy() {
  for (var i = 0; i < widgetsdata.length; i++) {
    var item = widgetsdata[i];

    if (item._class) {
      item._class.disableBase(); //BaseWidget: disableBase


      if (item._class.destroy) {
        item._class.destroy();
      }

      delete item._class;
    }
  }

  thismap = null;
} //事件相关

var eventTarget = new external_mars3d_["BaseClass"]();
/**
 * 绑定指定类型事件监听器
 *
 * @param {WidgetEventType|WidgetEventType[]} types 事件类型
 * @param {Function} fn 绑定的监听器回调方法
 * @param {Object} context  侦听器的上下文(this关键字将指向的对象)。
 * @return {void}  无
 */

function on(types, fn, context) {
  return eventTarget.on(types, fn, context);
}
/**
 * 解除绑定指定类型事件监听器
 *
 * @param {WidgetEventType|WidgetEventType[]} types 事件类型
 * @param {Function} fn 绑定的监听器回调方法
 * @param {Object} context  侦听器的上下文(this关键字将指向的对象)。
 * @return {void}  无
 */

function off(types, fn, context) {
  return eventTarget.off(types, fn, context);
}
/**
 * 触发指定类型的事件。
 *
 * @param {WidgetEventType} type 事件类型
 * @param {Object} data 传输的数据或对象，可在事件回调方法中event对象中获取进行使用
 * @param {BaseClass} [propagate=null] 将事件传播给父类 (用addEventParent设置)
 * @return {void}  无
 */

function fire(type, data, propagate) {
  return eventTarget.fire(type, data, propagate);
}
/**
 * 绑定一次性执行的指定类型事件监听器
 * 与on类似，监听器只会被触发一次，然后被删除。
 *
 * @param {WidgetEventType|WidgetEventType[]} types 事件类型
 * @param {Function} fn 绑定的监听器回调方法
 * @param {Object} context  侦听器的上下文(this关键字将指向的对象)。
 * @return {void}  无
 */

function once(types, fn, context) {
  return eventTarget.once(types, fn, context);
}
/**
 * 是否有绑定指定的事件
 *
 * @param {WidgetEventType} type 事件类型
 * @param {BaseClass} [propagate=null] 是否判断指定的父类 (用addEventParent设置的)
 * @return {Boolean} 是否存在
 */

function listens(type, propagate) {
  return eventTarget.listens(type, propagate);
}
// EXTERNAL MODULE: ./node_modules/_@babel_runtime@7.15.3@@babel/runtime/helpers/classCallCheck.js
var classCallCheck = __webpack_require__(4);
var classCallCheck_default = /*#__PURE__*/__webpack_require__.n(classCallCheck);

// EXTERNAL MODULE: ./node_modules/_@babel_runtime@7.15.3@@babel/runtime/helpers/createClass.js
var createClass = __webpack_require__(5);
var createClass_default = /*#__PURE__*/__webpack_require__.n(createClass);

// EXTERNAL MODULE: ./node_modules/_@babel_runtime@7.15.3@@babel/runtime/helpers/inherits.js
var inherits = __webpack_require__(6);
var inherits_default = /*#__PURE__*/__webpack_require__.n(inherits);

// EXTERNAL MODULE: ./node_modules/_@babel_runtime@7.15.3@@babel/runtime/helpers/possibleConstructorReturn.js
var possibleConstructorReturn = __webpack_require__(7);
var possibleConstructorReturn_default = /*#__PURE__*/__webpack_require__.n(possibleConstructorReturn);

// EXTERNAL MODULE: ./node_modules/_@babel_runtime@7.15.3@@babel/runtime/helpers/getPrototypeOf.js
var getPrototypeOf = __webpack_require__(3);
var getPrototypeOf_default = /*#__PURE__*/__webpack_require__.n(getPrototypeOf);

// CONCATENATED MODULE: ./src/widget/BaseWidget.js








function BaseWidget_ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) { symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); } keys.push.apply(keys, symbols); } return keys; }

function BaseWidget_objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { BaseWidget_ownKeys(Object(source), true).forEach(function (key) { defineProperty_default()(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { BaseWidget_ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }

function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = getPrototypeOf_default()(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = getPrototypeOf_default()(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return possibleConstructorReturn_default()(this, result); }; }

function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }





var BaseWidget_jQuery = window.jQuery;
var BaseWidget_layer = window.layer; //请引入layer弹窗插件

var BaseClass = external_mars3d_["BaseClass"];
var _resources_cache = [];
/**
 * widget 配置参数
 *
 * @typedef {Object} BaseWidget.widgetOptions
 *
 * @property {String} name 必须，中文名称，用于标识和弹窗标题。
 * @property {String} uri 必须，JS文件路径，路径是相对于widgets目录的路径。如："widgets/bookmark/widget.js"
 * @property {String} [id] 定义该插件的唯一标识,方便后续判断。
 * @property {Boolean} [autoDisable=true] 激活其他新插件时，是否自动释放本插件
 * @property {Boolean} [disableOther=true] 激活本插件时，是否释放其它已激活的插件
 * @property {String} [group] 配置group后，同group下的widget互斥，打开任意一个会自动释放其他的
 * @property {object} [windowOptions] 存在弹窗的插件的弹窗相关参数配置，更多参数请参考 [layer弹窗API]{@link https://www.layui.com/doc/modules/layer.html} 包括：
 * @property {Number|String} [windowOptions.width] 窗口宽度，可以是 像素数字(像素值) 或者 字符串(屏幕宽度百分比)，示例：200 或 "20%"
 * @property {Number|String} [windowOptions.height] 窗口高度，可以是 像素数字(像素值) 或者 字符串(屏幕高度百分比)，示例：600 或 "50%"
 * @property {String|Object} [windowOptions.position='auto'] 窗口所在位置坐标，配置字符串可选值：auto垂直水平居中，t顶部,b底部,r右边缘,l左边缘,lt左上角,lb左下角,rt右上角,rb右下角；也可以配置对象：
 * @property {Number|String} [windowOptions.position.top] 位置css的top值，可以是 像素数字(像素值) 或者 字符串(屏幕高度百分比)，示例：10 或 "5%"
 * @property {Number|String} [windowOptions.position.bottom] 位置css的top值，可以是 像素数字(像素值) 或者 字符串(屏幕高度百分比)，示例：10 或 "5%"
 * @property {Number|String} [windowOptions.position.left] 位置css的top值，可以是 像素数字(像素值) 或者 字符串(屏幕宽度百分比)，示例：10 或 "5%"
 * @property {Number|String} [windowOptions.position.right] 位置css的top值，可以是 像素数字(像素值) 或者 字符串(屏幕宽度百分比)，示例：10 或 "5%"
 * @property {Number} [windowOptions.minHeight] 限定的窗口最小高度(像素值)，默认不限制
 * @property {Number} [windowOptions.maxHeight] 限定的窗口最大高度(像素值)，默认不限制
 * @property {Number} [windowOptions.minWidth] 限定的窗口最小宽度(像素值)，默认不限制
 * @property {Number} [windowOptions.maxWidth] 限定的窗口最大宽度(像素值)，默认不限制
 *
 * @property {Boolean} [windowOptions.maxmin=true] 是否可以在弹层右下角拖动来拉伸尺寸
 * @property {Number|Array} [windowOptions.shade=0] 遮罩，默认为0不显示，可配置数字0.3透明度的黑色背景（'#000'），其他颜色，可以shade: [0.8, '#393D49']
 * @property {Boolean} [windowOptions.shadeClose=false] 当shade是存在的，点击弹层外区域后是否关闭弹窗。
 * @property {Number} [windowOptions.closeBtn=1] 当为0时，不显示关闭按钮，配置1和2来展示两种风格的关闭按钮
 * @property {Number} [windowOptions.noTitle=false] 是否不显示标题，为true是不显示标题
 *
 * @property {Boolean} [openAtStart=false] 打开系统后是否自动启动本插件
 * @property {String} [style] 添加到widget的view中的class样式名
 * @property {Object} [css] 添加到widget的css值
 * @property {Boolean} [show=true] 激活后是否显示弹窗，false时激活后自动隐藏弹窗。
 * @property {*} [其他] 传入数据等，定义的任意参数在widget内部方法中都可以通过this.config获取到
 */

/**
 * widget基础类,
 * 需要继承后使用，不用手动实例化，框架内部自动实例化及相关处理。
 * 【需要引入  mars3d-widget 插件库】
 *
 * @param {Map} map 地图对象
 * @param {BaseWidget.widgetOptions} options 配置参数
 * @class BaseWidget
 * @extends {BaseClass}
 * @see [支持的事件类型]{@link WidgetEventType}

 * @example
//使用示例
class MyWidget extends mars3d.widget.BaseWidget {
  //外部资源配置
  get resources() {
    return [
      'js/test.js', //当前同目录下
      './lib/dom2img/dom-to-image.js', //主页面相同目录下
    ]
  }
  //弹窗配置
  get view() {
    return {
      type: 'window',
      url: 'view.html',
      windowOptions: {  width: 250 },
    }
  }
  //初始化[仅执行1次]
  create() {}
  //每个窗口创建完成后调用
  winCreateOK(opt, result) {
    this.viewWindow = result
  }
  //打开激活
  activate() {}
  //关闭释放
  disable() {
    this.viewWindow = null
  }
}

//注册到widget管理器中。
mars3d.widget.bindClass(MyWidget)
 */

var BaseWidget_BaseWidget = /*#__PURE__*/function (_BaseClass) {
  inherits_default()(BaseWidget, _BaseClass);

  var _super = _createSuper(BaseWidget);

  function BaseWidget(map, options) {
    var _this;

    classCallCheck_default()(this, BaseWidget);

    _this = _super.call(this, options);
    /**
     *  获取当前地图
     * @type {Map}
     * @readonly
     */

    _this.map = map;
    /**
     *  获取当前配置参数
     * @type {BaseWidget.widgetOptions}
     * @readonly
     */

    _this.options = options; //配置的config信息

    /**
     *  获取当前配置参数，别名，同options
     * @type {BaseWidget.widgetOptions}
     * @readonly
     */

    _this.config = options;
    /**
     *  获取当前widget的目录路径
     * @type {String}
     * @readonly
     */

    _this.path = options.path || ""; //当前widget目录相对路径

    /**
     *  是否激活状态
     * @type {Boolean}
     * @readonly
     */

    _this.isActivate = false;
    /**
     *  是否已创建
     * @type {Boolean}
     * @readonly
     */

    _this.isCreate = false;
    _this._viewcreate_allcount = 0;
    _this._viewcreate_okcount = 0;
    _this._viewConfig = _this.view;

    _this.init();

    return _this;
  }
  /**
   * 该模块依赖的外部js、css资源文件，会在实例化之前加入的页面中。
   * 默认引用是当前widget所在同path目录的资源，
   * 相当于html主页面的资源 或 外部资源 请 以 “/” 或 “.” 或 “http” 开始的url
   * @type {String[]}
   * @readonly
   * @abstract
   */


  createClass_default()(BaseWidget, [{
    key: "resources",
    get: function get() {
      return null;
    }
    /**
     * 定义关联的view弹窗或页面配置信息，目前支持3种类型，
     * （1）type:'window'，iframe模式弹窗	,参考_example示例，	独立的html子页面，比较自由，简单粗暴、无任何限制；可以每个页面用不同的UI和第三方插件不用考虑冲突问题；任何水平的开发人员均容易快速开发。
     * （2）type:'divwindow'，div元素模式弹窗	参考_example_divwin示例，可直接互相访问，这种模式弊端是易引起模块间id命名冲突，在css和html中命名时需注意。
     * （3）type:'append'，任意html元素	参考_example_append示例，任意div节点，比较自由。
     * 为空时表示当前模块无关联的view页面，
     * 其中url地址规则，参考resources说明
     * @type {Object|Object[]}
     * @readonly
     * @abstract
     */

  }, {
    key: "view",
    get: function get() {
      return null;
    } //==============激活插件=================

    /**
     * 激活widget，同 mars3d.widget.activate方法
     * @return {void}  无
     */

  }, {
    key: "activateBase",
    value: function activateBase() {
      var that = this;

      if (this.isActivate) {
        //已激活状态时跳出
        this.eachView(function (viewopt) {
          if (viewopt._dom) {
            //将层置顶
            BaseWidget_jQuery(".layui-layer").each(function () {
              BaseWidget_jQuery(this).css("z-index", 19891000);
            });
            BaseWidget_jQuery(viewopt._dom).css("z-index", 19891014);
          }
        });
        return;
      }

      eventTarget.fire(WidgetEventType.beforeActivate, {
        sourceTarget: this
      });
      this.beforeActivate();
      this.isActivate = true;

      if (!this.isCreate) {
        eventTarget.fire(WidgetEventType.beforeCreate, {
          sourceTarget: this
        }); //首次进行创建

        if (this.resources && this.resources.length > 0) {
          var resources = [];

          for (var i = 0; i < this.resources.length; i++) {
            var _resource = this.resources[i];
            _resource = this._getUrl(_resource);

            if (_resources_cache.indexOf(_resource) != -1) {
              continue;
            } //不加重复资源


            resources.push(_resource);
          }

          _resources_cache = _resources_cache.concat(resources); //不加重复资源

          Loader.async(resources, function () {
            var result = that.create(function () {
              that._createWidgetView();

              that.isCreate = true;
            });
            eventTarget.fire(WidgetEventType.created, {
              sourceTarget: that
            });

            if (result) {
              return;
            }

            if (that.options.createAtStart) {
              that.options.createAtStart = false;
              that.isActivate = false;
              that.isCreate = true;
              return;
            }

            that._createWidgetView();

            that.isCreate = true;
          });
          return;
        } else {
          var result = this.create(function () {
            that._createWidgetView();

            this.isCreate = true;
          });
          eventTarget.fire(WidgetEventType.created, {
            sourceTarget: this
          });

          if (result) {
            return;
          }

          if (that.options.createAtStart) {
            that.options.createAtStart = false;
            that.isActivate = false;
            that.isCreate = true;
            return;
          }
        }

        this.isCreate = true;
      }

      this._createWidgetView();
    }
    /**
     * 构造方法完成后的钩子方法，子类继承后按需使用
     * @return {void}  无
     * @abstract
     */

  }, {
    key: "init",
    value: function init() {}
    /**
     * 模块初始化，仅首次初始化执行1次
     * @param {Function} [endfun] 当create内存在异步时，可以异步后调用下endfun
     * @return {void}  无
     * @abstract
     */

  }, {
    key: "create",
    value: function create() {} //创建插件的view

  }, {
    key: "_createWidgetView",
    value: function _createWidgetView() {
      var viewopt = this._viewConfig;

      if (viewopt === undefined || viewopt === null) {
        this._startActivate();
      } else if (Array.isArray(viewopt)) {
        this._viewcreate_allcount = viewopt.length;
        this._viewcreate_okcount = 0;

        for (var i = 0; i < viewopt.length; i++) {
          this.createItemView(viewopt[i]);
        }
      } else {
        this._viewcreate_allcount = 1;
        this._viewcreate_okcount = 0;
        this.createItemView(viewopt);
      }
    }
    /**
     * 遍历所有view配置
     *
     * @param {Function} callback 回调方法
     * @param {Number} [index] 当有多个view时，可以指定单个操作的view的index
     * @return {*} callback执行的返回结果
     */

  }, {
    key: "eachView",
    value: function eachView(callback, index) {
      var viewopt = this._viewConfig;

      if (viewopt === undefined || viewopt === null) {
        return false;
      } else if (Array.isArray(viewopt)) {
        var hascal = false;

        if (index != null) {
          return callback(viewopt[index]);
        }

        for (var i = 0; i < viewopt.length; i++) {
          hascal = callback(viewopt[i]);
        }

        return hascal;
      } else {
        return callback(viewopt);
      }
    }
  }, {
    key: "createItemView",
    value: function createItemView(viewopt) {
      var that = this;

      switch (viewopt.type) {
        default:
        case "window":
          this._openWindow(viewopt);

          break;

        case "divwindow":
          this._openDivWindow(viewopt);

          break;

        case "append":
          that.getHtml(this._getUrl(viewopt.url), function (html) {
            that._appendView(viewopt, html);
          });
          break;

        case "custom":
          //自定义
          viewopt.open(this._getUrl(viewopt.url), function (html) {
            that.winCreateOK(viewopt, html);
            eventTarget.fire(WidgetEventType.openView, {
              sourceTarget: that,
              view: viewopt,
              dom: html
            });
            that._viewcreate_okcount++;

            if (that._viewcreate_okcount >= that._viewcreate_allcount) {
              that._startActivate(html);
            }
          }, this);
          break;
      }
    } //==============layer弹窗=================

  }, {
    key: "_openWindow",
    value: function _openWindow(viewopt) {
      var _this2 = this;

      var view_url = this._getUrl(viewopt.url);

      var opts = {
        type: 2,
        content: [view_url, "no"],
        success: function success(layero, index) {
          if (!_this2.isActivate) {
            BaseWidget_layer.close(index);
            return;
          }

          if (viewopt._layerIdx != index) {
            BaseWidget_layer.close(viewopt._layerIdx);
            viewopt._layerIdx = index;
          }

          viewopt._layerOpening = false;
          viewopt._dom = layero; //得到iframe页的窗口对象，执行iframe页的方法：viewWindow.method();

          var viewWindow = window[layero.find("iframe")[0]["name"]]; //设置css

          if (_this2.options.css) {
            BaseWidget_jQuery("#layui-layer" + viewopt._layerIdx).css(_this2.options.css);
          } //隐藏弹窗


          if (_this2.options.hasOwnProperty("visible") && !_this2.options.visible) {
            BaseWidget_jQuery(layero).hide();
          }

          BaseWidget_layer.setTop(layero);

          _this2.winCreateOK(viewopt, viewWindow);

          eventTarget.fire(WidgetEventType.openView, {
            sourceTarget: _this2,
            view: viewopt,
            dom: layero
          });
          _this2._viewcreate_okcount++;

          if (_this2._viewcreate_okcount >= _this2._viewcreate_allcount) {
            _this2._startActivate(layero);
          } //通知页面,页面需要定义initWidgetView方法


          if (viewWindow && viewWindow.initWidgetView) {
            var _this2$config;

            if ((_this2$config = _this2.config) !== null && _this2$config !== void 0 && _this2$config.style) {
              BaseWidget_jQuery(viewWindow.document.body).addClass(_this2.config.style);
            }

            viewWindow.initWidgetView(_this2);
          } else {
            external_mars3d_["Log"].logError(view_url + "页面没有定义function initWidgetView(widget)方法，无法初始化widget页面!");
          }
        }
      };

      if (viewopt._layerIdx && viewopt._layerIdx > 0) {
        BaseWidget_layer.close(viewopt._layerIdx);
        viewopt._layerIdx = -1;
      }

      viewopt._layerOpening = true;
      viewopt._layerIdx = BaseWidget_layer.open(this._getWinOpt(viewopt, opts));
    }
  }, {
    key: "_openDivWindow",
    value: function _openDivWindow(viewopt) {
      var _this3 = this;

      var view_url = this._getUrl(viewopt.url); //div弹窗


      this.getHtml(view_url, function (data) {
        var opts = {
          type: 1,
          content: data,
          success: function success(layero, index) {
            if (!_this3.isActivate) {
              BaseWidget_layer.close(index);
              return;
            }

            if (viewopt._layerIdx != index) {
              BaseWidget_layer.close(viewopt._layerIdx);
              viewopt._layerIdx = index;
            }

            viewopt._layerOpening = false;
            viewopt._dom = layero; //隐藏弹窗

            if (_this3.options.hasOwnProperty("show") && !_this3.options.show) {
              BaseWidget_jQuery(layero).hide();
            }

            BaseWidget_layer.setTop(layero);

            _this3.winCreateOK(viewopt, layero);

            eventTarget.fire(WidgetEventType.openView, {
              sourceTarget: _this3,
              view: viewopt,
              dom: layero
            });
            _this3._viewcreate_okcount++;

            if (_this3._viewcreate_okcount >= _this3._viewcreate_allcount) {
              _this3._startActivate(layero);
            }
          }
        };
        viewopt._layerOpening = true;
        viewopt._layerIdx = BaseWidget_layer.open(_this3._getWinOpt(viewopt, opts));
      });
    }
  }, {
    key: "_getUrl",
    value: function _getUrl(url) {
      url = this.addCacheVersion(url);

      if (url.startsWith("/") || url.startsWith(".") || url.startsWith("http")) {
        return url;
      } else {
        return this.path + url;
      }
    }
  }, {
    key: "_getWinOpt",
    value: function _getWinOpt(viewopt, opts) {
      //优先使用cofig中配置，覆盖js中的定义
      var def = getDefWindowOptions();

      var windowOptions = BaseWidget_objectSpread(BaseWidget_objectSpread(BaseWidget_objectSpread({}, def), viewopt.windowOptions), this.options.windowOptions);

      viewopt.windowOptions = windowOptions; //赋值

      var that = this;

      var _size = this._getWinSize(windowOptions);

      var title = false;

      if (!windowOptions.noTitle) {
        title = this.options.name || " ";

        if (this.options.icon) {
          title = '<i class="' + this.options.icon + '" ></i>&nbsp;' + title;
        }
      } //默认值


      var defOpts = {
        title: title,
        area: _size.area,
        offset: _size.offset,
        shade: 0,
        maxmin: false,
        beforeEnd: function beforeEnd() {
          that.beforeDisable();
        },
        end: function end() {
          // 销毁后触发的回调
          viewopt._layerIdx = -1;
          viewopt._dom = null;
          that.disableBase();
        },
        full: function full(dom) {
          //最大化后触发的回调
          that.winFull(dom);
        },
        min: function min(dom) {
          //最小化后触发的回调
          that.winMin(dom);
        },
        restore: function restore(dom) {
          //还原 后触发的回调
          that.winRestore(dom);
        }
      };
      return BaseWidget_objectSpread(BaseWidget_objectSpread(BaseWidget_objectSpread({}, defOpts), windowOptions), opts);
    } //计算弹窗大小和位置

  }, {
    key: "_getWinSize",
    value: function _getWinSize(windowOptions) {
      //获取高宽
      var _width = this.bfb2Number(windowOptions.width, document.documentElement.clientWidth, windowOptions);

      var _height = this.bfb2Number(windowOptions.height, document.documentElement.clientHeight, windowOptions); //计算位置offset


      var offset = "";
      var position = windowOptions.position;

      if (position) {
        if (typeof position === "string") {
          //t顶部,b底部,r右边缘,l左边缘,lt左上角,lb左下角,rt右上角,rb右下角
          offset = position;
        } else if (typeof_default()(position) === "object") {
          var _top;

          var _left;

          if (position.hasOwnProperty("top") && position.top != null) {
            _top = this.bfb2Number(position.top, document.documentElement.clientHeight, windowOptions);
          }

          if (position.hasOwnProperty("bottom") && position.bottom != null) {
            windowOptions._hasresize = true;

            var _bottom = this.bfb2Number(position.bottom, document.documentElement.clientHeight, windowOptions);

            if (_top != null) {
              _height = document.documentElement.clientHeight - _top - _bottom;
            } else {
              _top = document.documentElement.clientHeight - _height - _bottom;
            }
          }

          if (position.hasOwnProperty("left") && position.left != null) {
            _left = this.bfb2Number(position.left, document.documentElement.clientWidth, windowOptions);
          }

          if (position.hasOwnProperty("right") && position.right != null) {
            windowOptions._hasresize = true;

            var _right = this.bfb2Number(position.right, document.documentElement.clientWidth, windowOptions);

            if (_left != null) {
              _width = document.documentElement.clientWidth - _left - _right;
            } else {
              _left = document.documentElement.clientWidth - _width - _right;
            }
          }

          if (_top == null) {
            _top = (document.documentElement.clientHeight - _height) / 2;
          }

          if (_left == null) {
            _left = (document.documentElement.clientWidth - _width) / 2;
          }

          offset = [_top + "px", _left + "px"];
        }
      } //最大最小高度判断


      if (windowOptions.hasOwnProperty("minHeight") && _height < windowOptions.minHeight) {
        windowOptions._hasresize = true;
        _height = windowOptions.minHeight;
      }

      if (windowOptions.hasOwnProperty("maxHeight") && _height > windowOptions.maxHeight) {
        windowOptions._hasresize = true;
        _height = windowOptions.maxHeight;
      } //最大最小宽度判断


      if (windowOptions.hasOwnProperty("minWidth") && _width < windowOptions.minWidth) {
        windowOptions._hasresize = true;
        _width = windowOptions.minWidth;
      }

      if (windowOptions.hasOwnProperty("maxWidth") && _width > windowOptions.maxWidth) {
        windowOptions._hasresize = true;
        _width = windowOptions.maxWidth;
      }

      var area;

      if (_width && _height) {
        area = [_width + "px", _height + "px"];
      } else {
        area = _width + "px";
      }

      return {
        area: area,
        offset: offset
      };
    }
    /**
     * 更新窗口大小或位置，改变了主页面尺寸后需要调用(内部已自动调用)。
     * @return {void}  无
     */

  }, {
    key: "indexResize",
    value: function indexResize() {
      if (!this.isActivate) {
        return;
      }

      var that = this;
      this.eachView(function (viewopt) {
        if (viewopt._layerIdx == null || viewopt._layerIdx == -1 || viewopt.windowOptions == null || !viewopt.windowOptions._hasresize) {
          return;
        }

        var _size = that._getWinSize(viewopt.windowOptions);

        var _style = {};

        if (Array.isArray(_size.area)) {
          if (_size.area[0]) {
            _style.width = _size.area[0];
          }

          if (_size.area[1]) {
            _style.height = _size.area[1];
          }
        }

        if (Array.isArray(_size.offset)) {
          if (_size.offset[1]) {
            _style.top = _size.offset[0];
          }

          if (_size.offset[1]) {
            _style.left = _size.offset[1];
          }
        }

        BaseWidget_jQuery(viewopt._dom).attr("myTopLeft", true);
        BaseWidget_layer.style(viewopt._layerIdx, _style);

        if (viewopt.type == "divwindow") {
          BaseWidget_layer.iframeAuto(viewopt._layerIdx);
        }
      });
    } //==============直接添加dom节点=================

  }, {
    key: "_appendView",
    value: function _appendView(viewopt, html) {
      viewopt._dom = BaseWidget_jQuery(html).appendTo(viewopt.parent || "body"); //设置css

      if (this.options.css) {
        BaseWidget_jQuery(viewopt._dom).css(this.options.css);
      }

      this.winCreateOK(viewopt, html);
      this._viewcreate_okcount++;

      if (this._viewcreate_okcount >= this._viewcreate_allcount) {
        this._startActivate(html);
      }
    }
    /**
     * 每个view窗口或页面创建完成后调用的钩子方法
     *
     * @param {Object} opt 对应的view配置
     * @param {Object|String} result 得到iframe页的窗口对象 或 view的html内容
     * @return {void}  无
     * @abstract
     */

  }, {
    key: "winCreateOK",
    value: function winCreateOK(opt, result) {}
    /**
     * 窗口最大化后触发后 的钩子方法
     * @return {void}  无
     * @abstract
     */

  }, {
    key: "winFull",
    value: function winFull() {}
    /**
     * 窗口最小化后触发 的钩子方法
     * @return {void}  无
     * @abstract
     */

  }, {
    key: "winMin",
    value: function winMin() {}
    /**
     * 最小化窗口
     * @return {void}  无
     */

  }, {
    key: "minView",
    value: function minView() {
      this.eachView(function (viewopt) {
        if (viewopt._layerIdx) {
          BaseWidget_layer.min(viewopt._layerIdx, viewopt);
        }
      });
    }
    /**
     * 还原窗口
     * @return {void}  无
     */

  }, {
    key: "restoreView",
    value: function restoreView() {
      this.eachView(function (viewopt) {
        if (viewopt._layerIdx) {
          BaseWidget_layer.restore(viewopt._layerIdx);
        }
      });
    }
    /**
     * 最大化窗口
     * @return {void}  无
     */

  }, {
    key: "fullView",
    value: function fullView() {
      this.eachView(function (viewopt) {
        if (viewopt._layerIdx) {
          BaseWidget_layer.full(viewopt._layerIdx, viewopt);
        }
      });
    }
    /**
     * 窗口还原后触发 的钩子方法
     * @return {void}  无
     * @abstract
     */

  }, {
    key: "winRestore",
    value: function winRestore() {}
  }, {
    key: "_startActivate",
    value: function _startActivate(layero) {
      this.activate(layero);
      eventTarget.fire(WidgetEventType.activated, {
        sourceTarget: this
      });

      if (this.options.success) {
        this.options.success(this);
        delete this.options.success; //一次性的
      }

      if (!this.isActivate) {
        //窗口打开中没加载完成时，被释放
        this.disableBase();
      }
    }
    /**
     * 激活模块之前 的钩子方法
     * @return {void}  无
     * @abstract
     */

  }, {
    key: "beforeActivate",
    value: function beforeActivate() {}
    /**
     * 激活模块【类内部实现方法】
     * @return {void}  无
     * @abstract
     */

  }, {
    key: "activate",
    value: function activate() {} //==============释放插件=================

    /**
     * 释放插件，同 mars3d.widget.disable方法
     * @return {void}  无
     */

  }, {
    key: "disableBase",
    value: function disableBase() {
      if (!this.isActivate) {
        return;
      }

      this.isActivate = false;
      this.beforeDisable();
      eventTarget.fire(WidgetEventType.beforeDisable, {
        sourceTarget: this
      }); //关闭所有窗口

      this.eachView(function (viewopt) {
        if (viewopt._layerIdx && viewopt._layerIdx > 0) {
          BaseWidget_layer.close(viewopt._layerIdx);

          if (viewopt._layerOpening) {//窗口还在加载中,success方法中去关闭
          } else {
            viewopt._layerIdx = -1;
          }

          return true;
        } else {
          if (viewopt.type == "append" && viewopt._dom) {
            viewopt._dom.remove();

            viewopt._dom = null;
          }

          if (viewopt.type == "custom" && viewopt.close) {
            viewopt.close();
          }

          return false;
        }
      });
      this.disable(); //还原配置为初始状态

      if (this.options.autoReset) {
        this.resetConfig();
      }

      eventTarget.fire(WidgetEventType.disabled, {
        sourceTarget: this
      });
    }
    /**
     * 释放模块前
     * @return {void}  无
     * @abstract
     */

  }, {
    key: "beforeDisable",
    value: function beforeDisable() {}
    /**
     * 释放模块【类内部实现方法】
     * @return {void}  无
     * @abstract
     */

  }, {
    key: "disable",
    value: function disable() {} //==============其他方法=================

  }, {
    key: "bfb2Number",
    value: function bfb2Number(str, allnum, windowOptions) {
      if (typeof str === "string" && str.indexOf("%") != -1) {
        windowOptions._hasresize = true;
        return allnum * Number(str.replace("%", "")) / 100;
      }

      return str;
    }
  }, {
    key: "addCacheVersion",
    value: function addCacheVersion(_resource) {
      if (_resource == null) {
        return _resource;
      }

      var cacheVersion = getCacheVersion();

      if (cacheVersion) {
        if (_resource.indexOf("?") == -1) {
          _resource += "?cache=" + cacheVersion;
        } else if (_resource.indexOf("cache=" + cacheVersion) == -1) {
          _resource += "&cache=" + cacheVersion;
        }
      }

      return _resource;
    }
    /**
     * 还原配置为初始状态
     * @return {void}  无
     */

  }, {
    key: "resetConfig",
    value: function resetConfig() {
      if (this.options._firstConfigBak) {
        var _backData = this.options._firstConfigBak;

        for (var aa in _backData) {
          if (aa == "uri") {
            continue;
          }

          this.options[aa] = _backData[aa];
        }
      }
    }
    /**
     * 设置view弹窗的显示和隐藏，基于修改css实现
     *
     * @param {Boolean} show 是否显示
     * @param {Number} [index] 当有多个view时，可以指定单个操作的view的index
     * @return {void}  无
     */

  }, {
    key: "setViewShow",
    value: function setViewShow(show, index) {
      this.eachView(function (viewopt) {
        if (viewopt._layerIdx && viewopt._layerIdx > 0) {
          if (show) {
            BaseWidget_jQuery("#layui-layer" + viewopt._layerIdx).show();
          } else {
            BaseWidget_jQuery("#layui-layer" + viewopt._layerIdx).hide();
          }
        } else if (viewopt.type == "append" && viewopt._dom) {
          if (show) {
            BaseWidget_jQuery(viewopt._dom).show();
          } else {
            BaseWidget_jQuery(viewopt._dom).hide();
          }
        }
      }, index);
    }
    /**
     * 设置view弹窗的css
     *
     * @param {Object} style css值
     * @param {Number} [index] 当有多个view时，可以指定单个操作的view的index
     * @return {void}  无
     */

  }, {
    key: "setViewCss",
    value: function setViewCss(style, index) {
      this.eachView(function (viewopt) {
        if (viewopt._layerIdx != null && viewopt._layerIdx > 0) {
          BaseWidget_layer.style(viewopt._layerIdx, style);
        } else if (viewopt.type == "append" && viewopt._dom) {
          BaseWidget_jQuery(viewopt._dom).css(style);
        }
      }, index);
    }
    /**
     * 设置view弹窗的标题
     *
     * @param {String} title css值
     * @param {Number} [index] 当有多个view时，可以指定单个操作的view的index
     * @return {void}  无
     */

  }, {
    key: "setTitle",
    value: function setTitle(title, index) {
      this.eachView(function (viewopt) {
        if (viewopt._dom) {
          viewopt._dom.find(".layui-layer-title").html(title);
        }
      }, index);
    }
    /**
     * 读取html页面的内容
     *
     * @param {string} url html页面的url
     * @param {Function} callback 读取完成后的回调方法
     * @return {void}  无
     */

  }, {
    key: "getHtml",
    value: function getHtml(url, callback) {
      BaseWidget_jQuery.ajax({
        url: url,
        type: "GET",
        dataType: "html",
        timeout: 0,
        //永不超时
        success: function success(data) {
          callback(data);
        }
      });
    }
  }]);

  return BaseWidget;
}(BaseClass);
// CONCATENATED MODULE: ./src/index.js


 // eslint-disable-next-line no-import-assign

external_mars3d_["widget"] = widgetManager_namespaceObject;

external_mars3d_["widget"].BaseWidget = BaseWidget_BaseWidget;

external_mars3d_["widget"].WidgetEventType = WidgetEventType;
external_mars3d_["widget"].EventType = WidgetEventType;


/***/ })
/******/ ]);
});
//# sourceMappingURL=mars3d-widget-src.js.map