easy-elplus 1.0.1 → 1.2.0

package/lib/packages/components/descriptions/index.js

@@ -0,0 +1,15 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var install = require('../../utils/vue/install.js');
+var descriptions = require('./src/descriptions.vue.js');
+
+// 用来整合组件的，最终实现导出组件
+
+
+// 通过 withInstall 方法给 button 添加了一个 Vue3 插件所需的 install 方法
+const EasyDescriptions = install.withInstall(descriptions.default);
+
+exports.EasyDescriptions = EasyDescriptions;
+exports.default = EasyDescriptions;

package/lib/packages/components/descriptions/src/comp.vue.js

@@ -0,0 +1,62 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var vue = require('vue');
+var useDynamicComponent = require('../../../hooks/src/useDynamicComponent.js');
+
+const _sfc_main = /*@__PURE__*/Object.assign({
+  name: "EasyDescriptionsComp"
+}, {
+  __name: 'comp',
+  props: /*@__PURE__*/vue.mergeModels({
+  id: {
+    type: String,
+    default: ""
+  },
+  components: {
+    type: [String, Number, Function, Object],
+    default: ""
+  },
+  props: {
+    type: Object,
+    default: () => ({})
+  }
+}, {
+    "modelValue": {},
+    "modelModifiers": {},
+  }),
+  emits: ["update:modelValue"],
+  setup(__props) {
+
+
+
+const componentProps = __props;
+
+const descriptionsData = vue.useModel(__props, "modelValue");
+const { getComponent } = useDynamicComponent.useDynamicComponent();
+
+// 1. 动态计算要渲染的组件
+const currentComponent = vue.computed(() => {
+  return componentProps.id
+    ? getComponent(componentProps.components, descriptionsData.value)
+    : getComponent(componentProps.components)
+});
+
+// 2. 动态构建 Model 绑定 (仅在有 id 时绑定)
+const dynamicModel = vue.computed(() => {
+  return componentProps.id ? { modelValue: descriptionsData.value[componentProps.id] } : {}
+});
+
+return (_ctx, _cache) => {
+  return vue.renderSlot(_ctx.$slots, __props.components, {}, () => [
+    (vue.openBlock(), vue.createBlock(vue.resolveDynamicComponent(currentComponent.value), vue.mergeProps({ ...dynamicModel.value, ...__props.props }, {
+      "onUpdate:modelValue": _cache[0] || (_cache[0] = val => __props.id && (descriptionsData.value[__props.id] = val))
+    }), null, 16 /* FULL_PROPS */))
+  ])
+}
+}
+
+});
+
+exports.default = _sfc_main;

package/lib/packages/components/descriptions/src/descriptions.vue.js

