@nutui/nutui 4.0.12-beta.1 → 4.0.12

package/dist/packages/_es/index-da0a7662.js

@@ -0,0 +1,259 @@
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+import { c as createComponent } from "./component-81a4c1d0.js";
+import { reactive, computed, watch, watchEffect, toRefs, resolveComponent, openBlock, createBlock, Teleport, mergeProps, createCommentVNode, createVNode, Transition, withCtx, withDirectives, createElementVNode, normalizeClass, normalizeStyle, renderSlot, createElementBlock, vShow } from "vue";
+import Overlay from "./Overlay.js";
+import { Close } from "@nutui/icons-vue";
+import { _ as _export_sfc } from "./_plugin-vue_export-helper-cc2b3d55.js";
+const popupProps = {
+  visible: {
+    type: Boolean,
+    default: false
+  },
+  zIndex: {
+    type: [Number, String],
+    default: 2e3
+  },
+  duration: {
+    type: [Number, String],
+    default: 0.3
+  },
+  lockScroll: {
+    type: Boolean,
+    default: true
+  },
+  closeOnClickOverlay: {
+    type: Boolean,
+    default: true
+  },
+  position: {
+    type: String,
+    default: "center"
+  },
+  transition: {
+    type: String,
+    default: ""
+  },
+  style: {
+    type: Object,
+    default: {}
+  },
+  popClass: {
+    type: String,
+    default: ""
+  },
+  closeable: {
+    type: Boolean,
+    default: false
+  },
+  closeIconPosition: {
+    type: String,
+    default: "top-right"
+  },
+  closeIcon: {
+    type: String,
+    default: "close"
+  },
+  destroyOnClose: {
+    type: Boolean,
+    default: true
+  },
+  teleport: {
+    type: [String, Element],
+    default: "body"
+  },
+  overlay: {
+    type: Boolean,
+    default: true
+  },
+  round: {
+    type: Boolean,
+    default: false
+  },
+  teleportDisable: {
+    type: Boolean,
+    default: false
+  },
+  safeAreaInsetBottom: {
+    type: Boolean,
+    default: false
+  },
+  overlayClass: {
+    type: String,
+    default: ""
+  },
+  overlayStyle: {
+    type: Object,
+    default: {}
+  }
+};
+const initIndex = 2e3;
+let _zIndex = initIndex;
+const component = (componentName2, components) => {
+  return {
+    components,
+    props: __spreadValues({}, popupProps),
+    emits: ["click-pop", "click-close-icon", "open", "close", "opend", "closed", "click-overlay", "update:visible"],
+    setup(props, { emit }) {
+      const state = reactive({
+        zIndex: props.zIndex,
+        showSlot: true,
+        closed: props.closeable
+      });
+      const classes = computed(() => {
+        const prefixCls = componentName2;
+        return {
+          [prefixCls]: true,
+          ["round"]: props.round,
+          [`nut-popup--${props.position}`]: true,
+          [`nut-popup--${props.position}--safebottom`]: props.position === "bottom" && props.safeAreaInsetBottom,
+          [props.popClass]: true
+        };
+      });
+      const popStyle = computed(() => {
+        return __spreadValues({
+          zIndex: state.zIndex,
+          transitionDuration: `${props.duration}s`
+        }, props.style);
+      });
+      const transitionName = computed(() => {
+        return props.transition ? props.transition : `nut-popup-slide-${props.position}`;
+      });
+      const open = () => {
+        if (props.zIndex !== initIndex) {
+          _zIndex = Number(props.zIndex);
+        }
+        emit("update:visible", true);
+        state.zIndex = ++_zIndex;
+        if (props.destroyOnClose) {
+          state.showSlot = true;
+        }
+        emit("open");
+      };
+      const close = () => {
+        emit("update:visible", false);
+        emit("close");
+        if (props.destroyOnClose) {
+          setTimeout(() => {
+            state.showSlot = false;
+          }, +props.duration * 1e3);
+        }
+      };
+      const onClick = (e) => {
+        emit("click-pop", e);
+      };
+      const onClickCloseIcon = (e) => {
+        e.stopPropagation();
+        emit("click-close-icon", e);
+        emit("update:visible", false);
+      };
+      const onClickOverlay = (e) => {
+        emit("click-overlay", e);
+        if (props.closeOnClickOverlay) {
+          emit("update:visible", false);
+        }
+      };
+      const onOpened = (e) => {
+        emit("opend", e);
+      };
+      const onClosed = (e) => {
+        emit("closed", e);
+      };
+      watch(
+        () => props.visible,
+        (val) => {
+          props.visible ? open() : close();
+        }
+      );
+      watchEffect(() => {
+        state.closed = props.closeable;
+      });
+      return __spreadProps(__spreadValues({}, toRefs(state)), {
+        popStyle,
+        transitionName,
+        classes,
+        onClick,
+        onClickCloseIcon,
+        onClickOverlay,
+        onOpened,
+        onClosed
+      });
+    }
+  };
+};
+const { componentName, create } = createComponent("popup");
+const _sfc_main = create(
+  component(componentName, {
+    [Overlay.name]: Overlay,
+    Close
+  })
+);
+function _sfc_render(_ctx, _cache, $props, $setup, $data, $options) {
+  const _component_nut_overlay = resolveComponent("nut-overlay");
+  const _component_Close = resolveComponent("Close");
+  return openBlock(), createBlock(Teleport, {
+    to: _ctx.teleport,
+    disabled: !_ctx.teleportDisable
+  }, [
+    _ctx.overlay ? (openBlock(), createBlock(_component_nut_overlay, mergeProps({
+      key: 0,
+      visible: _ctx.visible,
+      "close-on-click-overlay": _ctx.closeOnClickOverlay,
+      "z-index": _ctx.zIndex,
+      "lock-scroll": _ctx.lockScroll,
+      duration: _ctx.duration,
+      "overlay-class": _ctx.overlayClass,
+      "overlay-style": _ctx.overlayStyle,
+      onClick: _ctx.onClickOverlay
+    }, _ctx.$attrs), null, 16, ["visible", "close-on-click-overlay", "z-index", "lock-scroll", "duration", "overlay-class", "overlay-style", "onClick"])) : createCommentVNode("", true),
+    createVNode(Transition, {
+      name: _ctx.transitionName,
+      onAfterEnter: _ctx.onOpened,
+      onAfterLeave: _ctx.onClosed
+    }, {
+      default: withCtx(() => [
+        withDirectives(createElementVNode("view", {
+          class: normalizeClass(_ctx.classes),
+          style: normalizeStyle(_ctx.popStyle),
+          onClick: _cache[1] || (_cache[1] = (...args) => _ctx.onClick && _ctx.onClick(...args))
+        }, [
+          _ctx.showSlot ? renderSlot(_ctx.$slots, "default", { key: 0 }) : createCommentVNode("", true),
+          _ctx.closed ? (openBlock(), createElementBlock("view", {
+            key: 1,
+            onClick: _cache[0] || (_cache[0] = (...args) => _ctx.onClickCloseIcon && _ctx.onClickCloseIcon(...args)),
+            class: normalizeClass(["nut-popup__close-icon", "nut-popup__close-icon--" + _ctx.closeIconPosition])
+          }, [
+            renderSlot(_ctx.$slots, "close-icon", {}, () => [
+              createVNode(_component_Close, { height: "12px" })
+            ])
+          ], 2)) : createCommentVNode("", true)
+        ], 6), [
+          [vShow, _ctx.visible]
+        ])
+      ]),
+      _: 3
+    }, 8, ["name", "onAfterEnter", "onAfterLeave"])
+  ], 8, ["to", "disabled"]);
+}
+const Popup = /* @__PURE__ */ _export_sfc(_sfc_main, [["render", _sfc_render]]);
+export {
+  Popup as P,
+  popupProps as p
+};

