cbvirtua 1.0.9 → 1.0.11

package/vant/utils/router.ts

@@ -0,0 +1,54 @@
+/**
+ * Vue Router support
+ */
+
+import { RenderContext } from 'vue/types';
+import VueRouter, { RawLocation } from 'vue-router/types';
+
+export type RouteConfig = {
+  url?: string;
+  to?: RawLocation;
+  replace?: boolean;
+};
+
+function isRedundantNavigation(err: Error) {
+  return (
+    err.name === 'NavigationDuplicated' ||
+    // compatible with vue-router@3.3
+    (err.message && err.message.indexOf('redundant navigation') !== -1)
+  );
+}
+
+export function route(router: VueRouter, config: RouteConfig) {
+  const { to, url, replace } = config;
+  if (to && router) {
+    const promise = router[replace ? 'replace' : 'push'](to);
+
+    /* istanbul ignore else */
+    if (promise && promise.catch) {
+      promise.catch((err) => {
+        if (err && !isRedundantNavigation(err)) {
+          throw err;
+        }
+      });
+    }
+  } else if (url) {
+    replace ? location.replace(url) : (location.href = url);
+  }
+}
+
+export function functionalRoute(context: RenderContext) {
+  route(context.parent && context.parent.$router, context.props);
+}
+
+export type RouteProps = {
+  url?: string;
+  replace?: boolean;
+  to?: RawLocation;
+};
+
+export const routeProps = {
+  url: String,
+  replace: Boolean,
+  to: [String, Object],
+};

package/vant/utils/test/bem.spec.js

@@ -0,0 +1,39 @@
+import { createBEM } from '../create/bem';
+
+test('bem', () => {
+  const bem = createBEM('button');
+
+  expect(bem()).toEqual('button');
+
+  expect(bem('text')).toEqual('button__text');
+
+  expect(bem({ disabled: false })).toEqual('button');
+
+  expect(bem({ disabled: true })).toEqual('button button--disabled');
+
+  expect(bem('text', { disabled: true })).toEqual(
+    'button__text button__text--disabled'
+  );
+
+  expect(bem(['disabled', 'primary'])).toEqual(
+    'button button--disabled button--primary'
+  );
+
+  expect(bem([])).toEqual('button');
+
+  expect(bem(null)).toEqual('button');
+
+  expect(bem([null])).toEqual('button');
+
+  expect(bem(['disabled', ''])).toEqual('button button--disabled');
+
+  expect(bem(['disabled', undefined])).toEqual('button button--disabled');
+
+  expect(bem('text', ['disabled', 'primary'])).toEqual(
+    'button__text button__text--disabled button__text--primary'
+  );
+
+  expect(bem('text', [{ disabled: true }, 'primary'])).toEqual(
+    'button__text button__text--disabled button__text--primary'
+  );
+});

package/vant/utils/test/index.spec.js