@@ -0,0 +1,182 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var vue = require('vue');
+var elementPlus = require('element-plus');
+var type = require('../../../utils/type.js');
+var comp = require('./comp.vue.js');
+
+const _hoisted_1 = { class: "epl-descriptions" };
+
+
+const _sfc_main = /*@__PURE__*/Object.assign({
+  name: "EasyDescriptions"
+}, {
+  __name: 'descriptions',
+  props: /*@__PURE__*/vue.mergeModels({
+  items: {
+    type: Array,
+    default: () => []
+  }
+}, {
+    "modelValue": {},
+    "modelModifiers": {},
+  }),
+  emits: ["update:modelValue"],
+  setup(__props, { expose: __expose }) {
+
+
+
+const props = __props;
+
+const descriptionsData = vue.useModel(__props, "modelValue");
+
+// 内部处理单个列表的函数
+const normalizeItems = list => {
+  return list.reduce((prev, item) => {
+    const isHidden = type.isFunction(item.hidden) ? item.hidden(descriptionsData.value) : item.hidden;
+
+    if (isHidden) return prev
+
+    prev.push({
+      ...item,
+      label: type.isObject(item.label)
+        ? item.label
+        : {
+            components: item.label
+          },
+      value: type.isObject(item.value)
+        ? item.value
+        : {
+            id: item.value,
+            components: item.value
+          }
+    });
+
+    return prev
+  }, [])
+};
+
+const renderList = vue.computed(() => {
+  if (!props.items || props.items.length === 0) return []
+
+  // 判断是否为分组模式：第一项包含 items 字段且是一个数组
+  // 为了兼容性更好，这里假设如果 item 内部有 items 属性，则认为是分组
+  const isGroup = props.items.some(item => item.items && Array.isArray(item.items));
+
+  if (isGroup) {
+    // 分组模式
+    return props.items
+      .filter(group => {
+        const isHidden = type.isFunction(group.hidden) ? group.hidden(descriptionsData.value) : group.hidden;
+        return !isHidden
+      })
+      .map(group => {
+        // 分离出内部使用的属性，其他的属性放入 bindProps 透传给 el-descriptions
+        // eslint-disable-next-line no-unused-vars
+        const { extra, items, hidden, ...rest } = group;
+        return {
+          ...group,
+          rows: normalizeItems(group.items),
+          bindProps: rest
+        }
+      })
+  } else {
+    // 单组模式：包装成一个默认分组
+    return [
+      {
+        rows: normalizeItems(props.items),
+        bindProps: {}
+      }
+    ]
+  }
+});
+
+__expose({});
+
+return (_ctx, _cache) => {
+  return (vue.openBlock(), vue.createElementBlock("div", _hoisted_1, [
+    (vue.openBlock(true), vue.createElementBlock(vue.Fragment, null, vue.renderList(renderList.value, (group, index) => {
+      return (vue.openBlock(), vue.createBlock(vue.unref(elementPlus.ElDescriptions), vue.mergeProps({
+        key: index,
+        ref_for: true
+      }, { ..._ctx.$attrs, ...group.bindProps }, { style: {"margin-bottom":"20px"} }), vue.createSlots({
+        default: vue.withCtx(() => [
+          (vue.openBlock(true), vue.createElementBlock(vue.Fragment, null, vue.renderList(group.rows, (item) => {
+            return (vue.openBlock(), vue.createBlock(vue.unref(elementPlus.ElDescriptionsItem), vue.mergeProps({
+              key: item.label
+            }, { ref_for: true }, item), {
+              label: vue.withCtx(() => [
+                (vue.openBlock(), vue.createBlock(vue.resolveDynamicComponent(
+                vue.h(
+                  comp.default,
+                  {
+                    modelValue: descriptionsData.value,
+                    ...item.label
+                  },
+                  _ctx.$slots
+                )
+              )))
+              ]),
+              default: vue.withCtx(() => [
+                (vue.openBlock(), vue.createBlock(vue.resolveDynamicComponent(
+                vue.h(
+                  comp.default,
+                  {
+                    modelValue: descriptionsData.value,
+                    ...item.value
+                  },
+                  _ctx.$slots
+                )
+              )))
+              ]),
+              _: 2 /* DYNAMIC */
+            }, 1040 /* FULL_PROPS, DYNAMIC_SLOTS */))
+          }), 128 /* KEYED_FRAGMENT */))
+        ]),
+        _: 2 /* DYNAMIC */
+      }, [
+        (group.title || _ctx.$slots.title)
+          ? {
+              name: "title",
+              fn: vue.withCtx(() => [
+                (group.title)
+                  ? (vue.openBlock(), vue.createElementBlock(vue.Fragment, { key: 0 }, [
+                      vue.createTextVNode(vue.toDisplayString(group.title), 1 /* TEXT */)
+                    ], 64 /* STABLE_FRAGMENT */))
+                  : vue.renderSlot(_ctx.$slots, "title", {
+                      key: 1,
+                      group: group,
+                      index: index
+                    })
+              ]),
+              key: "0"
+            }
+          : undefined,
+        (group.extra || _ctx.$slots.extra)
+          ? {
+              name: "extra",
+              fn: vue.withCtx(() => [
+                (group.extra)
+                  ? (vue.openBlock(), vue.createElementBlock(vue.Fragment, { key: 0 }, [
+                      vue.createTextVNode(vue.toDisplayString(group.extra), 1 /* TEXT */)
+                    ], 64 /* STABLE_FRAGMENT */))
+                  : vue.renderSlot(_ctx.$slots, "extra", {
+                      key: 1,
+                      group: group,
+                      index: index
+                    })
+              ]),
+              key: "1"
+            }
+          : undefined
+      ]), 1040 /* FULL_PROPS, DYNAMIC_SLOTS */))
+    }), 128 /* KEYED_FRAGMENT */))
+  ]))
+}
+}
+
+});
+
+exports.default = _sfc_main;

package/{packages → lib/packages}/components/dialog/index.js

@@ -1,14 +1,14 @@
+'use strict';
+
+var useDialog = require('./src/useDialog.js');
+
 // Dialog 是一个命令式 API（函数式调用），而非 Vue 组件
 // 用法: const dialog = useDialog(component, props, options)
 // 或者: import { EasyDialog } from "@easy-elplus"; EasyDialog(...)
 
-import { useDialog } from "./src/useDialog"
 
 // 导出命名函数，保持与其他组件命名一致性
