@dfsj/components 3.0.0

package/dist/components/UnifyChart/src/hooks/useLoader.d.ts

@@ -0,0 +1,11 @@
+import { State } from '../../../Stateful';
+import { useLoaderProps } from '../props';
+export declare function useLoader(props: useLoaderProps, { immediate, condition, watchCondition }: {
+    immediate?: boolean;
+    condition?: {};
+    watchCondition?: boolean;
+}): {
+    datasource: import("vue").Ref<any>;
+    fetchData: () => Promise<void>;
+    stateful: State;
+};

package/dist/components/UnifyChart/src/hooks/useRender.d.ts

@@ -0,0 +1,24 @@
+import { Ref } from 'vue';
+import { IToolbox } from '../props';
+type EChartsType = object | any;
+export interface RenderConfig {
+    setOptions: Function;
+    echarts: EChartsType;
+    createOptions: Function;
+    getInstance: Function;
+    assemble: Function;
+    toggleTable: Function;
+    transform: Function;
+    toggleStatistic: Function;
+}
+type Toolbox = Array<IToolbox>;
+export declare function useRender(config: RenderConfig, datasource: Ref, toolbox: Toolbox): {
+    refreshCharts: (data: any) => void;
+    getBindValue: import("vue").ComputedRef<{
+        instance: Function;
+        toggleTable: Function;
+        toggleStatistic: Function;
+        toolbox: Toolbox;
+    }>;
+};
+export {};

package/dist/components/UnifyChart/src/hooks/useRender.js

@@ -0,0 +1,49 @@
+import { computed, watch, onMounted } from 'vue';
+import { EToolbox } from '../props.js';
+
+function useRender(config, datasource, toolbox) {
+  var getInstance = config.getInstance,
+    setOptions = config.setOptions,
+    _config$transform = config.transform,
+    transform = _config$transform === void 0 ? function (d) {
+      return d;
+    } : _config$transform,
+    _config$createOptions = config.createOptions,
+    createOptions = _config$createOptions === void 0 ? function (p) {
+      return p;
+    } : _config$createOptions,
+    assemble = config.assemble,
+    toggleTable = config.toggleTable,
+    toggleStatistic = config.toggleStatistic;
+  var getBindValue = computed(function () {
+    return {
+      instance: getInstance,
+      toggleTable: toggleTable,
+      toggleStatistic: toggleStatistic,
+      toolbox: toolbox !== null && toolbox !== void 0 ? toolbox : [EToolbox.Download, EToolbox.Table, EToolbox.Statistic]
+    };
+  });
+  function refreshCharts(data) {
+    if (!data) return;
+    transform(data);
+    var optioned = createOptions(data);
+    var options = assemble(data, optioned);
+    setTimeout(function () {
+      setOptions(options, true);
+    }, 100);
+  }
+  watch(function () {
+    return datasource.value;
+  }, function (v) {
+    refreshCharts(v);
+  });
+  onMounted(function () {
+    refreshCharts(datasource.value);
+  });
+  return {
+    refreshCharts: refreshCharts,
+    getBindValue: getBindValue
+  };
+}
+
+export { useRender };

package/dist/components/UnifyChart/src/props.d.ts

