zartui 0.1.112 → 3.0.2

package/es/toast/index.mjs

@@ -0,0 +1,26 @@
+import { withInstall } from "../utils/index.mjs";
+import _Toast from "./Toast.mjs";
+const Toast = withInstall(_Toast);
+var stdin_default = Toast;
+import {
+  showToast,
+  closeToast,
+  showFailToast,
+  showLoadingToast,
+  showSuccessToast,
+  allowMultipleToast,
+  setToastDefaultOptions,
+  resetToastDefaultOptions
+} from "./function-call.mjs";
+export {
+  Toast,
+  allowMultipleToast,
+  closeToast,
+  stdin_default as default,
+  resetToastDefaultOptions,
+  setToastDefaultOptions,
+  showFailToast,
+  showLoadingToast,
+  showSuccessToast,
+  showToast
+};

package/es/toast/lock-click.d.ts

@@ -0,0 +1 @@
+export declare function lockClick(lock: boolean): void;

package/es/toast/lock-click.mjs

@@ -0,0 +1,17 @@
+let lockCount = 0;
+function lockClick(lock) {
+  if (lock) {
+    if (!lockCount) {
+      document.body.classList.add("zt-toast--unclickable");
+    }
+    lockCount++;
+  } else if (lockCount) {
+    lockCount--;
+    if (!lockCount) {
+      document.body.classList.remove("zt-toast--unclickable");
+    }
+  }
+}
+export {
+  lockClick
+};

package/es/toast/style/index.d.ts

@@ -0,0 +1 @@
+export {};

package/es/toast/style/index.mjs

@@ -0,0 +1,7 @@
+import "../../style/base.css";
+import "../../badge/index.css";
+import "../../icon/index.css";
+import "../../loading/index.css";
+import "../../overlay/index.css";
+import "../../popup/index.css";
+import "../index.css";

package/es/toast/types.d.ts

@@ -0,0 +1,36 @@
+import type { ComponentPublicInstance, TeleportProps } from 'vue';
+import type { LoadingType } from '../loading';
+import type { Numeric } from '../utils';
+export declare type ToastType = 'text' | 'loading' | 'success' | 'warning' | 'html';
+export declare type ToastPosition = 'top' | 'middle' | 'bottom';
+export declare type ToastOptions = {
+    icon?: string;
+    type?: ToastType;
+    mask?: boolean;
+    message?: Numeric;
+    onClose?: () => void;
+    onOpened?: () => void;
+    overlay?: boolean;
+    duration?: number;
+    teleport?: TeleportProps['to'];
+    iconSize?: Numeric;
+    position?: ToastPosition;
+    className?: unknown;
+    transition?: string;
+    iconPrefix?: string;
+    loadingType?: LoadingType;
+    forbidClick?: boolean;
+    closeOnClick?: boolean;
+    overlayClass?: unknown;
+    overlayStyle?: Record<string, any>;
+    closeOnClickOverlay?: boolean;
+};
+export declare type ToastWrapperInstance = ComponentPublicInstance<{
+    message: Numeric;
+}, {
+    close: () => void;
+    /**
+     * @private
+     */
+    open: (props: Record<string, any>) => void;
+}>;

package/es/utils/basic.d.ts

@@ -0,0 +1,18 @@
+import type { ComponentPublicInstance } from 'vue';
+export declare function noop(): void;
+export declare const extend: {
+    <T extends {}, U>(target: T, source: U): T & U;
+    <T_1 extends {}, U_1, V>(target: T_1, source1: U_1, source2: V): T_1 & U_1 & V;
+    <T_2 extends {}, U_2, V_1, W>(target: T_2, source1: U_2, source2: V_1, source3: W): T_2 & U_2 & V_1 & W;
+    (target: object, ...sources: any[]): any;
+};
+export declare const inBrowser: boolean;
+export declare type Numeric = number | string;
+export declare type ComponentInstance = ComponentPublicInstance<{}, any>;
+export declare function get(object: any, path: string): any;
+export declare type Writeable<T> = {
+    -readonly [P in keyof T]: T[P];
+};
+export declare function pick<T, U extends keyof T>(obj: T, keys: ReadonlyArray<U>, ignoreUndefined?: boolean): Writeable<Pick<T, U>>;
+export declare const isSameValue: (newValue: unknown, oldValue: unknown) => boolean;
+export declare const toArray: <T>(item: T | T[]) => T[];

package/es/utils/basic.mjs