package/dist/packages/_es/index.vue_vue_type_script_lang-22dfc112.js

@@ -0,0 +1,46 @@
+import { provide, readonly, computed, watch, h } from "vue";
+import { c as createComponent } from "./component-81a4c1d0.js";
+const { componentName, create } = createComponent("radio-group");
+const _sfc_main = create({
+  props: {
+    modelValue: {
+      type: [Number, String, Boolean],
+      default: ""
+    },
+    direction: {
+      type: String,
+      default: "vertical"
+      //horizontal
+    },
+    textPosition: {
+      type: String,
+      default: "right"
+    }
+  },
+  emits: ["change", "update:modelValue"],
+  setup(props, { emit, slots }) {
+    const updateValue = (value) => emit("update:modelValue", value);
+    provide("parent", {
+      label: readonly(computed(() => props.modelValue)),
+      position: props.textPosition,
+      updateValue
+    });
+    watch(
+      () => props.modelValue,
+      (value) => emit("change", value)
+    );
+    return () => {
+      var _a;
+      return h(
+        "view",
+        {
+          class: `${componentName} ${componentName}--${props.direction}`
+        },
+        (_a = slots.default) == null ? void 0 : _a.call(slots)
+      );
+    };
+  }
+});
+export {
+  _sfc_main as _
+};

