@ctzy-web-client/plugin-component-vue 1.0.0 → 1.0.2

package/lib/filter-panel/filter-panel.js

@@ -0,0 +1,184 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var vue = require('vue');
+var webBaseClientVue = require('web-base-client-vue');
+var useFilterPanel = require('./use-filter-panel.js');
+var filterPanelItem = require('./filter-panel-item.js');
+var _pluginVue_exportHelper = require('../_virtual/_plugin-vue_export-helper.js');
+
+const __default__ = vue.defineComponent({
+  name: "BwaFilterPanel"
+});
+const _sfc_main = /* @__PURE__ */ Object.assign(__default__, {
+  props: {
+    dataTable: {
+      type: Object
+    },
+    showSearch: {
+      type: Boolean,
+      default: false
+    },
+    showFieldOptions: {
+      type: Boolean,
+      default: true
+    },
+    searchAttr: {
+      type: String,
+      default: "search"
+    },
+    searchPlaceholder: {
+      type: String,
+      default: ""
+    },
+    searchFields: {
+      type: Array,
+      default: () => []
+    }
+  },
+  emits: ["reset", "filter"],
+  setup(__props, { emit }) {
+    const props = __props;
+    const ns = webBaseClientVue.useNamespace("filterpanel");
+    const {
+      dataTable,
+      filterPanel,
+      currentFilterColumns,
+      selectedColumnAttrNames,
+      closableColumns,
+      searchParams,
+      handleFieldSearch,
+      searchValue,
+      isChange,
+      handleReset
+    } = useFilterPanel.useFilterPanel(props, { emit });
+    vue.watch(
+      filterPanel,
+      (filterPanel2, _, onCleanup) => {
+        filterPanel2.existComponent = true;
+        onCleanup(() => {
+          filterPanel2.existComponent = false;
+        });
+      },
+      { immediate: true }
+    );
+    vue.provide(
+      webBaseClientVue.filterPanelKey,
+      vue.reactive({
+        dataTable,
+        filterPanel,
+        currentFilterColumns
+      })
+    );
+    return (_ctx, _cache) => {
+      const _component_BwaCondition = vue.resolveComponent("BwaCondition");
+      const _component_ElCheckbox = vue.resolveComponent("ElCheckbox");
+      const _component_BwaAdvanceOption = vue.resolveComponent("BwaAdvanceOption");
+      const _component_BwaAdvanceSelect = vue.resolveComponent("BwaAdvanceSelect");
+      const _component_ElInput = vue.resolveComponent("ElInput");
+      const _component_ElButton = vue.resolveComponent("ElButton");
+      return vue.openBlock(), vue.createElementBlock("div", {
+        class: vue.normalizeClass(vue.unref(ns).b())
+      }, [
+        vue.renderSlot(_ctx.$slots, "default", {}, () => [
+          (vue.openBlock(true), vue.createElementBlock(vue.Fragment, null, vue.renderList(vue.unref(currentFilterColumns), (column) => {
+            return vue.renderSlot(_ctx.$slots, `condition-${column.attrName}`, {
+              key: column.attrName,
+              attrName: column.attrName
+            }, () => [
+              vue.createVNode(filterPanelItem["default"], {
+                prop: column.fullAttrName
+              }, {
+                default: vue.withCtx(({ data }) => [
+                  vue.createVNode(_component_BwaCondition, {
+                    modelValue: data.value,
+                    "onUpdate:modelValue": ($event) => data.value = $event,
+                    column,
+                    record: vue.unref(searchParams)
+                  }, null, 8, ["modelValue", "onUpdate:modelValue", "column", "record"])
+                ]),
+                _: 2
+              }, 1032, ["prop"])
+            ]);
+          }), 128))
+        ]),
+        __props.showFieldOptions ? (vue.openBlock(), vue.createBlock(filterPanelItem["default"], { key: 0 }, {
+          default: vue.withCtx(() => [
+            vue.createVNode(_component_BwaAdvanceSelect, {
+              modelValue: vue.unref(selectedColumnAttrNames),
+              "onUpdate:modelValue": _cache[1] || (_cache[1] = ($event) => vue.isRef(selectedColumnAttrNames) ? selectedColumnAttrNames.value = $event : null),
+              "show-selectIcon": true,
+              onSearch: vue.unref(handleFieldSearch),
+              class: vue.normalizeClass(vue.unref(ns).e("options"))
+            }, {
+              "reference-content": vue.withCtx(() => [
+                vue.createCommentVNode(" <ElIcon><Plus /></ElIcon> "),
+                vue.createElementVNode("div", {
+                  class: vue.normalizeClass(vue.unref(ns).be("filter", "plus"))
+                }, null, 2),
+                vue.createElementVNode("span", {
+                  class: vue.normalizeClass(vue.unref(ns).be("filter", "label"))
+                }, " \u7B5B\u9009 ", 2)
+              ]),
+              default: vue.withCtx(() => [
+                (vue.openBlock(true), vue.createElementBlock(vue.Fragment, null, vue.renderList(vue.unref(closableColumns), (column) => {
+                  return vue.openBlock(), vue.createBlock(_component_BwaAdvanceOption, {
+                    value: column.fullAttrName,
+                    label: column.title,
+                    key: column.fullAttrName,
+                    class: vue.normalizeClass(vue.unref(ns).be("filter", "option"))
+                  }, {
+                    default: vue.withCtx(() => [
+                      vue.createVNode(_component_ElCheckbox, {
+                        onClick: _cache[0] || (_cache[0] = vue.withModifiers(() => {
+                        }, ["prevent"])),
+                        modelValue: vue.unref(selectedColumnAttrNames).includes(column.fullAttrName),
+                        class: vue.normalizeClass(vue.unref(ns).be("filter", "checkbox"))
+                      }, {
+                        default: vue.withCtx(() => [
+                          vue.createTextVNode(vue.toDisplayString(column.title), 1)
+                        ]),
+                        _: 2
+                      }, 1032, ["modelValue", "class"]),
+                      vue.createElementVNode("span", {
+                        class: vue.normalizeClass(vue.unref(ns).be("filter", "title"))
+                      }, vue.toDisplayString(column.componentTitle), 3)
+                    ]),
+                    _: 2
+                  }, 1032, ["value", "label", "class"]);
+                }), 128))
+              ]),
+              _: 1
+            }, 8, ["modelValue", "onSearch", "class"])
+          ]),
+          _: 1
+        })) : vue.createCommentVNode("v-if", true),
+        __props.showSearch ? (vue.openBlock(), vue.createBlock(_component_ElInput, {
+          key: 1,
+          "prefix-icon": "Search",
+          size: "small",
+          clearable: "",
+          modelValue: vue.unref(searchValue),
+          "onUpdate:modelValue": _cache[2] || (_cache[2] = ($event) => vue.isRef(searchValue) ? searchValue.value = $event : null),
+          placeholder: __props.searchPlaceholder,
+          class: vue.normalizeClass(vue.unref(ns).e("search"))
+        }, null, 8, ["modelValue", "placeholder", "class"])) : vue.createCommentVNode("v-if", true),
+        vue.unref(isChange) ? (vue.openBlock(), vue.createBlock(_component_ElButton, {
+          key: 2,
+          size: "small",
+          class: vue.normalizeClass(vue.unref(ns).e("reset")),
+          onClick: vue.unref(handleReset)
+        }, {
+          default: vue.withCtx(() => [
+            vue.createTextVNode(" \u91CD\u7F6E ")
+          ]),
+          _: 1
+        }, 8, ["class", "onClick"])) : vue.createCommentVNode("v-if", true)
+      ], 2);
+    };
+  }
+});
+var FilterPanel = /* @__PURE__ */ _pluginVue_exportHelper["default"](_sfc_main, [["__file", "filter-panel.vue"]]);
+
+exports["default"] = FilterPanel;

