maz-ui 4.0.0-alpha.5 → 4.0.0-beta.1

package/dist/chunks/throttle.DN8ARw0a.js

@@ -0,0 +1,11 @@
+function throttle(func, limit) {
+  let inThrottle = !1, lastFunc, lastRan;
+  return function(...args) {
+    inThrottle ? (clearTimeout(lastFunc), lastFunc = setTimeout(() => {
+      Date.now() - lastRan >= limit && (func.apply(this, args), lastRan = Date.now());
+    }, Math.max(limit - (Date.now() - lastRan), 0))) : (func.apply(this, args), lastRan = Date.now(), inThrottle = !0);
+  };
+}
+export {
+  throttle as t
+};

package/dist/chunks/throttleId.7PhWZjcS.js

@@ -0,0 +1,62 @@
+function debounceId(identifier, func, delay) {
+  const debouncedFunctions = {};
+  return function(...args) {
+    debouncedFunctions[identifier] || (debouncedFunctions[identifier] = { timer: null, promise: null });
+    const debounced = debouncedFunctions[identifier];
+    return debounced.timer && clearTimeout(debounced.timer), debounced.promise = new Promise((resolve, reject) => {
+      debounced.timer = setTimeout(async () => {
+        try {
+          resolve(await func(...args));
+        } catch (error) {
+          reject(error);
+        } finally {
+          delete debouncedFunctions[identifier];
+        }
+      }, delay);
+    }), debounced.promise;
+  };
+}
+function isPrimitive(value) {
+  return value == null || typeof value == "string" || typeof value == "number" || typeof value == "boolean" || typeof value == "symbol" || typeof value == "bigint";
+}
+function isEqualArrays(a, b) {
+  if (a.length !== b.length)
+    return !1;
+  for (const [i, element] of a.entries())
+    if (!isEqual(element, b[i]))
+      return !1;
+  return !0;
+}
+function isEqualObjects(a, b) {
+  const keysA = Object.keys(a), keysB = Object.keys(b);
+  if (keysA.length !== keysB.length)
+    return !1;
+  for (const key of keysA)
+    if (!keysB.includes(key) || !isEqual(a[key], b[key]))
+      return !1;
+  return !0;
+}
+function isEqual(a, b) {
+  return isPrimitive(a) || isPrimitive(b) ? a === b : a instanceof Date && b instanceof Date ? a.getTime() === b.getTime() : typeof a != typeof b || Array.isArray(a) !== Array.isArray(b) ? !1 : Array.isArray(a) && Array.isArray(b) ? isEqualArrays(a, b) : typeof a == "object" && typeof b == "object" ? isEqualObjects(a, b) : !1;
+}
+function throttleId(identifier, func, interval) {
+  const state = {};
+  return async (...args) => {
+    const now = Date.now();
+    return state[identifier] || (state[identifier] = { promise: null, lastCall: 0, lastArgs: [] }), now - state[identifier].lastCall >= interval ? (state[identifier].lastCall = now, func(...args)) : (state[identifier].lastArgs = args, state[identifier].promise || (state[identifier].promise = new Promise((resolve) => {
+      setTimeout(
+        async () => {
+          state[identifier].lastCall = Date.now();
+          const result = await func(...state[identifier].lastArgs);
+          state[identifier].promise = null, resolve(result);
+        },
+        interval - (now - state[identifier].lastCall)
+      );
+    })), state[identifier].promise);
+  };
+}
+export {
+  debounceId as d,
+  isEqual as i,
+  throttleId as t
+};

package/dist/chunks/truthyFilter.C2WOKUCG.js

@@ -0,0 +1,6 @@
+function truthyFilter(value) {
+  return !!value;
+}
+export {
+  truthyFilter as t
+};

package/dist/chunks/useTranslations.BXuww4ux.js

@@ -0,0 +1,10 @@
+import { inject } from "vue";
+function useTranslations() {
+  const injected = inject("mazTranslations");
+  if (!injected)
+    throw new Error("MazTranslations plugin or MazUi plugin not installed. Please install the plugin first.");
+  return injected;
+}
+export {
+  useTranslations as u
+};