@@ -0,0 +1,152 @@
+import { deepClone } from '../deep-clone';
+import { deepAssign } from '../deep-assign';
+import { isDef, get, noop } from '..';
+import { raf, cancelRaf } from '../dom/raf';
+import { later } from '../../../test';
+import { isEmail } from '../validate/email';
+import { isMobile } from '../validate/mobile';
+import { isNumeric } from '../validate/number';
+import { isAndroid } from '../validate/system';
+import { camelize } from '../format/string';
+import { formatNumber } from '../format/number';
+import { addUnit, unitToPx } from '../format/unit';
+
+test('deepClone', () => {
+  const a = { foo: 0 };
+  const b = { foo: 0, bar: 1 };
+  const arr = [a, b];
+  expect(deepClone(a)).toEqual(a);
+  expect(deepClone(b)).toEqual(b);
+  expect(deepClone(noop)).toEqual(noop);
+  expect(deepClone(arr)).toEqual(arr);
+  expect(deepClone(undefined)).toEqual(undefined);
+  expect(deepClone(1)).toEqual(1);
+});
+
+test('deepAssign', () => {
+  expect(deepAssign({}, { foo: null })).toEqual({});
+  expect(deepAssign({}, { foo: undefined })).toEqual({});
+  expect(deepAssign({ noop: null }, { noop })).toEqual({ noop });
+  expect(deepAssign({ foo: 0 }, { bar: 1 })).toEqual({ foo: 0, bar: 1 });
+  expect(
+    deepAssign({ foo: { bar: false } }, { foo: { bar: true, foo: false } })
+  ).toEqual({
+    foo: {
+      bar: true,
+      foo: false,
+    },
+  });
+});
+
+test('isDef', () => {
+  expect(isDef(null)).toBeFalsy();
+  expect(isDef(undefined)).toBeFalsy();
+  expect(isDef(1)).toBeTruthy();
+  expect(isDef('1')).toBeTruthy();
+  expect(isDef({})).toBeTruthy();
+  expect(isDef(noop)).toBeTruthy();
+});
+
+test('camelize', () => {
+  expect(camelize('ab')).toEqual('ab');
+  expect(camelize('a-b')).toEqual('aB');
+  expect(camelize('a-b-c-d')).toEqual('aBCD');
+  expect(camelize('a-b-')).toEqual('aB-');
+  expect(camelize('-a-b')).toEqual('AB');
+  expect(camelize('-')).toEqual('-');
+});
+
+test('get', () => {
+  expect(get({ a: 1 }, 'a')).toEqual(1);
+  expect(get({ a: { b: 2 } }, 'a.b')).toEqual(2);
+  expect(get({ a: { b: 2 } }, 'a.b.c')).toEqual('');
+});
+
+test('isAndroid', () => {
+  expect(isAndroid()).toBeFalsy();
+});
+
+test('raf', async () => {
+  const spy = jest.fn();
+  raf(spy);
+
+  await later(50);
+  expect(spy).toHaveBeenCalledTimes(1);
+  cancelRaf(1);
+});
+
+test('isEmail', () => {
+  expect(isEmail('abc@gmail.com')).toBeTruthy();
+  expect(isEmail(' abc@gmail.com ')).toBeTruthy();
+  expect(isEmail('abc@@gmail.com')).toBeFalsy();
+  expect(isEmail('@gmail.com')).toBeFalsy();
+  expect(isEmail('abc@')).toBeFalsy();
+});
+
+test('isMobile', () => {
+  expect(isMobile('13000000000')).toBeTruthy();
+  expect(isMobile('+8613000000000')).toBeTruthy();
+  expect(isMobile('8613000000000')).toBeTruthy();
+  expect(isMobile('1300000000')).toBeFalsy();
+  expect(isMobile('abc')).toBeFalsy();
+});
+
+test('isNumeric', () => {
+  expect(isNumeric('1')).toBeTruthy();
+  expect(isNumeric('1.2')).toBeTruthy();
+  expect(isNumeric('1..2')).toBeFalsy();
+  expect(isNumeric('abc')).toBeFalsy();
+  expect(isNumeric('1b2')).toBeFalsy();
+});
+
+test('formatNumber', () => {
+  // with dot
+  expect(formatNumber('abc')).toEqual('');
+  expect(formatNumber('1.2')).toEqual('1.2');
+  expect(formatNumber('abc1.2')).toEqual('1.2');
+  expect(formatNumber('123.4.')).toEqual('123.4');
+
+  // without dot
+  expect(formatNumber('1.2', false)).toEqual('1');
+  expect(formatNumber('abc1.2', false)).toEqual('1');
+  expect(formatNumber('123.4.', false)).toEqual('123');
+
+  // minus
+  expect(formatNumber('-1.2', false)).toEqual('-1');
+  expect(formatNumber('-1.2', false, false)).toEqual('1');
+  expect(formatNumber('-1.2', true)).toEqual('-1.2');
+  expect(formatNumber('-1.2-', true)).toEqual('-1.2');
+  expect(formatNumber('123-')).toEqual('123');
+
+  // special cases
+  expect(formatNumber('.1', true)).toEqual('0.1');
+  expect(formatNumber('-.1')).toEqual('-0.1');
+});
+
+test('addUnit', () => {
+  expect(addUnit(0)).toEqual('0px');
+  expect(addUnit(10)).toEqual('10px');
+  expect(addUnit('1%')).toEqual('1%');
+  expect(addUnit('1px')).toEqual('1px');
+  expect(addUnit('1vw')).toEqual('1vw');
+  expect(addUnit('1vh')).toEqual('1vh');
+  expect(addUnit('1rem')).toEqual('1rem');
+});
+
+test('unitToPx', () => {
+  const originGetComputedStyle = window.getComputedStyle;
+
+  window.innerWidth = 100;
+  window.innerHeight = 200;
+  window.getComputedStyle = () => ({ fontSize: '16px' });
+
+  expect(unitToPx(0)).toEqual(0);
+  expect(unitToPx(10)).toEqual(10);
+  expect(unitToPx('10px')).toEqual(10);
+  expect(unitToPx('0rem')).toEqual(0);
+  expect(unitToPx('10rem')).toEqual(160);
+  expect(unitToPx('10vw')).toEqual(10);
+  expect(unitToPx('10vh')).toEqual(20);
+
+  window.getComputedStyle = originGetComputedStyle;
+});

