refactor: strict unit interface typing

Author: samuelmtimbo

package-lock.json

@@ -84,7 +84,7 @@
     "prettier-plugin-organize-imports": "3.2.3",
     "shx": "0.3.3",
     "ts-node": "10.4.0",
-    "typescript": "5.3.3",
+    "typescript": "5.5.3",
     "typescript-eslint": "0.0.1-alpha.0"
   }
 }

package.json

@@ -40,8 +40,8 @@ export type ElementEE<_EE extends Dict<any[]>> = StatefulEvents<
   Element_EE
 
 export class Element_<
-    I = any,
-    O = any,
+    I extends Dict<any> = any,
+    O extends Dict<any> = any,
     _J extends Dict<any> = {},
     _EE extends ElementEE<_EE> = ElementEE<Element_EE>,
     _C extends Component = Component,
@@ -57,7 +57,6 @@ export class Element_<
   public _parent_children: Component_[] = []
   public _slot: Dict<Component_> = {}
   public _component: _C
-  public _state: Dict<any> = {}
   public _animations: AnimationSpec[] = []
   public _stopPropagation: Dict<number> = {}
   public _stopImmediatePropagation: Dict<number> = {}
@@ -164,22 +163,19 @@ export class Element_<
     return removeParentChild(this, this._parent_children, component)
   }
 
-  appendChild(bundle: UnitBundle<Component_>): number {
+  appendChild(bundle: UnitBundle): number {
     return appendChild(this, this._children, bundle)
   }
 
-  appendChildren(bundles: UnitBundle<Component_<ComponentEvents>>[]): number {
+  appendChildren(bundles: UnitBundle[]): number {
     return appendChildren(this, this._children, bundles)
   }
 
-  insertChild(
-    Bundle: UnitBundle<Component_<ComponentEvents>>,
-    at: number
-  ): void {
+  insertChild(Bundle: UnitBundle, at: number): void {
     throw new MethodNotImplementedError()
   }
 
-  pushChild(Bundle: UnitBundle<Component_>): number {
+  pushChild(Bundle: UnitBundle): number {
     return pushChild(this, this._children, Bundle)[0]
   }
 

src/Class/Element/index.ts

@@ -51,7 +51,7 @@ export class Functional<
     this.addListener('destroy', this.d)
   }
 
-  private _on_input_data(name: string): void {
+  private _on_input_data<K extends keyof I>(name: K): void {
     if (this._i[name] !== undefined && this._i_active.size === this._i_count) {
       this._looping = false
     }
@@ -74,28 +74,28 @@ export class Functional<
     }
   }
 
-  private _on_input_invalid(name: string): void {
+  private _on_input_invalid<K extends keyof I>(name: K): void {
     if (this._i_invalid.size === 1) {
       this.d()
       this._invalidate()
     }
   }
 
-  onDataInputData(name: string): void {
+  onDataInputData<K extends keyof I>(name: K): void {
     this._on_input_data(name)
   }
 
-  onDataInputDrop(name: string, data: any): void {
+  onDataInputDrop<K extends keyof I>(name: K, data: any): void {
     this._on_input_drop()
   }
 
-  onDataInputStart(name: string): void {
+  onDataInputStart<K extends keyof I>(name: K): void {
     if (this._i_start.size === this._i_count) {
       this._start()
     }
   }
 
-  onDataInputInvalid(name: string): void {
+  onDataInputInvalid<K extends keyof I>(name: K): void {
     this._on_input_invalid(name)
   }
 
@@ -109,20 +109,20 @@ export class Functional<
     this._on_input_data(name)
   }
 
-  onRefInputDrop(name: string, data: any): void {
+  onRefInputDrop<K extends keyof I>(name: K, data: any): void {
     this._on_input_drop()
   }
 
-  onRefInputInvalid(name: string): void {
+  onRefInputInvalid<K extends keyof I>(name: K): void {
     this._on_input_invalid(name)
   }
 
-  private _on_data_output_drop = (name: string): void => {
+  private _on_data_output_drop = <K extends keyof O>(name: K): void => {
     this._backward_if_ready()
     this._forward_if_ready()
   }
 
-  onDataOutputDrop(name: string) {
+  onDataOutputDrop<K extends keyof O>(name: K) {
     this._on_data_output_drop(name)
   }