persagy-vant 0.0.28 → 0.0.29

package/es/utils/basic.ts

@@ -0,0 +1,42 @@
+import { isObject } from './validate';
+import type { ComponentPublicInstance } from 'vue';
+
+export function noop() {}
+
+export const extend = Object.assign;
+
+export const inBrowser = typeof window !== 'undefined';
+
+export type Numeric = number | string;
+
+// eslint-disable-next-line
+export type ComponentInstance = ComponentPublicInstance<{}, any>;
+
+export function get(object: any, path: string): any {
+  const keys = path.split('.');
+  let result = object;
+
+  keys.forEach((key) => {
+    result = isObject(result) ? result[key] ?? '' : '';
+  });
+
+  return result;
+}
+
+export type Writeable<T> = { -readonly [P in keyof T]: T[P] };
+
+export function pick<T, U extends keyof T>(
+  obj: T,
+  keys: ReadonlyArray<U>,
+  ignoreUndefined?: boolean
+) {
+  return keys.reduce((ret, key) => {
+    if (!ignoreUndefined || obj[key] !== undefined) {
+      ret[key] = obj[key];
+    }
+    return ret;
+  }, {} as Writeable<Pick<T, U>>);
+}
+
+export const toArray = <T>(item: T | T[]): T[] =>
+  Array.isArray(item) ? item : [item];

package/es/utils/constant.ts

@@ -0,0 +1,14 @@
+import type { InjectionKey } from 'vue';
+import type { FormProvide } from '../form/types';
+
+export const BORDER = 'van-hairline';
+export const BORDER_TOP = `${BORDER}--top`;
+export const BORDER_LEFT = `${BORDER}--left`;
+export const BORDER_BOTTOM = `${BORDER}--bottom`;
+export const BORDER_SURROUND = `${BORDER}--surround`;
+export const BORDER_TOP_BOTTOM = `${BORDER}--top-bottom`;
+export const BORDER_UNSET_TOP_BOTTOM = `${BORDER}-unset--top-bottom`;
+
+export const HAPTICS_FEEDBACK = 'van-haptics-feedback';
+
+export const FORM_KEY: InjectionKey<FormProvide> = Symbol('van-form');

package/es/utils/create.ts