@@ -0,0 +1,145 @@
+export interface Convert {
+    createOptions: Function;
+    transform: Function;
+}
+export declare const unifyChartProps: {
+    data: import("vue-types").VueTypeValidableDef<{
+        [key: string]: any;
+    }, import("vue-types/dist/types").ValidatorFunction<{
+        [key: string]: any;
+    }>> & {
+        default: () => {
+            [key: string]: any;
+        };
+    } & {
+        default: () => {
+            [key: string]: any;
+        };
+    };
+    options: import("vue-types").VueTypeValidableDef<{
+        [key: string]: any;
+    }, import("vue-types/dist/types").ValidatorFunction<{
+        [key: string]: any;
+    }>> & {
+        default: () => {
+            [key: string]: any;
+        };
+    } & {
+        default: () => {
+            [key: string]: any;
+        };
+    };
+    width: import("vue-types").VueTypeValidableDef<string, import("vue-types/dist/types").ValidatorFunction<string>> & {
+        default: string;
+    } & {
+        default: string;
+    };
+    height: import("vue-types").VueTypeValidableDef<string, import("vue-types/dist/types").ValidatorFunction<string>> & {
+        default: string;
+    } & {
+        default: string;
+    };
+    target: import("vue-types").VueTypeValidableDef<{
+        [key: string]: any;
+    }, import("vue-types/dist/types").ValidatorFunction<{
+        [key: string]: any;
+    }>> & {
+        default: () => {
+            [key: string]: any;
+        };
+    } & {
+        default: () => {
+            [key: string]: any;
+        };
+    };
+    convert: () => Convert;
+    datasource: import("vue-types").VueTypeValidableDef<{
+        [key: string]: any;
+    }, import("vue-types/dist/types").ValidatorFunction<{
+        [key: string]: any;
+    }>> & {
+        default: () => {
+            [key: string]: any;
+        };
+    } & {
+        default: () => {
+            [key: string]: any;
+        };
+    };
+    toolbox: () => Array<IToolbox>;
+    chartHooks: import("vue-types").VueTypeValidableDef<(...args: any[]) => any, import("vue-types/dist/types").ValidatorFunction<(...args: any[]) => any>> & {
+        default: (...args: any[]) => any;
+    };
+    stateful: import("vue-types").VueTypeValidableDef<{
+        [key: string]: any;
+    }, import("vue-types/dist/types").ValidatorFunction<{
+        [key: string]: any;
+    }>> & {
+        default: () => {
+            [key: string]: any;
+        };
+    } & {
+        default: () => {
+            [key: string]: any;
+        };
+    };
+};
+interface Options {
+    loader: Function;
+    condition: Object;
+}
+export declare const compProps: {
+    target: import("vue-types").VueTypeValidableDef<{
+        [key: string]: any;
+    }, import("vue-types/dist/types").ValidatorFunction<{
+        [key: string]: any;
+    }>> & {
+        default: () => {
+            [key: string]: any;
+        };
+    } & {
+        default: () => {
+            [key: string]: any;
+        };
+    };
+    options: () => Options;
+};
+export type useLoaderProps = {
+    target: Object;
+    options: Options;
+};
+export declare enum EToolbox {
+    Download = 0,
+    Statistic = 1,
+    Table = 2
+}
+export type EToolboxKeys = keyof typeof EToolbox;
+export type IToolbox = EToolbox[EToolboxKeys];
+export declare const toolboxProps: {
+    instance: import("vue-types").VueTypeValidableDef<{
+        [key: string]: any;
+    }, import("vue-types/dist/types").ValidatorFunction<{
+        [key: string]: any;
+    }>> & {
+        default: () => {
+            [key: string]: any;
+        };
+    } & {
+        default: () => {
+            [key: string]: any;
+        };
+    };
+    iconSize: import("vue-types").VueTypeValidableDef<number, import("vue-types/dist/types").ValidatorFunction<number>> & {
+        default: number;
+    } & {
+        default: number;
+    };
+    toggleTable: import("vue-types").VueTypeValidableDef<(...args: any[]) => any, import("vue-types/dist/types").ValidatorFunction<(...args: any[]) => any>> & {
+        default: (...args: any[]) => any;
+    };
+    toggleStatistic: import("vue-types").VueTypeValidableDef<(...args: any[]) => any, import("vue-types/dist/types").ValidatorFunction<(...args: any[]) => any>> & {
+        default: (...args: any[]) => any;
+    };
+    toolbox: () => Array<IToolbox>;
+};
+export {};

package/dist/components/UnifyChart/src/props.js

@@ -0,0 +1,33 @@
+import propTypes from '../../../utils/propTypes.js';
+
+var unifyChartProps = {
+  data: propTypes.object.def({}),
+  options: propTypes.object.def({}),
+  width: propTypes.string.def('100%'),
+  height: propTypes.string.def('100%'),
+  target: propTypes.object.def({}),
+  convert: Object,
+  datasource: propTypes.object.def({}),
+  toolbox: Array,
+  chartHooks: propTypes.func,
+  stateful: propTypes.object.def({})
+};
+var compProps = {
+  target: propTypes.object.def({}),
+  options: Object
+};
+var EToolbox;
+(function (EToolbox) {
+  EToolbox[EToolbox["Download"] = 0] = "Download";
+  EToolbox[EToolbox["Statistic"] = 1] = "Statistic";
+  EToolbox[EToolbox["Table"] = 2] = "Table";
+})(EToolbox || (EToolbox = {}));
+var toolboxProps = {
+  instance: propTypes.object.def({}),
+  iconSize: propTypes.number.def(28),
+  toggleTable: propTypes.func,
+  toggleStatistic: propTypes.func,
+  toolbox: Array
+};
+
+export { EToolbox, compProps, toolboxProps, unifyChartProps };