package/dist/packages/_es/index.vue_vue_type_script_lang-a8856969.js

@@ -0,0 +1,97 @@
+import { inject, computed, h } from "vue";
+import { c as createComponent } from "./component-81a4c1d0.js";
+import { CheckNormal, CheckChecked } from "@nutui/icons-vue";
+import { p as pxCheck } from "./pxCheck-c6b9f6b7.js";
+const { componentName, create } = createComponent("radio");
+const _sfc_main = create({
+  components: {
+    CheckNormal,
+    CheckChecked
+  },
+  props: {
+    disabled: {
+      type: Boolean,
+      default: false
+    },
+    shape: {
+      type: String,
+      default: "round"
+      // button
+    },
+    label: {
+      type: [String, Number, Boolean],
+      default: ""
+    },
+    iconSize: {
+      type: [String, Number],
+      default: ""
+    }
+  },
+  setup(props, { emit, slots }) {
+    let parent = inject("parent", null);
+    const isCurValue = computed(() => {
+      return parent.label.value === props.label;
+    });
+    const color = computed(() => {
+      return !props.disabled ? isCurValue.value ? "nut-radio__icon" : "nut-radio__icon--unchecked" : "nut-radio__icon--disable";
+    });
+    const position = computed(() => {
+      return parent.position;
+    });
+    const renderIcon = () => {
+      const { iconSize } = props;
+      const iconNodeMap = {
+        CheckNormal: slots.icon ? slots.icon : CheckNormal,
+        Checked: slots.checkedIcon ? slots.checkedIcon : CheckChecked
+      };
+      const iconNode = !isCurValue.value ? iconNodeMap.CheckNormal : iconNodeMap.Checked;
+      const size = pxCheck(iconSize);
+      return h(iconNode, {
+        width: size,
+        height: size,
+        class: color.value
+      });
+    };
+    const renderLabel = () => {
+      var _a;
+      return h(
+        "view",
+        {
+          class: `${componentName}__label ${props.disabled ? `${componentName}__label--disabled` : ""}`
+        },
+        (_a = slots.default) == null ? void 0 : _a.call(slots)
+      );
+    };
+    const renderButton = () => {
+      var _a;
+      return h(
+        "view",
+        {
+          class: `${componentName}__button ${isCurValue.value && `${componentName}__button--active`} ${props.disabled ? `${componentName}__button--disabled` : ""}`
+        },
+        (_a = slots.default) == null ? void 0 : _a.call(slots)
+      );
+    };
+    const handleClick = () => {
+      if (isCurValue.value || props.disabled)
+        return;
+      parent.updateValue(props.label);
+    };
+    let reverseState = position.value === "left";
+    return () => {
+      return h(
+        "view",
+        {
+          class: `${componentName} ${componentName}--${props.shape} ${reverseState ? `${componentName}--reverse` : ""}`,
+          onClick: handleClick
+        },
+        [
+          props.shape == "button" ? renderButton() : reverseState ? [renderLabel(), renderIcon()] : [renderIcon(), renderLabel()]
+        ]
+      );
+    };
+  }
+});
+export {
+  _sfc_main as _
+};