@@ -0,0 +1,74 @@
+import { get } from './basic';
+import { camelize } from './format';
+import { isFunction } from './validate';
+import locale from '../locale';
+
+export function createTranslate(name: string) {
+  const prefix = camelize(name) + '.';
+
+  return (path: string, ...args: unknown[]) => {
+    const messages = locale.messages();
+    const message = get(messages, prefix + path) || get(messages, path);
+
+    return isFunction(message) ? message(...args) : message;
+  };
+}
+
+export type Translate = ReturnType<typeof createTranslate>;
+
+export type Mod = string | { [key: string]: any };
+export type Mods = Mod | Mod[];
+
+function genBem(name: string, mods?: Mods): string {
+  if (!mods) {
+    return '';
+  }
+
+  if (typeof mods === 'string') {
+    return ` ${name}--${mods}`;
+  }
+
+  if (Array.isArray(mods)) {
+    return (mods as Mod[]).reduce<string>(
+      (ret, item) => ret + genBem(name, item),
+      ''
+    );
+  }
+
+  return Object.keys(mods).reduce(
+    (ret, key) => ret + (mods[key] ? genBem(name, key) : ''),
+    ''
+  );
+}
+
+/**
+ * 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 function createBEM(name: string) {
+  return (el?: Mods, mods?: Mods): Mods => {
+    if (el && typeof el !== 'string') {
+      mods = el;
+      el = '';
+    }
+
+    el = el ? `${name}__${el}` : name;
+
+    return `${el}${genBem(el, mods)}`;
+  };
+}
+
+export type BEM = ReturnType<typeof createBEM>;
+
+export function createNamespace(name: string) {
+  const prefixedName = `van-${name}`;
+  return [
+    prefixedName,
+    createBEM(prefixedName),
+    createTranslate(prefixedName),
+  ] as const;
+}

package/es/utils/deep-assign.ts

@@ -0,0 +1,28 @@
+import { isDef, isObject } from './validate';
+
+type ObjectIndex = Record<string, unknown>;
+
+const { hasOwnProperty } = Object.prototype;
+
+function assignKey(to: ObjectIndex, from: ObjectIndex, key: string) {
+  const val = from[key];
+
+  if (!isDef(val)) {
+    return;
+  }
+
+  if (!hasOwnProperty.call(to, key) || !isObject(val)) {
+    to[key] = val;
+  } else {
+    // eslint-disable-next-line no-use-before-define
+    to[key] = deepAssign(Object(to[key]), val);
+  }
+}
+
+export function deepAssign(to: ObjectIndex, from: ObjectIndex): ObjectIndex {
+  Object.keys(from).forEach((key) => {
+    assignKey(to, from, key);
+  });
+
+  return to;
+}

package/es/utils/deep-clone.ts

@@ -0,0 +1,24 @@
+import { isDef, isObject } from './validate';
+
+export function deepClone<T extends Record<string, any> | null | undefined>(
+  obj: T
+): T {
+  if (!isDef(obj)) {
+    return obj;
+  }
+
+  if (Array.isArray(obj)) {
+    return obj.map((item) => deepClone(item)) as unknown as T;
+  }
+
+  if (isObject(obj)) {
+    const to = {} as Record<string, any>;
+    Object.keys(obj).forEach((key) => {
+      to[key] = deepClone(obj[key]);
+    });
+
+    return to as T;
+  }
+
+  return obj;
+}

package/es/utils/dom.ts

@@ -0,0 +1,88 @@
+import { useRect, useWindowSize } from '@vant/use';
+import { unref, Ref } from 'vue';
+import { isIOS as checkIsIOS } from './validate';
+
+export type ScrollElement = Element | Window;
+
+export function getScrollTop(el: ScrollElement): number {
+  const top = 'scrollTop' in el ? el.scrollTop : el.pageYOffset;
+
+  // iOS scroll bounce cause minus scrollTop
+  return Math.max(top, 0);
+}
+
+export function setScrollTop(el: ScrollElement, value: number) {
+  if ('scrollTop' in el) {
+    el.scrollTop = value;
+  } else {
+    el.scrollTo(el.scrollX, value);
+  }
+}
+
+export function getRootScrollTop(): number {
+  return (
+    window.pageYOffset ||
+    document.documentElement.scrollTop ||
+    document.body.scrollTop ||
+    0
+  );
+}
+
+export function setRootScrollTop(value: number) {
+  setScrollTop(window, value);
+  setScrollTop(document.body, value);
+}
+
+// get distance from element top to page top or scroller top
+export function getElementTop(el: ScrollElement, scroller?: ScrollElement) {
+  if (el === window) {
+    return 0;
+  }
+
+  const scrollTop = scroller ? getScrollTop(scroller) : getRootScrollTop();
+  return useRect(el).top + scrollTop;
+}
+
+const isIOS = checkIsIOS();
+
+// hack for iOS12 page scroll
+// see: https://developers.weixin.qq.com/community/develop/doc/00044ae90742f8c82fb78fcae56800
+export function resetScroll() {
+  if (isIOS) {
+    setRootScrollTop(getRootScrollTop());
+  }
+}
+
+export const stopPropagation = (event: Event) => event.stopPropagation();
+
+export function preventDefault(event: Event, isStopPropagation?: boolean) {
+  /* istanbul ignore else */
+  if (typeof event.cancelable !== 'boolean' || event.cancelable) {
+    event.preventDefault();
+  }
+
+  if (isStopPropagation) {
+    stopPropagation(event);
+  }
+}
+
+export function isHidden(
+  elementRef: HTMLElement | Ref<HTMLElement | undefined>
+) {
+  const el = unref(elementRef);
+  if (!el) {
+    return false;
+  }
+
+  const style = window.getComputedStyle(el);
+  const hidden = style.display === 'none';
+
+  // offsetParent returns null in the following situations:
+  // 1. The element or its parent element has the display property set to none.
+  // 2. The element has the position property set to fixed
+  const parentHidden = el.offsetParent === null && style.position !== 'fixed';
+
+  return hidden || parentHidden;
+}
+
+export const { width: windowWidth, height: windowHeight } = useWindowSize();

package/es/utils/format.ts