package/dist/components/Video/index.d.ts

@@ -0,0 +1,2 @@
+import VideoPlayer from './src/VideoPlayer.vue';
+export { VideoPlayer };

package/dist/components/Video/src/VideoPlayer.vue.d.ts

@@ -0,0 +1,60 @@
+declare const _default: import("vue").DefineComponent<{
+    host: import("vue-types").VueTypeValidableDef<string, import("vue-types/dist/types").ValidatorFunction<string>> & {
+        default: string;
+    };
+    port: import("vue-types").VueTypeValidableDef<string, import("vue-types/dist/types").ValidatorFunction<string>> & {
+        default: string;
+    };
+    channel: import("vue-types").VueTypeValidableDef<string, import("vue-types/dist/types").ValidatorFunction<string>> & {
+        default: string;
+    };
+    username: import("vue-types").VueTypeValidableDef<string, import("vue-types/dist/types").ValidatorFunction<string>> & {
+        default: string;
+    };
+    password: import("vue-types").VueTypeValidableDef<string, import("vue-types/dist/types").ValidatorFunction<string>> & {
+        default: string;
+    };
+    streamType: import("vue-types").VueTypeValidableDef<string, import("vue-types/dist/types").ValidatorFunction<string>> & {
+        default: string;
+    };
+    videoType: import("vue-types").VueTypeValidableDef<string, import("vue-types/dist/types").ValidatorFunction<string>> & {
+        default: string;
+    } & {
+        default: string;
+    };
+}, (_ctx: any, _cache: any) => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}>, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    host: import("vue-types").VueTypeValidableDef<string, import("vue-types/dist/types").ValidatorFunction<string>> & {
+        default: string;
+    };
+    port: import("vue-types").VueTypeValidableDef<string, import("vue-types/dist/types").ValidatorFunction<string>> & {
+        default: string;
+    };
+    channel: import("vue-types").VueTypeValidableDef<string, import("vue-types/dist/types").ValidatorFunction<string>> & {
+        default: string;
+    };
+    username: import("vue-types").VueTypeValidableDef<string, import("vue-types/dist/types").ValidatorFunction<string>> & {
+        default: string;
+    };
+    password: import("vue-types").VueTypeValidableDef<string, import("vue-types/dist/types").ValidatorFunction<string>> & {
+        default: string;
+    };
+    streamType: import("vue-types").VueTypeValidableDef<string, import("vue-types/dist/types").ValidatorFunction<string>> & {
+        default: string;
+    };
+    videoType: import("vue-types").VueTypeValidableDef<string, import("vue-types/dist/types").ValidatorFunction<string>> & {
+        default: string;
+    } & {
+        default: string;
+    };
+}>>, {
+    host: string;
+    port: string;
+    channel: string;
+    username: string;
+    password: string;
+    streamType: string;
+    videoType: string;
+}, {}>;
+export default _default;

package/dist/components/Video/src/VideoPlayer.vue.js

@@ -0,0 +1,5 @@
+import script from './VideoPlayer.vue2.js';
+
+script.__file = "src/components/Video/src/VideoPlayer.vue";
+
+export { script as default };

package/dist/components/Video/src/VideoPlayer.vue2.js