package/dist/packages/_es/index.vue_vue_type_script_lang-cc5c4086.js

@@ -0,0 +1,151 @@
+import { ref, reactive, computed, watch, onMounted, onUnmounted, h, unref } from "vue";
+import { c as createComponent } from "./component-81a4c1d0.js";
+import { u as useRect } from "./index-29892cda.js";
+const { componentName, create } = createComponent("sticky");
+const _sfc_main = create({
+  props: {
+    position: {
+      type: String,
+      default: "top"
+    },
+    top: {
+      type: [Number, String],
+      default: 0
+    },
+    bottom: {
+      type: [Number, String],
+      default: 0
+    },
+    container: {
+      type: Object
+    },
+    zIndex: {
+      type: [Number, String],
+      default: 2e3
+    }
+  },
+  emits: ["change", "scroll"],
+  setup(props, { emit, slots }) {
+    const root = ref();
+    const state = reactive({
+      width: 0,
+      height: 0,
+      fixed: false,
+      transform: 0
+    });
+    const rootStyle = computed(() => {
+      const { fixed, width, height } = state;
+      if (fixed) {
+        return {
+          width: `${width}px`,
+          height: `${height}px`
+        };
+      }
+    });
+    const stickyStyle = computed(() => {
+      if (!state.fixed)
+        return;
+      const style = {
+        width: `${state.width}px`,
+        height: `${state.height}px`,
+        [props.position]: `${offset.value}px`,
+        zIndex: +props.zIndex
+      };
+      if (state.transform)
+        style.transform = `translate3d(0, ${state.transform}px, 0)`;
+      return style;
+    });
+    const offset = computed(() => {
+      return props.position === "top" ? props.top : props.bottom;
+    });
+    const isHidden = (elementRef) => {
+      const el = unref(elementRef);
+      if (!el)
+        return false;
+      const style = window.getComputedStyle(el);
+      const hidden = style.display === "none";
+      const parentHidden = el.offsetParent === null && style.position !== "fixed";
+      return hidden || parentHidden;
+    };
+    const isExistRoot = () => {
+      if (!root.value || isHidden(root))
+        return false;
+      return true;
+    };
+    const getScrollTop = (el) => {
+      return Math.max(0, "scrollTop" in el ? el.scrollTop : el.pageYOffset);
+    };
+    const renderFixed = () => {
+      var _a;
+      return h(
+        "view",
+        {
+          style: stickyStyle.value,
+          class: state.fixed ? `${componentName} nut-sticky--fixed` : componentName
+        },
+        (_a = slots.default) == null ? void 0 : _a.call(slots)
+      );
+    };
+    const onScroll = () => {
+      if (!isExistRoot())
+        return;
+      const { container, position } = props;
+      const scrollTop = getScrollTop(window);
+      const rootRect = useRect(root);
+      if (rootRect.width || rootRect.height) {
+        state.width = rootRect.width;
+        state.height = rootRect.height;
+      }
+      if (position === "top") {
+        if (container) {
+          const containerRect = useRect(container);
+          const diff = containerRect.bottom - +offset.value - state.height;
+          state.fixed = +offset.value > rootRect.top && containerRect.bottom > 0;
+          state.transform = diff < 0 ? diff : 0;
+        } else {
+          state.fixed = offset.value > rootRect.top;
+        }
+      } else if (position === "bottom") {
+        const clientHeight = document.documentElement.clientHeight;
+        if (container) {
+          const containerRect = useRect(container);
+          const diff = clientHeight - containerRect.top - +offset.value - state.height;
+          state.fixed = clientHeight - +offset.value < rootRect.bottom && clientHeight > containerRect.top;
+          state.transform = diff < 0 ? -diff : 0;
+        } else {
+          state.fixed = clientHeight - +offset.value < rootRect.bottom;
+        }
+      }
+      emit("scroll", {
+        top: scrollTop,
+        fixed: state.fixed
+      });
+    };
+    watch(
+      () => state.fixed,
+      (val) => {
+        emit("change", val);
+      }
+    );
+    onMounted(() => {
+      window.addEventListener("scroll", onScroll);
+      onScroll();
+    });
+    onUnmounted(() => {
+      window.removeEventListener("scroll", onScroll);
+    });
+    return () => {
+      return h(
+        "view",
+        {
+          style: rootStyle.value,
+          ref: root
+        },
+        [renderFixed()]
+      );
+    };
+  }
+});
+export {
+  _sfc_main as _
+};