package/lib/filter-panel/index.js

@@ -0,0 +1,20 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var install = require('element-plus/es/utils/vue/install');
+var filterPanel = require('./filter-panel.js');
+var filterPanelItem = require('./filter-panel-item.js');
+var index = require('./conditions/index.js');
+
+const BwaFilterPanel = install.withInstall(filterPanel["default"], {
+  FilterPanelItem: filterPanelItem["default"]
+});
+const BwaFilterpanelItem = install.withInstall(filterPanelItem["default"], {
+  BwaCondition: index.BwaCondition
+});
+
+exports["default"] = filterPanel["default"];
+exports.BwaCondition = index.BwaCondition;
+exports.BwaFilterPanel = BwaFilterPanel;
+exports.BwaFilterpanelItem = BwaFilterpanelItem;

package/lib/filter-panel/use-filter-panel-item.js

@@ -0,0 +1,56 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var vue = require('vue');
+var webBaseClientVue = require('web-base-client-vue');
+
+const useFilterPanelItem = (props) => {
+  const filterPanelContext = vue.inject(webBaseClientVue.filterPanelKey);
+  const filterPanel = vue.computed(() => filterPanelContext.filterPanel);
+  const column = vue.computed(() => {
+    if (!vue.unref(filterPanel)) {
+      return null;
+    }
+    return vue.unref(filterPanel).getColumn(props.prop);
+  });
+  const value = vue.computed({
+    get: () => {
+      if (!vue.unref(column)) {
+        return null;
+      }
+      return vue.unref(filterPanel).getFilterParam(vue.unref(column));
+    },
+    set: (v) => {
+      if (!vue.unref(column)) {
+        return;
+      }
+      vue.unref(filterPanel).setFilterParam(vue.unref(column), v);
+    }
+  });
+  const allowClose = vue.computed(() => {
+    var _a;
+    return props.close || !!((_a = vue.unref(column)) == null ? void 0 : _a.closable);
+  });
+  const closeHandle = () => {
+    if (!vue.unref(column)) {
+      return;
+    }
+    vue.unref(filterPanel).closeColumn(vue.unref(column));
+    vue.unref(filterPanel).dataTable.refresh();
+  };
+  vue.onMounted(() => {
+    vue.unref(filterPanel).changeOriginFilterParams();
+  });
+  vue.onBeforeUnmount(() => {
+    vue.unref(filterPanel).changeOriginFilterParams();
+  });
+  return {
+    value,
+    column,
+    allowClose,
+    closeHandle
+  };
+};
+
+exports.useFilterPanelItem = useFilterPanelItem;