package/dist/chunks/userVisibility.BbQSJASv.js

@@ -0,0 +1,50 @@
+import { i as isClient } from "./isClient.WI4oSt66.js";
+class UserVisibility {
+  constructor(callback, options) {
+    this.callback = callback, this.options = {
+      ...this.defaultOptions,
+      ...options
+    }, this.eventHandlerFunction = this.eventHandler.bind(this), isClient() && this.start();
+  }
+  eventHandlerFunction;
+  event = "visibilitychange";
+  timeoutHandler;
+  options;
+  defaultOptions = {
+    timeout: 5e3,
+    once: !1,
+    immediate: !0
+  };
+  isVisible = !1;
+  start() {
+    if (!isClient()) {
+      console.warn("[UserVisibility](start) you should run this method on client side");
+      return;
+    }
+    this.options.immediate && this.emitCallback(), this.addEventListener();
+  }
+  emitCallback() {
+    this.isVisible = document.visibilityState === "visible", this.callback({ isVisible: this.isVisible }), this.options.once && this.destroy();
+  }
+  eventHandler() {
+    document.visibilityState === "visible" && !this.isVisible ? (this.clearTimeout(), this.emitCallback()) : document.visibilityState === "hidden" && this.initTimeout();
+  }
+  clearTimeout() {
+    this.timeoutHandler && (clearTimeout(this.timeoutHandler), this.timeoutHandler = void 0);
+  }
+  initTimeout() {
+    this.clearTimeout(), this.timeoutHandler = setTimeout(this.emitCallback.bind(this), this.options.timeout);
+  }
+  addEventListener() {
+    document.addEventListener(this.event, this.eventHandlerFunction);
+  }
+  removeEventListener() {
+    document.removeEventListener(this.event, this.eventHandlerFunction);
+  }
+  destroy() {
+    this.removeEventListener(), this.timeoutHandler && clearTimeout(this.timeoutHandler);
+  }
+}
+export {
+  UserVisibility as U
+};

package/dist/chunks/utils.BBuYjMbK.js

