vue2-components-plus 1.0.3 → 1.0.6

package/dist/vue2-components-plus.js

@@ -0,0 +1,2895 @@
+import Vue, { getCurrentInstance, nextTick } from "vue";
+const main = "";
+function parseBindingValue(binding) {
+  const defaultConfig = { maxLength: 50, pattern: null, min: null, max: null, int: false };
+  const value = binding.value;
+  if (typeof value === "number") {
+    return { ...defaultConfig, maxLength: value };
+  }
+  if (value && typeof value === "object") {
+    return {
+      maxLength: value.maxLength || defaultConfig.maxLength,
+      pattern: value.pattern || null,
+      min: typeof value.min === "number" ? value.min : null,
+      max: typeof value.max === "number" ? value.max : null,
+      int: !!value.int
+    };
+  }
+  return defaultConfig;
+}
+function formatNumberInput(value, maxLength, allowNegative = true) {
+  let result = "";
+  let hasMinus = false;
+  let hasDot = false;
+  String(value || "").split("").forEach((char, index2) => {
+    if (char === "-") {
+      if (allowNegative && index2 === 0 && !hasMinus) {
+        result += char;
+        hasMinus = true;
+      }
+      return;
+    }
+    if (char === ".") {
+      if (index2 !== 0 && !hasDot && result[result.length - 1] !== "-") {
+        result += char;
+        hasDot = true;
+      }
+      return;
+    }
+    if (/^\d$/.test(char)) {
+      const current = hasMinus ? result.slice(1) : result;
+      if (current === "0" && char !== "0" && !hasDot) {
+        result = hasMinus ? "-" : "";
+      }
+      result += char;
+    }
+  });
+  return result.slice(0, maxLength);
+}
+function formatIntegerInput(value, maxLength, config) {
+  let result = "";
+  let hasMinus = false;
+  const allowNegative = config.min !== null && config.min < 0;
+  String(value || "").split("").forEach((char, index2) => {
+    if (char === "-") {
+      if (allowNegative && index2 === 0 && !hasMinus) {
+        result += char;
+        hasMinus = true;
+      }
+      return;
+    }
+    if (/^\d$/.test(char)) {
+      const current = hasMinus ? result.slice(1) : result;
+      if (current === "0" && char !== "0") {
+        result = hasMinus ? "-" : "";
+      }
+      result += char;
+    }
+  });
+  return result.slice(0, maxLength);
+}
+function formatRangeInput(value, config) {
+  if (config.int) {
+    const result2 = formatIntegerInput(value, config.maxLength || 50, config);
+    if (result2 === "" || result2 === "-")
+      return result2;
+    const numberValue2 = parseInt(result2, 10);
+    if (Number.isNaN(numberValue2))
+      return "";
+    if (config.min !== null && numberValue2 < config.min)
+      return String(Math.ceil(config.min));
+    if (config.max !== null && numberValue2 > config.max)
+      return String(Math.floor(config.max));
+    return result2;
+  }
+  const allowNegative = config.min !== null && config.min < 0;
+  const result = formatNumberInput(value, config.maxLength || 50, allowNegative);
+  if (result === "" || result === "-" || result === ".")
+    return result;
+  const numberValue = parseFloat(result);
+  if (Number.isNaN(numberValue))
+    return "";
+  if (config.min !== null && numberValue < config.min)
+    return String(config.min);
+  if (config.max !== null && numberValue > config.max)
+    return String(config.max);
+  return result;
+}
+function formatRegexInput(value, maxLength, pattern) {
+  let result = "";
+  String(value || "").split("").forEach((char) => {
+    if (result.length >= maxLength)
+      return;
+    const nextValue = result + char;
+    if (pattern.test(nextValue)) {
+      result = nextValue;
+    }
+  });
+  return result;
+}
+function getInputElement(el) {
+  if (!el)
+    return null;
+  if (el.tagName === "INPUT" || el.tagName === "TEXTAREA") {
+    return el;
+  }
+  return el.querySelector("input, textarea");
+}
+function updateInputValue(inputEl, binding) {
+  if (!inputEl)
+    return;
+  const config = parseBindingValue(binding);
+  let nextValue = inputEl.value || "";
+  if (binding.modifiers.range) {
+    nextValue = formatRangeInput(nextValue, config);
+  } else if (binding.modifiers.number) {
+    nextValue = formatNumberInput(nextValue, config.maxLength);
+  } else if (binding.modifiers.regex && config.pattern) {
+    nextValue = formatRegexInput(nextValue, config.maxLength, config.pattern);
+  } else {
+    nextValue = String(nextValue).slice(0, config.maxLength);
+  }
+  if (nextValue !== inputEl.value) {
+    inputEl.value = nextValue;
+    inputEl.dispatchEvent(new Event("input", { bubbles: true }));
+  }
+}
+function bindLengthDirective(el, binding) {
+  const inputEl = getInputElement(el);
+  if (!inputEl)
+    return;
+  let composing = false;
+  const handleCompositionStart = () => {
+    composing = true;
+  };
+  const handleCompositionEnd = () => {
+    composing = false;
+    updateInputValue(inputEl, binding);
+  };
+  const handleInput = () => {
+    if (!composing) {
+      updateInputValue(inputEl, binding);
+    }
+  };
+  inputEl.addEventListener("compositionstart", handleCompositionStart);
+  inputEl.addEventListener("compositionend", handleCompositionEnd);
+  inputEl.addEventListener("input", handleInput);
+  updateInputValue(inputEl, binding);
+  el.__nsLengthHandlers = {
+    inputEl,
+    handleCompositionStart,
+    handleCompositionEnd,
+    handleInput
+  };
+}
+function unbindLengthDirective(el) {
+  const handlers = el.__nsLengthHandlers;
+  if (!handlers)
+    return;
+  handlers.inputEl.removeEventListener("compositionstart", handlers.handleCompositionStart);
+  handlers.inputEl.removeEventListener("compositionend", handlers.handleCompositionEnd);
+  handlers.inputEl.removeEventListener("input", handlers.handleInput);
+  delete el.__nsLengthHandlers;
+}
+function registerDirective(Vue2) {
+  Vue2.directive("sline", {
+    inserted(el) {
+      el.style.whiteSpace = "nowrap";
+      el.style.overflow = "hidden";
+      el.style.textOverflow = "ellipsis";
+      el.style.display = "inline-block";
+      el.style.maxWidth = "100%";
+    }
+  });
+  Vue2.directive("permission", {
+    inserted(el, binding) {
+      let permissionList = [];
+      try {
+        permissionList = JSON.parse(sessionStorage.getItem("btnsPermission") || localStorage.getItem("btnsPermission") || "[]");
+      } catch (error) {
+        permissionList = [];
+      }
+      if (!Array.isArray(permissionList)) {
+        permissionList = [];
+      }
+      const selector = binding.modifiers.class ? "class" : "id";
+      const isDisplayNone = !!binding.modifiers.display;
+      const matched = selector === "class" ? permissionList.some((item) => el.classList.contains(item)) : permissionList.includes(el.getAttribute("id"));
+      if (!matched) {
+        if (isDisplayNone) {
+          el.style.display = "none";
+        } else {
+          el.style.visibility = "hidden";
+          el.style.pointerEvents = "none";
+        }
+      }
+    }
+  });
+  Vue2.directive("length", {
+    inserted(el, binding) {
+      bindLengthDirective(el, binding);
+    },
+    componentUpdated(el, binding) {
+      const inputEl = getInputElement(el);
+      updateInputValue(inputEl, binding);
+    },
+    unbind(el) {
+      unbindLengthDirective(el);
+    }
+  });
+  Vue2.directive("event-unuse", {
+    inserted(el) {
+      el.style.pointerEvents = "none";
+    }
+  });
+  Vue2.directive("event-use", {
+    inserted(el) {
+      el.style.pointerEvents = "auto";
+    }
+  });
+}
+let ThemeVar$1 = class ThemeVar {
+};
+ThemeVar$1.VARS = {};
+function loadCssVars$1() {
+  if (typeof document === "undefined") {
+    return ThemeVar$1.VARS;
+  }
+  if (Object.keys(ThemeVar$1.VARS).length > 0) {
+    return ThemeVar$1.VARS;
+  }
+  const variables = {};
+  Array.from(document.styleSheets || []).forEach((sheet) => {
+    let cssRules = [];
+    try {
+      cssRules = Array.from(sheet.cssRules || []);
+    } catch (error) {
+      cssRules = [];
+    }
+    cssRules.forEach((rule) => {
+      if (rule.selectorText !== ":root") {
+        return;
+      }
+      Array.from(rule.style || []).filter((name) => name.indexOf("--matrix-") === 0).forEach((name) => {
+        variables[name] = rule.style.getPropertyValue(name).trim();
+      });
+    });
+  });
+  ThemeVar$1.VARS = variables;
+  return variables;
+}
+function toKebabCase$1(value) {
+  if (typeof value !== "string")
+    return value;
+  if (value.indexOf("-") > -1)
+    return value.toLowerCase();
+  return value.replace(/([a-z0-9])([A-Z])/g, "$1-$2").toLowerCase();
+}
+function normalizeComponent$1(component) {
+  if (!component)
+    return "span";
+  if (typeof component === "string") {
+    return toKebabCase$1(component);
+  }
+  return component;
+}
+function cloneVNodeWithSlot(vnode, slotName) {
+  if (!vnode || slotName === "default") {
+    return vnode;
+  }
+  const data = vnode.data || (vnode.data = {});
+  data.slot = slotName;
+  return vnode;
+}
+function normalizeChildren(result, slotName) {
+  if (!result)
+    return [];
+  const list = Array.isArray(result) ? result : [result];
+  return list.map((item) => cloneVNodeWithSlot(item, slotName)).filter(Boolean);
+}
+function isComponentName(component, names) {
+  const name = String(typeof component === "string" ? component : component && component.name ? component.name : "").replace(/-/g, "").toLowerCase();
+  return names.some((item) => name === item.toLowerCase());
+}
+const FormFieldRenderer = {
+  name: "NsFormFieldRenderer",
+  inheritAttrs: false,
+  props: {
+    field: {
+      type: Object,
+      required: true
+    },
+    value: {
+      default: void 0
+    }
+  },
+  mounted() {
+    this.emitRef();
+  },
+  updated() {
+    this.emitRef();
+  },
+  methods: {
+    emitRef() {
+      this.$emit("ref", this.$refs.control || null);
+    },
+    getComponent() {
+      return normalizeComponent$1(this.field.component);
+    },
+    isUpload() {
+      return isComponentName(this.field.component, ["elupload"]);
+    },
+    rendersOptionsByChildren() {
+      return isComponentName(this.field.component, ["elselect", "elradiogroup", "elcheckboxgroup"]);
+    },
+    isFullWidthComponent() {
+      return isComponentName(this.field.component, [
+        "elinput",
+        "elselect",
+        "elcascader",
+        "eldatepicker",
+        "eltimepicker",
+        "elinputnumber",
+        "elautocomplete"
+      ]);
+    },
+    buildProps() {
+      const params = this.field.params || {};
+      const result = {};
+      Object.keys(params).forEach((key) => {
+        if (key.indexOf("v-") === 0)
+          return;
+        if (key === "rules" || key === "style")
+          return;
+        if (key === "options" && this.rendersOptionsByChildren())
+          return;
+        result[key] = params[key];
+      });
+      if (!this.isUpload()) {
+        result.value = this.value;
+      }
+      return result;
+    },
+    buildStyle() {
+      const params = this.field.params || {};
+      const style = {
+        ...this.field.style || {},
+        ...params.style || {}
+      };
+      if (this.isFullWidthComponent() && style.width === void 0) {
+        style.width = "100%";
+      }
+      return style;
+    },
+    buildDirectives() {
+      const params = this.field.params || {};
+      return Object.keys(params).filter((key) => key.indexOf("v-") === 0).map((key) => {
+        const [, definition] = key.split("v-");
+        const [name, ...modifiers] = definition.split(".");
+        const modifierObject = {};
+        modifiers.forEach((item) => {
+          modifierObject[item] = true;
+        });
+        return {
+          name,
+          value: params[key],
+          modifiers: modifierObject
+        };
+      });
+    },
+    buildEvents() {
+      const userEvents = this.field.events || {};
+      const listeners = {};
+      Object.keys(userEvents).forEach((name) => {
+        listeners[name] = (...args) => {
+          userEvents[name](...args);
+        };
+      });
+      if (!this.isUpload()) {
+        const originalInput = listeners.input;
+        listeners.input = (val, ...args) => {
+          this.$emit("input", val);
+          if (originalInput) {
+            originalInput(val, ...args);
+          }
+        };
+      }
+      return listeners;
+    },
+    buildScopedSlots() {
+      const slots = this.field.slots || {};
+      const scopedSlots = {};
+      Object.keys(slots).forEach((name) => {
+        if (typeof slots[name] === "function") {
+          scopedSlots[name] = (scope) => slots[name](scope);
+        }
+      });
+      return scopedSlots;
+    },
+    renderOptionNodes(h) {
+      const params = this.field.params || {};
+      const options = params.options || [];
+      const component = this.getComponent();
+      if (!Array.isArray(options) || options.length === 0) {
+        return [];
+      }
+      if (isComponentName(component, ["elselect"])) {
+        return options.map(
+          (option, index2) => h("el-option", {
+            key: option.value !== void 0 ? option.value : index2,
+            props: {
+              label: option.label,
+              value: option.value,
+              disabled: option.disabled
+            }
+          })
+        );
+      }
+      if (isComponentName(component, ["elradiogroup"])) {
+        return options.map(
+          (option, index2) => h(
+            "el-radio",
+            {
+              key: option.value !== void 0 ? option.value : index2,
+              props: {
+                label: option.value,
+                disabled: option.disabled
+              }
+            },
+            [option.label]
+          )
+        );
+      }
+      if (isComponentName(component, ["elcheckboxgroup"])) {
+        return options.map(
+          (option, index2) => h(
+            "el-checkbox",
+            {
+              key: option.value !== void 0 ? option.value : index2,
+              props: {
+                label: option.value,
+                disabled: option.disabled
+              }
+            },
+            [option.label]
+          )
+        );
+      }
+      return [];
+    }
+  },
+  render(h) {
+    const component = this.getComponent();
+    const slotNodes = [];
+    const slots = this.field.slots || {};
+    Object.keys(slots).forEach((name) => {
+      if (typeof slots[name] === "function") {
+        slotNodes.push(...normalizeChildren(slots[name]({ field: this.field, value: this.value }), name));
+      }
+    });
+    return h(
+      component,
+      {
+        ref: "control",
+        props: this.buildProps(),
+        style: this.buildStyle(),
+        on: this.buildEvents(),
+        directives: this.buildDirectives(),
+        scopedSlots: this.buildScopedSlots()
+      },
+      [...this.renderOptionNodes(h), ...slotNodes]
+    );
+  }
+};
+function isNotNull(value) {
+  if (Array.isArray(value)) {
+    return true;
+  }
+  if (value === 0 || value === "0") {
+    return true;
+  }
+  return !(value === "" || value === null || typeof value === "undefined" || value === "null" || value === "undefined" || String(value).trim() === "" || String(value).trim() === "undefined");
+}
+const DynamicForm_vue_vue_type_style_index_0_scoped_4efb4504_lang = "";
+function normalizeComponent(scriptExports, render7, staticRenderFns, functionalTemplate, injectStyles, scopeId, moduleIdentifier, shadowMode) {
+  var options = typeof scriptExports === "function" ? scriptExports.options : scriptExports;
+  if (render7) {
+    options.render = render7;
+    options.staticRenderFns = staticRenderFns;
+    options._compiled = true;
+  }
+  if (functionalTemplate) {
+    options.functional = true;
+  }
+  if (scopeId) {
+    options._scopeId = "data-v-" + scopeId;
+  }
+  var hook;
+  if (moduleIdentifier) {
+    hook = function(context) {
+      context = context || // cached call
+      this.$vnode && this.$vnode.ssrContext || // stateful
+      this.parent && this.parent.$vnode && this.parent.$vnode.ssrContext;
+      if (!context && typeof __VUE_SSR_CONTEXT__ !== "undefined") {
+        context = __VUE_SSR_CONTEXT__;
+      }
+      if (injectStyles) {
+        injectStyles.call(this, context);
+      }
+      if (context && context._registeredComponents) {
+        context._registeredComponents.add(moduleIdentifier);
+      }
+    };
+    options._ssrRegister = hook;
+  } else if (injectStyles) {
+    hook = shadowMode ? function() {
+      injectStyles.call(
+        this,
+        (options.functional ? this.parent : this).$root.$options.shadowRoot
+      );
+    } : injectStyles;
+  }
+  if (hook) {
+    if (options.functional) {
+      options._injectStyles = hook;
+      var originalRender = options.render;
+      options.render = function renderWithStyleInjection(h, context) {
+        hook.call(context);
+        return originalRender(h, context);
+      };
+    } else {
+      var existing = options.beforeCreate;
+      options.beforeCreate = existing ? [].concat(existing, hook) : [hook];
+    }
+  }
+  return {
+    exports: scriptExports,
+    options
+  };
+}
+function deepClone(value) {
+  if (value === null || typeof value !== "object") {
+    return value;
+  }
+  if (Array.isArray(value)) {
+    return value.map((item) => deepClone(item));
+  }
+  const result = {};
+  Object.keys(value).forEach((key) => {
+    result[key] = deepClone(value[key]);
+  });
+  return result;
+}
+function normalizeComponentName(component) {
+  const name = String(typeof component === "string" ? component : component && component.name ? component.name : "");
+  return name.replace(/-/g, "").toLowerCase();
+}
+const _sfc_main$5 = {
+  name: "NsForm",
+  components: {
+    FormFieldRenderer
+  },
+  props: {
+    model: {
+      type: String,
+      default: ""
+    },
+    readOnly: {
+      type: Boolean,
+      default: false
+    },
+    labelWidth: {
+      type: String,
+      default: "80px"
+    },
+    superLabelWidth: {
+      type: String,
+      default: "30px"
+    },
+    labelColor: {
+      type: String,
+      default: "#0A7BFF"
+    },
+    gapH: {
+      type: String,
+      default: "10px"
+    },
+    gapV: {
+      type: String,
+      default: "10px"
+    },
+    height: {
+      type: String,
+      default: "32px"
+    },
+    rows: {
+      type: Array,
+      default: () => []
+    },
+    backgroundColor: {
+      type: String,
+      default: ""
+    },
+    valueEmptyTag: {
+      type: String,
+      default: "--"
+    },
+    formPropKey: {
+      type: String,
+      default: "rows"
+    },
+    hasPoint: {
+      type: Boolean,
+      default: false
+    }
+  },
+  data() {
+    return {
+      componentRefs: {}
+    };
+  },
+  computed: {
+    formClassList() {
+      return {
+        "is-vertical": this.model.indexOf("vertical") > -1,
+        "is-table": this.model.indexOf("table") > -1,
+        "is-readonly": this.readOnly
+      };
+    },
+    wrapperStyle() {
+      return {
+        "--ns-form-label-width": this.normalizeSize(this.labelWidth),
+        "--ns-form-super-label-width": this.normalizeSize(this.superLabelWidth),
+        "--ns-form-label-color": this.labelColor,
+        "--ns-form-row-gap": this.gapV,
+        "--ns-form-col-gap": this.gapH,
+        "--ns-form-item-height": this.normalizeSize(this.height),
+        "--ns-form-background-color": this.backgroundColor || "#ffffff"
+      };
+    },
+    rowStyle() {
+      return {
+        marginBottom: this.model.indexOf("table") > -1 ? "0" : this.gapV
+      };
+    },
+    labelStyle() {
+      return {
+        width: this.normalizeSize(this.labelWidth),
+        color: this.labelColor
+      };
+    },
+    groupLabelStyle() {
+      return {
+        width: this.normalizeSize(this.superLabelWidth),
+        color: this.labelColor
+      };
+    },
+    valueStyle() {
+      return {
+        minHeight: this.normalizeSize(this.height)
+      };
+    }
+  },
+  watch: {
+    rows: {
+      handler(newRows) {
+        this.initializeDefaultValues(newRows);
+      },
+      deep: true,
+      immediate: true
+    }
+  },
+  methods: {
+    walkFields(callback) {
+      (this.rows || []).forEach((row, rowIndex) => {
+        (row || []).forEach((item, itemIndex) => {
+          callback(item, rowIndex, itemIndex, null, null);
+          (item.children || []).forEach((child, childIndex) => {
+            callback(child, rowIndex, itemIndex, childIndex, item);
+          });
+        });
+      });
+    },
+    initializeDefaultValues(rows) {
+      (rows || []).forEach((row) => {
+        (row || []).forEach((item) => {
+          if (item && item.key && item.defaultValue === void 0) {
+            this.$set(item, "defaultValue", deepClone(item.value));
+          }
+          (item.children || []).forEach((child) => {
+            if (child && child.key && child.defaultValue === void 0) {
+              this.$set(child, "defaultValue", deepClone(child.value));
+            }
+          });
+        });
+      });
+    },
+    normalizeSize(value) {
+      if (value === null || value === void 0 || value === "")
+        return "";
+      return /^\d+$/.test(String(value)) ? `${value}px` : String(value);
+    },
+    hasChildren(item) {
+      return Array.isArray(item.children) && item.children.length > 0;
+    },
+    getItemStyle(item, row) {
+      if (item.span === 0) {
+        return { display: "none" };
+      }
+      if (typeof item.span === "string" && item.span.indexOf("%") > -1) {
+        return {
+          flex: `0 0 ${item.span}`,
+          maxWidth: item.span
+        };
+      }
+      if (item.span !== void 0 && item.span !== null && item.span !== "") {
+        const span = Number(item.span);
+        if (!Number.isNaN(span)) {
+          const width2 = span > 24 ? `${span}px` : `${span / 24 * 100}%`;
+          return {
+            flex: `0 0 ${width2}`,
+            maxWidth: width2
+          };
+        }
+      }
+      const columns = (row || []).filter((field) => field && field.span !== 0).length || 1;
+      const width = `calc(${100 / columns}% - ${this.gapH})`;
+      return {
+        flex: `0 0 ${width}`,
+        maxWidth: width
+      };
+    },
+    getFieldRules(field) {
+      if (this.readOnly)
+        return [];
+      return field.params && field.params.rules || [];
+    },
+    isRequiredField(field) {
+      if (!field || this.readOnly)
+        return false;
+      if (typeof field.required === "boolean") {
+        return field.required;
+      }
+      return this.getFieldRules(field).some((rule) => rule && rule.required);
+    },
+    getFieldRequired(field) {
+      if (!field || this.readOnly)
+        return false;
+      return field && typeof field.required === "boolean" ? field.required : void 0;
+    },
+    updateFieldValue(field, value) {
+      this.$set(field, "value", value);
+    },
+    setComponentRef(field, ref) {
+      if (!field || !field.key)
+        return;
+      this.$set(field, "ref", ref);
+      this.$set(this.componentRefs, field.key, ref);
+    },
+    showReadOnlyText(field) {
+      return this.readOnly && !(field && field.readOnlyUseComponent);
+    },
+    normalizeDisplayValue(value, field) {
+      if (isNotNull(value)) {
+        if (Array.isArray(value)) {
+          return value.join("，");
+        }
+        return value;
+      }
+      return field && field.valueEmptyTag || this.valueEmptyTag;
+    },
+    getReadOnlyDisplayValue(field) {
+      var _a, _b, _c;
+      if (!field) {
+        return this.valueEmptyTag;
+      }
+      if (typeof ((_a = field.params) == null ? void 0 : _a.formatter) === "function") {
+        return field.params.formatter(field.value, field) || this.valueEmptyTag;
+      }
+      if (!isNotNull(field.value)) {
+        return field.valueEmptyTag || this.valueEmptyTag;
+      }
+      if (this.isUploadComponent(field)) {
+        return (field.value || []).map((item) => item.fileName || item.name || item.filePath).filter(Boolean).join("，") || (field.valueEmptyTag || this.valueEmptyTag);
+      }
+      if (this.isSwitchComponent(field)) {
+        return field.value ? ((_b = field.params) == null ? void 0 : _b.activeText) || "是" : ((_c = field.params) == null ? void 0 : _c.inactiveText) || "否";
+      }
+      if (this.isSelectLikeComponent(field)) {
+        return this.getOptionDisplayText(field);
+      }
+      if (this.isCascaderComponent(field)) {
+        return this.getCascaderDisplayValue(field);
+      }
+      if (Array.isArray(field.value)) {
+        return field.value.join("，");
+      }
+      return field.value;
+    },
+    getOptionDisplayText(field) {
+      var _a;
+      const options = ((_a = field.params) == null ? void 0 : _a.options) || [];
+      const rawValue = field.value;
+      const valueList = Array.isArray(rawValue) ? rawValue : typeof rawValue === "string" && rawValue.indexOf(",") > -1 ? rawValue.split(",").filter(Boolean) : [rawValue];
+      const labels = valueList.map((value) => {
+        const option = options.find((item) => item.value === value);
+        return option ? option.label : value;
+      }).filter((item) => item !== void 0 && item !== null && item !== "");
+      return labels.join("，") || field.valueEmptyTag || this.valueEmptyTag;
+    },
+    getCascaderDisplayValue(field) {
+      var _a, _b, _c, _d;
+      const params = field.params || {};
+      const options = params.options || [];
+      const propConfig = {
+        value: ((_a = params.props) == null ? void 0 : _a.value) || "value",
+        label: ((_b = params.props) == null ? void 0 : _b.label) || "label",
+        children: ((_c = params.props) == null ? void 0 : _c.children) || "children",
+        multiple: !!((_d = params.props) == null ? void 0 : _d.multiple),
+        separator: params.separator || " / "
+      };
+      const normalizePath = (pathValue) => {
+        if (Array.isArray(pathValue))
+          return pathValue;
+        if (typeof pathValue === "string" && pathValue.indexOf(",") > -1) {
+          return pathValue.split(",").filter(Boolean);
+        }
+        return [pathValue];
+      };
+      const getPathLabels = (pathValue) => {
+        const labels = [];
+        let currentOptions = options;
+        normalizePath(pathValue).forEach((value) => {
+          const current = (currentOptions || []).find((item) => item[propConfig.value] === value);
+          if (current) {
+            labels.push(current[propConfig.label]);
+            currentOptions = current[propConfig.children];
+          }
+        });
+        return labels.join(propConfig.separator);
+      };
+      if (propConfig.multiple && Array.isArray(field.value) && Array.isArray(field.value[0])) {
+        return field.value.map((item) => getPathLabels(item)).join("，");
+      }
+      return getPathLabels(field.value);
+    },
+    isSelectLikeComponent(field) {
+      return ["elselect", "elradiogroup", "elcheckboxgroup"].includes(normalizeComponentName(field.component));
+    },
+    isSwitchComponent(field) {
+      return normalizeComponentName(field.component) === "elswitch";
+    },
+    isCascaderComponent(field) {
+      return normalizeComponentName(field.component) === "elcascader";
+    },
+    isUploadComponent(field) {
+      return normalizeComponentName(field.component) === "elupload";
+    },
+    getFormNodeByKey(key) {
+      for (let rowIndex = 0; rowIndex < this.rows.length; rowIndex += 1) {
+        const row = this.rows[rowIndex];
+        for (let colIndex = 0; colIndex < row.length; colIndex += 1) {
+          const item = row[colIndex];
+          if (item.key === key)
+            return item;
+          for (let childIndex = 0; childIndex < (item.children || []).length; childIndex += 1) {
+            const child = item.children[childIndex];
+            if (child.key === key)
+              return child;
+          }
+        }
+      }
+      return null;
+    },
+    getFormNodeRefByKey(key) {
+      return this.componentRefs[key] || null;
+    },
+    getFormKvData() {
+      const result = {};
+      this.walkFields((field) => {
+        if (!field || !field.key)
+          return;
+        result[field.key] = Array.isArray(field.value) && Array.isArray(field.delValue) ? field.value.concat(field.delValue) : field.value;
+      });
+      return result;
+    },
+    resetForm(triggerEvents = false) {
+      this.walkFields((field) => {
+        var _a, _b;
+        if (!field || !field.key)
+          return;
+        const oldValue = deepClone(field.value);
+        const nextValue = field.defaultValue !== void 0 ? deepClone(field.defaultValue) : Array.isArray(field.value) ? [] : typeof field.value === "boolean" ? false : typeof field.value === "number" ? 0 : "";
+        this.$set(field, "value", nextValue);
+        if (field.delValue !== void 0) {
+          this.$set(field, "delValue", []);
+        }
+        if (field.params && Array.isArray(field.params.fileList)) {
+          field.params.fileList.splice(0, field.params.fileList.length);
+        }
+        if (triggerEvents && JSON.stringify(oldValue) !== JSON.stringify(nextValue)) {
+          if (typeof ((_a = field.events) == null ? void 0 : _a.change) === "function") {
+            this.$nextTick(() => field.events.change(nextValue));
+          }
+          if (typeof ((_b = field.events) == null ? void 0 : _b.input) === "function") {
+            this.$nextTick(() => field.events.input(nextValue));
+          }
+        }
+      });
+    },
+    setFormData(data) {
+      if (!data || typeof data !== "object") {
+        return;
+      }
+      this.walkFields((field) => {
+        if (!field || !field.key || !Object.prototype.hasOwnProperty.call(data, field.key))
+          return;
+        let nextValue = deepClone(data[field.key]);
+        if (this.isCascaderComponent(field) && typeof nextValue === "string" && nextValue.indexOf(",") > -1) {
+          nextValue = nextValue.split(",").filter(Boolean);
+        }
+        this.$set(field, "value", nextValue);
+        if (this.isUploadComponent(field)) {
+          const fileList = Array.isArray(nextValue) ? deepClone(nextValue) : [];
+          if (field.params) {
+            this.$set(field.params, "fileList", fileList);
+          }
+        }
+      });
+    },
+    initDefaultValues() {
+      this.initializeDefaultValues(this.rows);
+    }
+  }
+};
+var _sfc_render$5 = function render() {
+  var _vm = this, _c = _vm._self._c;
+  return _vm.rows && _vm.rows.length ? _c("div", { staticClass: "ns-dynamic-form", class: _vm.formClassList, style: _vm.wrapperStyle }, _vm._l(_vm.rows, function(row, rowIndex) {
+    return _c("div", { key: `row-${rowIndex}`, staticClass: "ns-dynamic-form__row", style: _vm.rowStyle }, _vm._l(row, function(item, itemIndex) {
+      return _c("div", { key: item.key || `${rowIndex}-${itemIndex}`, staticClass: "ns-dynamic-form__item", class: { "has-children": _vm.hasChildren(item) }, style: _vm.getItemStyle(item, row) }, [_vm.hasChildren(item) ? [!item.hideLabel && item.label ? _c("div", { staticClass: "ns-dynamic-form__group-label", style: _vm.groupLabelStyle }, [_vm._v(" " + _vm._s(item.label) + " ")]) : _vm._e(), _c("div", { staticClass: "ns-dynamic-form__children" }, _vm._l(item.children, function(child, childIndex) {
+        return _c("div", { key: child.key || `${rowIndex}-${itemIndex}-${childIndex}`, staticClass: "ns-dynamic-form__child" }, [!child.hideLabel && child.label ? _c("div", { staticClass: "ns-dynamic-form__label", class: { "has-point": _vm.hasPoint || _vm.isRequiredField(child) }, style: _vm.labelStyle }, [_vm._v(" " + _vm._s(child.label) + " ")]) : _vm._e(), _c("div", { staticClass: "ns-dynamic-form__value", style: _vm.valueStyle }, [_vm.showReadOnlyText(child) ? [_c("span", { directives: [{ name: "sline", rawName: "v-sline" }] }, [_vm._v(_vm._s(_vm.getReadOnlyDisplayValue(child)))])] : child.component ? [_c("el-form-item", { staticClass: "ns-dynamic-form__form-item", attrs: { "label-width": "0px", "prop": `${_vm.formPropKey}.${rowIndex}.${itemIndex}.children.${childIndex}.value`, "rules": _vm.getFieldRules(child), "required": _vm.getFieldRequired(child) } }, [_c("form-field-renderer", { attrs: { "field": child, "value": child.value }, on: { "input": function($event) {
+          return _vm.updateFieldValue(child, $event);
+        }, "ref": function($event) {
+          return _vm.setComponentRef(child, $event);
+        } } })], 1)] : [_c("span", { directives: [{ name: "sline", rawName: "v-sline" }] }, [_vm._v(_vm._s(_vm.normalizeDisplayValue(child.value, child)))])]], 2)]);
+      }), 0)] : [!item.hideLabel && item.label ? _c("div", { staticClass: "ns-dynamic-form__label", class: { "has-point": _vm.hasPoint || _vm.isRequiredField(item) }, style: _vm.labelStyle }, [_vm._v(" " + _vm._s(item.label) + " ")]) : _vm._e(), _c("div", { staticClass: "ns-dynamic-form__value", style: _vm.valueStyle }, [_vm.showReadOnlyText(item) ? [_c("span", { directives: [{ name: "sline", rawName: "v-sline" }] }, [_vm._v(_vm._s(_vm.getReadOnlyDisplayValue(item)))])] : item.component ? [_c("el-form-item", { staticClass: "ns-dynamic-form__form-item", attrs: { "label-width": "0px", "prop": `${_vm.formPropKey}.${rowIndex}.${itemIndex}.value`, "rules": _vm.getFieldRules(item), "required": _vm.getFieldRequired(item) } }, [_c("form-field-renderer", { attrs: { "field": item, "value": item.value }, on: { "input": function($event) {
+        return _vm.updateFieldValue(item, $event);
+      }, "ref": function($event) {
+        return _vm.setComponentRef(item, $event);
+      } } })], 1)] : [_c("span", { directives: [{ name: "sline", rawName: "v-sline" }] }, [_vm._v(_vm._s(_vm.normalizeDisplayValue(item.value, item)))])]], 2)]], 2);
+    }), 0);
+  }), 0) : _vm._e();
+};
+var _sfc_staticRenderFns$5 = [];
+var __component__$5 = /* @__PURE__ */ normalizeComponent(
+  _sfc_main$5,
+  _sfc_render$5,
+  _sfc_staticRenderFns$5,
+  false,
+  null,
+  "4efb4504",
+  null,
+  null
+);
+const NsForm = __component__$5.exports;
+class ThemeVar2 {
+}
+ThemeVar2.VARS = {};
+function loadCssVars() {
+  if (typeof document === "undefined") {
+    return ThemeVar2.VARS;
+  }
+  if (Object.keys(ThemeVar2.VARS).length > 0) {
+    return ThemeVar2.VARS;
+  }
+  const variables = {};
+  Array.from(document.styleSheets || []).forEach((sheet) => {
+    let cssRules = [];
+    try {
+      cssRules = Array.from(sheet.cssRules || []);
+    } catch (error) {
+      cssRules = [];
+    }
+    cssRules.forEach((rule) => {
+      if (rule.selectorText !== ":root") {
+        return;
+      }
+      Array.from(rule.style || []).filter((name) => name.indexOf("--matrix-") === 0).forEach((name) => {
+        variables[name] = rule.style.getPropertyValue(name).trim();
+      });
+    });
+  });
+  ThemeVar2.VARS = variables;
+  return variables;
+}
+const DynamicFormTitle_vue_vue_type_style_index_0_scoped_4e159c2c_lang = "";
+const _sfc_main$4 = {
+  name: "NsFormTitle",
+  props: {
+    title: {
+      type: String,
+      default: ""
+    }
+  },
+  mounted() {
+    loadCssVars();
+  }
+};
+var _sfc_render$4 = function render2() {
+  var _vm = this, _c = _vm._self._c;
+  return _c("div", { staticClass: "ns-form-title" }, [_c("div", { staticClass: "ns-form-title__header" }, [_vm._t("title", function() {
+    return [_c("span", { staticClass: "ns-form-title__icon" }), _c("span", { staticClass: "ns-form-title__text" }, [_vm._v(_vm._s(_vm.title))])];
+  })], 2), _c("div", { staticClass: "ns-form-title__content" }, [_vm._t("default")], 2)]);
+};
+var _sfc_staticRenderFns$4 = [];
+var __component__$4 = /* @__PURE__ */ normalizeComponent(
+  _sfc_main$4,
+  _sfc_render$4,
+  _sfc_staticRenderFns$4,
+  false,
+  null,
+  "4e159c2c",
+  null,
+  null
+);
+const NsFormTitle = __component__$4.exports;
+function getImageBaseUrl(instance) {
+  var _a;
+  return ((_a = instance == null ? void 0 : instance.proxy) == null ? void 0 : _a.$ImageBaseUrl) || "";
+}
+function getFieldPathByKey(rows, key, formPropKey = "rows") {
+  for (let rowIndex = 0; rowIndex < rows.length; rowIndex += 1) {
+    const row = rows[rowIndex];
+    for (let colIndex = 0; colIndex < row.length; colIndex += 1) {
+      const item = row[colIndex];
+      if (item.key === key) {
+        return `${formPropKey}.${rowIndex}.${colIndex}.value`;
+      }
+      if (Array.isArray(item.children)) {
+        for (let childIndex = 0; childIndex < item.children.length; childIndex += 1) {
+          const child = item.children[childIndex];
+          if (child.key === key) {
+            return `${formPropKey}.${rowIndex}.${colIndex}.children.${childIndex}.value`;
+          }
+        }
+      }
+    }
+  }
+  return null;
+}
+function useFileUpload(state) {
+  const instance = getCurrentInstance();
+  function handleFormatFileList(field, fileList) {
+    const baseUrl = getImageBaseUrl(instance);
+    const nextList = Array.isArray(fileList) ? fileList : [];
+    nextList.forEach((item) => {
+      if (item.filePath && !item.url) {
+        item.url = `${baseUrl}${item.filePath}`;
+      }
+      if (!item.name) {
+        item.name = item.fileName || item.name || item.filePath || "未命名文件";
+      }
+    });
+    if (field && field.params) {
+      field.params.fileList = nextList;
+    }
+    if (field) {
+      field.value = nextList.slice();
+    }
+    return nextList;
+  }
+  function handleRemoveFile(file, fileList, fieldKey, rows = state.rows) {
+    const field = getAllFormNodeByKey(rows, fieldKey);
+    if (!field) {
+      return fileList;
+    }
+    const nextValue = (fileList || []).map((item) => ({
+      ...item,
+      fileName: item.response ? item.response.data.fileName : item.fileName,
+      filePath: item.response ? item.response.data.filePath : item.filePath,
+      fileSize: item.response ? item.response.data.fileSize : item.fileSize
+    }));
+    if (!Array.isArray(field.delValue)) {
+      field.delValue = [];
+    }
+    if (!file.response && file.status === "success") {
+      field.delValue.push({ ...file, isDelete: 1 });
+    }
+    field.value = nextValue;
+    if (field.params) {
+      field.params.fileList = fileList || [];
+    }
+    return fileList;
+  }
+  function handleFileSuccessFile(response, file, fileList, fieldKey, rows = state.rows) {
+    const field = getAllFormNodeByKey(rows, fieldKey);
+    if (!field) {
+      return fileList;
+    }
+    if (!Array.isArray(field.value)) {
+      field.value = [];
+    }
+    if (file && file.status === "success" && response && response.data) {
+      field.value.push({ ...response.data });
+    }
+    if (field.params) {
+      field.params.fileList = fileList || [];
+    }
+    return fileList;
+  }
+  function handleCheckFileRequire(rows, key, formRef, formPropKey = "rows") {
+    const field = getAllFormNodeByKey(rows, key);
+    if (field && !Array.isArray(field.value)) {
+      field.value = [];
+    }
+    const fieldPath = getFieldPathByKey(rows, key, formPropKey);
+    nextTick(() => {
+      const formInstance = formRef && (formRef.value || formRef);
+      if (fieldPath && formInstance && typeof formInstance.validateField === "function") {
+        formInstance.validateField(fieldPath);
+      }
+    });
+  }
+  return {
+    handleFormatFileList,
+    handleRemoveFile,
+    handleFileSuccessFile,
+    handleCheckFileRequire
+  };
+}
+function installComponent(component) {
+  component.install = function install3(Vue2) {
+    Vue2.component(component.name, component);
+  };
+}
+installComponent(NsForm);
+installComponent(NsFormTitle);
+const originalNsFormInstall = NsForm.install;
+NsForm.install = function install(Vue2) {
+  registerDirective(Vue2);
+  originalNsFormInstall(Vue2);
+};
+function getAllFormKvData(rows) {
+  const result = {};
+  (rows || []).forEach((row) => {
+    (row || []).forEach((item) => {
+      if (item && item.key) {
+        result[item.key] = Array.isArray(item.value) && Array.isArray(item.delValue) ? item.value.concat(item.delValue) : item.value;
+      }
+      (item.children || []).forEach((child) => {
+        if (child && child.key) {
+          result[child.key] = Array.isArray(child.value) && Array.isArray(child.delValue) ? child.value.concat(child.delValue) : child.value;
+        }
+      });
+    });
+  });
+  return result;
+}
+function getAllFormNodeByKey(rows, key) {
+  for (let rowIndex = 0; rowIndex < (rows || []).length; rowIndex += 1) {
+    const row = rows[rowIndex] || [];
+    for (let colIndex = 0; colIndex < row.length; colIndex += 1) {
+      const item = row[colIndex];
+      if (item && item.key === key) {
+        return item;
+      }
+      const children = item && item.children || [];
+      for (let childIndex = 0; childIndex < children.length; childIndex += 1) {
+        if (children[childIndex] && children[childIndex].key === key) {
+          return children[childIndex];
+        }
+      }
+    }
+  }
+  return null;
+}
+function getAllFormNodeRefByKey(rows, key) {
+  const node = getAllFormNodeByKey(rows, key);
+  return node ? node.ref || null : null;
+}
+if (typeof globalThis !== "undefined") {
+  globalThis.getAllFormKvData = getAllFormKvData;
+  globalThis.getAllFormNodeByKey = getAllFormNodeByKey;
+  globalThis.getAllFormNodeRefByKey = getAllFormNodeRefByKey;
+}
+const SlotRenderer = {
+  name: "NsSlotRenderer",
+  functional: true,
+  props: {
+    renderer: {
+      type: Function,
+      default: null
+    },
+    scope: {
+      type: Object,
+      default: () => ({})
+    }
+  },
+  render(h, ctx) {
+    const renderer = ctx.props.renderer;
+    return renderer ? renderer(ctx.props.scope || {}) : null;
+  }
+};
+const PageSearch_vue_vue_type_style_index_0_scoped_9eea70d9_lang = "";
+function toKebabCase(value) {
+  if (typeof value !== "string")
+    return value;
+  if (value.indexOf("-") > -1)
+    return value.toLowerCase();
+  return value.replace(/([a-z0-9])([A-Z])/g, "$1-$2").toLowerCase();
+}
+const _sfc_main$3 = {
+  name: "NsSearch",
+  components: {
+    SlotRenderer
+  },
+  inheritAttrs: false,
+  props: {
+    items: {
+      type: Array,
+      default: () => []
+    },
+    externalParams: {
+      type: Object,
+      default: () => ({})
+    },
+    defaultSpan: {
+      type: Number,
+      default: 6
+    },
+    showCollapse: {
+      type: Boolean,
+      default: true
+    },
+    collapseLimit: {
+      type: Number,
+      default: 3
+    },
+    slotRenderers: {
+      type: Object,
+      default: () => ({})
+    }
+  },
+  data() {
+    return {
+      formData: {},
+      isCollapsed: true
+    };
+  },
+  computed: {
+    visibleItems() {
+      if (!this.showCollapse || !this.isCollapsed) {
+        return this.items;
+      }
+      return this.items.slice(0, this.collapseLimit);
+    }
+  },
+  watch: {
+    items: {
+      handler() {
+        this.initFormData();
+      },
+      deep: true,
+      immediate: true
+    },
+    externalParams: {
+      handler() {
+        this.formData = {
+          ...this.formData,
+          ...this.externalParams
+        };
+      },
+      deep: true,
+      immediate: true
+    }
+  },
+  methods: {
+    normalizeComponent(component) {
+      return typeof component === "string" ? toKebabCase(component) : component;
+    },
+    initFormData() {
+      const nextData = {};
+      (this.items || []).forEach((item) => {
+        nextData[item.prop] = item.defaultValue !== void 0 ? item.defaultValue : void 0;
+      });
+      this.formData = {
+        ...nextData,
+        ...this.externalParams
+      };
+    },
+    isSlotItem(item) {
+      return item && (item.type === "slot" || item.slot === true || typeof item.slot === "string");
+    },
+    getSlotRenderer(item) {
+      const name = typeof item.slot === "string" ? item.slot : item.slotName || item.prop;
+      return this.slotRenderers[name] || null;
+    },
+    isSelectComponent(item) {
+      const name = String(this.normalizeComponent(item.component || "") || "");
+      return name === "el-select";
+    },
+    handleSearch() {
+      this.$emit("search", { ...this.formData, _resetPage: true });
+    },
+    handleReset() {
+      const nextData = {};
+      (this.items || []).forEach((item) => {
+        nextData[item.prop] = item.defaultValue !== void 0 ? item.defaultValue : void 0;
+      });
+      this.formData = {
+        ...nextData,
+        ...this.externalParams
+      };
+      this.$emit("search", { ...this.formData, _resetPage: true });
+      this.$emit("reset");
+    },
+    toggleCollapse() {
+      this.isCollapsed = !this.isCollapsed;
+    },
+    getFormData() {
+      return { ...this.formData };
+    },
+    setFormData(data) {
+      this.formData = {
+        ...this.formData,
+        ...data || {}
+      };
+    },
+    resetForm() {
+      this.handleReset();
+    },
+    validate() {
+      return this.$refs.formRef && this.$refs.formRef.validate ? this.$refs.formRef.validate() : Promise.resolve(true);
+    },
+    clearValidate(props) {
+      if (this.$refs.formRef && this.$refs.formRef.clearValidate) {
+        this.$refs.formRef.clearValidate(props);
+      }
+    }
+  }
+};
+var _sfc_render$3 = function render3() {
+  var _vm = this, _c = _vm._self._c;
+  return _c("div", { staticClass: "page-search" }, [_c("el-form", _vm._b({ ref: "formRef", staticClass: "page-search__form", attrs: { "inline": true, "model": _vm.formData } }, "el-form", _vm.$attrs, false), [_c("el-row", { attrs: { "gutter": 16 } }, [_vm._l(_vm.visibleItems, function(item, index2) {
+    return _c("el-col", { key: item.prop || index2, attrs: { "span": item.span || _vm.defaultSpan } }, [_c("el-form-item", _vm._b({ attrs: { "label": item.label, "prop": item.prop } }, "el-form-item", item.formItemAttrs || {}, false), [_vm.isSlotItem(item) ? _c("slot-renderer", { attrs: { "renderer": _vm.getSlotRenderer(item), "scope": { formData: _vm.formData, item } } }) : _c(_vm.normalizeComponent(item.component || "el-input"), _vm._g(_vm._b({ tag: "component", model: { value: _vm.formData[item.prop], callback: function($$v) {
+      _vm.$set(_vm.formData, item.prop, $$v);
+    }, expression: "formData[item.prop]" } }, "component", item.attrs || {}, false), item.events || {}), [_vm.isSelectComponent(item) ? _vm._l(item.children || [], function(option, optionIndex) {
+      return _c("el-option", { key: option.value !== void 0 ? option.value : optionIndex, attrs: { "label": option.label, "value": option.value, "disabled": option.disabled } });
+    }) : _vm._e()], 2)], 1)], 1);
+  }), _c("el-col", { staticClass: "page-search__actions", attrs: { "span": _vm.defaultSpan } }, [_c("el-form-item", { attrs: { "label-width": "0" } }, [_c("el-button", { attrs: { "type": "primary" }, on: { "click": _vm.handleSearch } }, [_vm._v("查询")]), _c("el-button", { on: { "click": _vm.handleReset } }, [_vm._v("重置")]), _vm.showCollapse && _vm.items.length > _vm.collapseLimit ? _c("el-button", { attrs: { "type": "text" }, on: { "click": _vm.toggleCollapse } }, [_vm._v(" " + _vm._s(_vm.isCollapsed ? "展开" : "收起") + " ")]) : _vm._e()], 1)], 1)], 2)], 1)], 1);
+};
+var _sfc_staticRenderFns$3 = [];
+var __component__$3 = /* @__PURE__ */ normalizeComponent(
+  _sfc_main$3,
+  _sfc_render$3,
+  _sfc_staticRenderFns$3,
+  false,
+  null,
+  "9eea70d9",
+  null,
+  null
+);
+const NsSearch = __component__$3.exports;
+const RESERVED_KEYS = [
+  "children",
+  "slot",
+  "headerSlot",
+  "buttons",
+  "enum",
+  "type",
+  "imageWidth",
+  "imageHeight",
+  "linkText"
+];
+const TableColumn = {
+  name: "NsTableColumn",
+  props: {
+    column: {
+      type: Object,
+      required: true
+    },
+    slotRenderers: {
+      type: Object,
+      default: () => ({})
+    }
+  },
+  methods: {
+    getColumnProps(column) {
+      const props = { ...column };
+      RESERVED_KEYS.forEach((key) => delete props[key]);
+      return props;
+    },
+    getRenderer(name) {
+      return name ? this.slotRenderers[name] : null;
+    },
+    getCellValue(row, column) {
+      return column.prop ? row[column.prop] : void 0;
+    },
+    isVisible(config, row) {
+      if (typeof config.show === "function") {
+        return config.show(row) !== false;
+      }
+      if (config.show === void 0) {
+        return true;
+      }
+      return !!config.show;
+    },
+    isDisabled(config, row) {
+      return typeof config.disabled === "function" ? !!config.disabled(row) : !!config.disabled;
+    },
+    renderActionButtons(h, scope, column) {
+      const buttons = Array.isArray(column.buttons) ? column.buttons : [];
+      return buttons.filter((button) => this.isVisible(button, scope.row)).map((button, index2) => {
+        const slotRenderer = this.getRenderer(button.slot);
+        if (slotRenderer) {
+          return slotRenderer({ ...scope, row: scope.row, column, button });
+        }
+        return h(
+          "el-button",
+          {
+            key: button.label || index2,
+            props: {
+              size: button.size || "mini",
+              type: button.link ? "text" : button.type || "text",
+              icon: typeof button.icon === "string" ? button.icon : void 0,
+              disabled: this.isDisabled(button, scope.row)
+            },
+            on: {
+              click: () => {
+                if (typeof button.handler === "function") {
+                  button.handler(scope.row, scope.$index);
+                }
+                this.$emit("button-click", scope.row, column, button);
+              }
+            }
+          },
+          [button.label]
+        );
+      });
+    },
+    renderTag(h, scope, column) {
+      const cellValue = this.getCellValue(scope.row, column);
+      const tagType = typeof column.tagType === "function" ? column.tagType(scope.row, cellValue) : column.tagType;
+      const text = typeof column.formatter === "function" ? column.formatter(scope.row, column, cellValue) : this.resolveEnumText(column, cellValue);
+      return h("el-tag", { props: { type: tagType || "info", size: column.tagSize || "small" } }, [text]);
+    },
+    renderImage(h, scope, column) {
+      const src = this.getCellValue(scope.row, column);
+      if (!src) {
+        return "-";
+      }
+      return h("img", {
+        style: {
+          width: column.imageWidth || "40px",
+          height: column.imageHeight || "40px",
+          objectFit: "cover",
+          borderRadius: "4px"
+        },
+        attrs: {
+          src,
+          alt: column.label || "image"
+        }
+      });
+    },
+    renderLink(h, scope, column) {
+      const renderer = this.getRenderer(column.slot);
+      if (renderer) {
+        return renderer(scope);
+      }
+      const cellValue = this.getCellValue(scope.row, column);
+      return h(
+        "el-button",
+        {
+          props: {
+            type: "text"
+          },
+          on: {
+            click: () => this.$emit("link-click", scope.row, column)
+          }
+        },
+        [column.linkText || cellValue || "-"]
+      );
+    },
+    resolveEnumText(column, value) {
+      const enumList = column.enum || column.options || [];
+      if (!Array.isArray(enumList)) {
+        return value;
+      }
+      const matched = enumList.find((item) => item.value === value);
+      return matched ? matched.label : value;
+    },
+    renderDefaultCell(h, scope, column) {
+      const renderer = this.getRenderer(column.slot);
+      if (renderer) {
+        return renderer(scope);
+      }
+      if (column.type === "action") {
+        return h("div", { class: "ns-table-column__actions" }, this.renderActionButtons(h, scope, column));
+      }
+      if (column.type === "tag") {
+        return this.renderTag(h, scope, column);
+      }
+      if (column.type === "image") {
+        return this.renderImage(h, scope, column);
+      }
+      if (column.type === "link") {
+        return this.renderLink(h, scope, column);
+      }
+      const cellValue = this.getCellValue(scope.row, column);
+      if (typeof column.formatter === "function") {
+        return column.formatter(scope.row, column, cellValue);
+      }
+      if (column.enum) {
+        return this.resolveEnumText(column, cellValue);
+      }
+      return cellValue === void 0 || cellValue === null || cellValue === "" ? "-" : cellValue;
+    },
+    renderColumn(h, column) {
+      const children = Array.isArray(column.children) ? column.children.map(
+        (child, index2) => h(TableColumn, {
+          key: child.prop || child.label || index2,
+          props: {
+            column: child,
+            slotRenderers: this.slotRenderers
+          },
+          on: {
+            "link-click": (...args) => this.$emit("link-click", ...args),
+            "button-click": (...args) => this.$emit("button-click", ...args)
+          }
+        })
+      ) : [];
+      const headerRenderer = this.getRenderer(column.headerSlot);
+      return h(
+        "el-table-column",
+        {
+          props: this.getColumnProps(column),
+          scopedSlots: children.length ? headerRenderer ? { header: headerRenderer } : void 0 : {
+            default: (scope) => this.renderDefaultCell(h, scope, column),
+            ...headerRenderer ? { header: headerRenderer } : {}
+          }
+        },
+        children
+      );
+    }
+  },
+  render(h) {
+    return this.renderColumn(h, this.column);
+  }
+};
+const TableColumn$1 = TableColumn;
+const DEFAULT_PAGINATION = {
+  total: 0,
+  currentPage: 1,
+  pageSize: 10
+};
+const DEFAULT_KEY_CONFIG = {
+  totalKey: "total",
+  currentPageKey: "currentPage",
+  pageSizeKey: "pageSize"
+};
+function createPagination(customParams = {}) {
+  return {
+    ...DEFAULT_PAGINATION,
+    ...customParams
+  };
+}
+function createPaginationWithCustomKeys(pagination, keyConfig = {}) {
+  const config = {
+    ...DEFAULT_KEY_CONFIG,
+    ...keyConfig
+  };
+  return {
+    [config.totalKey]: pagination.total,
+    [config.currentPageKey]: pagination.currentPage,
+    [config.pageSizeKey]: pagination.pageSize
+  };
+}
+function resetPagination(pagination) {
+  pagination.total = 0;
+  pagination.currentPage = 1;
+  pagination.pageSize = 10;
+  return pagination;
+}
+const PageTable_vue_vue_type_style_index_0_scoped_e9b089a2_lang = "";
+const RESERVED_LISTENERS = ["add", "selection-change", "sort-change", "row-click", "size-change", "current-change", "link-click"];
+const _sfc_main$2 = {
+  name: "NsTable",
+  components: {
+    SlotRenderer,
+    TableColumn: TableColumn$1
+  },
+  inheritAttrs: false,
+  props: {
+    tableData: {
+      type: Array,
+      default: () => []
+    },
+    columns: {
+      type: Array,
+      default: () => []
+    },
+    actionButtons: {
+      type: Array,
+      default: () => []
+    },
+    showAddButton: {
+      type: Boolean,
+      default: true
+    },
+    addButtonText: {
+      type: String,
+      default: "新增"
+    },
+    showHeaderToolbar: {
+      type: Boolean,
+      default: true
+    },
+    showSelection: {
+      type: Boolean,
+      default: false
+    },
+    showIndex: {
+      type: Boolean,
+      default: false
+    },
+    border: {
+      type: Boolean,
+      default: true
+    },
+    stripe: {
+      type: Boolean,
+      default: false
+    },
+    height: {
+      type: [String, Number],
+      default: void 0
+    },
+    maxHeight: {
+      type: [String, Number],
+      default: void 0
+    },
+    rowKey: {
+      type: [String, Function],
+      default: void 0
+    },
+    defaultExpandAll: {
+      type: Boolean,
+      default: false
+    },
+    highlightCurrentRow: {
+      type: Boolean,
+      default: false
+    },
+    loading: {
+      type: Boolean,
+      default: false
+    },
+    showPagination: {
+      type: Boolean,
+      default: true
+    },
+    total: {
+      type: Number,
+      default: 0
+    },
+    currentPage: {
+      type: Number,
+      default: null
+    },
+    pageSize: {
+      type: Number,
+      default: null
+    },
+    pageSizes: {
+      type: Array,
+      default: () => [10, 20, 50, 100]
+    },
+    paginationLayout: {
+      type: String,
+      default: "total, sizes, prev, pager, next, jumper"
+    },
+    pageNumberKey: {
+      type: String,
+      default: "currentPage"
+    },
+    pageSizeKey: {
+      type: String,
+      default: "pageSize"
+    },
+    pageTotalKey: {
+      type: String,
+      default: "total"
+    },
+    slotRenderers: {
+      type: Object,
+      default: () => ({})
+    }
+  },
+  data() {
+    return {
+      internalPagination: createPagination()
+    };
+  },
+  computed: {
+    currentPageModel() {
+      return this.currentPage === null ? this.internalPagination.currentPage : this.currentPage;
+    },
+    pageSizeModel() {
+      return this.pageSize === null ? this.internalPagination.pageSize : this.pageSize;
+    },
+    mergedAttrs() {
+      return this.$attrs || {};
+    },
+    mergedListeners() {
+      const listeners = { ...this.$listeners || {} };
+      RESERVED_LISTENERS.forEach((name) => delete listeners[name]);
+      return listeners;
+    }
+  },
+  watch: {
+    currentPage: {
+      handler(value) {
+        if (value !== null) {
+          this.internalPagination.currentPage = value;
+        }
+      },
+      immediate: true
+    },
+    pageSize: {
+      handler(value) {
+        if (value !== null) {
+          this.internalPagination.pageSize = value;
+        }
+      },
+      immediate: true
+    }
+  },
+  methods: {
+    handleAdd() {
+      this.$emit("add");
+    },
+    handleSelectionChange(selection) {
+      this.$emit("selection-change", selection);
+    },
+    handleSortChange(sort) {
+      this.$emit("sort-change", sort);
+    },
+    handleRowClick(row, column, event) {
+      this.$emit("row-click", row, column, event);
+    },
+    handleSizeChange(size) {
+      this.internalPagination.pageSize = size;
+      this.$emit("update:pageSize", size);
+      this.$emit("size-change", size);
+    },
+    handleCurrentChange(page) {
+      this.internalPagination.currentPage = page;
+      this.$emit("update:currentPage", page);
+      this.$emit("current-change", page);
+    },
+    handleLinkClick(row, column) {
+      this.$emit("link-click", row, column);
+    },
+    getIndex(index2) {
+      if (!this.showPagination) {
+        return index2 + 1;
+      }
+      const currentPage = Number(this.currentPageModel || 1);
+      const pageSize = Number(this.pageSizeModel || 10);
+      return (currentPage - 1) * pageSize + index2 + 1;
+    },
+    getSelectionRows() {
+      return this.$refs.tableRef && this.$refs.tableRef.selection ? this.$refs.tableRef.selection : [];
+    },
+    getSelectionKeys() {
+      const rows = this.getSelectionRows();
+      if (!this.rowKey) {
+        return rows;
+      }
+      return rows.map((row) => typeof this.rowKey === "function" ? this.rowKey(row) : row[this.rowKey]);
+    },
+    setSelectionRows(rows) {
+      if (!this.$refs.tableRef)
+        return;
+      this.$refs.tableRef.clearSelection();
+      (rows || []).forEach((row) => {
+        this.$refs.tableRef.toggleRowSelection(row, true);
+      });
+    },
+    setSelectionKeys(keys) {
+      if (!this.$refs.tableRef || !this.rowKey)
+        return;
+      this.$refs.tableRef.clearSelection();
+      (keys || []).forEach((key) => {
+        const row = (this.tableData || []).find((item) => (typeof this.rowKey === "function" ? this.rowKey(item) : item[this.rowKey]) === key);
+        if (row) {
+          this.$refs.tableRef.toggleRowSelection(row, true);
+        }
+      });
+    },
+    isRowSelected(row) {
+      return this.getSelectionRows().includes(row);
+    },
+    isKeySelected(key) {
+      return this.getSelectionKeys().includes(key);
+    },
+    clearSelection() {
+      if (this.$refs.tableRef) {
+        this.$refs.tableRef.clearSelection();
+      }
+    },
+    toggleRowSelection(row, selected) {
+      if (this.$refs.tableRef) {
+        this.$refs.tableRef.toggleRowSelection(row, selected);
+      }
+    },
+    toggleAllSelection() {
+      if (this.$refs.tableRef) {
+        this.$refs.tableRef.toggleAllSelection();
+      }
+    },
+    selectAll() {
+      this.toggleAllSelection();
+    },
+    clearAllSelection() {
+      this.clearSelection();
+    },
+    clearSort() {
+      this.$refs.tableRef && this.$refs.tableRef.clearSort && this.$refs.tableRef.clearSort();
+    },
+    clearFilter(columnKey) {
+      this.$refs.tableRef && this.$refs.tableRef.clearFilter && this.$refs.tableRef.clearFilter(columnKey);
+    },
+    doLayout() {
+      this.$refs.tableRef && this.$refs.tableRef.doLayout && this.$refs.tableRef.doLayout();
+    },
+    sort(prop, order) {
+      this.$refs.tableRef && this.$refs.tableRef.sort && this.$refs.tableRef.sort(prop, order);
+    },
+    resetPage() {
+      this.internalPagination.currentPage = 1;
+      this.$emit("update:currentPage", 1);
+    },
+    setPage(page) {
+      this.internalPagination.currentPage = page;
+      this.$emit("update:currentPage", page);
+    },
+    setPageSize(size) {
+      this.internalPagination.pageSize = size;
+      this.$emit("update:pageSize", size);
+    },
+    getPagination() {
+      return {
+        [this.pageTotalKey]: this.total,
+        [this.pageNumberKey]: this.currentPageModel,
+        [this.pageSizeKey]: this.pageSizeModel
+      };
+    },
+    setPagination(pagination) {
+      if (pagination.currentPage !== void 0) {
+        this.setPage(pagination.currentPage);
+      }
+      if (pagination.pageSize !== void 0) {
+        this.setPageSize(pagination.pageSize);
+      }
+    }
+  }
+};
+var _sfc_render$2 = function render4() {
+  var _vm = this, _c = _vm._self._c;
+  return _c("div", { staticClass: "page-table" }, [_vm.showHeaderToolbar ? _c("div", { staticClass: "page-table__header" }, [_c("slot-renderer", { attrs: { "renderer": _vm.slotRenderers["header-left"], "scope": { tableData: _vm.tableData } } }), _c("div", { staticClass: "page-table__actions" }, [_c("slot-renderer", { attrs: { "renderer": _vm.slotRenderers["header-actions"], "scope": { tableData: _vm.tableData } } }), _vm.showAddButton && !_vm.slotRenderers["header-actions"] ? _c("el-button", { attrs: { "type": "primary", "size": "small" }, on: { "click": _vm.handleAdd } }, [_vm._v(" " + _vm._s(_vm.addButtonText) + " ")]) : _vm._e()], 1)], 1) : _vm._e(), _c("el-table", _vm._g(_vm._b({ directives: [{ name: "loading", rawName: "v-loading", value: _vm.loading, expression: "loading" }], ref: "tableRef", attrs: { "data": _vm.tableData, "border": _vm.border, "stripe": _vm.stripe, "height": _vm.height, "max-height": _vm.maxHeight, "row-key": _vm.rowKey, "default-expand-all": _vm.defaultExpandAll, "highlight-current-row": _vm.highlightCurrentRow }, on: { "selection-change": _vm.handleSelectionChange, "sort-change": _vm.handleSortChange, "row-click": _vm.handleRowClick } }, "el-table", _vm.mergedAttrs, false), _vm.mergedListeners), [_vm.showSelection ? _c("el-table-column", { attrs: { "type": "selection", "width": "55", "reserve-selection": !!_vm.rowKey } }) : _vm._e(), _vm.showIndex ? _c("el-table-column", { attrs: { "type": "index", "label": "序号", "width": "60", "index": _vm.getIndex } }) : _vm._e(), _vm._l(_vm.columns, function(column, index2) {
+    return _c("table-column", { key: column.prop || column.label || index2, attrs: { "column": column, "slot-renderers": _vm.slotRenderers }, on: { "link-click": _vm.handleLinkClick } });
+  }), _c("template", { slot: "empty" }, [_vm.slotRenderers.empty ? _c("slot-renderer", { attrs: { "renderer": _vm.slotRenderers.empty, "scope": { tableData: _vm.tableData } } }) : _c("div", { staticClass: "page-table__empty" }, [_vm._v("暂无数据")])], 1)], 2), _vm.showPagination ? _c("div", { staticClass: "page-table__pagination" }, [_c("el-pagination", { attrs: { "background": "", "current-page": _vm.currentPageModel, "page-size": _vm.pageSizeModel, "page-sizes": _vm.pageSizes, "total": _vm.total, "layout": _vm.paginationLayout }, on: { "size-change": _vm.handleSizeChange, "current-change": _vm.handleCurrentChange } })], 1) : _vm._e()], 1);
+};
+var _sfc_staticRenderFns$2 = [];
+var __component__$2 = /* @__PURE__ */ normalizeComponent(
+  _sfc_main$2,
+  _sfc_render$2,
+  _sfc_staticRenderFns$2,
+  false,
+  null,
+  "e9b089a2",
+  null,
+  null
+);
+const NsTable = __component__$2.exports;
+const PageContainer_vue_vue_type_style_index_0_scoped_400797f6_lang = "";
+const _sfc_main$1 = {
+  name: "NsTableContainer",
+  components: {
+    PageSearch: NsSearch,
+    PageTable: NsTable
+  },
+  props: {
+    showSearch: {
+      type: Boolean,
+      default: true
+    },
+    externalSearchParams: {
+      type: Object,
+      default: () => ({})
+    },
+    searchItems: {
+      type: Array,
+      default: () => []
+    },
+    tableData: {
+      type: Array,
+      default: () => []
+    },
+    columns: {
+      type: Array,
+      default: () => []
+    },
+    actionButtons: {
+      type: Array,
+      default: () => []
+    },
+    total: {
+      type: Number,
+      default: 0
+    },
+    currentPage: {
+      type: Number,
+      default: null
+    },
+    pageSize: {
+      type: Number,
+      default: null
+    },
+    pageNumberKey: {
+      type: String,
+      default: "currentPage"
+    },
+    pageSizeKey: {
+      type: String,
+      default: "pageSize"
+    },
+    pageTotalKey: {
+      type: String,
+      default: "total"
+    },
+    searchProps: {
+      type: Object,
+      default: () => ({})
+    },
+    tableProps: {
+      type: Object,
+      default: () => ({})
+    },
+    loadData: {
+      type: Function,
+      default: null
+    }
+  },
+  data() {
+    return {
+      internalPagination: createPagination(),
+      pendingSelectionKeys: /* @__PURE__ */ new Set(),
+      selectionRowMap: {},
+      isSyncingSelection: false
+    };
+  },
+  computed: {
+    currentPageModel() {
+      return this.currentPage === null ? this.internalPagination.currentPage : this.currentPage;
+    },
+    pageSizeModel() {
+      return this.pageSize === null ? this.internalPagination.pageSize : this.pageSize;
+    },
+    currentRowKey() {
+      return this.tableProps && this.tableProps.rowKey;
+    }
+  },
+  watch: {
+    currentPage: {
+      handler(value) {
+        if (value !== null) {
+          this.internalPagination.currentPage = value;
+        }
+      },
+      immediate: true
+    },
+    pageSize: {
+      handler(value) {
+        if (value !== null) {
+          this.internalPagination.pageSize = value;
+        }
+      },
+      immediate: true
+    },
+    tableData: {
+      handler() {
+        this.$nextTick(() => {
+          this.syncSelectionToCurrentPage();
+        });
+      },
+      deep: true,
+      immediate: true
+    }
+  },
+  methods: {
+    getRowKey(row) {
+      if (!this.currentRowKey)
+        return row;
+      return typeof this.currentRowKey === "function" ? this.currentRowKey(row) : row[this.currentRowKey];
+    },
+    resetSelectionState() {
+      this.pendingSelectionKeys = /* @__PURE__ */ new Set();
+      this.selectionRowMap = {};
+      this.$refs.tableRef && this.$refs.tableRef.clearSelection && this.$refs.tableRef.clearSelection();
+    },
+    syncSelectionToCurrentPage() {
+      if (!this.currentRowKey || !this.$refs.tableRef) {
+        return;
+      }
+      this.isSyncingSelection = true;
+      this.$refs.tableRef.clearSelection();
+      (this.tableData || []).forEach((row) => {
+        const key = this.getRowKey(row);
+        if (this.pendingSelectionKeys.has(key)) {
+          this.$set(this.selectionRowMap, key, row);
+          this.$refs.tableRef.toggleRowSelection(row, true);
+        }
+      });
+      this.$nextTick(() => {
+        this.isSyncingSelection = false;
+      });
+    },
+    handleSearch(params) {
+      this.resetSelectionState();
+      if (params && params._resetPage) {
+        const { _resetPage, ...searchParams } = params;
+        this.internalPagination.currentPage = 1;
+        this.$emit("update:currentPage", 1);
+        this.$emit("search", searchParams);
+        return;
+      }
+      this.$emit("search", params);
+    },
+    handleReset() {
+      this.resetSelectionState();
+      this.$emit("reset");
+    },
+    handleAdd() {
+      this.$emit("add");
+    },
+    handleSizeChange(size) {
+      this.internalPagination.pageSize = size;
+      this.$emit("update:pageSize", size);
+      this.$emit("size-change", size);
+      this.$emit("page-change", {
+        currentPage: this.currentPageModel,
+        pageSize: size
+      });
+      if (this.loadData) {
+        this.loadData();
+      }
+    },
+    handleCurrentChange(page) {
+      this.internalPagination.currentPage = page;
+      this.$emit("update:currentPage", page);
+      this.$emit("current-change", page);
+      this.$emit("page-change", {
+        currentPage: page,
+        pageSize: this.pageSizeModel
+      });
+      if (this.loadData) {
+        this.loadData();
+      }
+    },
+    handleSelectionChange(selection) {
+      if (this.isSyncingSelection) {
+        return;
+      }
+      if (!this.currentRowKey) {
+        this.$emit("selection-change", selection);
+        return;
+      }
+      const currentPageKeys = (this.tableData || []).map((row) => this.getRowKey(row));
+      currentPageKeys.forEach((key) => {
+        this.pendingSelectionKeys.delete(key);
+        this.$delete(this.selectionRowMap, key);
+      });
+      (selection || []).forEach((row) => {
+        const key = this.getRowKey(row);
+        this.pendingSelectionKeys.add(key);
+        this.$set(this.selectionRowMap, key, row);
+      });
+      this.$emit("selection-change", Object.values(this.selectionRowMap));
+    },
+    handleSortChange(sort) {
+      this.$emit("sort-change", sort);
+    },
+    handleRowClick(row, column, event) {
+      this.$emit("row-click", row, column, event);
+    },
+    handleLinkClick(row, column) {
+      this.$emit("link-click", row, column);
+    },
+    initSearchAndLoad() {
+      this.$nextTick(() => {
+        if (this.showSearch && this.$refs.searchRef) {
+          this.$emit("search", this.$refs.searchRef.getFormData());
+          return;
+        }
+        if (this.loadData) {
+          this.loadData();
+        }
+      });
+    },
+    getSearchFormData() {
+      return this.$refs.searchRef ? this.$refs.searchRef.getFormData() : {};
+    },
+    setSearchFormData(data) {
+      this.$refs.searchRef && this.$refs.searchRef.setFormData(data);
+    },
+    resetSearchForm() {
+      this.$refs.searchRef && this.$refs.searchRef.resetForm();
+    },
+    validateSearchForm() {
+      return this.$refs.searchRef ? this.$refs.searchRef.validate() : Promise.resolve(true);
+    },
+    getPagination() {
+      return {
+        [this.pageTotalKey]: this.total,
+        [this.pageNumberKey]: this.currentPageModel,
+        [this.pageSizeKey]: this.pageSizeModel
+      };
+    },
+    getSelectionRows() {
+      var _a, _b;
+      return this.currentRowKey ? Object.values(this.selectionRowMap) : ((_b = (_a = this.$refs.tableRef) == null ? void 0 : _a.getSelectionRows) == null ? void 0 : _b.call(_a)) || [];
+    },
+    getSelectionKeys() {
+      var _a, _b;
+      return this.currentRowKey ? Array.from(this.pendingSelectionKeys) : ((_b = (_a = this.$refs.tableRef) == null ? void 0 : _a.getSelectionKeys) == null ? void 0 : _b.call(_a)) || [];
+    },
+    setSelectionRows(rows) {
+      if (!this.currentRowKey) {
+        this.$refs.tableRef && this.$refs.tableRef.setSelectionRows(rows);
+        return;
+      }
+      this.pendingSelectionKeys = /* @__PURE__ */ new Set();
+      this.selectionRowMap = {};
+      (rows || []).forEach((row) => {
+        const key = this.getRowKey(row);
+        this.pendingSelectionKeys.add(key);
+        this.$set(this.selectionRowMap, key, row);
+      });
+      this.syncSelectionToCurrentPage();
+    },
+    setSelectionKeys(keys) {
+      if (!this.currentRowKey) {
+        this.$refs.tableRef && this.$refs.tableRef.setSelectionKeys(keys);
+        return;
+      }
+      this.pendingSelectionKeys = new Set(keys || []);
+      (this.tableData || []).forEach((row) => {
+        const key = this.getRowKey(row);
+        if (this.pendingSelectionKeys.has(key)) {
+          this.$set(this.selectionRowMap, key, row);
+        }
+      });
+      this.syncSelectionToCurrentPage();
+    },
+    clearAllSelection() {
+      this.resetSelectionState();
+    },
+    selectAll() {
+      if (!this.$refs.tableRef)
+        return;
+      if (!this.currentRowKey) {
+        this.$refs.tableRef.selectAll();
+        return;
+      }
+      (this.tableData || []).forEach((row) => {
+        const key = this.getRowKey(row);
+        this.pendingSelectionKeys.add(key);
+        this.$set(this.selectionRowMap, key, row);
+      });
+      this.$refs.tableRef.setSelectionRows(this.tableData);
+    },
+    isRowSelected(row) {
+      var _a, _b;
+      return this.currentRowKey ? this.pendingSelectionKeys.has(this.getRowKey(row)) : (_b = (_a = this.$refs.tableRef) == null ? void 0 : _a.isRowSelected) == null ? void 0 : _b.call(_a, row);
+    },
+    isKeySelected(key) {
+      var _a, _b;
+      return this.currentRowKey ? this.pendingSelectionKeys.has(key) : (_b = (_a = this.$refs.tableRef) == null ? void 0 : _a.isKeySelected) == null ? void 0 : _b.call(_a, key);
+    }
+  }
+};
+var _sfc_render$1 = function render5() {
+  var _vm = this, _c = _vm._self._c;
+  return _c("div", { staticClass: "page-container" }, [_vm.showSearch ? _c("page-search", _vm._b({ ref: "searchRef", attrs: { "items": _vm.searchItems, "external-params": _vm.externalSearchParams, "slot-renderers": _vm.$scopedSlots }, on: { "search": _vm.handleSearch, "reset": _vm.handleReset } }, "page-search", _vm.searchProps, false)) : _vm._e(), _c("page-table", _vm._b({ ref: "tableRef", attrs: { "table-data": _vm.tableData, "columns": _vm.columns, "action-buttons": _vm.actionButtons, "total": _vm.total, "current-page": _vm.currentPageModel, "page-size": _vm.pageSizeModel, "page-number-key": _vm.pageNumberKey, "page-size-key": _vm.pageSizeKey, "page-total-key": _vm.pageTotalKey, "slot-renderers": _vm.$scopedSlots }, on: { "add": _vm.handleAdd, "selection-change": _vm.handleSelectionChange, "sort-change": _vm.handleSortChange, "row-click": _vm.handleRowClick, "size-change": _vm.handleSizeChange, "current-change": _vm.handleCurrentChange, "link-click": _vm.handleLinkClick } }, "page-table", _vm.tableProps, false))], 1);
+};
+var _sfc_staticRenderFns$1 = [];
+var __component__$1 = /* @__PURE__ */ normalizeComponent(
+  _sfc_main$1,
+  _sfc_render$1,
+  _sfc_staticRenderFns$1,
+  false,
+  null,
+  "400797f6",
+  null,
+  null
+);
+const NsTableContainer = __component__$1.exports;
+[NsTableContainer, NsSearch, NsTable].forEach((component) => {
+  component.install = function install3(Vue2) {
+    Vue2.component(component.name, component);
+  };
+});
+const NsDialog_vue_vue_type_style_index_0_scoped_4f4f8603_lang = "";
+const _sfc_main = {
+  name: "NsDialogComponent",
+  props: {
+    className: {
+      type: String,
+      default: ""
+    },
+    title: {
+      type: String,
+      default: ""
+    },
+    width: {
+      type: [Number, String],
+      default: 500
+    },
+    height: {
+      type: [Number, String],
+      default: ""
+    },
+    modal: {
+      type: Boolean,
+      default: true
+    },
+    dialogPadding: {
+      type: [Number, String, Array],
+      default: -1
+    },
+    modalColor: {
+      type: String,
+      default: "rgba(0, 0, 0, 0.45)"
+    },
+    closeOnClickModal: {
+      type: Boolean,
+      default: true
+    },
+    dom: {
+      type: [Object, Function],
+      default: null
+    },
+    option: {
+      type: Object,
+      default: () => ({})
+    },
+    events: {
+      type: Object,
+      default: () => ({})
+    },
+    domCompleted: {
+      type: Function,
+      default: null
+    },
+    headerDom: {
+      type: [Object, Function],
+      default: null
+    },
+    headerOption: {
+      type: Object,
+      default: () => ({})
+    },
+    headerEvents: {
+      type: Object,
+      default: () => ({})
+    },
+    showFooter: {
+      type: Boolean,
+      default: true
+    },
+    footerDom: {
+      type: [Object, Function],
+      default: null
+    },
+    footerOption: {
+      type: Object,
+      default: () => ({})
+    },
+    footerTitle: {
+      type: Object,
+      default: () => ({
+        close: "取消",
+        confirm: "确定"
+      })
+    },
+    footerEvents: {
+      type: Object,
+      default: () => ({})
+    },
+    immediately: {
+      type: Boolean,
+      default: false
+    },
+    close: {
+      type: Function,
+      default: null
+    },
+    closed: {
+      type: Function,
+      default: null
+    },
+    draggable: {
+      type: Boolean,
+      default: false
+    },
+    confirm: {
+      type: Function,
+      default: null
+    },
+    x: {
+      type: [Number, String],
+      default: null
+    },
+    y: {
+      type: [Number, String],
+      default: null
+    },
+    maxSize: {
+      type: Function,
+      default: null
+    },
+    dialogInstance: {
+      type: Object,
+      default: null
+    },
+    containerId: {
+      type: String,
+      default: ""
+    }
+  },
+  data() {
+    return {
+      visible: false,
+      currentTitle: this.title,
+      currentOption: { ...this.option },
+      currentWidth: this.width,
+      currentHeight: this.height,
+      currentX: this.x,
+      currentY: this.y,
+      footerLoading: false,
+      isMaximized: false,
+      originalSize: {
+        width: this.width,
+        height: this.height,
+        x: this.x,
+        y: this.y
+      },
+      dragContext: null,
+      domCompletedCalled: false
+    };
+  },
+  computed: {
+    normalizedWidth() {
+      return this.normalizeSize(this.currentWidth || this.width || 500);
+    },
+    bodyStyle() {
+      const padding = this.resolvePadding();
+      return {
+        padding,
+        minHeight: this.currentHeight ? this.normalizeSize(this.currentHeight) : "auto",
+        maxHeight: this.currentHeight ? this.normalizeSize(this.currentHeight) : "none",
+        overflow: "auto"
+      };
+    },
+    dialogCustomClass() {
+      return ["ns-dialog-plus", this.className, this.hasAbsolutePosition ? "ns-dialog-plus--absolute" : ""].filter(Boolean).join(" ");
+    },
+    modalClassName() {
+      return `ns-dialog-plus-modal ns-dialog-plus-modal--${this.containerId}`;
+    },
+    resolvedDom() {
+      return this.resolveComponent(this.dom);
+    },
+    resolvedHeaderDom() {
+      return this.resolveComponent(this.headerDom);
+    },
+    resolvedFooterDom() {
+      return this.resolveComponent(this.footerDom);
+    },
+    footerButtonText() {
+      var _a, _b;
+      return {
+        close: ((_a = this.footerTitle) == null ? void 0 : _a.close) || "取消",
+        confirm: ((_b = this.footerTitle) == null ? void 0 : _b.confirm) || "确定"
+      };
+    },
+    showMaximizeButton() {
+      return typeof this.maxSize === "function";
+    },
+    hasAbsolutePosition() {
+      return this.currentX !== null || this.currentY !== null;
+    }
+  },
+  watch: {
+    option: {
+      handler(value) {
+        this.currentOption = { ...value };
+      },
+      deep: true
+    },
+    title(value) {
+      this.currentTitle = value;
+    },
+    width(value) {
+      if (!this.isMaximized)
+        this.currentWidth = value;
+    },
+    height(value) {
+      if (!this.isMaximized)
+        this.currentHeight = value;
+    },
+    x(value) {
+      if (!this.isMaximized)
+        this.currentX = value;
+    },
+    y(value) {
+      if (!this.isMaximized)
+        this.currentY = value;
+    },
+    visible() {
+      this.$nextTick(() => {
+        this.applyDialogLayout();
+        this.syncDialogInstance();
+        this.triggerDomCompleted();
+      });
+    }
+  },
+  mounted() {
+    loadCssVars$1();
+    this.visible = true;
+    this.updateModalStyle();
+    this.syncDialogInstance();
+    this.$nextTick(() => {
+      this.applyDialogLayout();
+      this.triggerDomCompleted();
+    });
+    document.addEventListener("keydown", this.handleKeydown);
+  },
+  updated() {
+    this.syncDialogInstance();
+    this.triggerDomCompleted();
+    this.$nextTick(() => {
+      this.applyDialogLayout();
+    });
+  },
+  beforeDestroy() {
+    document.removeEventListener("keydown", this.handleKeydown);
+    this.removeDragListeners();
+    this.removeModalStyle();
+  },
+  methods: {
+    normalizeSize(value) {
+      if (value === null || value === void 0 || value === "")
+        return "";
+      return /^\d+$/.test(String(value)) ? `${value}px` : String(value);
+    },
+    resolvePadding() {
+      if (Array.isArray(this.dialogPadding)) {
+        return this.dialogPadding.map((item) => this.normalizeSize(item)).join(" ");
+      }
+      if (this.dialogPadding === -1 || this.dialogPadding === "-1") {
+        return "16px 20px";
+      }
+      return this.normalizeSize(this.dialogPadding);
+    },
+    resolveComponent(source) {
+      if (!source)
+        return null;
+      if (source.default) {
+        return source.default;
+      }
+      if (typeof source.then === "function") {
+        return () => source;
+      }
+      return source;
+    },
+    mergeEvents(listeners = {}) {
+      return {
+        ...listeners,
+        close: () => this.closeDialog()
+      };
+    },
+    resolveDialogElement() {
+      return this.$el && this.$el.querySelector ? this.$el.querySelector(".el-dialog") : null;
+    },
+    resolveWrapperElement() {
+      return this.$el && this.$el.querySelector ? this.$el.querySelector(".el-dialog__wrapper") : null;
+    },
+    applyDialogLayout() {
+      const dialog = this.resolveDialogElement();
+      if (!dialog)
+        return;
+      if (this.currentHeight) {
+        dialog.style.height = this.normalizeSize(this.currentHeight);
+        dialog.style.display = "flex";
+        dialog.style.flexDirection = "column";
+      } else {
+        dialog.style.height = "";
+      }
+      if (this.hasAbsolutePosition) {
+        dialog.style.position = "fixed";
+        dialog.style.margin = "0";
+        if (this.currentX !== null) {
+          dialog.style.left = this.normalizeSize(this.currentX);
+        }
+        if (this.currentY !== null) {
+          dialog.style.top = this.normalizeSize(this.currentY);
+        }
+      } else {
+        dialog.style.position = "";
+        dialog.style.left = "";
+        dialog.style.top = "";
+      }
+    },
+    updateModalStyle() {
+      if (!this.containerId)
+        return;
+      let styleEl = document.getElementById(`style-${this.containerId}`);
+      if (!styleEl) {
+        styleEl = document.createElement("style");
+        styleEl.id = `style-${this.containerId}`;
+        document.head.appendChild(styleEl);
+      }
+      styleEl.textContent = `.${this.modalClassName.replace(/ /g, ".")} { background-color: ${this.modalColor} !important; }`;
+    },
+    removeModalStyle() {
+      if (!this.containerId)
+        return;
+      const styleEl = document.getElementById(`style-${this.containerId}`);
+      if (styleEl && styleEl.parentNode) {
+        styleEl.parentNode.removeChild(styleEl);
+      }
+    },
+    syncDialogInstance() {
+      if (!this.dialogInstance)
+        return;
+      this.dialogInstance.domRef = this.$refs.contentRef || null;
+      this.dialogInstance.updateOption = (newOption = {}) => {
+        if (Object.prototype.hasOwnProperty.call(newOption, "title")) {
+          this.currentTitle = newOption.title;
+        }
+        if (Object.prototype.hasOwnProperty.call(newOption, "width")) {
+          this.currentWidth = newOption.width;
+        }
+        if (Object.prototype.hasOwnProperty.call(newOption, "height")) {
+          this.currentHeight = newOption.height;
+        }
+        if (Object.prototype.hasOwnProperty.call(newOption, "x")) {
+          this.currentX = newOption.x;
+        }
+        if (Object.prototype.hasOwnProperty.call(newOption, "y")) {
+          this.currentY = newOption.y;
+        }
+        const mergedOption = { ...newOption };
+        delete mergedOption.title;
+        delete mergedOption.width;
+        delete mergedOption.height;
+        delete mergedOption.x;
+        delete mergedOption.y;
+        this.currentOption = {
+          ...this.currentOption,
+          ...mergedOption
+        };
+      };
+      this.dialogInstance.callMethod = (methodName, ...args) => {
+        const target = this.$refs.contentRef;
+        if (target && typeof target[methodName] === "function") {
+          return target[methodName](...args);
+        }
+        return void 0;
+      };
+      this.dialogInstance.close = () => this.closeDialog();
+    },
+    triggerDomCompleted() {
+      if (this.domCompletedCalled)
+        return;
+      if (this.$refs.contentRef) {
+        this.domCompletedCalled = true;
+        if (typeof this.domCompleted === "function") {
+          this.domCompleted(this.$refs.contentRef);
+        }
+      }
+    },
+    toggleMaximize() {
+      if (!this.showMaximizeButton)
+        return;
+      if (!this.isMaximized) {
+        this.originalSize = {
+          width: this.currentWidth,
+          height: this.currentHeight,
+          x: this.currentX,
+          y: this.currentY
+        };
+        const maxConfig = this.maxSize ? this.maxSize() || {} : {};
+        this.currentWidth = maxConfig.width || "100vw";
+        this.currentHeight = maxConfig.height || "100vh";
+        this.currentX = maxConfig.x !== void 0 ? maxConfig.x : 0;
+        this.currentY = maxConfig.y !== void 0 ? maxConfig.y : 0;
+        this.isMaximized = true;
+      } else {
+        this.currentWidth = this.originalSize.width;
+        this.currentHeight = this.originalSize.height;
+        this.currentX = this.originalSize.x;
+        this.currentY = this.originalSize.y;
+        this.isMaximized = false;
+      }
+      this.$nextTick(() => this.applyDialogLayout());
+    },
+    closeDialog() {
+      this.visible = false;
+    },
+    dealClose() {
+      if (typeof this.close === "function") {
+        this.close();
+      }
+    },
+    dealClosed() {
+      if (typeof this.closed === "function") {
+        this.closed();
+      }
+    },
+    dealConfirm() {
+      this.footerLoading = true;
+      if (!this.confirm) {
+        this.footerLoading = false;
+        return;
+      }
+      if (this.immediately) {
+        this.footerLoading = false;
+        this.visible = false;
+        this.confirm(null, this.$refs.contentRef);
+        return;
+      }
+      this.confirm(
+        () => {
+          this.footerLoading = false;
+          this.visible = false;
+          this.$message && this.$message.success && this.$message.success("操作成功");
+        },
+        this.$refs.contentRef,
+        {
+          value: this.footerLoading,
+          set value(nextValue) {
+            this.footerLoading = nextValue;
+          }
+        }
+      );
+    },
+    handleKeydown(event) {
+      if (!this.visible || !this.showFooter)
+        return;
+      if (event.key === "Enter" && !this.footerDom) {
+        event.preventDefault();
+        this.dealConfirm();
+      }
+    },
+    handleDragStart(event) {
+      if (!this.draggable || this.showMaximizeButton || event.button !== 0) {
+        return;
+      }
+      const dialog = this.resolveDialogElement();
+      if (!dialog)
+        return;
+      const rect = dialog.getBoundingClientRect();
+      this.currentX = rect.left;
+      this.currentY = rect.top;
+      this.dragContext = {
+        startX: event.clientX,
+        startY: event.clientY,
+        originX: rect.left,
+        originY: rect.top
+      };
+      document.addEventListener("mousemove", this.handleDragMove);
+      document.addEventListener("mouseup", this.handleDragEnd);
+    },
+    handleDragMove(event) {
+      if (!this.dragContext)
+        return;
+      const deltaX = event.clientX - this.dragContext.startX;
+      const deltaY = event.clientY - this.dragContext.startY;
+      this.currentX = this.dragContext.originX + deltaX;
+      this.currentY = this.dragContext.originY + deltaY;
+      this.applyDialogLayout();
+    },
+    handleDragEnd() {
+      this.removeDragListeners();
+    },
+    removeDragListeners() {
+      document.removeEventListener("mousemove", this.handleDragMove);
+      document.removeEventListener("mouseup", this.handleDragEnd);
+      this.dragContext = null;
+    }
+  }
+};
+var _sfc_render = function render6() {
+  var _vm = this, _c = _vm._self._c;
+  return _c("el-dialog", { attrs: { "visible": _vm.visible, "width": _vm.normalizedWidth, "modal": _vm.modal, "modal-class": _vm.modalClassName, "show-close": false, "append-to-body": false, "close-on-click-modal": _vm.closeOnClickModal, "custom-class": _vm.dialogCustomClass }, on: { "update:visible": function($event) {
+    _vm.visible = $event;
+  }, "close": _vm.dealClose, "closed": _vm.dealClosed } }, [_c("div", { staticClass: "ns-dialog-plus__header", attrs: { "slot": "title" }, on: { "mousedown": _vm.handleDragStart }, slot: "title" }, [_c("div", { staticClass: "ns-dialog-plus__title" }, [_vm.resolvedHeaderDom ? _c(_vm.resolvedHeaderDom, _vm._g(_vm._b({ tag: "component" }, "component", _vm.headerOption, false), _vm.mergeEvents(_vm.headerEvents))) : [_vm._v(_vm._s(_vm.currentTitle))]], 2), _c("div", { staticClass: "ns-dialog-plus__actions" }, [_vm.showMaximizeButton ? _c("el-button", { staticClass: "ns-dialog-plus__action-btn", attrs: { "type": "text" }, on: { "click": function($event) {
+    $event.stopPropagation();
+    return _vm.toggleMaximize.apply(null, arguments);
+  } } }, [_vm._v(" " + _vm._s(_vm.isMaximized ? "还原" : "最大化") + " ")]) : _vm._e(), _c("el-button", { staticClass: "ns-dialog-plus__action-btn", attrs: { "type": "text" }, on: { "click": function($event) {
+    $event.stopPropagation();
+    return _vm.closeDialog.apply(null, arguments);
+  } } }, [_vm._v("关闭")])], 1)]), _c("div", { staticClass: "ns-dialog-plus__body", style: _vm.bodyStyle }, [_c(_vm.resolvedDom, _vm._g(_vm._b({ ref: "contentRef", tag: "component" }, "component", _vm.currentOption, false), _vm.mergeEvents(_vm.events)))], 1), _vm.showFooter ? _c("div", { staticClass: "ns-dialog-plus__footer", attrs: { "slot": "footer" }, slot: "footer" }, [_vm.resolvedFooterDom ? _c(_vm.resolvedFooterDom, _vm._g(_vm._b({ tag: "component" }, "component", _vm.footerOption, false), _vm.mergeEvents(_vm.footerEvents))) : [_c("el-button", { on: { "click": _vm.closeDialog } }, [_vm._v(_vm._s(_vm.footerButtonText.close))]), _c("el-button", { attrs: { "type": "primary", "loading": _vm.footerLoading }, on: { "click": _vm.dealConfirm } }, [_vm._v(_vm._s(_vm.footerButtonText.confirm))])]], 2) : _vm._e()]);
+};
+var _sfc_staticRenderFns = [];
+var __component__ = /* @__PURE__ */ normalizeComponent(
+  _sfc_main,
+  _sfc_render,
+  _sfc_staticRenderFns,
+  false,
+  null,
+  "4f4f8603",
+  null,
+  null
+);
+const NsDialogComponent = __component__.exports;
+const dialogInstances = typeof window !== "undefined" ? window.__dialogInstances = window.__dialogInstances || [] : [];
+let externalVue = Vue;
+let dialogSeed = 0;
+function setExternalApp(app) {
+  if (!app)
+    return;
+  if (app.extend) {
+    externalVue = app;
+    return;
+  }
+  if (app.constructor && app.constructor.extend) {
+    externalVue = app.constructor;
+  }
+}
+function resolveMountTarget(selector) {
+  if (typeof document === "undefined") {
+    return null;
+  }
+  return document.querySelector(selector) || document.body;
+}
+function removeDialogInstance(instance) {
+  const index2 = dialogInstances.findIndex((item) => item.id === instance.id);
+  if (index2 > -1) {
+    dialogInstances.splice(index2, 1);
+  }
+}
+function closeAllNsDialog() {
+  dialogInstances.slice().forEach((instance) => {
+    if (instance && typeof instance.close === "function") {
+      instance.close();
+    }
+  });
+}
+function NsDialog(data, modal = true, appendTo = "#app") {
+  if (!data || !data.dom) {
+    return false;
+  }
+  const mountTarget = resolveMountTarget(appendTo);
+  if (!mountTarget) {
+    return false;
+  }
+  const id = data.id || `ns-dialog-${Date.now()}-${dialogSeed++}`;
+  const container = document.createElement("div");
+  container.id = id;
+  mountTarget.appendChild(container);
+  const instance = {
+    id,
+    class: data.class || "",
+    element: container,
+    vm: null,
+    domRef: null,
+    updateOption: () => {
+    },
+    callMethod: () => {
+    },
+    close: () => {
+    }
+  };
+  const DialogConstructor = (externalVue || Vue).extend(NsDialogComponent);
+  const propsData = {
+    ...data,
+    className: data.class || "",
+    modal,
+    containerId: id,
+    dialogInstance: instance,
+    close: () => {
+      if (typeof data.close === "function") {
+        data.close();
+      }
+    },
+    closed: () => {
+      try {
+        if (typeof data.closed === "function") {
+          data.closed();
+        }
+      } finally {
+        if (instance.vm) {
+          instance.vm.$destroy();
+        }
+        if (container.parentNode) {
+          container.parentNode.removeChild(container);
+        }
+        removeDialogInstance(instance);
+      }
+    }
+  };
+  const vm = new DialogConstructor({ propsData });
+  instance.vm = vm;
+  instance.close = () => {
+    if (vm && typeof vm.closeDialog === "function") {
+      vm.closeDialog();
+    }
+  };
+  dialogInstances.push(instance);
+  vm.$mount(container);
+  return instance;
+}
+const components = [NsForm, NsFormTitle, NsTableContainer, NsSearch, NsTable];
+function install2(Vue2) {
+  if (install2.installed)
+    return;
+  install2.installed = true;
+  registerDirective(Vue2);
+  components.forEach((component) => {
+    if (component && component.name) {
+      Vue2.component(component.name, component);
+    }
+  });
+  setExternalApp(Vue2);
+  loadCssVars$1();
+  if (Vue2 && Vue2.prototype) {
+    Vue2.prototype.$NsDialog = NsDialog;
+    Vue2.prototype.$closeAllNsDialog = closeAllNsDialog;
+  }
+  if (typeof window !== "undefined") {
+    window.NsDialog = NsDialog;
+    window.closeAllNsDialog = closeAllNsDialog;
+  }
+}
+const index = {
+  install: install2,
+  NsForm,
+  NsFormTitle,
+  NsTableContainer,
+  NsSearch,
+  NsTable,
+  NsDialog,
+  closeAllNsDialog,
+  setExternalApp,
+  useFileUpload,
+  getAllFormNodeByKey,
+  getAllFormKvData,
+  getAllFormNodeRefByKey,
+  createPagination,
+  createPaginationWithCustomKeys,
+  resetPagination
+};
+export {
+  NsDialog,
+  NsForm,
+  NsFormTitle,
+  NsSearch,
+  NsTable,
+  NsTableContainer,
+  closeAllNsDialog,
+  createPagination,
+  createPaginationWithCustomKeys,
+  index as default,
+  getAllFormKvData,
+  getAllFormNodeByKey,
+  getAllFormNodeRefByKey,
+  install2 as install,
+  resetPagination,
+  setExternalApp,
+  useFileUpload
+};