@@ -0,0 +1,154 @@
+import type { CSSProperties } from 'vue';
+import { inBrowser, type Numeric } from './basic';
+import { windowWidth, windowHeight } from './dom';
+import { isDef, isNumeric } from './validate';
+
+export function addUnit(value?: Numeric): string | undefined {
+  if (isDef(value)) {
+    return isNumeric(value) ? `${value}px` : String(value);
+  }
+  return undefined;
+}
+
+export function getSizeStyle(
+  originSize?: Numeric | Numeric[]
+): CSSProperties | undefined {
+  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,
+    };
+  }
+}
+
+export function getZIndexStyle(zIndex?: Numeric) {
+  const style: CSSProperties = {};
+  if (zIndex !== undefined) {
+    style.zIndex = +zIndex;
+  }
+  return style;
+}
+
+// cache
+let rootFontSize: number;
+
+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: string) {
+  value = value.replace(/rem/g, '');
+  return +value * getRootFontSize();
+}
+
+function convertVw(value: string) {
+  value = value.replace(/vw/g, '');
+  return (+value * windowWidth.value) / 100;
+}
+
+function convertVh(value: string) {
+  value = value.replace(/vh/g, '');
+  return (+value * windowHeight.value) / 100;
+}
+
+export function unitToPx(value: Numeric): number {
+  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;
+
+export const camelize = (str: string): string =>
+  str.replace(camelizeRE, (_, c) => c.toUpperCase());
+
+export const kebabCase = (str: string) =>
+  str
+    .replace(/([A-Z])/g, '-$1')
+    .toLowerCase()
+    .replace(/^-/, '');
+
+export function padZero(num: Numeric, targetLength = 2): string {
+  let str = num + '';
+
+  while (str.length < targetLength) {
+    str = '0' + str;
+  }
+
+  return str;
+}
+
+/** clamps number within the inclusive lower and upper bounds */
+export const clamp = (num: number, min: number, max: number): number =>
+  Math.min(Math.max(num, min), max);
+
+function trimExtraChar(value: string, char: string, regExp: 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, '');
+}
+
+export function formatNumber(
+  value: string,
+  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, '');
+}
+
+// add num and avoid float number
+export function addNumber(num1: number, num2: number) {
+  const cardinal = 10 ** 10;
+  return Math.round((num1 + num2) * cardinal) / cardinal;
+}

package/es/utils/interceptor.ts

@@ -0,0 +1,42 @@
+import { noop } from './basic';
+import { isPromise } from './validate';
+
+export type Interceptor = (
+  ...args: any[]
+) => Promise<boolean> | boolean | undefined | void;
+
+export function callInterceptor(
+  interceptor: Interceptor | undefined,
+  {
+    args = [],
+    done,
+    canceled,
+  }: {
+    args?: unknown[];
+    done: () => void;
+    canceled?: () => void;
+  }
+) {
+  if (interceptor) {
+    // eslint-disable-next-line prefer-spread
+    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();
+  }
+}

package/es/utils/mount-component.ts

@@ -0,0 +1,47 @@
+import { createApp, reactive, Component } from 'vue';
+import { extend } from '../utils';
+import { useExpose } from '../composables/use-expose';
+
+export function usePopupState() {
+  const state = reactive<{
+    show: boolean;
+    [key: string]: any;
+  }>({
+    show: false,
+  });
+
+  const toggle = (show: boolean) => {
+    state.show = show;
+  };
+
+  const open = (props: Record<string, any>) => {
+    extend(state, props, { transitionAppear: true });
+    toggle(true);
+  };
+
+  const close = () => toggle(false);
+
+  useExpose({ open, close, toggle });
+
+  return {
+    open,
+    close,
+    state,
+    toggle,
+  };
+}
+
+export function mountComponent(RootComponent: Component) {
+  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);
+    },
+  };
+}

package/es/utils/props.ts

@@ -0,0 +1,39 @@
+/**
+ * prop type helpers
+ * help us to write less code and reduce bundle size
+ */
+import type { PropType } from 'vue';
+
+export const unknownProp = null as unknown as PropType<unknown>;
+
+export const numericProp = [Number, String];
+
+export const truthProp = {
+  type: Boolean,
+  default: true as const,
+};
+
+export const makeRequiredProp = <T>(type: T) => ({
+  type,
+  required: true as const,
+});
+
+export const makeArrayProp = <T>() => ({
+  type: Array as PropType<T[]>,
+  default: () => [],
+});
+
+export const makeNumberProp = <T>(defaultVal: T) => ({
+  type: Number,
+  default: defaultVal,
+});
+
+export const makeNumericProp = <T>(defaultVal: T) => ({
+  type: numericProp,
+  default: defaultVal,
+});
+
+export const makeStringProp = <T>(defaultVal: T) => ({
+  type: String as unknown as PropType<T>,
+  default: defaultVal,
+});

package/es/utils/validate.ts