@@ -0,0 +1,32 @@
+function noop() {
+}
+const extend = Object.assign;
+const inBrowser = typeof window !== "undefined";
+function get(object, path) {
+  const keys = path.split(".");
+  let result = object;
+  keys.forEach((key) => {
+    var _a;
+    result = (_a = result[key]) != null ? _a : "";
+  });
+  return result;
+}
+function pick(obj, keys, ignoreUndefined) {
+  return keys.reduce((ret, key) => {
+    if (!ignoreUndefined || obj[key] !== void 0) {
+      ret[key] = obj[key];
+    }
+    return ret;
+  }, {});
+}
+const isSameValue = (newValue, oldValue) => JSON.stringify(newValue) === JSON.stringify(oldValue);
+const toArray = (item) => Array.isArray(item) ? item : [item];
+export {
+  extend,
+  get,
+  inBrowser,
+  isSameValue,
+  noop,
+  pick,
+  toArray
+};

package/es/utils/constant.d.ts

@@ -0,0 +1,8 @@
+export declare const BORDER = "zt-hairline";
+export declare const BORDER_TOP: string;
+export declare const BORDER_LEFT: string;
+export declare const BORDER_BOTTOM: string;
+export declare const BORDER_SURROUND: string;
+export declare const BORDER_TOP_BOTTOM: string;
+export declare const BORDER_UNSET_TOP_BOTTOM: string;
+export declare const HAPTICS_FEEDBACK = "zt-haptics-feedback";

package/es/utils/constant.mjs

@@ -0,0 +1,18 @@
+const BORDER = "zt-hairline";
+const BORDER_TOP = `${BORDER}--top`;
+const BORDER_LEFT = `${BORDER}--left`;
+const BORDER_BOTTOM = `${BORDER}--bottom`;
+const BORDER_SURROUND = `${BORDER}--surround`;
+const BORDER_TOP_BOTTOM = `${BORDER}--top-bottom`;
+const BORDER_UNSET_TOP_BOTTOM = `${BORDER}-unset--top-bottom`;
+const HAPTICS_FEEDBACK = "zt-haptics-feedback";
+export {
+  BORDER,
+  BORDER_BOTTOM,
+  BORDER_LEFT,
+  BORDER_SURROUND,
+  BORDER_TOP,
+  BORDER_TOP_BOTTOM,
+  BORDER_UNSET_TOP_BOTTOM,
+  HAPTICS_FEEDBACK
+};

package/es/utils/create.d.ts

@@ -0,0 +1,17 @@
+export declare function createTranslate(name: string): (path: string, ...args: unknown[]) => any;
+export declare type Translate = ReturnType<typeof createTranslate>;
+export declare type Mod = string | {
+    [key: string]: any;
+};
+export declare type Mods = Mod | Mod[];
+/**
+ * bem helper
+ * b() // 'button'
+ * b('text') // 'button__text'
+ * b({ disabled }) // 'button button--disabled'
+ * b('text', { disabled }) // 'button__text button__text--disabled'
+ * b(['disabled', 'primary']) // 'button button--disabled button--primary'
+ */
+export declare function createBEM(name: string): (el?: Mods, mods?: Mods) => Mods;
+export declare type BEM = ReturnType<typeof createBEM>;
+export declare function createNamespace(name: string): readonly [string, (el?: Mods | undefined, mods?: Mods | undefined) => Mods, (path: string, ...args: unknown[]) => any];

package/es/utils/create.mjs

@@ -0,0 +1,50 @@
+import { get } from "./basic.mjs";
+import { camelize } from "./format.mjs";
+import { isFunction } from "./validate.mjs";
+import locale from "../locale/index.mjs";
+function createTranslate(name) {
+  const prefix = camelize(name) + ".";
+  return (path, ...args) => {
+    const messages = locale.messages();
+    const message = get(messages, prefix + path) || get(messages, path);
+    return isFunction(message) ? message(...args) : message;
+  };
+}
+function genBem(name, mods) {
+  if (!mods) {
+    return "";
+  }
+  if (typeof mods === "string") {
+    return ` ${name}--${mods}`;
+  }
+  if (Array.isArray(mods)) {
+    return mods.reduce((ret, item) => ret + genBem(name, item), "");
+  }
+  return Object.keys(mods).reduce(
+    (ret, key) => ret + (mods[key] ? genBem(name, key) : ""),
+    ""
+  );
+}
+function createBEM(name) {
+  return (el, mods) => {
+    if (el && typeof el !== "string") {
+      mods = el;
+      el = "";
+    }
+    el = el ? `${name}__${el}` : name;
+    return `${el}${genBem(el, mods)}`;
+  };
+}
+function createNamespace(name) {
+  const prefixedName = `zt-${name}`;
+  return [
+    prefixedName,
+    createBEM(prefixedName),
+    createTranslate(prefixedName)
+  ];
+}
+export {
+  createBEM,
+  createNamespace,
+  createTranslate
+};