package/vant/utils/test/interceptor.spec.js

@@ -0,0 +1,50 @@
+import { later } from '../../../test';
+import { callInterceptor } from '../interceptor';
+
+test('#callInterceptor', async () => {
+  const done = jest.fn();
+  callInterceptor({ done });
+  expect(done).toHaveBeenCalledTimes(1);
+
+  callInterceptor({
+    interceptor: () => false,
+    done,
+  });
+  expect(done).toHaveBeenCalledTimes(1);
+
+  callInterceptor({
+    interceptor: () => true,
+    done,
+  });
+  expect(done).toHaveBeenCalledTimes(2);
+
+  callInterceptor({
+    interceptor: () => Promise.resolve(false),
+    done,
+  });
+  await later();
+  expect(done).toHaveBeenCalledTimes(2);
+
+  callInterceptor({
+    interceptor: () => Promise.resolve(true),
+    done,
+  });
+  await later();
+  expect(done).toHaveBeenCalledTimes(3);
+
+  callInterceptor({
+    interceptor: () => Promise.reject(),
+    done,
+  });
+  await later();
+  expect(done).toHaveBeenCalledTimes(3);
+
+  callInterceptor({
+    interceptor: (...args) => {
+      expect(args).toEqual(['foo']);
+    },
+    args: ['foo'],
+    done,
+  });
+  expect(done).toHaveBeenCalledTimes(3);
+});

package/vant/utils/types.ts

@@ -0,0 +1,40 @@
+import { VNode, CreateElement, RenderContext } from 'vue';
+import { InjectOptions, PropsDefinition } from 'vue/types/options';
+
+export type EventHandler = (event: Event) => void;
+
+export type ObjectIndex = Record<string, any>;
+
+export type ScopedSlot<Props = any> = (
+  props?: Props
+) => VNode[] | VNode | undefined;
+
+export type DefaultSlots = {
+  default?: ScopedSlot;
+};
+
+export type ScopedSlots = DefaultSlots & {
+  [key: string]: ScopedSlot | undefined;
+};
+
+export type ModelOptions = {
+  prop?: string;
+  event?: string;
+};
+
+export type DefaultProps = ObjectIndex;
+
+export type FunctionComponent<
+  Props = DefaultProps,
+  PropDefs = PropsDefinition<Props>
+> = {
+  (
+    h: CreateElement,
+    props: Props,
+    slots: ScopedSlots,
+    context: RenderContext<Props>
+  ): VNode | undefined;
+  props?: PropDefs;
+  model?: ModelOptions;
+  inject?: InjectOptions;
+};

package/vant/utils/validate/date.ts

@@ -0,0 +1,8 @@
+import { isNaN } from './number';
+
+export function isDate(val: Date): val is Date {
+  return (
+    Object.prototype.toString.call(val) === '[object Date]' &&
+    !isNaN(val.getTime())
+  );
+}

package/vant/utils/validate/email.ts

@@ -0,0 +1,5 @@
+/* eslint-disable */
+export function isEmail(value: string): boolean {
+  const reg = /^[a-zA-Z0-9_.+-]+@[a-zA-Z0-9-]+\.[a-zA-Z0-9-.]+$/;
+  return reg.test(value.trim());
+}