@@ -0,0 +1,33 @@
+import { inBrowser, type Numeric } from './basic';
+
+export const isDef = <T>(val: T): val is NonNullable<T> =>
+  val !== undefined && val !== null;
+
+// eslint-disable-next-line @typescript-eslint/ban-types
+export const isFunction = (val: unknown): val is Function =>
+  typeof val === 'function';
+
+export const isObject = (val: unknown): val is Record<any, any> =>
+  val !== null && typeof val === 'object';
+
+export const isPromise = <T = any>(val: unknown): val is Promise<T> =>
+  isObject(val) && isFunction(val.then) && isFunction(val.catch);
+
+export const isDate = (val: unknown): val is Date =>
+  Object.prototype.toString.call(val) === '[object Date]' &&
+  !Number.isNaN((val as Date).getTime());
+
+export function isMobile(value: string): boolean {
+  value = value.replace(/[^-|\d]/g, '');
+  return (
+    /^((\+86)|(86))?(1)\d{10}$/.test(value) || /^0[0-9-]{10,13}$/.test(value)
+  );
+}
+
+export const isNumeric = (val: Numeric): val is string =>
+  typeof val === 'number' || /^\d+(\.\d+)?$/.test(val);
+
+export const isIOS = (): boolean =>
+  inBrowser
+    ? /ios|iphone|ipad|ipod/.test(navigator.userAgent.toLowerCase())
+    : false;

package/es/utils/with-install.ts

@@ -0,0 +1,27 @@
+import { camelize } from './format';
+import type { App, Component } from 'vue';
+
+// https://github.com/vant-ui/vant/issues/8302
+type EventShim = {
+  new (...args: any[]): {
+    $props: {
+      onClick?: (...args: any[]) => void;
+    };
+  };
+};
+
+export type WithInstall<T> = T & {
+  install(app: App): void;
+} & EventShim;
+
+export function withInstall<T extends Component>(options: T) {
+  (options as Record<string, unknown>).install = (app: App) => {
+    const { name } = options;
+    if (name) {
+      app.component(name, options);
+      app.component(camelize(`-${name}`), options);
+    }
+  };
+
+  return options as WithInstall<T>;
+}

package/es/video-preview/README.md

@@ -0,0 +1,66 @@
+# VideoPreview
+
+### Intro
+
+Preview a video in a full-screen popup. It is built on [Plyr](https://github.com/sampotts/plyr), an MIT-licensed open-source player, and provides play, seek, mute, speed and fullscreen controls. Tap the empty player area or the close button to exit.
+
+### Usage
+
+```js
+import { VideoPreview } from 'vant';
+import 'vant/es/video-preview/style';
+
+VideoPreview({ src: 'https://example.com/video.mp4' });
+```
+
+Or use it as a component:
+
+```vue
+<van-video-preview
+  v-model:show="show"
+  src="https://example.com/video.mp4"
+/>
+```
+
+## API
+
+### Options
+
+| Option | Description | Type | Default |
+| --- | --- | --- | --- |
+| src | Video URL | _string_ | - |
+| poster | Video poster URL | _string_ | - |
+| autoplay | Whether to autoplay | _boolean_ | `false` |
+| muted | Whether to mute | _boolean_ | `false` |
+| loop | Whether to loop | _boolean_ | `false` |
+| controls | Whether to show controls | _boolean_ | `true` |
+| fit | Video fit mode: `contain` or `cover` | _string_ | `contain` |
+| closeable | Whether to show close icon | _boolean_ | `true` |
+| closeIcon | Close icon name | _string_ | `cross` |
+| closeIconPosition | Close icon position | _string_ | `top-left` |
+| playbackRates | Available playback speeds | _number[]_ | `[0.5, 1, 1.5, 2]` |
+| teleport | Mount target | _string \| Element_ | `body` |
+
+All options except `onXxx` callbacks can be used as component props.
+
+### Events
+
+| Event | Description | Arguments |
+| --- | --- | --- |
+| update:show | Emitted when visibility changes | _show: boolean_ |
+| close | Emitted when closing | - |
+| closed | Emitted after closed | - |
+| play | Emitted when playing | _event: Event_ |
+| pause | Emitted when paused | _event: Event_ |
+| ended | Emitted when playback ends | _event: Event_ |
+| timeupdate | Emitted when playback time changes | _event: Event_ |
+| error | Emitted on playback error | _event: Event_ |
+
+### Methods
+
+| Method | Description |
+| --- | --- |
+| play | Play the video |
+| pause | Pause the video |
+| close | Close the preview |
+| toggleFullscreen | Toggle fullscreen |