@@ -0,0 +1,107 @@
+import _defineProperty from '@babel/runtime/helpers/defineProperty';
+import { defineComponent, ref, getCurrentInstance, onMounted, nextTick, toRaw, unref, onBeforeUnmount, openBlock, createElementBlock, createBlock, withCtx, createElementVNode, withModifiers, createTextVNode, toDisplayString, createCommentVNode } from 'vue';
+import './VideoPlayerToolbar.vue.js';
+import { EventEnum } from './enums/CommonEnum.js';
+import VideoFactory from './control/VideoFactory.js';
+import propTypes from '../../../utils/propTypes.js';
+import script$1 from './VideoPlayerToolbar.vue2.js';
+
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+var _hoisted_1 = {
+  style: {
+    "color": "white"
+  }
+};
+var script = defineComponent({
+  __name: 'VideoPlayer',
+  props: {
+    host: propTypes.string,
+    port: propTypes.string,
+    channel: propTypes.string,
+    username: propTypes.string,
+    password: propTypes.string,
+    streamType: propTypes.string,
+    videoType: propTypes.string.def('Hikvision')
+  },
+  setup: function setup(__props) {
+    var _getCurrentInstance;
+    var instance = null;
+    var wrapEl = ref();
+    var isPlay = ref(false);
+    var isFullscreen = ref(false);
+    var props = __props;
+    var componentId = (_getCurrentInstance = getCurrentInstance()) === null || _getCurrentInstance === void 0 ? void 0 : _getCurrentInstance.uid;
+    onMounted(function () {
+      nextTick(function () {
+        instance = VideoFactory.create(props.videoType, _objectSpread({
+          wrapEl: wrapEl.value,
+          elId: componentId
+        }, toRaw(unref(props))));
+        instance.on(EventEnum.PLAY, function (ev) {
+          console.log('开始播放', {
+            ev: ev
+          });
+          isPlay.value = true;
+        });
+        instance.on(EventEnum.PAUSE, function (ev) {
+          console.log('结束播放', {
+            ev: ev
+          });
+          isPlay.value = false;
+        });
+      });
+    });
+    function stop() {
+      var _instance, _instance$stop;
+      console.log('props.control', instance);
+      (_instance = instance) === null || _instance === void 0 || (_instance$stop = _instance.stop) === null || _instance$stop === void 0 || _instance$stop.call(_instance);
+    }
+    function play() {
+      var _instance2, _instance2$play;
+      console.log('props.control', instance);
+      (_instance2 = instance) === null || _instance2 === void 0 || (_instance2$play = _instance2.play) === null || _instance2$play === void 0 || _instance2$play.call(_instance2);
+    }
+    function toggleFullScreen() {
+      isFullscreen.value = !isFullscreen.value;
+      instance.fullScreen(isFullscreen.value);
+    }
+    onBeforeUnmount(function () {
+      var _instance3, _instance3$dispose;
+      (_instance3 = instance) === null || _instance3 === void 0 || (_instance3$dispose = _instance3.dispose) === null || _instance3$dispose === void 0 || _instance3$dispose.call(_instance3);
+      instance = null;
+    });
+    function downloadFile() {
+      var fileUrl = 'libs/hikvision/WebComponentsKit.exe';
+      console.log('fileUrl', fileUrl);
+      var link = document.createElement('a');
+      link.href = fileUrl;
+      link.download = 'WebComponentsKit.exe';
+      link.click();
+    }
+    return function (_ctx, _cache) {
+      return openBlock(), createElementBlock("div", {
+        ref_key: "wrapEl",
+        ref: wrapEl,
+        "class": "wrap-el"
+      }, [wrapEl.value ? (openBlock(), createBlock(script$1, {
+        key: 0,
+        stop: stop,
+        play: play,
+        isPlay: isPlay.value,
+        isFullscreen: isFullscreen.value,
+        "toggle-fullscreen-fn": toggleFullScreen,
+        "dom-ref": wrapEl.value
+      }, {
+        "default": withCtx(function () {
+          return [createElementVNode("span", _hoisted_1, [createElementVNode("span", {
+            onClick: withModifiers(downloadFile, ["stop"])
+          }, "下载插件"), createTextVNode(" " + toDisplayString(unref(componentId)), 1)])];
+        }),
+        _: 1
+      }, 8, ["isPlay", "isFullscreen", "dom-ref"])) : createCommentVNode("v-if", true)], 512);
+    };
+  }
+});
+
+export { script as default };

package/dist/components/Video/src/VideoPlayerToolbar.vue.d.ts