package/es/utils/deep-assign.d.ts

@@ -0,0 +1,3 @@
+declare type ObjectIndex = Record<string, unknown>;
+export declare function deepAssign(to: ObjectIndex, from: ObjectIndex): ObjectIndex;
+export {};

package/es/utils/deep-assign.mjs

@@ -0,0 +1,22 @@
+import { isDef, isObject } from "./validate.mjs";
+const { hasOwnProperty } = Object.prototype;
+function assignKey(to, from, key) {
+  const val = from[key];
+  if (!isDef(val)) {
+    return;
+  }
+  if (!hasOwnProperty.call(to, key) || !isObject(val)) {
+    to[key] = val;
+  } else {
+    to[key] = deepAssign(Object(to[key]), val);
+  }
+}
+function deepAssign(to, from) {
+  Object.keys(from).forEach((key) => {
+    assignKey(to, from, key);
+  });
+  return to;
+}
+export {
+  deepAssign
+};

package/es/utils/deep-clone.d.ts

@@ -0,0 +1 @@
+export declare function deepClone<T extends Record<string, any> | null | undefined>(obj: T): T;

package/es/utils/deep-clone.mjs

@@ -0,0 +1,20 @@
+import { isDef, isObject } from "./validate.mjs";
+function deepClone(obj) {
+  if (!isDef(obj)) {
+    return obj;
+  }
+  if (Array.isArray(obj)) {
+    return obj.map((item) => deepClone(item));
+  }
+  if (isObject(obj)) {
+    const to = {};
+    Object.keys(obj).forEach((key) => {
+      to[key] = deepClone(obj[key]);
+    });
+    return to;
+  }
+  return obj;
+}
+export {
+  deepClone
+};

package/es/utils/dom.d.ts

@@ -0,0 +1,12 @@
+import { Ref } from 'vue';
+export declare type ScrollElement = Element | Window;
+export declare function getScrollTop(el: ScrollElement): number;
+export declare function setScrollTop(el: ScrollElement, value: number): void;
+export declare function getRootScrollTop(): number;
+export declare function setRootScrollTop(value: number): void;
+export declare function getElementTop(el: ScrollElement, scroller?: ScrollElement): number;
+export declare function resetScroll(): void;
+export declare const stopPropagation: (event: Event) => void;
+export declare function preventDefault(event: Event, isStopPropagation?: boolean): void;
+export declare function isHidden(elementRef: HTMLElement | Ref<HTMLElement | undefined>): boolean;
+export declare const windowWidth: Ref<number>, windowHeight: Ref<number>;

package/es/utils/dom.mjs

@@ -0,0 +1,67 @@
+import { useRect, useWindowSize } from "@zartui/use";
+import { unref } from "vue";
+import { isIOS as checkIsIOS } from "./validate.mjs";
+function getScrollTop(el) {
+  const top = "scrollTop" in el ? el.scrollTop : el.pageYOffset;
+  return Math.max(top, 0);
+}
+function setScrollTop(el, value) {
+  if ("scrollTop" in el) {
+    el.scrollTop = value;
+  } else {
+    el.scrollTo(el.scrollX, value);
+  }
+}
+function getRootScrollTop() {
+  return window.pageYOffset || document.documentElement.scrollTop || document.body.scrollTop || 0;
+}
+function setRootScrollTop(value) {
+  setScrollTop(window, value);
+  setScrollTop(document.body, value);
+}
+function getElementTop(el, scroller) {
+  if (el === window) {
+    return 0;
+  }
+  const scrollTop = scroller ? getScrollTop(scroller) : getRootScrollTop();
+  return useRect(el).top + scrollTop;
+}
+const isIOS = checkIsIOS();
+function resetScroll() {
+  if (isIOS) {
+    setRootScrollTop(getRootScrollTop());
+  }
+}
+const stopPropagation = (event) => event.stopPropagation();
+function preventDefault(event, isStopPropagation) {
+  if (typeof event.cancelable !== "boolean" || event.cancelable) {
+    event.preventDefault();
+  }
+  if (isStopPropagation) {
+    stopPropagation(event);
+  }
+}
+function 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 { width: windowWidth, height: windowHeight } = useWindowSize();
+export {
+  getElementTop,
+  getRootScrollTop,
+  getScrollTop,
+  isHidden,
+  preventDefault,
+  resetScroll,
+  setRootScrollTop,
+  setScrollTop,
+  stopPropagation,
+  windowHeight,
+  windowWidth
+};