@@ -0,0 +1,317 @@
+import { i as isEqual, d as debounceId, t as throttleId } from "./throttleId.7PhWZjcS.js";
+import { getCurrentInstance, inject, nextTick } from "vue";
+import { useFreezeValue } from "../composables/useFreezeValue.js";
+const CONFIG = {
+  mode: "lazy",
+  scrollToErrorSelector: ".has-field-error",
+  debounceTime: 300,
+  throttleTime: 1e3
+};
+function fieldHasValidation(field, schema) {
+  return Object.keys(schema).includes(field);
+}
+function scrollToError(selector = CONFIG.scrollToErrorSelector) {
+  const element = document.querySelector(selector);
+  element && element.scrollIntoView({ behavior: "smooth", block: "center" });
+}
+function getErrorMessages(errors, fieldsStates) {
+  const errorMessages = {};
+  for (const [name, value] of Object.entries(errors)) {
+    const issues = value;
+    errorMessages[name] = fieldsStates[name].error && issues[0] ? issues[0].message : void 0;
+  }
+  return errorMessages;
+}
+function isEmptyValue(value) {
+  return value == null || value === "";
+}
+function getValidateFunction({
+  name,
+  hasValidation,
+  debouncedFields,
+  throttledFields
+}) {
+  if (!hasValidation)
+    return;
+  const fieldName = String(name);
+  if (debouncedFields?.[fieldName] && throttledFields?.[fieldName])
+    throw new Error(`The field "${String(fieldName)}" cannot be both debounced and throttled`);
+  return debouncedFields?.[fieldName] ? debounceId(
+    String(fieldName),
+    setFieldValidationState,
+    typeof debouncedFields[fieldName] == "number" ? debouncedFields[fieldName] : CONFIG.debounceTime
+  ) : throttledFields?.[fieldName] ? throttleId(
+    String(fieldName),
+    setFieldValidationState,
+    typeof throttledFields[fieldName] == "number" ? throttledFields[fieldName] : CONFIG.throttleTime
+  ) : setFieldValidationState;
+}
+function getFieldState({
+  name,
+  schema,
+  initialValue,
+  fieldState,
+  options
+}) {
+  const hasValidation = schema ? fieldHasValidation(name, schema) : !1, validateFunction = getValidateFunction({
+    name,
+    hasValidation,
+    debouncedFields: options?.debouncedFields,
+    throttledFields: options?.throttledFields
+  });
+  return {
+    blurred: !1,
+    dirty: !1,
+    errors: [],
+    error: !1,
+    valid: !hasValidation,
+    validating: !1,
+    validated: !1,
+    initialValue: useFreezeValue(initialValue),
+    validateFunction,
+    mode: hasValidation ? options?.mode ?? fieldState?.mode ?? CONFIG.mode : void 0
+  };
+}
+function getFieldsStates({
+  schema,
+  payload,
+  options
+}) {
+  const fieldsStates = {};
+  for (const fieldName in schema) {
+    const name = fieldName;
+    fieldsStates[name] = getFieldState({
+      name,
+      schema,
+      options,
+      fieldState: fieldsStates[name],
+      initialValue: payload?.[name]
+    });
+  }
+  return fieldsStates;
+}
+function updateFieldsStates({
+  fieldsStates,
+  payload,
+  schema,
+  options,
+  updateMode = !1
+}) {
+  for (const fieldName in schema) {
+    const name = fieldName;
+    fieldsStates[name] = updateFieldState({
+      name,
+      fieldState: fieldsStates[name],
+      payload,
+      schema,
+      options,
+      updateMode
+    });
+  }
+}
+function updateFieldState({
+  name,
+  fieldState,
+  payload,
+  schema,
+  options,
+  updateMode = !0
+}) {
+  const { initialValue, mode, ...rest } = getFieldState({
+    name,
+    schema,
+    initialValue: options.defaultValue ?? payload[name],
+    fieldState,
+    options
+  }), newMode = updateMode ? mode ?? fieldState.mode ?? CONFIG.mode : fieldState.mode;
+  return {
+    ...fieldState,
+    initialValue,
+    mode: newMode,
+    ...fieldState?.mode && newMode !== fieldState.mode ? rest : {}
+  };
+}
+function getFieldsErrors(fieldsStates) {
+  const fieldsErrors = {};
+  for (const [name, { errors }] of Object.entries(fieldsStates))
+    fieldsErrors[name] = errors;
+  return fieldsErrors;
+}
+function findInteractiveElements(el) {
+  return el instanceof HTMLInputElement || el instanceof HTMLSelectElement || el instanceof HTMLTextAreaElement ? [el] : el instanceof HTMLElement ? el.querySelectorAll(
+    "input, select, textarea"
+  ) : [];
+}
+function addEventToInteractiveElements({
+  interactiveElements,
+  onBlur,
+  mode
+}) {
+  interactiveElements.forEach((element) => {
+    hasModeIncludes(["eager", "blur", "progressive"], mode) && element.addEventListener("blur", onBlur);
+  });
+}
+function removeEventFromInteractiveElements({
+  interactiveElements,
+  onBlur
+}) {
+  interactiveElements.forEach((element) => {
+    element.removeEventListener("blur", onBlur);
+  });
+}
+async function getFieldValidationResult(name, schema, value) {
+  const fieldSchema = await getValidationSchema(schema), result = await (await getValibotValidationMethod("safeParseAsync"))(fieldSchema.entries[name], value ?? "");
+  return {
+    result,
+    isValid: result.success
+  };
+}
+async function setFieldValidationState({
+  name,
+  fieldState,
+  schema,
+  payload,
+  setError = !0,
+  setErrorIfInvalidAndNotEmpty = !1
+}) {
+  if (await nextTick(), fieldState.validating = !0, !schema[name]) {
+    fieldState.valid = !0, fieldState.validating = !1, fieldState.validated = !0, fieldState.errors = [], fieldState.error = !1;
+    return;
+  }
+  const { result, isValid } = await getFieldValidationResult(name, schema, payload[name]);
+  fieldState.valid = isValid, (setError || setErrorIfInvalidAndNotEmpty && !isValid && !isEmptyValue(payload[name])) && (fieldState.error = !isValid), fieldState.errors = result.issues ?? [], fieldState.validating = !1, fieldState.validated = !0;
+}
+function validateField({
+  name,
+  fieldState,
+  payload,
+  schema
+}) {
+  const validationParams = {
+    name,
+    fieldState,
+    payload,
+    schema,
+    setError: fieldState.mode === "progressive" ? fieldState.valid || fieldState.blurred : !0
+  };
+  return fieldState.validateFunction?.(validationParams);
+}
+function validateForm({
+  fieldsStates,
+  payload,
+  showErrors = !0,
+  schema
+}) {
+  return Promise.all(
+    Object.keys(fieldsStates).map(
+      (name) => setFieldValidationState({
+        name,
+        setError: showErrors,
+        fieldState: fieldsStates[name],
+        payload,
+        schema,
+        setErrorIfInvalidAndNotEmpty: fieldsStates[name].mode === "lazy"
+      })
+    )
+  );
+}
+function canExecuteValidation({
+  eventName,
+  fieldState,
+  isSubmitted
+}) {
+  const { dirty, blurred, mode, valid } = fieldState;
+  return eventName === "blur" && (hasModeIncludes(["lazy", "aggressive"], mode) || valid) || eventName === "input" && mode === "blur" || !mode ? !1 : isSubmitted || mode === "eager" && blurred || mode === "blur" && blurred || mode === "aggressive" && dirty || mode === "lazy" && dirty || mode === "progressive";
+}
+function handleFieldBlur({
+  name,
+  force = !1,
+  payload,
+  fieldState,
+  schema,
+  isSubmitted
+}) {
+  const fieldValue = payload[name], isDirty = !isEqual(fieldValue, fieldState.initialValue);
+  if (fieldState.dirty = isDirty, fieldState.blurred = fieldState.blurred || (fieldState.mode === "eager" ? isDirty : !0), !!(force || canExecuteValidation({ eventName: "blur", fieldState, isSubmitted })))
+    return validateField({
+      name,
+      fieldState,
+      schema,
+      payload
+    });
+}
+function handleFieldInput({
+  name,
+  payload,
+  fieldState,
+  schema,
+  isSubmitted,
+  forceValidation = !1
+}) {
+  const fieldValue = payload[name];
+  fieldState.validated = !1;
+  const isDirty = !isEqual(fieldValue, fieldState.initialValue);
+  if (fieldState.dirty = isDirty, !!(forceValidation || canExecuteValidation({ eventName: "input", fieldState, isSubmitted })))
+    return validateField({
+      name,
+      fieldState,
+      schema,
+      payload
+    });
+}
+function getInstance(composableName) {
+  const instance = getCurrentInstance();
+  if (!instance)
+    throw new Error(`${composableName} must be called within setup()`);
+  return instance;
+}
+function getContext(identifier, composableName) {
+  const context = getInstance(composableName).formContexts?.get(identifier) ?? inject(identifier);
+  if (!context)
+    throw new Error("useFormField must be used within a form (useFormValidator)");
+  return context;
+}
+function getValidationEvents({
+  hasRef,
+  fieldState,
+  onBlur
+}) {
+  if (!(hasRef || hasModeIncludes(["aggressive", "lazy"], fieldState.mode)))
+    return {
+      onBlur
+    };
+}
+const storeValidbot = {};
+async function getValibotValidationMethod(methodName) {
+  if (storeValidbot[methodName])
+    return storeValidbot[methodName];
+  const valibot = await import("valibot");
+  return storeValidbot[methodName] = valibot[methodName], valibot[methodName];
+}
+async function getValidationSchema(formSchema) {
+  return (await getValibotValidationMethod("objectAsync"))(formSchema);
+}
+function hasModeIncludes(modes, value) {
+  return value ? modes.includes(value) : !1;
+}
+export {
+  CONFIG as C,
+  getFieldsStates as a,
+  getFieldsErrors as b,
+  getErrorMessages as c,
+  hasModeIncludes as d,
+  getContext as e,
+  fieldHasValidation as f,
+  getInstance as g,
+  handleFieldInput as h,
+  updateFieldState as i,
+  setFieldValidationState as j,
+  getValidationEvents as k,
+  handleFieldBlur as l,
+  findInteractiveElements as m,
+  addEventToInteractiveElements as n,
+  removeEventFromInteractiveElements as r,
+  scrollToError as s,
+  updateFieldsStates as u,
+  validateForm as v
+};