package/lib/filter-panel/use-filter-panel.js

@@ -0,0 +1,139 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var ElementPlus = require('element-plus');
+var webBaseClientVue = require('web-base-client-vue');
+var vue = require('vue');
+var rxjs = require('rxjs');
+var db = require('../utils/db.js');
+
+const useFilterPanel = (props, context) => {
+  var _a;
+  const dataTable = ElementPlus.useProp("dataTable");
+  const filterPanel = vue.computed(() => vue.unref(dataTable).filterPanel);
+  const filterPanelTable = db.dataModelDB.filterPanel;
+  const currentFilterColumns = vue.computed(() => vue.unref(filterPanel).getAppliedColumns());
+  const userService = webBaseClientVue.useService("UserService");
+  const _userID = ((_a = userService == null ? void 0 : userService.userInfo) == null ? void 0 : _a.id) || "0";
+  const searchParams = vue.computed(() => vue.unref(filterPanel)._filterParams);
+  const selectedColumnAttrNames = vue.computed({
+    get: () => vue.unref(filterPanel).getSelectedColumnAttrNames(),
+    set: (v) => {
+      const oldSelectedColumnAttrNames = selectedColumnAttrNames.value;
+      vue.unref(filterPanel).setSelectedColumnAttrNames(v);
+      if (vue.unref(filterPanel).ready) {
+        const existsOldAttrNames = oldSelectedColumnAttrNames.filter((attrName) => v.includes(attrName));
+        if (existsOldAttrNames.length < oldSelectedColumnAttrNames.length) {
+          vue.unref(dataTable).refresh();
+        }
+      }
+    }
+  });
+  const closableColumns = vue.computed(() => vue.unref(filterPanel).getSearchClosableColumns());
+  const searchValue = vue.computed({
+    get: () => vue.unref(filterPanel).getSearchValue(),
+    set: (v) => vue.unref(filterPanel).setSeachValue(v)
+  });
+  const isChange = vue.computed(() => vue.unref(filterPanel).isChange());
+  vue.watch(ElementPlus.useProp("searchAttr"), (searchAttr) => {
+    vue.unref(filterPanel).setSearchAttr(searchAttr);
+  }, {
+    immediate: true
+  });
+  vue.watch(ElementPlus.useProp("searchFields"), (searchFields) => {
+    vue.unref(filterPanel).setSearchFields(searchFields);
+  }, {
+    immediate: true
+  });
+  const handleFieldSearch = (value) => {
+    vue.unref(filterPanel).fieldSearchValue = value;
+  };
+  const handleReset = () => {
+    vue.unref(filterPanel).resetFilterParams();
+    context.emit("reset");
+  };
+  webBaseClientVue.useEventDispatcher(filterPanel, "params-change", () => {
+    const _filterPanel = vue.unref(filterPanel);
+    context.emit("filter", {
+      ..._filterPanel.getFilterParams(),
+      [_filterPanel.getSearchAttr()]: _filterPanel.getSearchValue()
+    });
+  });
+  const appName = webBaseClientVue.useValue("AppName");
+  const selectedColumnChangeSubscription = new rxjs.Observable((observer) => webBaseClientVue.useEventDispatcher(filterPanel, "selected-column-change", observer.next.bind(observer))).subscribe(async () => {
+    var _a2;
+    const _appName = vue.unref(appName);
+    const _tableName = vue.unref(dataTable).name;
+    let result = await filterPanelTable.where("[app+tableName+userID]").equals([_appName, _tableName, _userID]).toArray();
+    let filterPanelOrder = result.length ? (_a2 = result[0].order) != null ? _a2 : [] : [];
+    const attrNames = vue.unref(filterPanel).getSelectedColumnAttrNames();
+    attrNames.sort((a1, a2) => {
+      const index1 = filterPanelOrder.indexOf(a1);
+      const index2 = filterPanelOrder.indexOf(a2);
+      if (index1 === -1 && index2 === -1) {
+        return 1;
+      }
+      if (index1 === -1) {
+        return 1;
+      }
+      if (index2 === -1) {
+        return -1;
+      }
+      return index1 - index2;
+    });
+    filterPanelTable.put({
+      app: _appName,
+      tableName: _tableName,
+      userID: _userID,
+      order: attrNames
+    });
+  });
+  const loadFilterPanelItemOrder = () => {
+    filterPanelTable.where("[app+tableName+userID]").equals([vue.unref(appName), vue.unref(dataTable).name, _userID]).toArray((res) => {
+      var _a2, _b;
+      selectedColumnAttrNames.value = (_b = (_a2 = res[0]) == null ? void 0 : _a2.order) != null ? _b : [];
+      vue.nextTick(() => {
+        vue.unref(filterPanel).ready = true;
+        vue.unref(filterPanel).changeOriginFilterParams();
+        vue.unref(filterPanel).changeOriginSearchValue();
+      });
+    });
+  };
+  if (!vue.unref(filterPanel).isInited) {
+    webBaseClientVue.useEventDispatcher(filterPanel, "initCompleted", loadFilterPanelItemOrder);
+  } else {
+    loadFilterPanelItemOrder();
+  }
+  vue.onBeforeUnmount(() => {
+    selectedColumnChangeSubscription.unsubscribe();
+  });
+  const columns = vue.computed(() => vue.unref(filterPanel).getColumns());
+  const instance = vue.getCurrentInstance();
+  vue.watch(vue.computed(() => vue.unref(columns).map((column) => column.componentTitle)), vue.withCtx(() => {
+    for (const column of vue.unref(columns)) {
+      const component = vue.resolveComponent(column.component || "BwaMultipleMenuCondition");
+      if (!component) {
+        vue.unref(column).componentTitle = "";
+        return;
+      }
+      vue.unref(column).componentTitle = component.__conditionTitle__;
+    }
+  }, instance), {
+    immediate: true
+  });
+  return {
+    dataTable,
+    filterPanel,
+    currentFilterColumns,
+    searchParams,
+    selectedColumnAttrNames,
+    closableColumns,
+    handleFieldSearch,
+    searchValue,
+    isChange,
+    handleReset
+  };
+};
+
+exports.useFilterPanel = useFilterPanel;