package/es/utils/format.d.ts

@@ -0,0 +1,13 @@
+import type { CSSProperties } from 'vue';
+import { type Numeric } from './basic';
+export declare function addUnit(value?: Numeric): string | undefined;
+export declare function getSizeStyle(originSize?: Numeric | Numeric[]): CSSProperties | undefined;
+export declare function getZIndexStyle(zIndex?: Numeric): CSSProperties;
+export declare function unitToPx(value: Numeric): number;
+export declare const camelize: (str: string) => string;
+export declare const kebabCase: (str: string) => string;
+export declare function padZero(num: Numeric, targetLength?: number): string;
+/** clamps number within the inclusive lower and upper bounds */
+export declare const clamp: (num: number, min: number, max: number) => number;
+export declare function formatNumber(value: string, allowDot?: boolean, allowMinus?: boolean): string;
+export declare function addNumber(num1: number, num2: number): number;

package/es/utils/format.mjs

@@ -0,0 +1,120 @@
+import { inBrowser } from "./basic.mjs";
+import { windowWidth, windowHeight } from "./dom.mjs";
+import { isDef, isNumeric } from "./validate.mjs";
+function addUnit(value) {
+  if (isDef(value)) {
+    return isNumeric(value) ? `${value}px` : String(value);
+  }
+  return void 0;
+}
+function getSizeStyle(originSize) {
+  if (isDef(originSize)) {
+    if (Array.isArray(originSize)) {
+      return {
+        width: addUnit(originSize[0]),
+        height: addUnit(originSize[1])
+      };
+    }
+    const size = addUnit(originSize);
+    return {
+      width: size,
+      height: size
+    };
+  }
+}
+function getZIndexStyle(zIndex) {
+  const style = {};
+  if (zIndex !== void 0) {
+    style.zIndex = +zIndex;
+  }
+  return style;
+}
+let rootFontSize;
+function getRootFontSize() {
+  if (!rootFontSize) {
+    const doc = document.documentElement;
+    const fontSize = doc.style.fontSize || window.getComputedStyle(doc).fontSize;
+    rootFontSize = parseFloat(fontSize);
+  }
+  return rootFontSize;
+}
+function convertRem(value) {
+  value = value.replace(/rem/g, "");
+  return +value * getRootFontSize();
+}
+function convertVw(value) {
+  value = value.replace(/vw/g, "");
+  return +value * windowWidth.value / 100;
+}
+function convertVh(value) {
+  value = value.replace(/vh/g, "");
+  return +value * windowHeight.value / 100;
+}
+function unitToPx(value) {
+  if (typeof value === "number") {
+    return value;
+  }
+  if (inBrowser) {
+    if (value.includes("rem")) {
+      return convertRem(value);
+    }
+    if (value.includes("vw")) {
+      return convertVw(value);
+    }
+    if (value.includes("vh")) {
+      return convertVh(value);
+    }
+  }
+  return parseFloat(value);
+}
+const camelizeRE = /-(\w)/g;
+const camelize = (str) => str.replace(camelizeRE, (_, c) => c.toUpperCase());
+const kebabCase = (str) => str.replace(/([A-Z])/g, "-$1").toLowerCase().replace(/^-/, "");
+function padZero(num, targetLength = 2) {
+  let str = num + "";
+  while (str.length < targetLength) {
+    str = "0" + str;
+  }
+  return str;
+}
+const clamp = (num, min, max) => Math.min(Math.max(num, min), max);
+function trimExtraChar(value, char, regExp) {
+  const index = value.indexOf(char);
+  if (index === -1) {
+    return value;
+  }
+  if (char === "-" && index !== 0) {
+    return value.slice(0, index);
+  }
+  return value.slice(0, index + 1) + value.slice(index).replace(regExp, "");
+}
+function formatNumber(value, allowDot = true, allowMinus = true) {
+  if (allowDot) {
+    value = trimExtraChar(value, ".", /\./g);
+  } else {
+    value = value.split(".")[0];
+  }
+  if (allowMinus) {
+    value = trimExtraChar(value, "-", /-/g);
+  } else {
+    value = value.replace(/-/, "");
+  }
+  const regExp = allowDot ? /[^-0-9.]/g : /[^-0-9]/g;
+  return value.replace(regExp, "");
+}
+function addNumber(num1, num2) {
+  const cardinal = 10 ** 10;
+  return Math.round((num1 + num2) * cardinal) / cardinal;
+}
+export {
+  addNumber,
+  addUnit,
+  camelize,
+  clamp,
+  formatNumber,
+  getSizeStyle,
+  getZIndexStyle,
+  kebabCase,
+  padZero,
+  unitToPx
+};