package/dist/chunks/x-mark.CTalOvvY.js

@@ -0,0 +1,23 @@
+import { createElementBlock, openBlock, createElementVNode } from "vue";
+const _hoisted_1 = {
+  xmlns: "http://www.w3.org/2000/svg",
+  width: "1em",
+  height: "1em",
+  fill: "none",
+  viewBox: "0 0 24 24"
+};
+function render(_ctx, _cache) {
+  return openBlock(), createElementBlock("svg", _hoisted_1, _cache[0] || (_cache[0] = [
+    createElementVNode("path", {
+      stroke: "currentColor",
+      "stroke-linecap": "round",
+      "stroke-linejoin": "round",
+      "stroke-width": "1.5",
+      d: "M6 18 18 6M6 6l12 12"
+    }, null, -1)
+  ]));
+}
+const XMark = { render };
+export {
+  XMark as X
+};

package/dist/chunks/zh-CN.CCkuvk-E.js

@@ -0,0 +1,82 @@
+const zhCN = {
+  selectCountry: {
+    searchPlaceholder: "搜索国家"
+  },
+  inputPhoneNumber: {
+    countrySelect: {
+      placeholder: "国家代码",
+      error: "选择国家",
+      searchPlaceholder: "搜索国家"
+    },
+    phoneInput: {
+      placeholder: "电话号码",
+      example: "示例：{example}"
+    }
+  },
+  dropzone: {
+    dragAndDrop: "拖放文件",
+    selectFile: "选择文件",
+    divider: "或",
+    fileMaxCount: "最多 {count} 个文件",
+    fileMaxSize: "最大 {size} MB",
+    fileTypes: "允许的文件类型：{types}"
+  },
+  datePicker: {
+    shortcuts: {
+      lastSevenDays: "最近7天",
+      lastThirtyDays: "最近30天",
+      thisWeek: "本周",
+      lastWeek: "上周",
+      thisMonth: "本月",
+      thisYear: "今年",
+      lastYear: "去年"
+    }
+  },
+  dropdown: {
+    screenReaderDescription: "打开下拉菜单"
+  },
+  select: {
+    searchPlaceholder: "搜索"
+  },
+  table: {
+    noResults: "无结果",
+    actionColumnTitle: "操作",
+    searchByInput: {
+      all: "全部",
+      placeholder: "搜索条件"
+    },
+    searchInput: {
+      placeholder: "搜索"
+    },
+    pagination: {
+      all: "全部",
+      rowsPerPage: "每页行数",
+      of: "共"
+    }
+  },
+  pagination: {
+    navAriaLabel: "页面导航",
+    screenReader: {
+      firstPage: "第一页，第 {page} 页",
+      previousPage: "上一页，第 {page} 页",
+      page: "第 {page} 页",
+      nextPage: "下一页，第 {page} 页",
+      lastPage: "最后一页，第 {page} 页"
+    }
+  },
+  carousel: {
+    ariaLabel: {
+      previousButton: "滚动到上一项",
+      nextButton: "滚动到下一项"
+    }
+  },
+  checklist: {
+    noResultsFound: "未找到结果",
+    searchInput: {
+      placeholder: "搜索"
+    }
+  }
+};
+export {
+  zhCN as default
+};