-export const EasyDialog = useDialog
-
-// 导出原始函数名，方便理解其用途
-export { useDialog }
+const EasyDialog = useDialog.useDialog;
 
-// 默认导出
-export default useDialog
+exports.useDialog = useDialog.useDialog;
+exports.EasyDialog = EasyDialog;

package/lib/packages/components/dialog/src/useDialog.js

@@ -0,0 +1,184 @@
+'use strict';
+
+var vue = require('vue');
+var elementPlus = require('element-plus');
+var type = require('../../../utils/type.js');
+var appContext = require('../../../utils/vue/appContext.js');
+
+/**
+ *
+ * @param {*} component 组件
+ * @param {*} componentProps 组件属性
+ * @param {*} modalProps 对话框属性
+ * @param {*} context 上下文
+ * @returns Promise
+ */
+const useDialog = (component, componentProps = {}, modalProps = {}, context = null) => {
+  // 如果 component 是字符串，转换为渲染函数
+  const contentComponent = type.isString(component) ? { render: () => vue.h("div", component) } : vue.markRaw(component);
+
+  const {
+    title = "提示",
+    confirmButtonText = "确 认",
+    cancelButtonText = "取 消",
+    showConfirmButton = true,
+    showCancelButton = true,
+    methodKey = "submit",
+    beforeClose,
+    onConfirm,
+    onCancel,
+    footer,
+    draggable = true,
+    ...dialogProps
+  } = modalProps;
+
+  const visible = vue.ref(true);
+  const loading = vue.ref(false);
+  const componentRef = vue.ref(null);
+
+  const appContext$1 = context || appContext.getGlobalAppContext();
+
+  const div = document.createElement("div");
+  document.body.appendChild(div);
+
+  return new Promise((resolve, reject) => {
+    let app = null;
+    let isSettled = false; // 标记 Promise 是否已完成，防止重复触发
+
+    // 销毁
+    const destroy = () => {
+      if (app) {
+        app.unmount();
+        app = null;
+      }
+      if (div.parentNode) {
+        div.parentNode.removeChild(div);
+      }
+    };
+
+    // 关闭
+    const close = () => {
+      visible.value = false;
+    };
+
+    // 统一处理 Promise 结束逻辑
+    const handleAction = async (action, data) => {
+      if (isSettled) return
+      isSettled = true;
+      if (action === "resolve") resolve(data);
+      else reject(data);
+      close();
+    };
+
+    // 确认
+    const handleConfirm = async () => {
+      loading.value = true;
+      try {
+        const target = componentRef.value;
+        // 调用组件方法
+        if (target && methodKey && type.isFunction(target[methodKey])) {
+          await target[methodKey]();
+        }
+        // 调用 onConfirm
+        if (type.isFunction(onConfirm)) {
+          await onConfirm(target);
+        }
+        // 返回 resolve
+        await handleAction("resolve", target);
+      } catch (e) {
+        isSettled = false; // 失败时不沉淀状态，允许用户修正后重试
+        reject(e);
+      } finally {
+        loading.value = false;
+      }
+    };
+
+    // 取消
+    const handleCancel = () => {
+      if (type.isFunction(onCancel)) onCancel();
+      handleAction("reject", "closed");
+    };
+
+    // DialogApp
+    const DialogApp = {
+      setup() {
+        return () =>
+          vue.h(
+            elementPlus.ElDialog,
+            {
+              ...dialogProps,
+              modelValue: visible.value,
+              "onUpdate:modelValue": val => {
+                visible.value = val;
+                if (!val && !isSettled) handleAction("reject", "closed");
+              },
+              title,
+              draggable,
+              destroyOnClose: true,
+              onClosed: destroy, // 动画结束后彻底回收
+              // 拦截右上角 X 和遮罩层点击
+              beforeClose: done => {
+                if (beforeClose) {
+                  beforeClose(() => {
+                    if (!isSettled) handleAction("reject", "closed");
+                    done();
+                  });
+                } else {
+                  if (!isSettled) handleAction("reject", "closed");
+                  done();
+                }
+              }
+            },
+            {
+              // 默认内容 渲染组件
+              default: () => vue.h(contentComponent, { ...componentProps, ref: componentRef }),
+
+              // 底部内容
+              footer: () => {
+                // 自定义 footer
+                if (footer) {
+                  return type.isFunction(footer)
+                    ? footer({ close: handleCancel, confirm: handleConfirm, loading: loading.value })
+                    : footer
+                }
+                return vue.h("div", { class: "dialog-footer" }, [
+                  // 取消按钮
+                  showCancelButton && vue.h(elementPlus.ElButton, { onClick: handleCancel }, () => cancelButtonText),
+                  // 确认按钮
+                  showConfirmButton &&
+                    vue.h(
+                      elementPlus.ElButton,
+                      {
+                        type: "primary",
+                        loading: loading.value,
+                        onClick: handleConfirm
+                      },
+                      () => confirmButtonText
+                    )
+                ])
+              }
+            }
+          )
+      }
+    };
+
+    app = vue.createApp(DialogApp);
+
+    // 优化：上下文继承
+    if (appContext$1) {
+      // 核心插件继承 (避免直接操作 _context 私有属性的风险)
+      // 如果你的 getGlobalAppContext 已经拿到了真实的 context，可以这样同步
+      Object.assign(app._context, {
+        ...appContext$1,
+        reload: app._context.reload // 保留新应用的 reload 方法
+      });
+
+      // 必须手动同步 provides 以确保 inject 可用
+      app._context.provides = { ...(appContext$1.provides || {}), ...app._context.provides };
+    }
+
+    app.mount(div);
+  })
+};
+
+exports.useDialog = useDialog;

