Rename some interface from State to Component

src/components/entities/hasTrigger.ts

@@ -3,7 +3,7 @@ import { Size } from 'components/hasSize';
 import { ExtendedPhaserScene } from 'components/isScene';
 import Phaser from 'phaser';
 
-export interface TriggerState {
+export interface TriggerComponent {
     init(parentScene: ExtendedPhaserScene): void;
     onEntityLeftRange(entity: Phaser.Tilemaps.Tile | Phaser.Types.Physics.Arcade.GameObjectWithBody): void;
     onEntityEnteredRange(entity: Phaser.Tilemaps.Tile | Phaser.Types.Physics.Arcade.GameObjectWithBody): void;
@@ -15,7 +15,7 @@ export interface TriggerState {
     update(): void;
 }
 
-const hasTrigger = function hasTriggerFunc(state: TriggerState): TriggerState {
+const hasTrigger = function hasTriggerFunc(state: TriggerComponent): TriggerComponent {
     let parentScene: ExtendedPhaserScene | undefined;
 
     let triggerZone: Phaser.GameObjects.Zone | undefined;

src/components/events/canEmit.ts

@@ -3,17 +3,17 @@ import Phaser from 'phaser';
 import createListener, { Listener } from 'core/createListener';
 import { EventData } from 'configs/eventConfig';
 
-export interface EmitState {
+export interface EmitComponent {
     emitGlobal: <T extends keyof EventData>(event: T, data: EventData[T]) => void;
     emit: <T extends keyof EventData>(event: T, data: EventData[T]) => void;
-    on: <T extends keyof EventData>(event: T, fn: (e: EventData[T]) => void, context: EmitState) => Listener<T>;
-    once: <T extends keyof EventData>(event: T, fn: (e: EventData[T]) => void, context: EmitState) => Listener<T>;
+    on: <T extends keyof EventData>(event: T, fn: (e: EventData[T]) => void, context: EmitComponent) => Listener<T>;
+    once: <T extends keyof EventData>(event: T, fn: (e: EventData[T]) => void, context: EmitComponent) => Listener<T>;
     off: <T extends keyof EventData>(listener: Listener<T>) => void;
     removeAllListeners: () => void;
     destroy: () => void;
 }
 
-function canEmit(state: EmitState) {
+function canEmit(state: EmitComponent) {
     const localEmitter = new Phaser.Events.EventEmitter();
     const listeners: Array<Listener<any>> = [];
 
@@ -25,14 +25,14 @@ function canEmit(state: EmitState) {
         localEmitter.emit(event, data);
     }
 
-    function on<T extends keyof EventData>(event: T, fn: (e: EventData[T]) => void, context: EmitState): Listener<T> {
+    function on<T extends keyof EventData>(event: T, fn: (e: EventData[T]) => void, context: EmitComponent): Listener<T> {
         localEmitter.on(event, fn, context);
         const listener = createListener(event, fn, false, state);
         listeners.push(listener);
         return listener;
     }
 
-    function once<T extends keyof EventData>(event: T, fn: (e: EventData[T]) => void, context: EmitState): Listener<T> {
+    function once<T extends keyof EventData>(event: T, fn: (e: EventData[T]) => void, context: EmitComponent): Listener<T> {
         localEmitter.once(event, fn, context);
         const listener = createListener(event, fn, true, state);
         listeners.push(listener);
@@ -60,7 +60,7 @@ function canEmit(state: EmitState) {
             localEmitter.destroy();
         }
     }
-    const returnState: EmitState = {
+    const returnState: EmitComponent = {
         // props
         // methods
         emitGlobal,

src/components/events/canListen.ts

@@ -1,42 +1,42 @@
 import store from 'root/store';
-import { EmitState } from './canEmit';
+import { EmitComponent } from './canEmit';
 import { EventData } from 'configs/eventConfig';
 import { Listener } from 'core/createListener';
 import { LifeCycle } from 'components/isScene';
 
-export interface ListenState extends LifeCycle {
+export interface ListenComponent extends LifeCycle {
     dropListener(listener: Listener<any>): void;
-    listenOn<T extends keyof EventData>(emitState: EmitState, event: T, fn: (e: EventData[T]) => void, context: EmitState): Listener<T> | undefined;
-    listenOnce<T extends keyof EventData>(emitState: EmitState, event: T, fn: (e: EventData[T]) => void, context: EmitState): Listener<T> | undefined;
-    listenGlobal<T extends keyof EventData>(event: T, fn: (e: EventData[T]) => void, context: EmitState): Listener<T> | undefined;
-    listenOnceGlobal<T extends keyof EventData>(event: T, fn: (e: EventData[T]) => void, context: EmitState): Listener<T> | undefined;
+    listenOn<T extends keyof EventData>(emitState: EmitComponent, event: T, fn: (e: EventData[T]) => void, context: EmitComponent): Listener<T> | undefined;
+    listenOnce<T extends keyof EventData>(emitState: EmitComponent, event: T, fn: (e: EventData[T]) => void, context: EmitComponent): Listener<T> | undefined;
+    listenGlobal<T extends keyof EventData>(event: T, fn: (e: EventData[T]) => void, context: EmitComponent): Listener<T> | undefined;
+    listenOnceGlobal<T extends keyof EventData>(event: T, fn: (e: EventData[T]) => void, context: EmitComponent): Listener<T> | undefined;
 }
 
 // eslint-disable-next-line @typescript-eslint/no-unused-vars
-const canListen = function canListenFunc(state: ListenState): ListenState {
+const canListen = function canListenFunc(state: ListenComponent): ListenComponent {
     const listeners: Array<Listener<any>> = [];
 
-    function listenOn<T extends keyof EventData>(emitState: EmitState, event: T, fn: (e: EventData[T]) => void, context: EmitState): Listener<T> {
+    function listenOn<T extends keyof EventData>(emitState: EmitComponent, event: T, fn: (e: EventData[T]) => void, context: EmitComponent): Listener<T> {
         const listener = emitState.on(event, fn, context);
         listeners.push(listener);
         return listener;
     }
 
-    function listenOnce<T extends keyof EventData>(emitState: EmitState, event: T, fn: (e: EventData[T]) => void, context: EmitState): Listener<T> {
+    function listenOnce<T extends keyof EventData>(emitState: EmitComponent, event: T, fn: (e: EventData[T]) => void, context: EmitComponent): Listener<T> {
         const listener = emitState.once(event, fn, context);
         listeners.push(listener);
         return listener;
     }
 
-    function listenGlobal<T extends keyof EventData>(event: T, fn: (e: EventData[T]) => void, context: EmitState): Listener<T> | undefined{
+    function listenGlobal<T extends keyof EventData>(event: T, fn: (e: EventData[T]) => void, context: EmitComponent): Listener<T> | undefined{
         const listener = store.messageBus?.on(event, fn, context);
         if(listener) {
             listeners.push(listener);
         }
         return listener;
     }
 
-    function listenOnceGlobal<T extends keyof EventData>(event: T, fn: (e: EventData[T]) => void, context: EmitState): Listener<T> | undefined {
+    function listenOnceGlobal<T extends keyof EventData>(event: T, fn: (e: EventData[T]) => void, context: EmitComponent): Listener<T> | undefined {
         const listener = store.messageBus?.once(event, fn, context);
         if(listener) {
             listeners.push(listener);
@@ -55,7 +55,7 @@ const canListen = function canListenFunc(state: ListenState): ListenState {
         });
     }
 
-    const returnState: ListenState = {
+    const returnState: ListenComponent = {
         // props
         // methods
         dropListener,

src/components/hasInput.ts

@@ -1,7 +1,7 @@
 import { SCENES } from 'configs/gameConfig';
-import { SceneState } from './isScene';
+import { SceneComponent } from './isScene';
 
-export interface Input extends SceneState {
+export interface Input extends SceneComponent {
 }
 
 function hasInput(state: Input) {

src/components/hasPosition.ts

@@ -3,7 +3,7 @@ export interface Position {
     y: number;
 }
 
-export interface PositionState {
+export interface PositionComponent {
     setPosition: (position: Position) => Position;
     setX: (xp: number) => number;
     setY: (yp: number) => number;
@@ -12,7 +12,7 @@ export interface PositionState {
     getY: () => number;
 }
 
-function hasPosition(state: PositionState): PositionState {
+function hasPosition(state: PositionComponent): PositionComponent {
     let x = 0;
     let y = 0;
 

src/components/hasSize.ts

@@ -3,7 +3,7 @@ export interface Size {
     height: number;
 }
 
-export interface SizeState {
+export interface SizeComponent {
     setSize: (size: Size) => Size;
     setWidth: (wp: number) => number;
     setHeight: (hp: number) => number;
@@ -12,7 +12,7 @@ export interface SizeState {
     getHeight: () => number;
 }
 
-function hasSize(state: SizeState): SizeState {
+function hasSize(state: SizeComponent): SizeComponent {
     let width = 0;
     let height = 0;
 

src/components/isScene.ts

@@ -11,7 +11,7 @@ export interface LifeCycle {
 
 export type ExtendedPhaserScene = Phaser.Scene & LifeCycle
 
-export interface SceneState extends LifeCycle {
+export interface SceneComponent extends LifeCycle {
     sceneManager?: Phaser.Scenes.ScenePlugin;
     scene: ExtendedPhaserScene;
     addScene: (key: SCENES, sceneRef: ExtendedPhaserScene, autoStart: boolean) => Phaser.Scene | undefined | null;
@@ -24,7 +24,7 @@ export interface SceneState extends LifeCycle {
  * Phaser.Scene abstraction.
  * Init -> Preload -> Create -> Update -> Destroy
  */
-function isScene(state: SceneState, sceneKey: SCENES): SceneState {
+function isScene(state: SceneComponent, sceneKey: SCENES): SceneComponent {
     if (!sceneKey) {
         throw new Error('Missing sceneKey');
     }

src/core/createKeyboard.ts

@@ -1,8 +1,8 @@
-import canEmit, { EmitState } from 'components/events/canEmit';
+import canEmit, { EmitComponent } from 'components/events/canEmit';
 import { EVENTS } from 'configs/eventConfig';
 import createState from 'utils/createState';
 
-export interface KeyboardInput extends EmitState {
+export interface KeyboardInput extends EmitComponent {
     disable: () => void;
     enable: () => void;
 }

src/core/createListener.ts

@@ -1,4 +1,4 @@
-import { EmitState } from 'components/events/canEmit';
+import { EmitComponent } from 'components/events/canEmit';
 import { EventData } from 'configs/eventConfig';
 import { v4 as uuidv4 } from 'uuid';
 
@@ -11,7 +11,7 @@ export interface Listener<T extends keyof EventData> {
     drop: () => void;
 }
 
-function createListener<T extends keyof EventData>(event: T, fn: (event: EventData[T]) => void, once: boolean, emitState: EmitState): Listener<T> {
+function createListener<T extends keyof EventData>(event: T, fn: (event: EventData[T]) => void, once: boolean, emitState: EmitComponent): Listener<T> {
     const state = {} as Listener<T>;
 
     function drop() {

src/core/createLoadingBar.ts

@@ -1,10 +1,10 @@
-import hasPosition, { Position, PositionState } from 'components/hasPosition';
-import hasSize, { Size, SizeState } from 'components/hasSize';
+import hasPosition, { Position, PositionComponent } from 'components/hasPosition';
+import hasSize, { Size, SizeComponent } from 'components/hasSize';
 import { ExtendedPhaserScene, LifeCycle } from 'components/isScene';
 import createState from 'utils/createState';
 import pipe from 'utils/pipe';
 
-export interface LoadingBar extends PositionState, SizeState, LifeCycle { }
+export interface LoadingBar extends PositionComponent, SizeComponent, LifeCycle { }
 
 /**
  * A multipurpose loading bar that can be added to any scene.

src/core/createMessageBus.ts

@@ -1,7 +1,7 @@
-import canEmit, { EmitState } from 'components/events/canEmit';
+import canEmit, { EmitComponent } from 'components/events/canEmit';
 import createState from 'utils/createState';
 
-export interface MessageBus extends EmitState {
+export interface MessageBus extends EmitComponent {
 }
 
 function createMessageBus(): MessageBus {

src/entities/createButton.ts

@@ -1,11 +1,11 @@
-import canEmit, { EmitState } from 'components/events/canEmit';
-import hasSize, { Size, SizeState } from 'components/hasSize';
-import hasPosition, { Position, PositionState } from 'components/hasPosition';
+import canEmit, { EmitComponent } from 'components/events/canEmit';
+import hasSize, { Size, SizeComponent } from 'components/hasSize';
+import hasPosition, { Position, PositionComponent } from 'components/hasPosition';
 import pipe from 'utils/pipe';
 import createState from 'utils/createState';
 import { EVENTS } from 'configs/eventConfig';
 
-export interface Button extends EmitState, PositionState, SizeState {
+export interface Button extends EmitComponent, PositionComponent, SizeComponent {
     refresh: () => void;
     setText: (val: string) => void;
 }

src/entities/createPlayer.ts

@@ -1,11 +1,11 @@
 import isGameEntity, { GameEntityState } from 'components/entities/isGameEntity';
-import canEmit, { EmitState } from 'components/events/canEmit';
-import hasPosition, { PositionState } from 'components/hasPosition';
+import canEmit, { EmitComponent } from 'components/events/canEmit';
+import hasPosition, { PositionComponent } from 'components/hasPosition';
 import createState from 'utils/createState';
 import hasAudio, { Audio } from 'components/hasAudio';
 import { SFX } from 'configs/audioConfig';
 
-export interface Player extends PositionState, Audio, EmitState, GameEntityState {
+export interface Player extends PositionComponent, Audio, EmitComponent, GameEntityState {
     name: string;
     printInfo: () => void;
 }

src/scenes/Boot.ts

@@ -1,10 +1,10 @@
 import { GAME, SCENES } from 'configs/gameConfig';
 import resizeCanvas from 'utils/resizeCanvas';
-import isScene, { LifeCycle, SceneState } from 'components/isScene';
+import isScene, { LifeCycle, SceneComponent } from 'components/isScene';
 import createState from 'utils/createState';
 import hasCamera, { Camera } from 'components/hasCamera';
 
-export interface BootScene extends SceneState, Camera, LifeCycle { }
+export interface BootScene extends SceneComponent, Camera, LifeCycle { }
 
 const BootScene = function BootSceneFunc() {
     const state: BootScene = {} as BootScene;

src/scenes/Game.ts

@@ -3,13 +3,13 @@ import { BACKGROUND } from 'configs/spriteConfig';
 import createAudioManager, { AudioManager } from 'core/createAudioManager';
 import createPlayer from 'entities/createPlayer';
 import UI, { UIScene } from 'scenes/UI';
-import canListen, { ListenState } from 'components/events/canListen';
-import isScene, { SceneState } from 'components/isScene';
+import canListen, { ListenComponent } from 'components/events/canListen';
+import isScene, { SceneComponent } from 'components/isScene';
 import createState from 'utils/createState';
 import store from 'root/store';
 import hasCamera, { Camera } from 'components/hasCamera';
 
-export interface GameScene extends SceneState, Camera, ListenState { }
+export interface GameScene extends SceneComponent, Camera, ListenComponent { }
 /**
  * Responsible for delegating the various levels, holding the various core systems and such.
  */

src/scenes/Load.ts

@@ -1,11 +1,11 @@
 import { GAME, SCENES } from 'configs/gameConfig';
 import createLoadingBar, { LoadingBar } from 'core/createLoadingBar';
 import { MUSIC, SFX } from 'configs/audioConfig';
-import isScene, { SceneState } from 'components/isScene';
+import isScene, { SceneComponent } from 'components/isScene';
 import createState from 'utils/createState';
 import { BACKGROUND, SPEAKER, SPEAKER_OFF } from 'configs/spriteConfig';
 
-export interface LoadSceneState extends SceneState { }
+export interface LoadSceneState extends SceneComponent { }
 
 function LoadScene(): LoadSceneState {
     const state = {} as LoadSceneState;

src/scenes/UI.ts

@@ -1,14 +1,14 @@
 import Stats from 'stats.js';
 import * as dat from 'dat.gui';
 import { SCENES } from 'configs/gameConfig';
-import isScene, { SceneState } from 'components/isScene';
+import isScene, { SceneComponent } from 'components/isScene';
 import createState from 'utils/createState';
 
 /**
  * Layer/Scene for UI elements.
  */
 
-export interface UIScene extends SceneState {
+export interface UIScene extends SceneComponent {
     guiData: {
         name: string;
     };