package/lib/hooks/use-data/index.js

@@ -0,0 +1,157 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var webBaseClientVue = require('web-base-client-vue');
+var ElementPlus = require('element-plus');
+var vue = require('vue');
+var rxjs = require('rxjs');
+var lodash = require('lodash');
+
+const dataProps = {
+  dataTable: {
+    type: Object
+  },
+  itfInfo: {
+    type: Object
+  },
+  labelAttr: {
+    type: String
+  },
+  valueAttr: {
+    type: String
+  },
+  searchAttr: {
+    type: String
+  },
+  lazy: {
+    type: Boolean,
+    default: true
+  }
+};
+function useData(disabled, search) {
+  const httpRequest = webBaseClientVue.useService(webBaseClientVue.HttpRequest);
+  const data = vue.ref([]);
+  const debounceDelay = webBaseClientVue.useGlobalConfig("debounceDelay", 500);
+  const filterPanelItem = vue.inject(webBaseClientVue.filterPanelItemKey, null);
+  const _dataTable = ElementPlus.useProp("dataTable");
+  const dataTable = vue.ref(null);
+  const itfInfo = ElementPlus.useProp("itfInfo");
+  const _labelAttr = ElementPlus.useProp("labelAttr");
+  const labelAttr = vue.computed(() => vue.unref(_labelAttr) || "label");
+  const _valueAttr = ElementPlus.useProp("valueAttr");
+  const valueAttr = vue.computed(() => vue.unref(_valueAttr) || "value");
+  const _searchAttr = ElementPlus.useProp("searchAttr");
+  const searchAttr = vue.computed(() => vue.unref(_searchAttr) || "search");
+  const lazy = ElementPlus.useProp("lazy");
+  const loading = vue.ref(false);
+  const searchAttrObserable = new rxjs.Observable((observer) => vue.watch(searchAttr, (value, oldValue) => {
+    observer.next([value, oldValue]);
+  }, {
+    immediate: true
+  }));
+  const searchObserable = new rxjs.Observable((observer) => vue.watch(search, observer.next.bind(observer), {
+    immediate: true
+  })).pipe(rxjs.debounceTime(vue.unref(debounceDelay)));
+  const searchObservable = rxjs.combineLatest([searchAttrObserable, searchObserable]).pipe(rxjs.debounceTime(vue.unref(debounceDelay)), rxjs.filter(() => !vue.unref(disabled)));
+  const disabledObservable = new rxjs.Observable((observer) => vue.watch(disabled, observer.next.bind(observer), {
+    immediate: true
+  }));
+  if (vue.unref(_dataTable)) {
+    dataTable.value = vue.unref(_dataTable).clone();
+    const loadDataSubscription = new rxjs.Observable((observer) => webBaseClientVue.useEventDispatcher(dataTable, "load-successfully", observer.next.bind(observer))).subscribe((res) => {
+      if (res.code != 0) {
+        data.value = [];
+        ElementPlus.ElMessage.error(res.msg);
+        return;
+      }
+      data.value = (res.data || []).map((item) => ({
+        value: item[vue.unref(valueAttr)],
+        label: item[vue.unref(labelAttr)]
+      }));
+    });
+    const loadingSubscription = new rxjs.Observable((observer) => vue.watch(vue.computed(() => vue.unref(dataTable).locking), observer.next.bind(observer), {
+      immediate: true
+    })).subscribe((locking) => {
+      loading.value = locking;
+    });
+    const searchSubscription = searchObservable.subscribe(([[searchAttr2, oldSearchAttr], search2]) => {
+      if (oldSearchAttr) {
+        vue.unref(dataTable).removeParam(oldSearchAttr);
+      }
+      if (searchAttr2) {
+        vue.unref(dataTable).setParam(searchAttr2, search2);
+      }
+      vue.unref(dataTable).refresh();
+    });
+    vue.unref(dataTable).setParam(vue.unref(searchAttr), "");
+    const disabledSubscription = disabledObservable.pipe(rxjs.filter((disabled2) => !disabled2)).subscribe(() => {
+      vue.unref(dataTable).refresh();
+    });
+    vue.onBeforeUnmount(() => {
+      loadDataSubscription.unsubscribe();
+      loadingSubscription.unsubscribe();
+      searchSubscription.unsubscribe();
+      disabledSubscription.unsubscribe();
+    });
+  } else if (vue.unref(itfInfo)) {
+    const _itfInfo = vue.computed(() => ({
+      url: vue.unref(itfInfo).url,
+      method: vue.unref(itfInfo).method || "POST",
+      options: vue.unref(itfInfo).options || {}
+    }));
+    const inputParamsOberserble = new rxjs.Observable((observer) => {
+      vue.watch(vue.computed(() => vue.unref(itfInfo).params), (newVal = {}, oldVall) => {
+        if (!lodash.isEqual(oldVall, newVal)) {
+          observer.next(newVal);
+        }
+      }, {
+        immediate: true
+      });
+    });
+    const paramsObserable = rxjs.combineLatest([searchAttrObserable, searchObserable, inputParamsOberserble]).pipe(rxjs.map(([[searchAttr2], search2, params]) => ({
+      ...params,
+      [searchAttr2]: search2
+    })));
+    let inited = false;
+    const subscription = rxjs.combineLatest([paramsObserable, disabledObservable]).pipe(rxjs.tap(() => {
+      loading.value = true;
+    }), rxjs.debounceTime(vue.unref(debounceDelay)), rxjs.filter(([_, disabled2]) => {
+      return !inited && !vue.unref(lazy) || !disabled2;
+    }), rxjs.map(([params]) => ({
+      ...vue.unref(_itfInfo),
+      params
+    })), rxjs.map(({
+      url,
+      method,
+      params,
+      options
+    }) => rxjs.from(vue.unref(httpRequest)[method.toLowerCase()](url, params, options)).pipe(rxjs.catchError(() => rxjs.of({
+      code: 1,
+      msg: "\u7F51\u7EDC\u5F02\u5E38\uFF01"
+    })))), rxjs.mergeAll()).subscribe((result) => {
+      try {
+        inited = true;
+        if (result.code != 0) {
+          data.value = [];
+          ElementPlus.ElMessage.error(result.msg);
+          return;
+        }
+        data.value = (result.data || []).map((item) => ({
+          value: item[vue.unref(valueAttr)],
+          label: item[vue.unref(labelAttr)]
+        }));
+      } finally {
+        loading.value = false;
+      }
+    });
+    vue.onBeforeUnmount(subscription.unsubscribe.bind(subscription));
+  }
+  return {
+    data,
+    loading
+  };
+}
+
+exports.dataProps = dataProps;
+exports.useData = useData;