@@ -0,0 +1,34 @@
+declare const _default: import("vue").DefineComponent<{
+    domRef: import("vue-types").VueTypeValidableDef<any, import("vue-types/dist/types").ValidatorFunction<any>>;
+    stop: import("vue-types").VueTypeValidableDef<(...args: any[]) => any, import("vue-types/dist/types").ValidatorFunction<(...args: any[]) => any>> & {
+        default: (...args: any[]) => any;
+    };
+    play: import("vue-types").VueTypeValidableDef<(...args: any[]) => any, import("vue-types/dist/types").ValidatorFunction<(...args: any[]) => any>> & {
+        default: (...args: any[]) => any;
+    };
+    isPlay: import("vue-types").VueTypeValidableDef<boolean, import("vue-types/dist/types").ValidatorFunction<boolean>>;
+    isFullscreen: import("vue-types").VueTypeValidableDef<boolean, import("vue-types/dist/types").ValidatorFunction<boolean>>;
+    toggleFullscreenFn: import("vue-types").VueTypeValidableDef<(...args: any[]) => any, import("vue-types/dist/types").ValidatorFunction<(...args: any[]) => any>> & {
+        default: (...args: any[]) => any;
+    };
+}, (_ctx: any, _cache: any) => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}>, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    domRef: import("vue-types").VueTypeValidableDef<any, import("vue-types/dist/types").ValidatorFunction<any>>;
+    stop: import("vue-types").VueTypeValidableDef<(...args: any[]) => any, import("vue-types/dist/types").ValidatorFunction<(...args: any[]) => any>> & {
+        default: (...args: any[]) => any;
+    };
+    play: import("vue-types").VueTypeValidableDef<(...args: any[]) => any, import("vue-types/dist/types").ValidatorFunction<(...args: any[]) => any>> & {
+        default: (...args: any[]) => any;
+    };
+    isPlay: import("vue-types").VueTypeValidableDef<boolean, import("vue-types/dist/types").ValidatorFunction<boolean>>;
+    isFullscreen: import("vue-types").VueTypeValidableDef<boolean, import("vue-types/dist/types").ValidatorFunction<boolean>>;
+    toggleFullscreenFn: import("vue-types").VueTypeValidableDef<(...args: any[]) => any, import("vue-types/dist/types").ValidatorFunction<(...args: any[]) => any>> & {
+        default: (...args: any[]) => any;
+    };
+}>>, {
+    stop: (...args: any[]) => any;
+    play: (...args: any[]) => any;
+    toggleFullscreenFn: (...args: any[]) => any;
+}, {}>;
+export default _default;

package/dist/components/Video/src/VideoPlayerToolbar.vue.js

@@ -0,0 +1,5 @@
+import script from './VideoPlayerToolbar.vue2.js';
+
+script.__file = "src/components/Video/src/VideoPlayerToolbar.vue";
+
+export { script as default };

package/dist/components/Video/src/VideoPlayerToolbar.vue2.js

@@ -0,0 +1,65 @@
+import { defineComponent, toRefs, computed, openBlock, createElementBlock, renderSlot, createVNode, unref, mergeProps, withModifiers } from 'vue';
+import { useFullscreen } from '../../../node_modules/.pnpm/@vueuse_core@10.7.2_vue@3.4.21/node_modules/@vueuse/core/index.js';
+import '../../Icon/src/Icon.vue.js';
+import '../../Icon/src/SvgIcon.vue.js';
+import propTypes from '../../../utils/propTypes.js';
+import script$1 from '../../Icon/src/Icon.vue2.js';
+
+var _hoisted_1 = {
+  "class": "video-player-toolbar"
+};
+var script = defineComponent({
+  __name: 'VideoPlayerToolbar',
+  props: {
+    domRef: propTypes.any,
+    stop: propTypes.func,
+    play: propTypes.func,
+    isPlay: propTypes.bool,
+    isFullscreen: propTypes.bool,
+    toggleFullscreenFn: propTypes.func
+  },
+  setup: function setup(__props) {
+    var props = __props;
+    var _toRefs = toRefs(props),
+      domRef = _toRefs.domRef,
+      isPlay = _toRefs.isPlay,
+      isFullscreen = _toRefs.isFullscreen;
+    console.log('props', props.domRef);
+    var _useFullscreen = useFullscreen(domRef.value),
+      toggleDom = _useFullscreen.toggle;
+    var getAttr = computed(function () {
+      return {
+        color: "#fff",
+        size: 24
+      };
+    });
+    function playToggle() {
+      if (isPlay.value) {
+        var _props$stop;
+        (_props$stop = props.stop) === null || _props$stop === void 0 || _props$stop.call(props);
+      } else {
+        var _props$play;
+        (_props$play = props.play) === null || _props$play === void 0 || _props$play.call(props);
+      }
+    }
+    function fullToggle() {
+      var _props$toggleFullscre;
+      toggleDom();
+      (_props$toggleFullscre = props.toggleFullscreenFn) === null || _props$toggleFullscre === void 0 || _props$toggleFullscre.call(props);
+    }
+    return function (_ctx, _cache) {
+      return openBlock(), createElementBlock("div", _hoisted_1, [renderSlot(_ctx.$slots, "default"), createVNode(unref(script$1), mergeProps({
+        icon: !unref(isFullscreen) ? 'mdi:fullscreen' : 'mdi:fit-to-screen'
+      }, getAttr.value, {
+        onClick: withModifiers(fullToggle, ["stop"])
+      }), null, 16, ["icon"]), createVNode(unref(script$1), mergeProps({
+        icon: !unref(isPlay) ? 'mdi:play-circle-outline' : 'mdi:pause-circle',
+        onClick: _cache[0] || (_cache[0] = withModifiers(function () {
+          return playToggle();
+        }, ["stop"]))
+      }, getAttr.value), null, 16, ["icon"])]);
+    };
+  }
+});
+
+export { script as default };

