#228

Committed 07 Nov 2025 07:01AM UTC coverage: 95.814% (-2.0%) from 97.806%

Build # #228

Build Type

push

travis-pro

Committed by

lzxb

Commit Message

release: vue-class-setup@1.4.5

Run Details

139 of 156 branches covered (89.1%)

Branch coverage included in aggregate %.

479 of 489 relevant lines covered (97.96%)

10.85 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

89.47

/src/define.ts

import { type VueInstance, isVue2 } from './vue';
import { Context, DefaultProps, DefaultEmit } from './context';
import { createDefineProperty } from './property-descriptors';
import { SETUP_SETUP_DEFINE } from './config';

interface DefineInstance<T, E> {
    readonly $props: T;
    readonly $emit: E;
    readonly $vm: VueInstance;
    readonly $defaultProps: Readonly<Partial<T>>;
}

type DefineInstanceType<
    T extends DefaultProps,
    E extends DefaultEmit = DefaultEmit,
> = Readonly<T> & DefineInstance<T, E>;

export interface DefineConstructor {
    inject: (typeof Context)['inject'];
    use: (typeof Context)['use'];
    setup: (typeof Context)['setup'];
    setupOptions: (typeof Context)['setupOptions'];
    setupDefine: boolean;
    setupPropertyDescriptor: Map<string, PropertyDescriptor>;
    new <T extends {} = {}, E extends DefaultEmit = DefaultEmit>(
        ...args: any[]
    ): DefineInstanceType<T, E>;
}
function GET_TRUE() {
    return true;
}

export const Define: DefineConstructor = class Define extends Context {
    public static setupDefine = true;
    public $defaultProps: Record<string, any> = {};
    public constructor() {
        super();
        const defineProperty = createDefineProperty(this);
        defineProperty('$defaultProps', {
            enumerable: false,
            writable: false,
        });
        defineProperty(SETUP_SETUP_DEFINE, {
            get: GET_TRUE,
        });
    }
} as any;

export function initDefine(target: InstanceType<DefineConstructor>) {
    const definePropertyTarget = createDefineProperty(target);
    const props = target.$props;

    Object.keys(props).forEach((k) => {
        if (k in target) {
            // @ts-ignore
            target.$defaultProps[k] = target[k];
            const defaultProps = target.$defaultProps;
            definePropertyTarget(k, {
                get() {
                    let value = props[k];
                    if (typeof value === 'boolean') {
                        if (!hasDefaultValue(target.$vm, k)) {
                            value = defaultProps[k];
                        }
                    } else if (isNull(value)) {
                        value = defaultProps[k];
                    }
                    return value;
                },
            });
        } else {
            definePropertyTarget(k, {
                get() {
                    return props[k];
                },
            });
        }
    });
}

function hasDefaultValue(vm: VueInstance, key: string): boolean {
    let props: Record<string, any> | null = null;
    if (isVue2) {
        props = vm.$options && vm.$options['propsData'];
    } else {
        props = vm.$ && vm.$.vnode && vm.$.vnode.props;
    }
    if (props) {
        const value = props[key];
        return !isNull(isNull(value) ? props[kebabCase(key)] : value);
    }
    return false;
}

function isNull(value: unknown) {
    return typeof value === 'undefined' || value === null;
}

const KEBAB_REGEX = /[A-Z]/g;

function kebabCase(str: string) {
    return str
        .replace(KEBAB_REGEX, (match) => {
            return '-' + match.toLowerCase();
        })
        .replace(/^-/, '');
}

1	import { type VueInstance, isVue2 } from './vue';
2	import { Context, DefaultProps, DefaultEmit } from './context';
3	import { createDefineProperty } from './property-descriptors';
4	import { SETUP_SETUP_DEFINE } from './config';
5
6	interface DefineInstance<T, E> {
7	readonly $props: T;
8	readonly $emit: E;
9	readonly $vm: VueInstance;
10	readonly $defaultProps: Readonly<Partial<T>>;
11	}
12
13	type DefineInstanceType<
14	T extends DefaultProps,
15	E extends DefaultEmit = DefaultEmit,
16	> = Readonly<T> & DefineInstance<T, E>;
17
18	export interface DefineConstructor {
19	inject: (typeof Context)['inject'];
20	use: (typeof Context)['use'];
21	setup: (typeof Context)['setup'];
22	setupOptions: (typeof Context)['setupOptions'];
23	setupDefine: boolean;
24	setupPropertyDescriptor: Map<string, PropertyDescriptor>;
25	new <T extends {} = {}, E extends DefaultEmit = DefaultEmit>(
26	...args: any[]
27	): DefineInstanceType<T, E>;
28	}
29	function GET_TRUE() {
30	return true;	20✔
31	}
32
33	export const Define: DefineConstructor = class Define extends Context {	21✔
34	public static setupDefine = true;	21✔
35	public $defaultProps: Record<string, any> = {};	17✔
36	public constructor() {
37	super();	17✔
38	const defineProperty = createDefineProperty(this);	17✔
39	defineProperty('$defaultProps', {	17✔
40	enumerable: false,
41	writable: false,
42	});
43	defineProperty(SETUP_SETUP_DEFINE, {	17✔
44	get: GET_TRUE,
45	});
46	}
47	} as any;
48
49	export function initDefine(target: InstanceType<DefineConstructor>) {
50	const definePropertyTarget = createDefineProperty(target);	17✔
51	const props = target.$props;	17✔
52
53	Object.keys(props).forEach((k) => {	17✔
54	if (k in target) {	21✔
55	// @ts-ignore
56	target.$defaultProps[k] = target[k];	9✔
57	const defaultProps = target.$defaultProps;	9✔
58	definePropertyTarget(k, {	9✔
59	get() {
60	let value = props[k];	26✔
61	if (typeof value === 'boolean') {	26✔
62	if (!hasDefaultValue(target.$vm, k)) {	16✔
63	value = defaultProps[k];	7✔
64	}
65	} else if (isNull(value)) {	10✔
66	value = defaultProps[k];	6✔
67	}
68	return value;	26✔
69	},
70	});
71	} else {
72	definePropertyTarget(k, {	12✔
73	get() {
74	return props[k];	9✔
75	},
76	});
77	}
78	});
79	}
80
81	function hasDefaultValue(vm: VueInstance, key: string): boolean {
82	let props: Record<string, any> \| null = null;	16✔
83	if (isVue2) {	16!
84	props = vm.$options && vm.$options['propsData'];	×
85	} else {
86	props = vm.$ && vm.$.vnode && vm.$.vnode.props;	16✔
87	}
88	if (props) {	16!
89	const value = props[key];	16✔
90	return !isNull(isNull(value) ? props[kebabCase(key)] : value);	16✔
91	}
92	return false;	×
93	}
94
95	function isNull(value: unknown) {
96	return typeof value === 'undefined' \|\| value === null;	42✔
97	}
98
99	const KEBAB_REGEX = /[A-Z]/g;	21✔
100
101	function kebabCase(str: string) {
102	return str	7✔
103	.replace(KEBAB_REGEX, (match) => {
104	return '-' + match.toLowerCase();	1✔
105	})
106	.replace(/^-/, '');
107	}

fmfe / vue-class-setup / #228

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous