@vuemap/vue-amap/lib/packages/vector/Rectangle/Rectangle.vue2.js

高德地图vue3版本封装

'use strict';

Object.defineProperty(exports, '__esModule', { value: true });

var vue = require('vue');
var lodashEs = require('lodash-es');
require('../../../mixins/index.js');
var useEditor = require('../../../mixins/useEditor.js');
require('../../../utils/index.js');
var props = require('./props.js');
var useRegister = require('../../../mixins/useRegister.js');
var util = require('../../../utils/util.js');
var convertHelper = require('../../../utils/convert-helper.js');

var script = /* @__PURE__ */ vue.defineComponent({
  ...{
    name: "ElAmapRectangle",
    inheritAttrs: false
  },
  __name: "Rectangle",
  props: props.propsTypes,
  emits: ["init", "update:bounds"],
  setup(__props, { expose: __expose, emit: __emit }) {
    const props = __props;
    const emits = __emit;
    let $amapComponent;
    let destroying = false;
    const { $$getInstance, parentInstance } = useRegister.useRegister((options, parentComponent) => {
      return new Promise((resolve) => {
        $amapComponent = new AMap.Rectangle(options);
        if (util.isMapInstance(parentComponent)) {
          parentComponent.add($amapComponent);
        } else if (util.isOverlayGroupInstance(parentComponent)) {
          parentComponent.addOverlay($amapComponent);
        } else if (util.isVectorLayerInstance(parentComponent)) {
          parentComponent.add($amapComponent);
        }
        bindModelEvents();
        resolve($amapComponent);
      });
    }, {
      emits,
      converts: {
        bounds: (path) => {
          return new AMap.Bounds(convertHelper.toLngLat(path[0]), convertHelper.toLngLat(path[1]));
        }
      },
      watchRedirectFn: {
        __zIndex(value) {
          if ($amapComponent) {
            $amapComponent.setOptions({ zIndex: value });
          }
        },
        __strokeColor(value) {
          if ($amapComponent) {
            $amapComponent.setOptions({ strokeColor: value });
          }
        },
        __strokeOpacity(value) {
          if ($amapComponent) {
            $amapComponent.setOptions({ strokeOpacity: value });
          }
        },
        __strokeWeight(value) {
          if ($amapComponent) {
            $amapComponent.setOptions({ strokeWeight: value });
          }
        },
        __fillColor(value) {
          if ($amapComponent) {
            $amapComponent.setOptions({ fillColor: value });
          }
        },
        __fillOpacity(value) {
          if ($amapComponent) {
            $amapComponent.setOptions({ fillOpacity: value });
          }
        },
        __strokeStyle(value) {
          if ($amapComponent) {
            $amapComponent.setOptions({ strokeStyle: value });
          }
        },
        __strokeDasharray(value) {
          if ($amapComponent) {
            $amapComponent.setOptions({ strokeDasharray: value });
          }
        },
        __editable(flag) {
          createEditor().then(() => {
            flag ? resetEditor() : editor.close();
          });
        },
        __bounds(bounds) {
          if ($amapComponent) {
            $amapComponent.setBounds(bounds);
            resetEditor();
          }
        }
      },
      destroyComponent() {
        destroying = true;
        if ($amapComponent && (parentInstance == null ? void 0 : parentInstance.$amapComponent)) {
          if (editor) {
            if (!parentInstance.isDestroy) {
              editor.close();
            }
            editor = null;
          }
          if (!parentInstance.isDestroy) {
            if (util.isMapInstance(parentInstance.$amapComponent)) {
              parentInstance.$amapComponent.remove($amapComponent);
            } else if (util.isOverlayGroupInstance(parentInstance.$amapComponent)) {
              parentInstance.$amapComponent.removeOverlay($amapComponent);
            } else if (util.isVectorLayerInstance(parentInstance.$amapComponent)) {
              parentInstance.$amapComponent.remove($amapComponent);
            }
          }
          if ($amapComponent.destroy) {
            $amapComponent.destroy();
          }
          $amapComponent = null;
        }
      }
    });
    const resetEditor = lodashEs.debounce(() => {
      if (editor && props.editable) {
        editor.close();
        editor.setTarget();
        editor.setTarget($amapComponent);
        editor.open();
      }
    }, 50);
    const bindModelEvents = () => {
      $amapComponent.on("dragend", () => {
        emitModel($amapComponent);
      });
      $amapComponent.on("touchend", () => {
        emitModel($amapComponent);
      });
    };
    const emitModel = (target) => {
      if (destroying) {
        return;
      }
      const bounds = target.getBounds();
      const southWest = bounds.getSouthWest();
      const northEast = bounds.getNorthEast();
      const paths = [southWest.toArray(), northEast.toArray()];
      emits("update:bounds", paths);
    };
    let editor;
    const attrs = vue.useAttrs();
    const createEditor = () => {
      return new Promise((resolve) => {
        if (editor) {
          resolve();
        } else {
          AMap.plugin(["AMap.RectangleEditor"], () => {
            editor = new AMap.RectangleEditor(parentInstance == null ? void 0 : parentInstance.$amapComponent, $amapComponent, props.editOptions);
            useEditor.useEditor(editor, attrs);
            bindEditorModelEvents();
            resolve();
          });
        }
      });
    };
    const bindEditorModelEvents = () => {
      editor.on("addnode", (e) => {
        emitModel(e.target);
      });
      editor.on("adjust", (e) => {
        emitModel(e.target);
      });
      editor.on("removenode", (e) => {
        emitModel(e.target);
      });
      editor.on("add", (e) => {
        emitModel(e.target);
      });
    };
    __expose({
      $$getInstance
    });
    return (_ctx, _cache) => {
      return vue.openBlock(), vue.createElementBlock("div");
    };
  }
});

exports.default = script;
//# sourceMappingURL=Rectangle.vue2.js.map