New Case Study:See how Anthropic automated 95% of dependency reviews with Socket.Learn More →
Socket
Sign inDemoInstall
Socket
Sign inDemoInstall

vue-facing-decorator

Package Overview
Dependencies
Maintainers
1
Versions
43
Alerts
File Explorer

Advanced tools

License
Socket logo

Install Socket

Detect and block malicious and high-risk dependencies

Install

vue-facing-decorator - npm Package Compare versions

Comparing version

1.0.7
to
2.0.3

dist/migration/vue-class-component/component.d.ts
dist/migration/vue-class-component/component.d.ts.map
dist/migration/vue-class-component/component.js
dist/migration/vue-class-component/component.js.map
dist/migration/vue-class-component/index.d.ts
dist/migration/vue-class-component/index.d.ts.map
dist/migration/vue-class-component/index.js
dist/migration/vue-class-component/index.js.map
src/migration/vue-class-component/index.ts

2

dist/component.d.ts

@@ -35,5 +35,5 @@ import { ComponentCustomOptions } from 'vue';

declare type ComponentConsOption = Cons | ComponentOption;
export declare function ComponentBase(cons: Cons): Cons;
export declare function ComponentBase(arg: ComponentConsOption): any;
export declare function Component(arg: ComponentConsOption): any;
export {};
//# sourceMappingURL=component.d.ts.map

75

dist/component.js