package/vant/utils/validate/mobile.ts

@@ -0,0 +1,6 @@
+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)
+  );
+}

package/vant/utils/validate/number.ts

@@ -0,0 +1,12 @@
+export function isNumeric(val: string): boolean {
+  return /^\d+(\.\d+)?$/.test(val);
+}
+
+export function isNaN(val: number): val is typeof NaN {
+  if (Number.isNaN) {
+    return Number.isNaN(val);
+  }
+
+  // eslint-disable-next-line no-self-compare
+  return val !== val;
+}

package/vant/utils/validate/system.ts

@@ -0,0 +1,13 @@
+import { isServer } from '..';
+
+export function isAndroid(): boolean {
+  /* istanbul ignore next */
+  return isServer ? false : /android/.test(navigator.userAgent.toLowerCase());
+}
+
+export function isIOS(): boolean {
+  /* istanbul ignore next */
+  return isServer
+    ? false
+    : /ios|iphone|ipad|ipod/.test(navigator.userAgent.toLowerCase());
+}

package/vant/utils/vnodes.ts

@@ -0,0 +1,33 @@
+import { VNode } from 'vue';
+
+function flattenVNodes(vnodes: VNode[]) {
+  const result: VNode[] = [];
+
+  function traverse(vnodes: VNode[]) {
+    vnodes.forEach((vnode) => {
+      result.push(vnode);
+
+      if (vnode.componentInstance) {
+        traverse(vnode.componentInstance.$children.map((item) => item.$vnode));
+      }
+
+      if (vnode.children) {
+        traverse(vnode.children);
+      }
+    });
+  }
+
+  traverse(vnodes);
+  return result;
+}
+
+// sort children instances by vnodes order
+export function sortChildren(children: Vue[], parent: Vue) {
+  const { componentOptions } = parent.$vnode;
+  if (!componentOptions || !componentOptions.children) {
+    return;
+  }
+
+  const vnodes = flattenVNodes(componentOptions.children);
+  children.sort((a, b) => vnodes.indexOf(a.$vnode) - vnodes.indexOf(b.$vnode));
+}

package/vue2/ex.vue

@@ -0,0 +1,66 @@
+<template>
+    <div>
+        <p @click="exfun()" v-if="status">222</p>
+        <div v-if="refresh">
+            <exx v-show="hasData" />
+        </div>
+    </div>
+</template>
+<script>
+import exx from './exx.vue'
+let context = {}
+const setContext = (vnode) => {
+    const p = new Promise((resolve, reject) => {
+        context.resolve = resolve
+        context.reject = reject
+        if (!vnode.context) {
+            vnode.context = context
+        }
+    })
+    return p
+}
+const initContext = () => {
+    setContext(exx) && context.resolve()
+}
+
+initContext()
+
+
+export default {
+    name: 'ex',
+
+    data() {
+        return {
+            refresh: false,
+            status: true,
+            hasData: false
+        }
+    },
+    async beforeCreated() {
+
+    },
+
+    async mounted() {
+
+    },
+    components: {
+        exx
+    },
+    methods: {
+        async exfun() {
+            let p = setContext(exx)
+            this.refresh = !this.refresh
+            if (this.refresh) {
+                let d = await p
+                if (d) {
+                    this.hasData = true
+                    this.status = false
+                }
+            }
+        }
+    }
+}
+</script>
+  
+<style></style>
+  

package/vue2/exx.vue

@@ -0,0 +1,44 @@
+<script>
+const NOOP = () => { }
+export function useContext() {
+
+}
+
+let i = 0
+export default {
+    name: 'ex',
+    data() {
+        return {
+            exx: 'exx1'
+        }
+    },
+    created() {
+        console.log(122222)
+        this.test()
+    },
+    mounted() {
+
+    },
+    components: {
+
+    },
+    methods: {
+        test() {
+            setTimeout(() => {
+                this.exx = 'exx2'
+                const { resolve } = this.$options.context
+                console.log(resolve)
+                i++
+                resolve(i)
+
+            }, 3000)
+        }
+    },
+    render() {
+        return <div>{this.exx}</div>
+    }
+}
+</script>
+  
+<style></style>
+