Identity and tsx types

Author: ruojianll

src/identity.ts

@@ -0,0 +1,25 @@
+export const IdentitySymbol: unique symbol = Symbol('vue-facing-decorator-identity')
+
+export type IdentityType = {
+    props: Record<string, any>
+    events: Record<string, any>
+}
+
+type AssertIs<O, T extends O> = T
+
+export interface Identity<T extends IdentityType = IdentityType> {
+    [IdentitySymbol]: T
+}
+
+type MergeRecord<N extends Record<string, any>, O extends Record<string, any>> = {
+    [I in (keyof N) | (keyof O)]: I extends keyof N ? N[I] : I extends keyof O ? O[I] : never
+}
+
+export type MergeIdentityType<N extends IdentityType, O extends IdentityType> = AssertIs<
+    IdentityType,
+    {
+        props: MergeRecord<N['props'], O['props']>
+        events: MergeRecord<N['events'], O['events']>
+    }
+>
+

src/index.ts

@@ -14,21 +14,10 @@ export { mixins } from './mixins'
 import type { ComponentPublicInstance } from 'vue'
 import type { OptionBuilder } from './optionBuilder'
 export { TSX } from './tsx/type'
-const IdentifySymbol = Symbol('vue-facing-decorator-identify')
-export interface BaseTypeIdentify {
-    [IdentifySymbol]: undefined
-}
-// export function TSX<Properties extends {} = {}, Events extends {} = {}>() {
-//     type TEvents = { [index in keyof Events as `on${Capitalize<index & string>}`]: Events[index] extends Function ? Events[index] : { (param: Events[index]): any } }
-//     return function <C extends VueCons>(cons: C) {
-//         return cons as unknown as {
-//             new(): ComponentPublicInstance<Properties & TEvents> & InstanceType<C>//& ComponentPublicInstance & BaseTypeIdentify
-//         }
-//     }
-// }
+import type { IdentityType, Identity, IdentitySymbol } from './identity'
 