@@ -31,6 +31,3 @@ "use strict";

}
function ComponentStep(cons, extend) {
return (0, vue_1.defineComponent)(ComponentOption(cons, extend));
}
function ComponentStepWithOption(cons, arg, extend) {
function buildComponent(cons, arg, extend) {
let option = ComponentOption(cons, extend);

@@ -54,49 +51,49 @@ const slot = (0, utils_1.obtainSlot)(cons.prototype);

if (arg.modifier) {
option = arg.modifier(option);
if (!option) {
throw 'Component modifier should return vue component option';
}
arg.modifier(option);
}
return (0, vue_1.defineComponent)(option);
}
function ComponentBase(cons) {
function build(cons, option) {
const slot = (0, utils_1.obtainSlot)(cons.prototype);
slot.inComponent = true;
return cons;
const superSlot = (0, utils_1.getSuperSlot)(cons.prototype);
if (superSlot) {
if (!superSlot.inComponent) {
throw 'Class should be decorated by Component or ComponentBase: ' + slot.master;
}
if (superSlot.cachedVueComponent === null) {
throw 'Component decorator 1';
}
}
const component = buildComponent(cons, option, superSlot === null ? undefined : superSlot.cachedVueComponent);
slot.cachedVueComponent = component;
}
exports.ComponentBase = ComponentBase;
function Component(arg) {
function extend(cons) {
ComponentBase(cons);
const slotPath = (0, utils_1.extendSlotPath)(cons.prototype);
slotPath.forEach(proto => {
const slot = (0, utils_1.obtainSlot)(proto);
if (!slot.inComponent) {
throw 'Class should be decorated by Component or ComponentBase: ' + proto.constructor;
}
});
return slotPath.reduceRight((pv, cv, ci) => {
if (ci > 0) {
return ComponentStep(cv.constructor, pv === null ? undefined : pv);
}
else {
if (typeof arg === 'function') {
return ComponentStepWithOption(cv.constructor, {}, pv === null ? undefined : pv);
}
else {
return ComponentStepWithOption(cv.constructor, arg, pv === null ? undefined : pv);
}
}
}, null);
}
function _Component(arg, cb) {
if (typeof arg === 'function') {
const finalComp = extend(arg);
return finalComp;
return cb(arg, {});
}
return function (cons) {
const finalComp = extend(cons);
return finalComp;
return cb(cons, arg);
};
}
function ComponentBase(arg) {
return _Component(arg, function (cons, option) {
build(cons, option);
return cons;
});
}
exports.ComponentBase = ComponentBase;
function Component(arg) {
return _Component(arg, function (cons, option) {
build(cons, option);
// const slot = getSlot(cons.prototype)!
// Object.defineProperty(cons, '__vccOpts', {
// value: slot.cachedVueComponent
// })
// console.log('kkkk', '__vccOpts' in cons, cons)
// return cons
return (0, utils_1.obtainSlot)(cons.prototype).cachedVueComponent;
});
}
exports.Component = Component;
//# sourceMappingURL=component.js.map

7

dist/utils.d.ts
import type { BaseTypeIdentify } from './index';
declare class Slot {
master: any;
constructor(master: any);
names: Map<string, Map<string, any>>;
obtainMap<T extends Map<string, any>>(name: string): T;
inComponent: boolean;
cachedVueComponent: any;
}

@@ -12,5 +15,3 @@ export declare function makeSlot(obj: any): Slot;

export declare function toComponentReverse(obj: any): any[];
export declare function extendSlotPath(obj: any): {
constructor: any;
}[];
export declare function getSuperSlot(obj: any): Slot | null;
export declare function excludeNames(names: string[], slot: Slot): string[];

@@ -17,0 +18,0 @@ export declare function getValidNames(obj: any, filter: (des: PropertyDescriptor, name: string) => boolean): string[];

35

dist/utils.js
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.optoinNullableMemberDecorator = exports.getValidNames = exports.excludeNames = exports.extendSlotPath = exports.toComponentReverse = exports.makeObject = exports.obtainSlot = exports.getSlot = exports.makeSlot = void 0;
exports.optoinNullableMemberDecorator = exports.getValidNames = exports.excludeNames = exports.getSuperSlot = exports.toComponentReverse = exports.makeObject = exports.obtainSlot = exports.getSlot = exports.makeSlot = void 0;
const index_1 = require("./index");
const SlotSymbol = Symbol('vue-facing-decorator-slot');
class Slot {
constructor() {
constructor(master) {
this.names = new Map;
this.inComponent = false;
this.cachedVueComponent = null;
this.master = master;
}

@@ -26,3 +28,3 @@ obtainMap(name) {

}
const slot = new Slot;
const slot = new Slot(obj);
Object.defineProperty(obj, SlotSymbol, {

@@ -74,14 +76,27 @@ enumerable: false,

exports.toComponentReverse = toComponentReverse;
function extendSlotPath(obj) {
const arr = [];
let curr = obj;
function getSuperSlot(obj) {
let curr = Object.getPrototypeOf(obj);
while (curr.constructor !== index_1.Base) {
if (getSlot(curr)) {
arr.push(curr);
const slot = getSlot(curr);
if (slot) {
return slot;
}
curr = Object.getPrototypeOf(curr);
}
return arr;
return null;
}
exports.extendSlotPath = extendSlotPath;
exports.getSuperSlot = getSuperSlot;
// export function extendSlotPath(obj: any): {
// constructor: any
// }[] {
// const arr: any[] = []
// let curr = obj
// while (curr.constructor !== Base) {
// if (getSlot(curr)) {
// arr.push(curr)
// }
// curr = Object.getPrototypeOf(curr)
// }
// return arr
// }
function excludeNames(names, slot) {

@@ -88,0 +103,0 @@ return names.filter(name => {

2

package.json
{
"name": "vue-facing-decorator",
"version": "1.0.7",
"version": "2.0.3",
"description": "Vue typescript class and decorator based component.",

@@ -5,0 +5,0 @@ "main": "dist/index.js",

613

readme.md
# Read me
![GitHub](https://img.shields.io/github/license/facing-dev/vue-facing-decorator) ![GitHub package.json version (branch)](https://img.shields.io/github/package-json/v/facing-dev/vue-facing-decorator/release) ![npm peer dependency version (scoped)](https://img.shields.io/npm/dependency-version/vue-facing-decorator/peer/vue)
![GitHub](https://img.shields.io/github/license/facing-dev/vue-facing-decorator) ![npm](https://img.shields.io/npm/v/vue-facing-decorator) ![npm peer dependency version (scoped)](https://img.shields.io/npm/dependency-version/vue-facing-decorator/peer/vue)

@@ -10,3 +10,3 @@ Designed for vue 3, do the same work like [vue-class-component](https://github.com/vuejs/vue-class-component) and [vue-property-decorator](https://github.com/kaorun343/vue-property-decorator).

* Performance. Once transform on project loading, ready for everywhere.
* Support es class inherit, vue component `extends` and vue `mixins`.
* Support es class inherit, vue `extends` and vue `mixins`.

@@ -16,609 +16,4 @@

# Install
# Document
`npm install -S vue-facing-decorator`
# How to use
### Index
* [Basic](#basic)
* [Extends and mixins](#extends-and-mixins)
* [Tsx render](#tsx-render)
* [In class lifecycle names](#in-class-lifecycle-names)
### Basic
```typescript
import {
Component,
Ref,
Watch,
Prop,
Inject,
Emit,
Base,
} from "vue-facing-decorator";
import AnotherComponent from "./AnotherComponent.vue";
//super class. See extends section.
class Sup extends Base {
//reactivity super property
supProperty = "supProperty";
//super method
supMethod() {}
//super getter
get supGetter() {
return "supGetter";
}
}
//component class
@Component({
//OPTION, component name
name: "MyComponent",
//OPTION, emits
emits: ["update:modelValue"],
//OPTION, provide object or function(this:Comp){return {foo:'bar'}}
provide: {
provideKey: "provideValue",
},
//OPTION, components
components: {
AnotherComponent,
},
//OPTION, inheritAttrs
inheritAttrs:true,
//OPTION, expose
expose:[],
//OPTION, directives
directives:{
},
//OPTION, mixins
mixins:[{}],
//OPTION, template string, [NEED VUE FULL BUILD](https://vuejs.org/api/options-rendering.html#template).
template:'<div></div>',
//OPTION, render function
render(){
},
//OPTION, this will be assigned to vue option
options: {
beforeRouteEnter() {
},
},
//OPTION, use modifier to modify component option built by vue-facing-decorator
modifier: (option: any) => {
console.log("generated optoin", option);
option.methods ??= {};
option.methods.method2 = function () {
console.log("method2");
};
return option;
},
})
export default class Comp extends Sup {
//emit an event with name of method
@Emit()
eventName(arg: any) {
return arg;
}
//emit an event with custom name and promise value
//event will be emitted when promise resolved
@Emit("eventCustomNamePromise")
event2(arg: any) {
return new Promise((resolver) => {
resolver(arg);
});
}
//create a ref
@Ref
readonly ref!: HTMLDivElement;
//create a prop
@Prop({
//prop options
required: true,
default: "default prop",
type: String,
validator(v: string) {
console.log("prop validator", v);
return true;
},
})
readonly prop!: string;
//v-model default prop
@Prop({
required: true,
type: Number,
})
readonly modelValue!: number;
//reactivity property
property = "property";
//getter
get getter() {
return "getter";
}
//method
method() {
//call vue api
this.$forceUpdate();
//set reactivity property
this.property += ">";
//trigger update v-model
this.$emit("update:modelValue", this.modelValue + 1);
}
//create a watcher
@Watch("property", {
//watcher options
deep: true,
immediate: true,
flush: "post",
})
propertyWatcher(newv: string, oldv: string) {
console.log("property changed", newv, oldv);
}
//inject from acient components
@Inject({
//inject options
default: "defult value",
from: "provideAcientKey",
})
provideAcientKeyAlias!: string;
mounted() {
//vue lifecycle
console.log(
this.ref,
this.getter,
this.property,
this.supProperty,
this.supGetter,
this.prop,
this.provideAcientKeyAlias
);
this.eventName("eventName value");
this.event2("eventCustomNamePromise value");
}
}
```
is equal to
```typescript
import { defineComponent} from "vue";
import AnotherComponent from "./AnotherComponent.vue";
export default defineComponent({
name: "MyComponent",
components: {
AnotherComponent,
},
emits: ["update:modelValue", "eventName", "eventCustomNamePromise"],
provide: {
provideKey: "provideValue",
},
inject: {
provideAcientKeyAlias: {
default: "defult value",
from: "provideAcientKey",
},
},
data() {
return {
supProperty: "supProperty",
property: "property",
};
},
methods: {
supMethod() {},
method() {
this.$forceUpdate();
this.$emit("update:modelValue", this.modelValue + 1);
},
method2() {
console.log("method2");
},
eventName() {
this.$emit("eventName", "eventName value");
},
async event2() {
const value = await new Promise<any>((resolver) => {
resolver("eventCustomNamePromise value");
});
this.$emit("eventCustomNamePromise", value);
},
},
watch: {
property: function (newv: string, oldv: string) {
console.log("property changed", newv, oldv);
},
},
computed: {
supGetter() {
return "supGetter";
},
getter() {
return "getter";
},
ref() {
this.$refs["ref"];
},
},
props: {
prop: {
required: true,
default: "default prop",
type: String,
validator: function (v: string) {
console.log("prop validator", v);
return true;
} as any, // type error
},
modelValue: { type: Number, required: true },
},
mounted() {
console.log(
this.ref,
this.property,
this.supProperty,
this.getter,
this.supGetter,
this.prop,
(this as any).provideAcientKeyAlias //type error
);
},
beforeRouteEnter() {},
mixins:[{}],
template:'<div></div>',
render(){
}
});
```
### Extends and mixins
```typescript
import { Component, ComponentBase, Base } from 'vue-facing-decorator'
//Comp1 super class
class Comp1Sup extends Base {
method1Sup() {
return 'method1Sup value'
}
}
/*
Comp1 base component. To define a base component use `@ComponentBase` instead of `@Component`.
Runtime will bundle Class `Comp1` and `Comp1Sup` to a vue option component.
Methods of Comp1 will override `Comp1Sup`'s.
Decorators can be only used on `@Component` and `@ComponentBase` classes. Comp1Sup don't accept any decorators.
*/
@ComponentBase
class Comp1 extends Comp1Sup {
method1Comp() {
return 'method1Comp value'
}
}
class Comp2Sup extends Comp1 {
method2Sup() {
return 'method2Sup value'
}
}
/*
Similer to Comp1, runtime will bundle class `Comp2` and `Comp2Sup` into a vue option component.
Bundled `Comp2` will extends bundled `Comp1` by vue `extends` option `{extends:Comp1}`
*/
@ComponentBase
class Comp2 extends Comp2Sup {
method2Comp() {
return 'method2Comp value'
}
sameMethodName(){
console.log('in Comp2')
}
}
class Comp3Sup extends Comp2 {
method3Sup() {
return 'method3Sup value'
}
sameMethodName(){
console.log('in Comp3Sup')
}
}
/*
(Comp3 -> Comp3Sup) vue extends (Comp2 -> Comp2Sup) vue extends (Comp1 -> Comp1Sup)
Class extends class by ES class extending strategy i.e. `Comp3 -> Comp3Sup` .
Vue component extends vue component by vue component exteding strategy i.e. `(Comp3 -> Comp3Sup) vue extends (Comp2 -> Comp2Sup)`
`Comp3` is a "Final Component" decorated by '@Component'.
*/
/*
The sameMethodName method is the one in Comp3.
The priority is Comp3 > Comp3Sup > Comp2
*/
@Component
export class Comp3 extends Comp3Sup {
method3Comp() {
return 'method3Comp value'
}
sameMethodName(){
console.log('in Comp3')
}
}
/*
If `mixins` is provided to Component decorator, it will be setted to vue option api `mixins`. Both `extends` and `mixins` will be effective.
Mixins component will lost them type information. So wo should cast `this` context to `any`.
In this case, the sameMethodName method is the one in Comp3.
The priority is Comp3 > Comp3Sup > mixin2 > mixin1 > Comp2
Comp3 and Comp3Sup considered one component. It `mixins: [mixin1,mixin2]` and `extends: Comp2`
*/
@Component({
mixins:[{
methods:{
mixin1Method(){
},
sameMethodName(){
console.log('in mixin1')
}
}
},{
methods:{
mixin2Method(){
},
sameMethodName(){
console.log('in mixin2')
}
}
}]
})
export class Comp3Mixins extends Comp3Sup{
sameMethodName(){
console.log('in Comp3Mixins')
}
get mixinContext():any { // Mixins will lost type information, for now return any this
return this
}
mounted(){
this.mixinContext.mixin1Method()
this.mixinContext.mixin2Method()
}
}
```
is euqal to
```typescript
//For Comp3
import { defineComponent } from 'vue';
defineComponent({
extends: {//This is Comp2 includes Comp2Sup
extends: {//This is Comp2 includes Comp3Sup
methods: {
method1Sup() {
return 'method1Sup value'
},
method1Comp() {
return 'method1Comp value'
}
}
},
methods: {
method2Sup() {
return 'method2Sup value'
},
method2Comp() {
return 'method2Comp value'
},
sameMethodName(){
console.log('in Comp2')
}
}
},
methods: {
method3Sup() {
return 'method3Sup value'
},
method3Comp() {
return 'method3Comp value'
},
sameMethodName(){//This method in Comp3 overwrites the one in Comp3Sup
console.log('in Comp3')
}
}
})
//For Comp3Mixins
defineComponent({
mixins:[{
methods:{
mixin1Method(){
},
sameMethodName(){
console.log('in mixin1')
}
}
},{
methods:{
mixin2Method(){
},
sameMethodName(){
console.log('in mixin2')
}
}
}],
extends: {
extends: {
methods: {
method1Sup() {
return 'method1Sup value'
},
method1Comp() {
return 'method1Comp value'
}
}
},
methods: {
method2Sup() {
return 'method2Sup value'
},
method2Comp() {
return 'method2Comp value'
},
sameMethodName(){
console.log('in Comp2')
}
}
},
methods: {
method3Sup() {
return 'method3Sup value'
},
method3Comp() {
return 'method3Comp value'
},
sameMethodName(){
console.log('in Comp3')
}
},
computed:{
mixinContext(){
return this
}
},
mounted(){
this.mixinContext.mixin1Method()
this.mixinContext.mixin2Method()
}
})
```
### Tsx render
```tsx
//in Comp.render.tsx
import type Comp from './Comp'
export default function render(this: Comp) {
return <div onClick={this.onClick}>Tsx render {this.number}</div>
}
//in Comp.ts
import {
Component,
Base,
} from 'vue-facing-decorator'
import render from './Comp.render'
@Component({
render
})
export default class Comp extends Base {
number = 1
onClick() {
this.number++
}
}
//in parent component
import {
Component,
Base,
} from 'vue-facing-decorator';
import Comp from "./Comp"
@Component({
components:{
Comp
}
})
export default class ParentComponent extends Base {
}
```
is euqal to
```typescript
//in Comp.ts
import { defineComponent } from "vue";
import render from './Comp.render'
export default defineComponent({
render,
data(){
return {
number:1
}
},
methods:{
onClick(){
this.number++
}
}
})
```
### In class lifecycle names
These class names could be defined in class directly.
```js
[
"beforeCreate",
"created",
"beforeMount",
"mounted",
"beforeUpdate",
"updated",
"activated",
"deactivated",
"beforeDestroy",
"beforeUnmount",
"destroyed",
"unmounted",
"renderTracked",
"renderTriggered",
"errorCaptured",
"serverPrefetch"
]
```
For names not in this list, use
```typescript
@Component({
options:{
foo(){
}
}
})
```
or
```typescript
@Component({
modifier(opt:any){
opt.foo=function(){}
return opt
}
})
```
[To document](https://facing-dev.github.io/vue-facing-decorator/#/)

83

src/component.ts
import { defineComponent, ComponentCustomOptions } from 'vue';
import { obtainSlot, extendSlotPath } from './utils'
import { obtainSlot, getSuperSlot, getSlot } from './utils'
import { build as optionComputed } from './option/computed'

@@ -65,10 +65,5 @@ import { build as optionData } from './option/data'

type ComponentConsOption = Cons | ComponentOption
function ComponentStep(cons: Cons, extend?: any) {
return defineComponent(ComponentOption(cons, extend))
}
function ComponentStepWithOption(cons: Cons, arg: ComponentOption, extend?: any): any {
function buildComponent(cons: Cons, arg: ComponentOption, extend?: any): any {
let option = ComponentOption(cons, extend)
const slot = obtainSlot(cons.prototype)
Object.keys(arg).reduce<Record<string, any>>((option, name: string) => {

@@ -81,3 +76,2 @@ if (['options', 'modifier', 'emits'].includes(name)) {

}, option)
let emits = Array.from(slot.obtainMap('emits').keys())

@@ -93,51 +87,48 @@ if (Array.isArray(arg.emits)) {

if (arg.modifier) {
option = arg.modifier(option)
if (!option) {
throw 'Component modifier should return vue component option'
}
arg.modifier(option)
}
return defineComponent(option)
}
export function ComponentBase(cons: Cons) {
function build(cons: Cons, option: ComponentOption) {
const slot = obtainSlot(cons.prototype)
slot.inComponent = true
return cons
const superSlot = getSuperSlot(cons.prototype)
if (superSlot) {
if (!superSlot.inComponent) {
throw 'Class should be decorated by Component or ComponentBase: ' + slot.master
}
if (superSlot.cachedVueComponent === null) {
throw 'Component decorator 1'
}
}
const component = buildComponent(cons, option, superSlot === null ? undefined : superSlot.cachedVueComponent)
slot.cachedVueComponent = component
}
export function Component(arg: ComponentConsOption) {
function extend(cons: Cons) {
ComponentBase(cons)
const slotPath = extendSlotPath(cons.prototype)
slotPath.forEach(proto => {
const slot = obtainSlot(proto)
if (!slot.inComponent) {
throw 'Class should be decorated by Component or ComponentBase: ' + proto.constructor
}
})
return slotPath.reduceRight<any>((pv, cv, ci) => {
if (ci > 0) {
return ComponentStep(cv.constructor, pv === null ? undefined : pv)
} else {
if (typeof arg === 'function') {
return ComponentStepWithOption(cv.constructor, {}, pv === null ? undefined : pv)
} else {
return ComponentStepWithOption(cv.constructor, arg, pv === null ? undefined : pv)
}
}
}, null)
}
function _Component(arg: ComponentConsOption, cb: (cons: Cons, option: ComponentOption) => any) {
if (typeof arg === 'function') {
const finalComp = extend(arg)
return finalComp
return cb(arg, {})
}
return function (cons: Cons) {
return cb(cons, arg)
}
}
export function ComponentBase(arg: ComponentConsOption): any {
return _Component(arg, function (cons: Cons, option: ComponentOption) {
build(cons, option)
return cons
})
}
const finalComp = extend(cons)
export function Component(arg: ComponentConsOption): any {
return _Component(arg, function (cons: Cons, option: ComponentOption) {
build(cons, option)
// const slot = getSlot(cons.prototype)!
// Object.defineProperty(cons, '__vccOpts', {
// value: slot.cachedVueComponent
// })
// console.log('kkkk', '__vccOpts' in cons, cons)
// return cons
return obtainSlot(cons.prototype).cachedVueComponent
})
return finalComp
}
}

37

src/utils.ts

@@ -5,2 +5,6 @@ import { Base } from './index'

class Slot {
master: any
constructor(master: any) {
this.master = master
}
names: Map<string, Map<string, any>> = new Map

@@ -19,2 +23,3 @@ obtainMap<T extends Map<string, any>>(name: string): T {

inComponent = false
cachedVueComponent: any = null
}

@@ -26,3 +31,3 @@

}
const slot = new Slot
const slot = new Slot(obj)
Object.defineProperty(obj, SlotSymbol, {

@@ -77,18 +82,30 @@ enumerable: false,

}
export function getSuperSlot(obj: any) {
let curr = Object.getPrototypeOf(obj)
export function extendSlotPath(obj: any): {
constructor: any
}[] {
const arr: any[] = []
let curr = obj
while (curr.constructor !== Base) {
if (getSlot(curr)) {
arr.push(curr)
const slot = getSlot(curr)
if (slot) {
return slot
}
curr = Object.getPrototypeOf(curr)
}
return arr
return null
}
// export function extendSlotPath(obj: any): {
// constructor: any
// }[] {
// const arr: any[] = []
// let curr = obj
// while (curr.constructor !== Base) {
// if (getSlot(curr)) {
// arr.push(curr)
// }
// curr = Object.getPrototypeOf(curr)
// }
// return arr
// }
export function excludeNames(names: string[], slot: Slot) {

@@ -95,0 +112,0 @@ return names.filter(name => {

1

test/component.ts

@@ -6,2 +6,3 @@

import { isEmptyObject } from './utils';
@Component

@@ -8,0 +9,0 @@ export class Empty extends Base {

6

test/feature/componentExtends.ts

@@ -5,3 +5,5 @@

import { Component, ComponentBase, Base } from '../../dist'
@ComponentBase
@ComponentBase({
name:'ComponentBase'
})
class Sup extends Base {

@@ -37,2 +39,3 @@ dataSup = 'dataSup value'

it('sup',()=>{
expect('object').to.equal(typeof SupContext)

@@ -44,2 +47,3 @@ expect('function').to.equal(typeof SupContext?.data)

expect('methodSup value').to.equal(SupContext.methods.methodSup())
expect('ComponentBase').to.equal(SupContext.name)
})

@@ -46,0 +50,0 @@ }

10

test/internal/utils.ts

@@ -40,4 +40,2 @@

class Comp3 extends Comp3Sup {

@@ -86,12 +84,4 @@ method3Comp() {

})
it('extendSlotPath', () => {
const path = Utils.extendSlotPath(Comp3.prototype)
expect(3).to.equal(path.length)
expect(Comp3.prototype).to.equal(path[0])
expect(Comp2.prototype).to.equal(path[1])
expect(Comp1.prototype).to.equal(path[2])
})
}
)
export default {}
dist/component.d.ts.map

Sorry, the diff of this file is not supported yet

dist/component.js.map

Sorry, the diff of this file is not supported yet

dist/utils.d.ts.map

Sorry, the diff of this file is not supported yet

dist/utils.js.map

Sorry, the diff of this file is not supported yet