@hoci/core 0.8.0 → 0.9.0

package/dist/index.cjs

@@ -1,1688 +0,0 @@
-'use strict';
-
-const shared = require('@hoci/shared');
-const vue = require('vue');
-const tslx = require('tslx');
-const virtualCore = require('@tanstack/virtual-core');
-
-function tryOnScopeDispose(fn) {
-  if (vue.getCurrentScope()) {
-    vue.onScopeDispose(fn);
-    return true;
-  }
-  return false;
-}
-
-function isDefined(v) {
-  return vue.unref(v) != null;
-}
-
-const isClient = typeof window !== "undefined" && typeof document !== "undefined";
-typeof WorkerGlobalScope !== "undefined" && globalThis instanceof WorkerGlobalScope;
-const isDef = (val) => typeof val !== "undefined";
-const notNullish = (val) => val != null;
-const toString = Object.prototype.toString;
-const isObject = (val) => toString.call(val) === "[object Object]";
-const noop = () => {
-};
-const isIOS = /* @__PURE__ */ getIsIOS();
-function getIsIOS() {
-  var _a, _b;
-  return isClient && ((_a = window == null ? void 0 : window.navigator) == null ? void 0 : _a.userAgent) && (/iP(?:ad|hone|od)/.test(window.navigator.userAgent) || ((_b = window == null ? void 0 : window.navigator) == null ? void 0 : _b.maxTouchPoints) > 2 && /iPad|Macintosh/.test(window == null ? void 0 : window.navigator.userAgent));
-}
-
-function createFilterWrapper(filter, fn) {
-  function wrapper(...args) {
-    return new Promise((resolve, reject) => {
-      Promise.resolve(filter(() => fn.apply(this, args), { fn, thisArg: this, args })).then(resolve).catch(reject);
-    });
-  }
-  return wrapper;
-}
-const bypassFilter = (invoke) => {
-  return invoke();
-};
-function pausableFilter(extendFilter = bypassFilter, options = {}) {
-  const {
-    initialState = "active"
-  } = options;
-  const isActive = toRef(initialState === "active");
-  function pause() {
-    isActive.value = false;
-  }
-  function resume() {
-    isActive.value = true;
-  }
-  const eventFilter = (...args) => {
-    if (isActive.value)
-      extendFilter(...args);
-  };
-  return { isActive: vue.readonly(isActive), pause, resume, eventFilter };
-}
-function getLifeCycleTarget(target) {
-  return vue.getCurrentInstance();
-}
-function toArray(value) {
-  return Array.isArray(value) ? value : [value];
-}
-
-function toRef(...args) {
-  if (args.length !== 1)
-    return vue.toRef(...args);
-  const r = args[0];
-  return typeof r === "function" ? vue.readonly(vue.customRef(() => ({ get: r, set: noop }))) : vue.ref(r);
-}
-
-function watchWithFilter(source, cb, options = {}) {
-  const {
-    eventFilter = bypassFilter,
-    ...watchOptions
-  } = options;
-  return vue.watch(
-    source,
-    createFilterWrapper(
-      eventFilter,
-      cb
-    ),
-    watchOptions
-  );
-}
-
-function watchPausable(source, cb, options = {}) {
-  const {
-    eventFilter: filter,
-    initialState = "active",
-    ...watchOptions
-  } = options;
-  const { eventFilter, pause, resume, isActive } = pausableFilter(filter, { initialState });
-  const stop = watchWithFilter(
-    source,
-    cb,
-    {
-      ...watchOptions,
-      eventFilter
-    }
-  );
-  return { stop, pause, resume, isActive };
-}
-
-function syncRef(left, right, ...[options]) {
-  const {
-    flush = "sync",
-    deep = false,
-    immediate = true,
-    direction = "both",
-    transform = {}
-  } = options || {};
-  const watchers = [];
-  const transformLTR = "ltr" in transform && transform.ltr || ((v) => v);
-  const transformRTL = "rtl" in transform && transform.rtl || ((v) => v);
-  if (direction === "both" || direction === "ltr") {
-    watchers.push(watchPausable(
-      left,
-      (newValue) => {
-        watchers.forEach((w) => w.pause());
-        right.value = transformLTR(newValue);
-        watchers.forEach((w) => w.resume());
-      },
-      { flush, deep, immediate }
-    ));
-  }
-  if (direction === "both" || direction === "rtl") {
-    watchers.push(watchPausable(
-      right,
-      (newValue) => {
-        watchers.forEach((w) => w.pause());
-        left.value = transformRTL(newValue);
-        watchers.forEach((w) => w.resume());
-      },
-      { flush, deep, immediate }
-    ));
-  }
-  const stop = () => {
-    watchers.forEach((w) => w.stop());
-  };
-  return stop;
-}
-
-function tryOnMounted(fn, sync = true, target) {
-  const instance = getLifeCycleTarget();
-  if (instance)
-    vue.onMounted(fn, target);
-  else if (sync)
-    fn();
-  else
-    vue.nextTick(fn);
-}
-
-function watchImmediate(source, cb, options) {
-  return vue.watch(
-    source,
-    cb,
-    {
-      ...options,
-      immediate: true
-    }
-  );
-}
-
-function watchOnce(source, cb, options) {
-  const stop = vue.watch(source, (...args) => {
-    vue.nextTick(() => stop());
-    return cb(...args);
-  }, options);
-  return stop;
-}
-
-const defaultWindow = isClient ? window : void 0;
-
-function unrefElement(elRef) {
-  var _a;
-  const plain = vue.toValue(elRef);
-  return (_a = plain == null ? void 0 : plain.$el) != null ? _a : plain;
-}
-
-function useEventListener(...args) {
-  const cleanups = [];
-  const cleanup = () => {
-    cleanups.forEach((fn) => fn());
-    cleanups.length = 0;
-  };
-  const register = (el, event, listener, options) => {
-    el.addEventListener(event, listener, options);
-    return () => el.removeEventListener(event, listener, options);
-  };
-  const firstParamTargets = vue.computed(() => {
-    const test = toArray(vue.toValue(args[0])).filter((e) => e != null);
-    return test.every((e) => typeof e !== "string") ? test : void 0;
-  });
-  const stopWatch = watchImmediate(
-    () => {
-      var _a, _b;
-      return [
-        (_b = (_a = firstParamTargets.value) == null ? void 0 : _a.map((e) => unrefElement(e))) != null ? _b : [defaultWindow].filter((e) => e != null),
-        toArray(vue.toValue(firstParamTargets.value ? args[1] : args[0])),
-        toArray(vue.unref(firstParamTargets.value ? args[2] : args[1])),
-        // @ts-expect-error - TypeScript gets the correct types, but somehow still complains
-        vue.toValue(firstParamTargets.value ? args[3] : args[2])
-      ];
-    },
-    ([raw_targets, raw_events, raw_listeners, raw_options]) => {
-      cleanup();
-      if (!(raw_targets == null ? void 0 : raw_targets.length) || !(raw_events == null ? void 0 : raw_events.length) || !(raw_listeners == null ? void 0 : raw_listeners.length))
-        return;
-      const optionsClone = isObject(raw_options) ? { ...raw_options } : raw_options;
-      cleanups.push(
-        ...raw_targets.flatMap(
-          (el) => raw_events.flatMap(
-            (event) => raw_listeners.map((listener) => register(el, event, listener, optionsClone))
-          )
-        )
-      );
-    },
-    { flush: "post" }
-  );
-  const stop = () => {
-    stopWatch();
-    cleanup();
-  };
-  tryOnScopeDispose(cleanup);
-  return stop;
-}
-
-let _iOSWorkaround = false;
-function onClickOutside(target, handler, options = {}) {
-  const { window = defaultWindow, ignore = [], capture = true, detectIframe = false, controls = false } = options;
-  if (!window) {
-    return controls ? { stop: noop, cancel: noop, trigger: noop } : noop;
-  }
-  if (isIOS && !_iOSWorkaround) {
-    _iOSWorkaround = true;
-    const listenerOptions = { passive: true };
-    Array.from(window.document.body.children).forEach((el) => useEventListener(el, "click", noop, listenerOptions));
-    useEventListener(window.document.documentElement, "click", noop, listenerOptions);
-  }
-  let shouldListen = true;
-  const shouldIgnore = (event) => {
-    return vue.toValue(ignore).some((target2) => {
-      if (typeof target2 === "string") {
-        return Array.from(window.document.querySelectorAll(target2)).some((el) => el === event.target || event.composedPath().includes(el));
-      } else {
-        const el = unrefElement(target2);
-        return el && (event.target === el || event.composedPath().includes(el));
-      }
-    });
-  };
-  function hasMultipleRoots(target2) {
-    const vm = vue.toValue(target2);
-    return vm && vm.$.subTree.shapeFlag === 16;
-  }
-  function checkMultipleRoots(target2, event) {
-    const vm = vue.toValue(target2);
-    const children = vm.$.subTree && vm.$.subTree.children;
-    if (children == null || !Array.isArray(children))
-      return false;
-    return children.some((child) => child.el === event.target || event.composedPath().includes(child.el));
-  }
-  const listener = (event) => {
-    const el = unrefElement(target);
-    if (event.target == null)
-      return;
-    if (!(el instanceof Element) && hasMultipleRoots(target) && checkMultipleRoots(target, event))
-      return;
-    if (!el || el === event.target || event.composedPath().includes(el))
-      return;
-    if ("detail" in event && event.detail === 0)
-      shouldListen = !shouldIgnore(event);
-    if (!shouldListen) {
-      shouldListen = true;
-      return;
-    }
-    handler(event);
-  };
-  let isProcessingClick = false;
-  const cleanup = [
-    useEventListener(window, "click", (event) => {
-      if (!isProcessingClick) {
-        isProcessingClick = true;
-        setTimeout(() => {
-          isProcessingClick = false;
-        }, 0);
-        listener(event);
-      }
-    }, { passive: true, capture }),
-    useEventListener(window, "pointerdown", (e) => {
-      const el = unrefElement(target);
-      shouldListen = !shouldIgnore(e) && !!(el && !e.composedPath().includes(el));
-    }, { passive: true }),
-    detectIframe && useEventListener(window, "blur", (event) => {
-      setTimeout(() => {
-        var _a;
-        const el = unrefElement(target);
-        if (((_a = window.document.activeElement) == null ? void 0 : _a.tagName) === "IFRAME" && !(el == null ? void 0 : el.contains(window.document.activeElement))) {
-          handler(event);
-        }
-      }, 0);
-    }, { passive: true })
-  ].filter(Boolean);
-  const stop = () => cleanup.forEach((fn) => fn());
-  if (controls) {
-    return {
-      stop,
-      cancel: () => {
-        shouldListen = false;
-      },
-      trigger: (event) => {
-        shouldListen = true;
-        listener(event);
-        shouldListen = false;
-      }
-    };
-  }
-  return stop;
-}
-
-function useMounted() {
-  const isMounted = vue.shallowRef(false);
-  const instance = vue.getCurrentInstance();
-  if (instance) {
-    vue.onMounted(() => {
-      isMounted.value = true;
-    }, instance);
-  }
-  return isMounted;
-}
-
-function useSupported(callback) {
-  const isMounted = useMounted();
-  return vue.computed(() => {
-    isMounted.value;
-    return Boolean(callback());
-  });
-}
-
-function useMutationObserver(target, callback, options = {}) {
-  const { window = defaultWindow, ...mutationOptions } = options;
-  let observer;
-  const isSupported = useSupported(() => window && "MutationObserver" in window);
-  const cleanup = () => {
-    if (observer) {
-      observer.disconnect();
-      observer = void 0;
-    }
-  };
-  const targets = vue.computed(() => {
-    const value = vue.toValue(target);
-    const items = toArray(value).map(unrefElement).filter(notNullish);
-    return new Set(items);
-  });
-  const stopWatch = vue.watch(
-    () => targets.value,
-    (targets2) => {
-      cleanup();
-      if (isSupported.value && targets2.size) {
-        observer = new MutationObserver(callback);
-        targets2.forEach((el) => observer.observe(el, mutationOptions));
-      }
-    },
-    { immediate: true, flush: "post" }
-  );
-  const takeRecords = () => {
-    return observer == null ? void 0 : observer.takeRecords();
-  };
-  const stop = () => {
-    stopWatch();
-    cleanup();
-  };
-  tryOnScopeDispose(stop);
-  return {
-    isSupported,
-    stop,
-    takeRecords
-  };
-}
-
-function cloneFnJSON(source) {
-  return JSON.parse(JSON.stringify(source));
-}
-
-function useResizeObserver(target, callback, options = {}) {
-  const { window = defaultWindow, ...observerOptions } = options;
-  let observer;
-  const isSupported = useSupported(() => window && "ResizeObserver" in window);
-  const cleanup = () => {
-    if (observer) {
-      observer.disconnect();
-      observer = void 0;
-    }
-  };
-  const targets = vue.computed(() => {
-    const _targets = vue.toValue(target);
-    return Array.isArray(_targets) ? _targets.map((el) => unrefElement(el)) : [unrefElement(_targets)];
-  });
-  const stopWatch = vue.watch(
-    targets,
-    (els) => {
-      cleanup();
-      if (isSupported.value && window) {
-        observer = new ResizeObserver(callback);
-        for (const _el of els) {
-          if (_el)
-            observer.observe(_el, observerOptions);
-        }
-      }
-    },
-    { immediate: true, flush: "post" }
-  );
-  const stop = () => {
-    cleanup();
-    stopWatch();
-  };
-  tryOnScopeDispose(stop);
-  return {
-    isSupported,
-    stop
-  };
-}
-
-function useElementBounding(target, options = {}) {
-  const {
-    reset = true,
-    windowResize = true,
-    windowScroll = true,
-    immediate = true,
-    updateTiming = "sync"
-  } = options;
-  const height = vue.shallowRef(0);
-  const bottom = vue.shallowRef(0);
-  const left = vue.shallowRef(0);
-  const right = vue.shallowRef(0);
-  const top = vue.shallowRef(0);
-  const width = vue.shallowRef(0);
-  const x = vue.shallowRef(0);
-  const y = vue.shallowRef(0);
-  function recalculate() {
-    const el = unrefElement(target);
-    if (!el) {
-      if (reset) {
-        height.value = 0;
-        bottom.value = 0;
-        left.value = 0;
-        right.value = 0;
-        top.value = 0;
-        width.value = 0;
-        x.value = 0;
-        y.value = 0;
-      }
-      return;
-    }
-    const rect = el.getBoundingClientRect();
-    height.value = rect.height;
-    bottom.value = rect.bottom;
-    left.value = rect.left;
-    right.value = rect.right;
-    top.value = rect.top;
-    width.value = rect.width;
-    x.value = rect.x;
-    y.value = rect.y;
-  }
-  function update() {
-    if (updateTiming === "sync")
-      recalculate();
-    else if (updateTiming === "next-frame")
-      requestAnimationFrame(() => recalculate());
-  }
-  useResizeObserver(target, update);
-  vue.watch(() => unrefElement(target), (ele) => !ele && update());
-  useMutationObserver(target, update, {
-    attributeFilter: ["style", "class"]
-  });
-  if (windowScroll)
-    useEventListener("scroll", update, { capture: true, passive: true });
-  if (windowResize)
-    useEventListener("resize", update, { passive: true });
-  tryOnMounted(() => {
-    if (immediate)
-      update();
-  });
-  return {
-    height,
-    bottom,
-    left,
-    right,
-    top,
-    width,
-    x,
-    y,
-    update
-  };
-}
-
-function useIntersectionObserver(target, callback, options = {}) {
-  const {
-    root,
-    rootMargin = "0px",
-    threshold = 0,
-    window = defaultWindow,
-    immediate = true
-  } = options;
-  const isSupported = useSupported(() => window && "IntersectionObserver" in window);
-  const targets = vue.computed(() => {
-    const _target = vue.toValue(target);
-    return toArray(_target).map(unrefElement).filter(notNullish);
-  });
-  let cleanup = noop;
-  const isActive = vue.shallowRef(immediate);
-  const stopWatch = isSupported.value ? vue.watch(
-    () => [targets.value, unrefElement(root), isActive.value],
-    ([targets2, root2]) => {
-      cleanup();
-      if (!isActive.value)
-        return;
-      if (!targets2.length)
-        return;
-      const observer = new IntersectionObserver(
-        callback,
-        {
-          root: unrefElement(root2),
-          rootMargin,
-          threshold
-        }
-      );
-      targets2.forEach((el) => el && observer.observe(el));
-      cleanup = () => {
-        observer.disconnect();
-        cleanup = noop;
-      };
-    },
-    { immediate, flush: "post" }
-  ) : noop;
-  const stop = () => {
-    cleanup();
-    stopWatch();
-    isActive.value = false;
-  };
-  tryOnScopeDispose(stop);
-  return {
-    isSupported,
-    isActive,
-    pause() {
-      cleanup();
-      isActive.value = false;
-    },
-    resume() {
-      isActive.value = true;
-    },
-    stop
-  };
-}
-
-function useElementVisibility(element, options = {}) {
-  const {
-    window = defaultWindow,
-    scrollTarget,
-    threshold = 0,
-    rootMargin,
-    once = false
-  } = options;
-  const elementIsVisible = vue.shallowRef(false);
-  const { stop } = useIntersectionObserver(
-    element,
-    (intersectionObserverEntries) => {
-      let isIntersecting = elementIsVisible.value;
-      let latestTime = 0;
-      for (const entry of intersectionObserverEntries) {
-        if (entry.time >= latestTime) {
-          latestTime = entry.time;
-          isIntersecting = entry.isIntersecting;
-        }
-      }
-      elementIsVisible.value = isIntersecting;
-      if (once) {
-        watchOnce(elementIsVisible, () => {
-          stop();
-        });
-      }
-    },
-    {
-      root: scrollTarget,
-      window,
-      threshold,
-      rootMargin: vue.toValue(rootMargin)
-    }
-  );
-  return elementIsVisible;
-}
-
-function useVModel(props, key, emit, options = {}) {
-  var _a, _b, _c;
-  const {
-    clone = false,
-    passive = false,
-    eventName,
-    deep = false,
-    defaultValue,
-    shouldEmit
-  } = options;
-  const vm = vue.getCurrentInstance();
-  const _emit = emit || (vm == null ? void 0 : vm.emit) || ((_a = vm == null ? void 0 : vm.$emit) == null ? void 0 : _a.bind(vm)) || ((_c = (_b = vm == null ? void 0 : vm.proxy) == null ? void 0 : _b.$emit) == null ? void 0 : _c.bind(vm == null ? void 0 : vm.proxy));
-  let event = eventName;
-  if (!key) {
-    key = "modelValue";
-  }
-  event = event || `update:${key.toString()}`;
-  const cloneFn = (val) => !clone ? val : typeof clone === "function" ? clone(val) : cloneFnJSON(val);
-  const getValue = () => isDef(props[key]) ? cloneFn(props[key]) : defaultValue;
-  const triggerEmit = (value) => {
-    if (shouldEmit) {
-      if (shouldEmit(value))
-        _emit(event, value);
-    } else {
-      _emit(event, value);
-    }
-  };
-  if (passive) {
-    const initialValue = getValue();
-    const proxy = vue.ref(initialValue);
-    let isUpdating = false;
-    vue.watch(
-      () => props[key],
-      (v) => {
-        if (!isUpdating) {
-          isUpdating = true;
-          proxy.value = cloneFn(v);
-          vue.nextTick(() => isUpdating = false);
-        }
-      }
-    );
-    vue.watch(
-      proxy,
-      (v) => {
-        if (!isUpdating && (v !== props[key] || deep))
-          triggerEmit(v);
-      },
-      { deep }
-    );
-    return proxy;
-  } else {
-    return vue.computed({
-      get() {
-        return getValue();
-      },
-      set(value) {
-        triggerEmit(value);
-      }
-    });
-  }
-}
-
-const affixProps = shared.defineHookProps(
-  {
-    fixedClass: {
-      type: String,
-      default: ""
-    },
-    /**
-     * @zh 距离窗口顶部达到指定偏移量后触发
-     * @en Triggered when the specified offset is reached from the top of the window
-     */
-    offset: {
-      type: Number,
-      default: 0
-    },
-    /**
-     * @zh 固定的相对方向
-     */
-    position: {
-      type: String,
-      default: "top"
-    },
-    /**
-     * @zh 滚动容器，默认是 `window`
-     * @en Scroll container, default is `window`
-     */
-    target: {
-      type: [String, Object, Function]
-    },
-    /**
-     * @zh z-index 值
-     * @en Z index value
-     */
-    zIndex: {
-      type: Number,
-      default: 998
-    }
-  }
-);
-const affixEmits = shared.defineHookEmits(["scroll", "change"]);
-const AFFIX_TARGET_KEY = Symbol("AFFIX_TARGET_KEY");
-function getTargetRect(target) {
-  return shared.isWindow(target) ? {
-    top: 0,
-    bottom: window.innerHeight
-  } : target.getBoundingClientRect();
-}
-const useAffix = shared.defineHookComponent({
-  props: affixProps,
-  setup(props, { emit }) {
-    const wrapperRef = shared.elementRef();
-    const wrapperRect = shared.toReactive(useElementBounding(wrapperRef));
-    const parentRef = vue.inject(AFFIX_TARGET_KEY, void 0);
-    const targetRef = shared.useElement(props.target, parentRef);
-    const isFixed = vue.ref(false);
-    const placeholderStyle = vue.ref({});
-    const fixedStyle = vue.ref({});
-    const className = vue.computed(() => {
-      return isFixed.value ? props.fixedClass : "";
-    });
-    const wrapperVisible = useElementVisibility(wrapperRef);
-    const containerRef = vue.computed(() => {
-      if (!wrapperVisible.value) {
-        return null;
-      }
-      return targetRef.value ?? window;
-    });
-    const updatePosition = shared.throttleByRaf(async () => {
-      if (!wrapperRef.value || !containerRef.value) {
-        return;
-      }
-      const area = wrapperRect.width * wrapperRect.height;
-      if (area === 0) {
-        return;
-      }
-      const newPlaceholderStyles = {
-        width: tslx.px(wrapperRect.width),
-        height: tslx.px(wrapperRect.height)
-      };
-      const targetRect = getTargetRect(containerRef.value);
-      let newIsFixed = false;
-      let newFixedStyles = {};
-      const offset = props.offset;
-      if (props.position === "top") {
-        newIsFixed = wrapperRect.top - targetRect.top < offset && offset >= 0;
-        newFixedStyles = newIsFixed ? {
-          position: "fixed",
-          zIndex: props.zIndex,
-          top: tslx.px(targetRect.top + offset)
-        } : {};
-      } else {
-        newIsFixed = targetRect.bottom - wrapperRect.bottom < offset;
-        newFixedStyles = newIsFixed ? {
-          position: "fixed",
-          bottom: tslx.px(window.innerHeight - targetRect.bottom + offset)
-        } : {};
-      }
-      if (newIsFixed !== isFixed.value) {
-        isFixed.value = newIsFixed;
-        emit("change", newIsFixed);
-      }
-      placeholderStyle.value = newPlaceholderStyles;
-      fixedStyle.value = {
-        ...newFixedStyles,
-        ...newIsFixed ? newPlaceholderStyles : {}
-      };
-    });
-    useEventListener(containerRef, "scroll", () => {
-      emit("scroll");
-      updatePosition();
-    });
-    useEventListener(containerRef, "resize", updatePosition);
-    vue.watchPostEffect(updatePosition);
-    return {
-      className,
-      wrapperRef,
-      containerRef,
-      isFixed,
-      placeholderStyle,
-      fixedStyle,
-      updatePosition
-    };
-  }
-});
-function provideAffixTarget(target) {
-  vue.provide(AFFIX_TARGET_KEY, target);
-}
-
-const configProviderProps = shared.defineHookProps({
-  icon: {
-    type: Object
-  },
-  activateEvent: {
-    type: String
-  }
-});
-
-const fileUploadProps = shared.defineHookProps({
-  modelValue: {
-    type: [File, Array],
-    default: () => []
-  },
-  multiple: {
-    type: Boolean,
-    default: false
-  }
-});
-const fileUploadEmits = shared.defineHookEmits([
-  "update:modelValue",
-  "change"
-]);
-const useFileUpload = shared.defineHookComponent({
-  props: fileUploadProps,
-  emits: fileUploadEmits,
-  setup(props, { emit }) {
-    const fileInputRef = shared.elementRef();
-    const files = vue.ref([]);
-    vue.watch(() => shared.toArray(props.modelValue), (value) => {
-      files.value = value;
-    }, {
-      immediate: true,
-      deep: true
-    });
-    const openFileInput = () => {
-      fileInputRef.value?.click();
-    };
-    const toModelValue = (files2) => {
-      if (props.multiple) {
-        return files2;
-      }
-      if (files2.length) {
-        return files2[files2.length - 1];
-      }
-      return null;
-    };
-    useEventListener(fileInputRef, "change", (event) => {
-      const newFiles = Array.from(event.target.files ?? []);
-      if (newFiles?.length) {
-        if (props.multiple) {
-          files.value.push(...newFiles);
-        } else {
-          files.value = newFiles.slice(newFiles.length - 1);
-        }
-      }
-      const value = toModelValue(files.value);
-      emit("update:modelValue", value);
-      emit("change", value);
-    });
-    return {
-      fileInputRef,
-      files,
-      openFileInput
-    };
-  }
-});
-
-const iconProps = shared.defineHookProps({
-  src: {
-    type: String,
-    required: true
-  },
-  size: {
-    type: [Number, String]
-  },
-  width: {
-    type: [Number, String]
-  },
-  height: {
-    type: [Number, String]
-  },
-  color: {
-    type: String,
-    default: "currentColor"
-  },
-  mask: {
-    type: [Boolean, String],
-    default: () => "auto"
-  }
-});
-const isSvg = (src) => src.endsWith(".svg") || src.startsWith("data:image/svg+xml");
-const useIcon = shared.defineHookComponent({
-  props: iconProps,
-  setup(props, context) {
-    const sharedConfig = shared.useSharedConfig("icon");
-    const sizeStyle = vue.computed(() => {
-      const s = props.size ?? sharedConfig.size;
-      const unit = tslx.createUnitFormat(sharedConfig.sizeUnit ?? "px");
-      const size = s ? unit(s) : void 0;
-      const w = props.width ?? size;
-      const h = props.height ?? size;
-      const width = w ? unit(w) : void 0;
-      const height = h ? unit(h) : void 0;
-      return {
-        width,
-        height
-      };
-    });
-    const dynamicStyle = vue.computed(() => {
-      const mask = props.mask === "auto" ? isSvg(props.src) : props.mask;
-      if (!mask) {
-        return {
-          "background-image": "var(--icon-url)",
-          "background-size": "100% 100%"
-        };
-      }
-      return {
-        "mask": "var(--icon-url) no-repeat",
-        "mask-size": "100% 100%",
-        "-webkit-mask": "var(--icon-url) no-repeat",
-        "-webkit-mask-size": "100% 100%",
-        "background-color": props.color
-      };
-    });
-    const staticStyle = vue.computed(() => {
-      return {
-        "--icon-url": `url("${props.src}")`
-      };
-    });
-    const style = vue.computed(() => {
-      return {
-        ...staticStyle.value,
-        ...dynamicStyle.value,
-        ...sizeStyle.value,
-        ...context.attrs.style ?? {}
-      };
-    });
-    return {
-      style
-    };
-  }
-});
-
-const selectionProps = shared.defineHookProps({
-  modelValue: {
-    type: shared.valuePropType,
-    default: () => null
-  },
-  /**
-   * 选中时的 class
-   */
-  activeClass: {
-    type: shared.classPropType,
-    default: "active"
-  },
-  /**
-   *  每个选项的 class
-   */
-  itemClass: {
-    type: shared.classPropType,
-    default: ""
-  },
-  disabledClass: {
-    type: shared.classPropType,
-    default: "disabled"
-  },
-  unactiveClass: {
-    type: shared.classPropType,
-    default: ""
-  },
-  label: {
-    type: shared.labelPropType
-  },
-  /**
-   *  多选模式
-   */
-  multiple: {
-    type: [Boolean, Number, Array],
-    default: () => false
-  },
-  /**
-   * 可清除
-   */
-  clearable: {
-    type: Boolean
-  },
-  defaultValue: {
-    type: shared.valuePropType,
-    default: () => null
-  },
-  activateEvent: {
-    type: String
-  }
-});
-const selectionEmits = shared.defineHookEmits([
-  "update:modelValue",
-  "change",
-  "load",
-  "unload",
-  "reject"
-]);
-const HiSelectionContextSymbol = Symbol("[hi-selection]context");
-function useSelectionContext() {
-  const sharedConfig = shared.useSharedConfig();
-  return vue.inject(HiSelectionContextSymbol, {
-    isActive: () => false,
-    activate: () => {
-    },
-    changeActive: () => {
-    },
-    reject: () => {
-    },
-    activeClass: "active",
-    unactiveClass: "unactive",
-    disabledClass: "disabled",
-    itemClass: "",
-    activateEvent: sharedConfig.activateEvent,
-    label: null,
-    multiple: false,
-    limit: [0, Number.POSITIVE_INFINITY]
-  });
-}
-const useSelectionList = shared.defineHookComponent({
-  props: selectionProps,
-  emits: selectionEmits,
-  setup(props, { emit, slots }) {
-    const options = vue.reactive([]);
-    function toArray(value) {
-      if (!isDefined(value)) {
-        return [];
-      }
-      if (props.multiple && Array.isArray(value)) {
-        return value.filter((v) => v != null || v !== void 0);
-      }
-      return [value];
-    }
-    const actives = vue.reactive([
-      ...toArray(props.modelValue ?? props.defaultValue)
-    ]);
-    const currentValue = vue.computed({
-      get() {
-        return props.multiple ? actives : actives[0];
-      },
-      set(val) {
-        actives.splice(0, actives.length, ...toArray(val));
-      }
-    });
-    const modelValue = vue.computed({
-      get() {
-        return props.modelValue ?? props.defaultValue;
-      },
-      set(val) {
-        emit("update:modelValue", val);
-      }
-    });
-    syncRef(currentValue, modelValue, { immediate: true, deep: true });
-    const emitChange = () => emit("change", currentValue.value);
-    function isActive(value) {
-      return actives.includes(value);
-    }
-    const multipleActive = vue.computed(() => !!props.multiple);
-    const multipleLimit = vue.computed(() => {
-      if (Array.isArray(props.multiple)) {
-        if (props.multiple[1] === void 0) {
-          return [props.multiple[0], Number.POSITIVE_INFINITY];
-        }
-        return props.multiple;
-      }
-      return [0, Number.POSITIVE_INFINITY];
-    });
-    function activate(value) {
-      const [min, max] = multipleLimit.value;
-      if (isActive(value)) {
-        if (multipleActive.value && actives.length > min || props.clearable) {
-          actives.splice(actives.indexOf(value), 1);
-          emitChange();
-        }
-      } else {
-        if (props.multiple) {
-          if (actives.length < max) {
-            actives.push(value);
-            emitChange();
-          }
-        } else {
-          actives.splice(0, actives.length, value);
-          emitChange();
-        }
-      }
-    }
-    function reject(value) {
-      emit("reject", value);
-    }
-    const init = (option) => {
-      function remove() {
-        const index = options.findIndex((e) => e.id === option.id);
-        if (index > -1) {
-          options.splice(index, 1);
-          emit("unload", option);
-        }
-      }
-      for (let i = 0; i < options.length; i++) {
-        if (options[i].value === option.value) {
-          options.splice(i, 1);
-          i--;
-        }
-      }
-      options.push(option);
-      emit("load", option);
-      return remove;
-    };
-    const sharedConfig = shared.useSharedConfig();
-    vue.provide(HiSelectionContextSymbol, shared.toReactive({
-      activeClass: vue.computed(() => tslx.cls(props.activeClass)),
-      unactiveClass: vue.computed(() => tslx.cls(props.unactiveClass)),
-      disabledClass: vue.computed(() => tslx.cls(props.disabledClass)),
-      itemClass: vue.computed(() => tslx.cls(props.itemClass)),
-      label: vue.computed(() => props.label),
-      multiple: multipleActive,
-      limit: multipleLimit,
-      clearable: vue.computed(() => props.clearable),
-      defaultValue: vue.computed(() => props.defaultValue),
-      activateEvent: vue.computed(() => props.activateEvent ?? sharedConfig.activateEvent),
-      active: currentValue,
-      activate,
-      changeActive: activate,
-      isActive,
-      reject,
-      init
-    }));
-    const renderItem = () => {
-      const children = options.filter((e) => actives.includes(e.value)).map((e) => e.render());
-      return props.multiple ? children : shared.getFirstChilld(children);
-    };
-    const slotData = {
-      isActive,
-      changeActive: activate,
-      renderItem
-    };
-    const render = () => {
-      return vue.renderSlot(slots, "default", slotData);
-    };
-    return {
-      options,
-      actives,
-      isActive,
-      changeActive: activate,
-      renderItem,
-      render
-    };
-  }
-});
-
-const itemProps = shared.defineHookProps({
-  value: {
-    type: shared.valuePropType,
-    default() {
-      return Math.random().toString(16).slice(2);
-    }
-  },
-  label: {
-    type: [Function, String]
-  },
-  keepAlive: {
-    type: Boolean,
-    default: () => true
-  },
-  activateEvent: {
-    type: String
-  },
-  disabled: {
-    type: Boolean,
-    default: false
-  }
-});
-const itemEmits = shared.defineHookEmits(["reject"]);
-const useSelectionItem = shared.defineHookComponent({
-  props: itemProps,
-  emits: itemEmits,
-  setup(props, { slots, emit }) {
-    const context = useSelectionContext();
-    const activate = () => {
-      if (props.disabled) {
-        emit("reject", props.value);
-        context.reject(props.value);
-        return;
-      }
-      context.activate(props.value);
-    };
-    const label = vue.computed(() => {
-      let label2 = props.label ?? context.label;
-      if (label2 && typeof label2 === "function") {
-        label2 = label2(props.value);
-      }
-      return Array.isArray(label2) ? label2 : [label2];
-    });
-    function render() {
-      return slots.default?.({
-        active: context.isActive(props.value),
-        activate
-      }) ?? label.value.filter(Boolean);
-    }
-    let remove = () => {
-    };
-    const init = context.init;
-    if (init) {
-      vue.watch(
-        () => props.value,
-        (value) => {
-          remove();
-          remove = init({
-            id: Math.random().toString(16).slice(2),
-            label: typeof props.label === "string" ? props.label : void 0,
-            value,
-            render
-          });
-        },
-        { immediate: true }
-      );
-      tryOnScopeDispose(remove);
-    }
-    const isActive = vue.computed(() => context.isActive(props.value));
-    const isDisabled = vue.computed(() => props.disabled);
-    const className = vue.computed(() => {
-      const array = [context.itemClass];
-      if (!isDisabled.value) {
-        array.push(context.isActive(props.value) ? context.activeClass : context.unactiveClass);
-      } else {
-        array.push(context.disabledClass);
-      }
-      return tslx.cls(array);
-    });
-    const activateEvent = vue.computed(() => props.activateEvent ?? context.activateEvent);
-    return {
-      activate,
-      render,
-      isActive,
-      isDisabled,
-      className,
-      activateEvent,
-      label
-    };
-  }
-});
-
-const popoverProps = shared.defineHookProps({
-  popupClass: {
-    type: String
-  },
-  placement: {
-    type: String,
-    default: () => "auto"
-  },
-  triggerEvent: {
-    type: String,
-    default: () => "hover"
-  },
-  offset: {
-    type: Number,
-    default: () => 8
-  },
-  lazy: {
-    type: Boolean,
-    default: () => false
-  },
-  visible: {
-    type: Boolean,
-    default: () => false
-  },
-  disabled: {
-    type: Boolean,
-    default: () => false
-  },
-  teleport: {
-    type: [String, Object, Boolean],
-    default: () => true
-  }
-});
-const popoverEmits = shared.defineHookEmits(["update:visible", "change"]);
-const usePopover = shared.defineHookComponent({
-  props: popoverProps,
-  emits: popoverEmits,
-  setup(props, context) {
-    const visible = useVModel(props, "visible", context.emit, {
-      passive: true
-    });
-    const triggerRef = shared.elementRef();
-    const popupRef = shared.elementRef();
-    const validate = (event) => {
-      const events2 = Array.isArray(event) ? event : [event];
-      return !props.disabled && events2.includes(props.triggerEvent);
-    };
-    let timer;
-    const toggle = (_value) => {
-      const value = _value ?? !visible.value;
-      visible.value = value;
-      context.emit("change", value);
-    };
-    function onMouseover() {
-      if (!validate("hover")) {
-        return;
-      }
-      timer = setTimeout(
-        () => {
-          toggle(true);
-        },
-        props.lazy ? 800 : 100
-      );
-    }
-    function onMouseout() {
-      if (!validate("hover")) {
-        return;
-      }
-      clearTimeout(timer);
-      toggle(false);
-    }
-    const onClick = (e) => {
-      if (!validate("click")) {
-        return;
-      }
-      e.preventDefault();
-      e.stopPropagation();
-      toggle();
-    };
-    onClickOutside(triggerRef, () => {
-      if (!validate(["click", "contextmenu", "touch", "dblclick", "mousedown"])) {
-        return;
-      }
-      toggle(false);
-    }, {
-      ignore: [popupRef]
-    });
-    const onContextmenu = (e) => {
-      if (!validate("contextmenu")) {
-        return;
-      }
-      e.preventDefault();
-      e.stopPropagation();
-      toggle();
-    };
-    const onFocusin = () => {
-      if (!validate("focus")) {
-        return;
-      }
-      toggle(true);
-    };
-    const onFocusout = () => {
-      if (!validate("focus")) {
-        return;
-      }
-      toggle(false);
-    };
-    const onTouchend = () => {
-      if (!validate("touch")) {
-        return;
-      }
-      toggle(true);
-    };
-    const onDblclick = () => {
-      if (!validate("dblclick")) {
-        return;
-      }
-      toggle(true);
-    };
-    const onMousedown = () => {
-      if (!validate("mousedown")) {
-        return;
-      }
-      toggle(true);
-    };
-    const onMouseup = () => {
-      if (!validate("mousedown")) {
-        return;
-      }
-      toggle(false);
-    };
-    const events = {
-      onMouseover,
-      onMouseout,
-      onMousedown,
-      onMouseup,
-      onContextmenu,
-      onClick,
-      onDblclick,
-      onFocusin,
-      onFocusout,
-      onTouchend
-    };
-    const dropdownPosition = vue.reactive({ x: 0, y: 0 });
-    const popupClass = vue.computed(() => {
-      return props.popupClass;
-    });
-    function resize() {
-      const trigger = triggerRef.value;
-      const popup = popupRef.value;
-      if (!!trigger && !!popup && visible.value) {
-        const { width, height, left, top } = trigger.getBoundingClientRect();
-        const { clientWidth: pWidth, clientHeight: pHeight } = popup;
-        let x = 0;
-        let y = 0;
-        const offset = props.offset;
-        switch (props.placement) {
-          case "auto":
-          case "bottom":
-            x = left - (pWidth - width) / 2;
-            y = top + height + offset;
-            break;
-          case "bottom-left":
-            x = left;
-            y = top + height + offset;
-            break;
-          case "bottom-right":
-            x = left + width - pWidth;
-            y = top + height + offset;
-            break;
-          case "top":
-            x = left - (pWidth - width) / 2;
-            y = top - pHeight - offset;
-            break;
-          case "top-left":
-            x = left;
-            y = top - pHeight - offset;
-            break;
-          case "top-right":
-            x = left + width - pWidth;
-            y = top - pHeight - offset;
-            break;
-          case "left":
-            x = left - pWidth - offset;
-            y = top - (pHeight - height) / 2;
-            break;
-          case "left-top":
-            x = left - pWidth - offset;
-            y = top;
-            break;
-          case "left-bottom":
-            x = left - pWidth - offset;
-            y = top + height - pHeight;
-            break;
-          case "right":
-            x = left + width + offset;
-            y = top - (pHeight - height) / 2;
-            break;
-          case "right-top":
-            x = left + width + offset;
-            y = top;
-            break;
-          case "right-bottom":
-            x = left + width + offset;
-            y = top + height - pHeight;
-            break;
-        }
-        dropdownPosition.x = x;
-        dropdownPosition.y = y;
-      }
-    }
-    vue.watch(visible, () => {
-      vue.nextTick(resize);
-    });
-    const popupStyle = vue.computed(() => {
-      return {
-        left: tslx.px(dropdownPosition.x),
-        top: tslx.px(dropdownPosition.y),
-        visibility: visible.value ? "visible" : "hidden",
-        position: "fixed"
-      };
-    });
-    return {
-      events,
-      dropdownPosition,
-      triggerRef,
-      popupRef,
-      popupClass,
-      popupStyle
-    };
-  }
-});
-
-const switchProps = shared.defineHookProps({
-  modelValue: {
-    type: Boolean,
-    default: () => false
-  },
-  class: {
-    type: shared.classPropType
-  },
-  activeClass: {
-    type: shared.classPropType
-  },
-  unactiveClass: {
-    type: shared.classPropType
-  },
-  activateEvent: {
-    type: String
-  },
-  disabled: {
-    type: Boolean,
-    default: () => false
-  },
-  disabledClass: {
-    type: shared.classPropType
-  }
-});
-const switchEmits = shared.defineHookEmits(["update:modelValue", "change", "reject"]);
-const useSwitch = shared.defineHookComponent({
-  props: switchProps,
-  emits: switchEmits,
-  setup(props, context) {
-    const modelValue = useVModel(props, "modelValue", context.emit, {
-      passive: true,
-      defaultValue: false
-    });
-    const toggle = function(value) {
-      if (props.disabled) {
-        context.emit("reject", value);
-        return;
-      }
-      const oldValue = modelValue.value;
-      const newValue = typeof value === "boolean" ? value : !oldValue;
-      if (newValue !== oldValue) {
-        modelValue.value = newValue;
-        context.emit("change", newValue);
-      }
-    };
-    const isDisabled = vue.computed(() => props.disabled);
-    const className = vue.computed(() => {
-      return tslx.cls([
-        props.class,
-        modelValue.value ? props.activeClass : props.unactiveClass,
-        isDisabled.value ? props.disabledClass : ""
-      ]);
-    });
-    const sharedConfig = shared.useSharedConfig();
-    const activateEvent = vue.computed(() => props.activateEvent ?? sharedConfig.activateEvent);
-    return {
-      toggle,
-      modelValue,
-      className,
-      isDisabled,
-      activateEvent
-    };
-  }
-});
-
-const virtualListProps = shared.defineHookProps({
-  options: {
-    type: Object,
-    default: () => ({})
-  },
-  count: {
-    type: Number,
-    default: () => 0
-  },
-  estimateSize: {
-    type: [Function, Number],
-    default: () => 50
-  },
-  horizontal: {
-    type: Boolean,
-    default: () => false
-  }
-});
-const virtualListEmits = shared.defineHookEmits({
-  scrollEnd: () => true,
-  scrollStart: () => true,
-  scroll: (_) => true
-});
-const useVirtualList = shared.defineHookComponent({
-  props: virtualListProps,
-  emits: virtualListEmits,
-  setup(props, context) {
-    const { emit } = context;
-    const scrollElementRef = shared.elementRef();
-    const propsEstimateSize = props.estimateSize;
-    const estimateSize = typeof propsEstimateSize === "function" ? propsEstimateSize : () => propsEstimateSize;
-    const options = vue.computed(() => {
-      const opts = { ...props.options || {} };
-      return {
-        ...opts,
-        count: props.count,
-        estimateSize,
-        horizontal: props.horizontal,
-        getScrollElement: () => scrollElementRef.value,
-        observeElementRect: virtualCore.observeElementRect,
-        observeElementOffset: virtualCore.observeElementOffset,
-        scrollToFn: virtualCore.elementScroll
-      };
-    });
-    const virtualizer = new virtualCore.Virtualizer(options.value);
-    const state = vue.shallowRef(virtualizer);
-    const virtualItems = vue.computed(() => state.value.getVirtualItems());
-    const virtualIndexes = vue.computed(() => state.value.getVirtualIndexes());
-    const totalSize = vue.computed(() => state.value.getTotalSize());
-    vue.watch(
-      virtualIndexes,
-      (indexes) => {
-        if (indexes.length === 0) {
-          return;
-        }
-        if (indexes[indexes.length - 1] === props.count - 1) {
-          emit("scrollEnd");
-        } else if (indexes[0] === 0) {
-          emit("scrollStart");
-        }
-        emit("scroll", indexes);
-      },
-      { immediate: true }
-    );
-    vue.watch(
-      options,
-      (opts) => {
-        virtualizer.setOptions({
-          ...opts,
-          onChange: (instance, sync) => {
-            opts.onChange?.(instance, sync);
-            vue.triggerRef(state);
-          }
-        });
-        virtualizer._willUpdate();
-        vue.triggerRef(state);
-      },
-      { immediate: true }
-    );
-    vue.watch(
-      scrollElementRef,
-      (el) => {
-        if (el) {
-          virtualizer._willUpdate();
-          vue.triggerRef(state);
-        }
-      },
-      { immediate: true }
-    );
-    tryOnScopeDispose(virtualizer._didMount());
-    const measureElement = (el) => {
-      virtualizer.measureElement(el);
-    };
-    const scrollToIndex = (index, options2 = {
-      behavior: "smooth"
-    }) => {
-      virtualizer.scrollToIndex(index, options2);
-    };
-    const scrollToStart = (options2 = {
-      behavior: "smooth"
-    }) => {
-      scrollToIndex(0, options2);
-    };
-    const scrollToEnd = (options2 = {
-      behavior: "smooth"
-    }) => {
-      scrollToIndex(props.count - 1, options2);
-    };
-    return {
-      virtualizer,
-      virtualItems,
-      virtualIndexes,
-      totalSize,
-      scrollElementRef,
-      measureElement,
-      scrollToIndex,
-      scrollToStart,
-      scrollToEnd
-    };
-  }
-});
-
-exports.AFFIX_TARGET_KEY = AFFIX_TARGET_KEY;
-exports.affixEmits = affixEmits;
-exports.affixProps = affixProps;
-exports.configProviderProps = configProviderProps;
-exports.fileUploadEmits = fileUploadEmits;
-exports.fileUploadProps = fileUploadProps;
-exports.iconProps = iconProps;
-exports.itemEmits = itemEmits;
-exports.itemProps = itemProps;
-exports.popoverEmits = popoverEmits;
-exports.popoverProps = popoverProps;
-exports.provideAffixTarget = provideAffixTarget;
-exports.selectionEmits = selectionEmits;
-exports.selectionProps = selectionProps;
-exports.switchEmits = switchEmits;
-exports.switchProps = switchProps;
-exports.useAffix = useAffix;
-exports.useFileUpload = useFileUpload;
-exports.useIcon = useIcon;
-exports.usePopover = usePopover;
-exports.useSelectionContext = useSelectionContext;
-exports.useSelectionItem = useSelectionItem;
-exports.useSelectionList = useSelectionList;
-exports.useSwitch = useSwitch;
-exports.useVirtualList = useVirtualList;
-exports.virtualListEmits = virtualListEmits;
-exports.virtualListProps = virtualListProps;
-Object.prototype.hasOwnProperty.call(shared, '__proto__') &&
-  !Object.prototype.hasOwnProperty.call(exports, '__proto__') &&
-  Object.defineProperty(exports, '__proto__', {
-    enumerable: true,
-    value: shared['__proto__']
-  });
-
-Object.keys(shared).forEach(function (k) {
-  if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) exports[k] = shared[k];
-});