package/dist/components/Video/src/abstract/AbstractVideoControl.d.ts

@@ -0,0 +1,7 @@
+export default interface AbstractVideoControl {
+    login(): void;
+    logout(): void;
+    play(): void;
+    stop(): void;
+    dispose(): void;
+}

package/dist/components/Video/src/abstract/Observable.d.ts

@@ -0,0 +1,6 @@
+declare const Observable: {
+    (): void;
+    hasOwnKey: any;
+    slice: any;
+};
+export default Observable;

package/dist/components/Video/src/abstract/Observable.js

@@ -0,0 +1,89 @@
+import _typeof from '@babel/runtime/helpers/typeof';
+
+var Observable = function Observable() {
+  this.Events = {};
+  this.__cnt = 0;
+};
+Observable.hasOwnKey = Function.call.bind(Object.hasOwnProperty);
+Observable.slice = Function.call.bind(Array.prototype.slice);
+Observable.prototype.on = function (eventName, callback, context) {
+  return this.bindEvent(eventName, callback, 0, context);
+};
+Observable.prototype.un = function (event) {
+  var eventName = '';
+  var key = '';
+  var r = false;
+  var type = _typeof(event);
+  var that = this;
+  if (type === 'string') {
+    if (Observable.hasOwnKey(this.Events, event)) {
+      delete this.Events[event];
+      return true;
+    }
+    return false;
+  } else if (type === 'object') {
+    eventName = event[0];
+    key = event[1];
+    if (Observable.hasOwnKey(this.Events, eventName) && Observable.hasOwnKey(this.Events[eventName], key)) {
+      delete this.Events[eventName][key];
+      return true;
+    }
+    return false;
+  } else if (type === 'function') {
+    that.eachEvent(that.Events, function (keyA, itemA) {
+      that.eachEvent(itemA, function (keyB, itemB) {
+        if (itemB[0] === event) {
+          delete that.Events[keyA][keyB];
+          r = true;
+        }
+      });
+    });
+    return r;
+  }
+  return true;
+};
+Observable.prototype.once = function (eventName, callback, context) {
+  return this.bindEvent(eventName, callback, 1, context);
+};
+Observable.prototype.action = function (eventName, args) {
+  if (Observable.hasOwnKey(this.Events, eventName)) {
+    this.eachEvent(this.Events[eventName], function (key, item) {
+      item[0].apply(item[2], args);
+      if (item[1]) {
+        delete this.Events[eventName][key];
+      }
+    });
+  }
+};
+Observable.prototype.dispatch = function (eventName) {
+  var that = this;
+  var args = Observable.slice(arguments, 1);
+  setTimeout(function () {
+    that.action(eventName, args);
+  });
+};
+Observable.prototype.dispatchSync = function (eventName) {
+  this.action(eventName, Observable.slice(arguments, 1));
+};
+Observable.prototype.clear = function () {
+  this.Events = {};
+};
+Observable.prototype.bindEvent = function (eventName, callback, isOne, context) {
+  if (typeof eventName !== 'string' || typeof callback !== 'function') {
+    throw new Error('传入的事件名称和回调函数有误！');
+  }
+  if (!Observable.hasOwnKey(this.Events, eventName)) {
+    this.Events[eventName] = {};
+  }
+  this.Events[eventName][++this.__cnt] = [callback, isOne, context];
+  return [eventName, this.__cnt];
+};
+Observable.prototype.eachEvent = function (obj, callback) {
+  for (var key in obj) {
+    if (Observable.hasOwnKey(obj, key)) {
+      callback(key, obj[key]);
+    }
+  }
+};
+
+export { Observable as default };