package/es/utils/index.d.ts

@@ -0,0 +1,9 @@
+export * from './basic';
+export * from './props';
+export * from './dom';
+export * from './create';
+export * from './format';
+export * from './constant';
+export * from './validate';
+export * from './interceptor';
+export * from './with-install';

package/es/utils/index.mjs

@@ -0,0 +1,9 @@
+export * from "./basic.mjs";
+export * from "./props.mjs";
+export * from "./dom.mjs";
+export * from "./create.mjs";
+export * from "./format.mjs";
+export * from "./constant.mjs";
+export * from "./validate.mjs";
+export * from "./interceptor.mjs";
+export * from "./with-install.mjs";

package/es/utils/interceptor.d.ts

@@ -0,0 +1,6 @@
+export declare type Interceptor = (...args: any[]) => Promise<boolean> | boolean | undefined | void;
+export declare function callInterceptor(interceptor: Interceptor | undefined, { args, done, canceled, }: {
+    args?: unknown[];
+    done: () => void;
+    canceled?: () => void;
+}): void;

package/es/utils/interceptor.mjs

@@ -0,0 +1,29 @@
+import { noop } from "./basic.mjs";
+import { isPromise } from "./validate.mjs";
+function callInterceptor(interceptor, {
+  args = [],
+  done,
+  canceled
+}) {
+  if (interceptor) {
+    const returnVal = interceptor.apply(null, args);
+    if (isPromise(returnVal)) {
+      returnVal.then((value) => {
+        if (value) {
+          done();
+        } else if (canceled) {
+          canceled();
+        }
+      }).catch(noop);
+    } else if (returnVal) {
+      done();
+    } else if (canceled) {
+      canceled();
+    }
+  } else {
+    done();
+  }
+}
+export {
+  callInterceptor
+};

package/es/utils/mount-component.d.ts

@@ -0,0 +1,14 @@
+import { Component } from 'vue';
+export declare function usePopupState(): {
+    open: (props: Record<string, any>) => void;
+    close: () => void;
+    state: {
+        [x: string]: any;
+        show: boolean;
+    };
+    toggle: (show: boolean) => void;
+};
+export declare function mountComponent(RootComponent: Component): {
+    instance: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}>>;
+    unmount(): void;
+};

package/es/utils/mount-component.mjs

@@ -0,0 +1,39 @@
+import { createApp, reactive } from "vue";
+import { extend } from "../utils/index.mjs";
+import { useExpose } from "../composables/use-expose.mjs";
+function usePopupState() {
+  const state = reactive({
+    show: false
+  });
+  const toggle = (show) => {
+    state.show = show;
+  };
+  const open = (props) => {
+    extend(state, props, { transitionAppear: true });
+    toggle(true);
+  };
+  const close = () => toggle(false);
+  useExpose({ open, close, toggle });
+  return {
+    open,
+    close,
+    state,
+    toggle
+  };
+}
+function mountComponent(RootComponent) {
+  const app = createApp(RootComponent);
+  const root = document.createElement("div");
+  document.body.appendChild(root);
+  return {
+    instance: app.mount(root),
+    unmount() {
+      app.unmount();
+      document.body.removeChild(root);
+    }
+  };
+}
+export {
+  mountComponent,
+  usePopupState
+};

package/es/utils/props.d.ts

@@ -0,0 +1,31 @@
+/**
+ * prop type helpers
+ * help us to write less code and reduce bundle size
+ */
+import type { PropType } from 'vue';
+export declare const unknownProp: PropType<unknown>;
+export declare const numericProp: (NumberConstructor | StringConstructor)[];
+export declare const truthProp: {
+    type: BooleanConstructor;
+    default: true;
+};
+export declare const makeRequiredProp: <T>(type: T) => {
+    type: T;
+    required: true;
+};
+export declare const makeArrayProp: <T>() => {
+    type: PropType<T[]>;
+    default: () => never[];
+};
+export declare const makeNumberProp: <T>(defaultVal: T) => {
+    type: NumberConstructor;
+    default: T;
+};
+export declare const makeNumericProp: <T>(defaultVal: T) => {
+    type: (NumberConstructor | StringConstructor)[];
+    default: T;
+};
+export declare const makeStringProp: <T>(defaultVal: T) => {
+    type: PropType<T>;
+    default: T;
+};