@varlet/ui/es/utils/components.mjs

A Vue3 component library based on Material Design 2 and 3, supporting mobile and desktop.

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));
var __async = (__this, __arguments, generator) => {
  return new Promise((resolve, reject) => {
    var fulfilled = (value) => {
      try {
        step(generator.next(value));
      } catch (e) {
        reject(e);
      }
    };
    var rejected = (value) => {
      try {
        step(generator.throw(value));
      } catch (e) {
        reject(e);
      }
    };
    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
    step((generator = generator.apply(__this, __arguments)).next());
  });
};
import {
  Comment,
  createApp,
  defineComponent,
  Fragment,
  h,
  onActivated,
  onDeactivated,
  ref
} from "vue";
import {
  createNamespaceFn,
  hasOwn,
  isArray,
  isFunction,
  isPlainObject,
  isString,
  normalizeToArray
} from "@varlet/shared";
import { useEventListener } from "@varlet/use";
function pickProps(props, propsKey) {
  return isArray(propsKey) ? propsKey.reduce((pickedProps, key) => {
    pickedProps[key] = props[key];
    return pickedProps;
  }, {}) : props[propsKey];
}
function withInstall(component, target) {
  const componentWithInstall = target != null ? target : component;
  componentWithInstall.install = function(app) {
    const { name } = component;
    if (name) {
      app.component(name, component);
    }
  };
  return componentWithInstall;
}
function withPropsDefaultsSetter(target, props) {
  target.setPropsDefaults = function(defaults) {
    Object.entries(defaults).forEach(([key, value]) => {
      const prop = props[key];
      if (prop == null) {
        return;
      }
      if (isPlainObject(prop)) {
        props[key] = __spreadProps(__spreadValues({}, prop), {
          default: value
        });
        return;
      }
      props[key] = {
        type: prop,
        default: value
      };
    });
  };
}
function mount(component) {
  const app = createApp(component);
  const host = document.createElement("div");
  document.body.appendChild(host);
  return {
    instance: app.mount(host),
    unmount() {
      app.unmount();
      if (host.parentNode) {
        document.body.removeChild(host);
      }
    }
  };
}
function mountInstance(component, props = {}, eventListener = {}) {
  const Host = {
    setup() {
      return () => h(component, __spreadValues(__spreadValues({}, props), eventListener));
    }
  };
  const { unmount } = mount(Host);
  return { unmountInstance: unmount };
}
function flatFragment(vNodes) {
  const result = [];
  vNodes.forEach((vNode) => {
    if (vNode.type === Comment) {
      return;
    }
    if (vNode.type === Fragment && isArray(vNode.children)) {
      vNode.children.forEach((item) => {
        result.push(item);
      });
      return;
    }
    result.push(vNode);
  });
  return result;
}
function isZodRule(rule) {
  return isPlainObject(rule) && isFunction(rule.safeParseAsync);
}
function isZodResult(result) {
  return isPlainObject(result) && hasOwn(result, "success");
}
function useValidation() {
  const errorMessage = ref("");
  const validate = (ruleOrRules, value, apis) => __async(this, null, function* () {
    const rules = normalizeToArray(ruleOrRules).filter((rule) => isZodRule(rule) || isFunction(rule));
    const results = yield Promise.all(
      rules.map((rule) => isZodRule(rule) ? rule.safeParseAsync(value) : rule(value, apis))
    );
    resetValidation();
    return !results.some((result) => {
      if (isZodResult(result)) {
        if (result.success === false) {
          errorMessage.value = result.error.issues[0].message;
          return true;
        }
      } else if (result !== true) {
        errorMessage.value = String(result);
        return true;
      }
      return false;
    });
  });
  const resetValidation = () => {
    errorMessage.value = "";
  };
  const validateWithTrigger = (validateTrigger, trigger, rules, value, apis) => __async(this, null, function* () {
    if (validateTrigger.includes(trigger)) {
      ;
      (yield validate(rules, value, apis)) && (errorMessage.value = "");
    }
  });
  return {
    errorMessage,
    validate,
    resetValidation,
    validateWithTrigger
  };
}
function useRouteListener(listener) {
  useEventListener(() => window, "hashchange", listener);
  useEventListener(() => window, "popstate", listener);
}
function useTeleport() {
  const disabled = ref(false);
  onActivated(() => {
    disabled.value = false;
  });
  onDeactivated(() => {
    disabled.value = true;
  });
  return {
    disabled
  };
}
const createNamespace = createNamespaceFn("var");
function defineListenerProp(fallback) {
  return {
    type: [Function, Array],
    default: fallback
  };
}
function formatElevation(elevation, defaultLevel) {
  if (elevation === false) {
    return null;
  }
  if (elevation === true && defaultLevel) {
    elevation = defaultLevel;
  }
  return `var-elevation--${elevation}`;
}
const MaybeVNode = defineComponent({
  props: {
    is: {
      type: [String, Object]
    },
    tag: {
      type: String,
      default: "span"
    }
  },
  setup(props) {
    return () => isString(props.is) ? h(props.tag, props.is) : props.is;
  }
});
export {
  MaybeVNode,
  createNamespace,
  defineListenerProp,
  flatFragment,
  formatElevation,
  isZodResult,
  isZodRule,
  mount,
  mountInstance,
  pickProps,
  useRouteListener,
  useTeleport,
  useValidation,
  withInstall,
  withPropsDefaultsSetter
};