package/lib/packages/components/table/index.js

@@ -0,0 +1,15 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var install = require('../../utils/vue/install.js');
+var table = require('./src/table.vue.js');
+
+// 用来整合组件的，最终实现导出组件
+
+
+// 通过 withInstall 方法给 button 添加了一个 Vue3 插件所需的 install 方法
+const EasyTable = install.withInstall(table.default);
+
+exports.EasyTable = EasyTable;
+exports.default = EasyTable;

package/{packages → lib/packages}/components/table/src/scrollTo.js

@@ -1,19 +1,21 @@
-import { isUndefined, isFunction } from "@easy-elplus/utils"
+'use strict';
+
+var type = require('../../../utils/type.js');
 
 Math.easeInOutQuad = function (t, b, c, d) {
-  t /= d / 2
+  t /= d / 2;
   if (t < 1) {
     return (c / 2) * t * t + b
   }
-  t--
+  t--;
   return (-c / 2) * (t * (t - 2) - 1) + b
-}
+};
 
 // requestAnimationFrame for Smart Animating http://goo.gl/sx5sts
 var requestAnimFrame = (function () {
   if (typeof window === "undefined") {
     return function (callback) {
-      setTimeout(callback, 1000 / 60)
+      setTimeout(callback, 1000 / 60);
     }
   }
   return (
@@ -21,19 +23,19 @@ var requestAnimFrame = (function () {
     window.webkitRequestAnimationFrame ||
     window.mozRequestAnimationFrame ||
     function (callback) {
-      window.setTimeout(callback, 1000 / 60)
+      window.setTimeout(callback, 1000 / 60);
     }
   )
-})()
+})();
 
 /**
  * Because it's so fucking difficult to detect the scrolling element, just move them all
  * @param {number} amount
  */
 function move(amount) {
-  document.documentElement.scrollTop = amount
-  document.body.parentNode.scrollTop = amount
-  document.body.scrollTop = amount
+  document.documentElement.scrollTop = amount;
+  document.body.parentNode.scrollTop = amount;
+  document.body.scrollTop = amount;
 }
 
 function position() {
@@ -45,28 +47,25 @@ function position() {
  * @param {number} duration
  * @param {Function} callback
  */
-export function scrollTo(to, duration, callback) {
-  const start = position()
-  const change = to - start
-  const increment = 20
-  let currentTime = 0
-  duration = isUndefined(duration) ? 500 : duration
+function scrollTo(to, duration, callback) {
+  const start = position();
+  const change = to - start;
+  const increment = 20;
+  let currentTime = 0;
+  duration = type.isUndefined(duration) ? 500 : duration;
   var animateScroll = function () {
     // increment the time
-    currentTime += increment
+    currentTime += increment;
     // find the value with the quadratic in-out easing function
-    var val = Math.easeInOutQuad(currentTime, start, change, duration)
+    var val = Math.easeInOutQuad(currentTime, start, change, duration);
     // move the document.body
-    move(val)
+    move(val);
     // do the animation unless its over
     if (currentTime < duration) {
-      requestAnimFrame(animateScroll)
-    } else {
-      if (callback && isFunction(callback)) {
-        // the animation is done so lets callback
-        callback()
-      }
+      requestAnimFrame(animateScroll);
     }
-  }
-  animateScroll()
+  };
+  animateScroll();
 }
+
+exports.scrollTo = scrollTo;