-export type VueCons<T = {}> = {
-    new(optionBuilder: OptionBuilder, vueInstance: any): ComponentPublicInstance & BaseTypeIdentify & T
+export type VueCons<RawInstance extends Identity = Identity, IT extends IdentityType = { props:{} , events: {} }, Bundle = IT['props'] & { [index in keyof IT['events']as `on${Capitalize<index & string>}`]?: IT['events'][index] extends Function ? IT['events'][index] : { (param: IT['events'][index]): any } }> = {
+    new(optionBuilder: OptionBuilder, vueInstance: any): ComponentPublicInstance<Bundle> & Identity<IT> & Omit<RawInstance, typeof IdentitySymbol>
 }
 
 export const Base = class {

src/mixins.ts

@@ -2,20 +2,25 @@ import { ComponentBase } from './component'
 import { obtainSlot } from './utils'
 import type { VueCons } from './index'
 import { Vue } from './index'
-type UnionToIntersection<U> = (U extends any ? (k: U) => void : never) extends (k: infer I) => void ? I : never;
-type MixedClass<Mixins extends VueCons[]> = UnionToIntersection<{ [index in keyof Mixins]: InstanceType<Mixins[index]> }[number]>
+import type { MergeIdentityType, IdentitySymbol } from './identity'
+type MixedClass<Mixins extends VueCons[], Base extends VueCons = VueCons> =
+    Mixins extends [infer T extends VueCons, ...infer E extends VueCons[]] ?
+    MixedClass<E,
+        VueCons<InstanceType<Base> & InstanceType<T>,
+            MergeIdentityType<InstanceType<T>[typeof IdentitySymbol], InstanceType<Base>[typeof IdentitySymbol]>
+        >
+    > :
+    Base
 export function mixins<T extends VueCons[]>(...conses: T) {
     class MixinsClass extends Vue {
 
     }
     ComponentBase({
         mixins: conses.map((cons => obtainSlot(cons.prototype).cachedVueComponent))
     })(MixinsClass)
-    return MixinsClass as any as VueCons<MixedClass<T>>
-}
-
-
 
+    return MixinsClass as any as MixedClass<T>
+}
 
 
 

src/tsx/type.ts

@@ -1,10 +1,11 @@
-import type { ComponentPublicInstance } from 'vue'
+import type { IdentityType, MergeIdentityType, IdentitySymbol } from '../identity'
 import type { VueCons } from '../index'
-export function TSX<Properties extends {} = {}, Events extends {} = {}>() {
-    type TEvents = { [index in keyof Events as `on${Capitalize<index & string>}`]: Events[index] extends Function ? Events[index] : { (param: Events[index]): any } }
-    return function <C extends VueCons>(cons: C) {
-        return cons as unknown as {
-            new(): ComponentPublicInstance<Properties & TEvents> & InstanceType<C>
-        }
+
+export function TSX<Properties extends IdentityType['props'] = {}, Events extends IdentityType['events'] = {}, IT extends IdentityType = {
+    props: Properties
+    events: Events
+}>() {
+    return function <C extends VueCons>(cons: C): VueCons<InstanceType<C>, MergeIdentityType<IT, InstanceType<C>[typeof IdentitySymbol]>> {
+        return cons as any
     }
-}
+}

src/utils.ts

@@ -1,6 +1,6 @@
 import { Metadata } from 'facing-metadata'
 import { Base } from './index'
-import type { BaseTypeIdentify } from './index'
+import type { Identity } from './identity'
 import type { InjectConfig } from "./option/inject";
 import type { EmitConfig } from "./option/emit";
 import type { PropsConfig } from "./option/props";
@@ -153,9 +153,9 @@ export function getValidNames(obj: any, filter: (des: PropertyDescriptor, name:
 
 export function optionNullableMemberDecorator<T>(handler: { (proto: any, name: string, option?: T): any }) {
     function decorator(option?: T): any
-    function decorator(proto: BaseTypeIdentify, name: any): any
+    function decorator(proto: Identity, name: any): any
     function decorator(value: any, ctx: ClassMemberDecoratorContext): any //deco stage 3
-    function decorator(optionOrProto?: T | BaseTypeIdentify | any, name?: string | ClassMemberDecoratorContext): any {
+    function decorator(optionOrProto?: T | Identity | any, name?: string | ClassMemberDecoratorContext): any {
         if (name) {
             compatibleMemberDecorator(function (proto: any, name: any) {
                 handler(proto, name)

test/feature/mixinsFunction.ts

@@ -20,13 +20,14 @@ class B extends Vue {
 
 @Component
 class Comp extends mixins(A, B) {
-
+    checkType() {
+        this.methodA()
+        this.methodB()
+    }
 }
 
 const CompContext = toNative(Comp) as any
 
-
-
 describe('mixins function',
     () => {
         it('default', () => {

test/tsx/attributeTypes.tsx

@@ -1,19 +1,52 @@
-import { Component, TSX, Prop, Base } from '../../dist/esm'
-interface Props {
-    p: string
+import { Component, TSX, Base, mixins } from '../../dist/esm'
+
+@Component
+class A extends TSX<{
+    pA: number
+}, {
+    eA: () => void
+}>()(Base) {
+
 }
-interface Events {
-    e: Function
-    e2: string
+
+@Component
+class B extends TSX<{
+    pB: number
+}, {
+    eB: () => void
+}>()(A) {
+
 }
+
 @Component
-class TsxAttributeTypes extends TSX<Props, Events>()(Base) implements Props {
-    @Prop({
-        required: true
-    })
-    p!: string
+class C extends TSX<{
+    pC: number
+}, {
+    eC: () => void
+}>()(Base) {
+
+}
+
+@Component
+class D extends TSX<{
+    pD:number
+}, {
+    eD: () => void
+}>()(mixins(B, C)) {
+    checkType() {
+        this.pA
+        this.onEA
+        this.pB
+        this.onEB
+        this.pC
+        this.onEC
+        this.pD
+        this.onED
+
+    }
 }
 
 export default {}
 
-// const template = <TsxAttributeTypes p="" onE={() => { }} onE2={() => { }}></TsxAttributeTypes>
+
+// const template = <D q-a={1} kk={1}></D>