package/dist/components/MazAccordion.js

@@ -0,0 +1,84 @@
+import { defineComponent, useSlots, computed, ref, createElementBlock, openBlock, Fragment, renderList, createBlock, withCtx, createElementVNode, createVNode, unref, renderSlot, normalizeClass } from "vue";
+import { MazPlus } from "@maz-ui/icons";
+import { useInstanceUniqId } from "../composables/useInstanceUniqId.js";
+import MazCardSpotlight from "./MazCardSpotlight.js";
+import MazExpandAnimation from "./MazExpandAnimation.js";
+import { _ as _export_sfc } from "../chunks/_plugin-vue_export-helper.B--vMWp3.js";
+import '../assets/MazAccordion.esK3rR4p.css';const _hoisted_1 = {
+  class: "m-accordion m-reset-css",
+  role: "presentation"
+}, _hoisted_2 = ["id", "aria-controls", "aria-expanded", "onClick"], _sfc_main = /* @__PURE__ */ defineComponent({
+  __name: "MazAccordion",
+  props: {
+    id: { default: void 0 },
+    modelValue: { default: 0 },
+    contentClass: { default: void 0 }
+  },
+  emits: ["update:model-value"],
+  setup(__props, { emit: __emit }) {
+    const props = __props, emits = __emit, instanceId = useInstanceUniqId({
+      componentName: "MazAccordion",
+      providedId: props.id
+    }), slots = useSlots(), stepCount = computed(
+      () => Object.keys(slots).filter((slot) => slot.startsWith("title-")).length
+    ), localModelValue = ref(props.modelValue), currentStep = computed({
+      get: () => props.modelValue || localModelValue.value,
+      set: (value) => {
+        localModelValue.value = value, emits("update:model-value", value);
+      }
+    });
+    function isStepOpen(index) {
+      return currentStep.value === index;
+    }
+    function selectStep(index) {
+      currentStep.value === index ? (localModelValue.value = 0, emits("update:model-value", 0)) : (localModelValue.value = index, emits("update:model-value", index));
+    }
+    return (_ctx, _cache) => (openBlock(), createElementBlock("div", _hoisted_1, [
+      (openBlock(!0), createElementBlock(Fragment, null, renderList(stepCount.value, (step) => (openBlock(), createBlock(MazCardSpotlight, {
+        key: step,
+        class: "m-accordion__spotlight",
+        padding: !1
+      }, {
+        default: withCtx(() => [
+          createElementVNode("button", {
+            id: `step-${step}-${unref(instanceId)}`,
+            class: "m-accordion__header",
+            "aria-controls": `step-${step}-${unref(instanceId)}`,
+            "aria-expanded": isStepOpen(step),
+            onClick: ($event) => selectStep(step)
+          }, [
+            renderSlot(_ctx.$slots, `title-${step}`, {
+              isOpen: isStepOpen(step)
+            }, void 0, !0),
+            createVNode(unref(MazPlus), {
+              class: normalizeClass(["header-icon", { "--rotate": isStepOpen(step) }])
+            }, null, 8, ["class"])
+          ], 8, _hoisted_2),
+          createVNode(MazExpandAnimation, {
+            "animation-duration": "300ms",
+            "model-value": isStepOpen(step),
+            "aria-labelledby": `step-${step}-${unref(instanceId)}`
+          }, {
+            default: withCtx(() => [
+              createElementVNode("div", {
+                class: normalizeClass(["m-accordion__content", _ctx.contentClass])
+              }, [
+                renderSlot(_ctx.$slots, "content", {
+                  isOpen: isStepOpen(step)
+                }, void 0, !0),
+                renderSlot(_ctx.$slots, `content-${step}`, {
+                  isOpen: isStepOpen(step)
+                }, void 0, !0)
+              ], 2)
+            ]),
+            _: 2
+          }, 1032, ["model-value", "aria-labelledby"])
+        ]),
+        _: 2
+      }, 1024))), 128))
+    ]));
+  }
+}), MazAccordion = /* @__PURE__ */ _export_sfc(_sfc_main, [["__scopeId", "data-v-3531c128"]]);
+export {
+  MazAccordion as default
+};