package/lib/index.js

@@ -0,0 +1,60 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var makeInstaller = require('./make-installer.js');
+var components = require('./components.js');
+var plugins = require('./plugins.js');
+var index$1 = require('./data-form/index.js');
+var index$2 = require('./data-table/index.js');
+var index$3 = require('./filter-panel/index.js');
+var index$4 = require('./advance-select/index.js');
+var index$5 = require('./date-range/index.js');
+var index$6 = require('./application-slot/index.js');
+var index$7 = require('./layout/index.js');
+var index$8 = require('./menu/index.js');
+var index$9 = require('./panel/index.js');
+var index$a = require('./panel-tabs/index.js');
+var index$b = require('./contextmenu/index.js');
+var index$c = require('./breadcrumb-select/index.js');
+var index$d = require('./datatable-settings/index.js');
+var index$e = require('./drag-list/index.js');
+var index$f = require('./progress/index.js');
+var index$g = require('./dragable/index.js');
+var useContextmenu = require('./contextmenu/use-contextmenu.js');
+
+const install = makeInstaller.makeInstaller([...components["default"], ...plugins["default"]]);
+var index = {
+  install
+};
+
+exports.BwaDataForm = index$1.BwaDataForm;
+exports.BwaDataFormItem = index$1.BwaDataFormItem;
+exports.BwaDataColumnView = index$2.BwaDataColumnView;
+exports.BwaDataTable = index$2.BwaDataTable;
+exports.BwaDataTableColumn = index$2.BwaDataTableColumn;
+exports.BwaFilterPanel = index$3.BwaFilterPanel;
+exports.BwaFilterpanelItem = index$3.BwaFilterpanelItem;
+exports.BwaAdvanceOperation = index$4.BwaAdvanceOperation;
+exports.BwaAdvanceOption = index$4.BwaAdvanceOption;
+exports.BwaAdvanceSelect = index$4.BwaAdvanceSelect;
+exports.BwaDateRange = index$5.BwaDateRange;
+exports.BwaApplicationSlot = index$6.BwaApplicationSlot;
+exports.BwaBreadcrumbItem = index$6.BwaBreadcrumbItem;
+exports.BwaHeaderToolsItem = index$6.BwaHeaderToolsItem;
+exports.BwaLayout = index$7.BwaLayout;
+exports.BwaMenu = index$8.BwaMenu;
+exports.BwaPanel = index$9.BwaPanel;
+exports.BwaPanelTab = index$a.BwaPanelTab;
+exports.BwaContextmenu = index$b.BwaContextmenu;
+exports.BwaBreadcrumbSelect = index$c.BwaBreadcrumbSelect;
+exports.BwaDataTableSetting = index$d.BwaDataTableSetting;
+exports.BwaDraglist = index$e.BwaDraglist;
+exports.BwaProgress = index$f.BwaProgress;
+exports.BwaProgressItem = index$f.BwaProgressItem;
+exports.BwaDragable = index$g.BwaDragable;
+exports.BwaDragableItem = index$g.BwaDragableItem;
+exports.BwaDragableOperation = index$g.BwaDragableOperation;
+exports.useContextmenu = useContextmenu.useContextmenu;
+exports["default"] = index;
+exports.install = install;

package/lib/layout/index.js

@@ -0,0 +1,11 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var install = require('element-plus/es/utils/vue/install');
+var layout = require('./layout.js');
+
+const BwaLayout = install.withInstall(layout["default"]);
+
+exports.BwaLayout = BwaLayout;
+exports["default"] = BwaLayout;