package/dist/packages/_es/mountComponent-8b24c346.js

@@ -0,0 +1,39 @@
+import { createApp } from "vue";
+import { j as isString, k as isFunction } from "./component-81a4c1d0.js";
+const CreateComponent = (options, component) => {
+  let elWrap = document.body;
+  const teleport = options.teleport || "body";
+  if (teleport != "body") {
+    if (isString(teleport)) {
+      elWrap = document.querySelector(teleport);
+    } else {
+      elWrap = options.teleport;
+    }
+  }
+  const root = document.createElement("view");
+  const name = component.name ? component.name + "-" : "";
+  const id1 = options.id || (/* @__PURE__ */ new Date()).getTime();
+  root.id = name + id1;
+  let Wrapper = {};
+  if (isFunction(component.wrapper)) {
+    Wrapper = component.wrapper(elWrap, root);
+  } else {
+    Wrapper = component.wrapper;
+  }
+  const instance = createApp(Wrapper, options);
+  const componens = component.components;
+  componens && componens.forEach((comp) => {
+    instance.use(comp);
+  });
+  elWrap.appendChild(root);
+  return {
+    instance: instance.mount(root),
+    unmount: () => {
+      instance.unmount();
+      elWrap.removeChild(root);
+    }
+  };
+};
+export {
+  CreateComponent as C
+};

package/dist/packages/_es/pxCheck-c6b9f6b7.js

@@ -0,0 +1,6 @@
+const pxCheck = (value) => {
+  return isNaN(Number(value)) ? String(value) : `${value}px`;
+};
+export {
+  pxCheck as p
+};

package/dist/packages/_es/raf-729dad54.js

@@ -0,0 +1,25 @@
+const _window = window;
+const inBrowser = typeof window !== "undefined";
+function requestAniFrame() {
+  if (typeof _window !== "undefined") {
+    return _window.requestAnimationFrame || _window.webkitRequestAnimationFrame || function(callback) {
+      _window.setTimeout(callback, 1e3 / 60);
+    };
+  } else {
+    return function(callback) {
+      setTimeout(callback, 1e3 / 60);
+    };
+  }
+}
+function cancelRaf(id) {
+  if (inBrowser) {
+    cancelAnimationFrame(id);
+  } else {
+    clearTimeout(id);
+  }
+}
+const requestAniFrame$1 = requestAniFrame();
+export {
+  cancelRaf as c,
+  requestAniFrame$1 as r
+};

package/dist/packages/_es/renderIcon-3d0fd47c.js

@@ -0,0 +1,9 @@
+import { h } from "vue";
+const renderIcon = (icon, props) => {
+  if (icon)
+    return h(icon, props);
+  return "";
+};
+export {
+  renderIcon as r
+};

package/dist/packages/locale/lang/baseLang-3a8457ac.js

@@ -0,0 +1,5 @@
+class BaseLang {
+}
+export {
+  BaseLang as B
+};