Use dependency container

src/Container.ts

@@ -0,0 +1,50 @@
+import { Scheduler } from './Scheduler';
+import { DataStorageTaskProvider, TaskQueue } from './Queue/TaskQueue';
+import { ConsoleLogger } from './Logger';
+import { ActionQueue } from './Queue/ActionQueue';
+import { Executor } from './Executor';
+import { ControlPanel } from './ControlPanel';
+
+export class Container {
+    private readonly version: string;
+
+    constructor(version: string) {
+        this.version = version;
+    }
+
+    private _scheduler;
+
+    get scheduler(): Scheduler {
+        this._scheduler =
+            this._scheduler ||
+            (() => {
+                const taskProvider = DataStorageTaskProvider.create();
+                const taskQueue = new TaskQueue(taskProvider, new ConsoleLogger(TaskQueue.name));
+                const actionQueue = new ActionQueue();
+                return new Scheduler(taskQueue, actionQueue, new ConsoleLogger(Scheduler.name));
+            })();
+        return this._scheduler;
+    }
+
+    private _executor;
+
+    get executor(): Executor {
+        this._executor =
+            this._executor ||
+            (() => {
+                return new Executor(this.version, this.scheduler);
+            })();
+        return this._executor;
+    }
+
+    private _controlPanel;
+
+    get controlPanel(): ControlPanel {
+        this._controlPanel =
+            this._controlPanel ||
+            (() => {
+                return new ControlPanel(this.version, this.scheduler);
+            })();
+        return this._controlPanel;
+    }
+}

src/Queue/TaskQueue.ts

@@ -1,5 +1,5 @@
 import { uniqId } from '../utils';
-import { ConsoleLogger, Logger } from '../Logger';
+import { Logger } from '../Logger';
 import { DataStorage } from '../DataStorage';
 import { Args } from './Args';
 
@@ -39,13 +39,48 @@ type TaskList = Array<Task>;
 
 export type ImmutableTaskList = ReadonlyArray<Task>;
 
-export class TaskQueue {
+export interface TaskProvider {
-    private readonly logger: Logger;
+    getTasks(): TaskList;
+    setTasks(tasks: TaskList): void;
+}
+
+export class DataStorageTaskProvider implements TaskProvider {
     private storage: DataStorage;
 
-    constructor() {
+    constructor(storage: DataStorage) {
-        this.storage = new DataStorage(NAMESPACE);
+        this.storage = storage;
-        this.logger = new ConsoleLogger(this.constructor.name);
+    }
+
+    static create() {
+        return new DataStorageTaskProvider(new DataStorage(NAMESPACE));
+    }
+
+    getTasks(): TaskList {
+        const serialized = this.storage.get(QUEUE_NAME);
+        if (!Array.isArray(serialized)) {
+            return [];
+        }
+
+        const storedItems = serialized as Array<{ [key: string]: any }>;
+
+        return storedItems.map(i => {
+            const task = new Task(uniqId(), 0, '', {});
+            return Object.assign(task, i);
+        });
+    }
+
+    setTasks(tasks: TaskList): void {
+        this.storage.set(QUEUE_NAME, tasks);
+    }
+}
+
+export class TaskQueue {
+    private provider: TaskProvider;
+    private readonly logger: Logger;
+
+    constructor(provider: TaskProvider, logger: Logger) {
+        this.provider = provider;
+        this.logger = logger;
     }
 
     push(name: string, args: Args, ts: number): Task {
@@ -105,21 +140,11 @@ export class TaskQueue {
     }
 
     private getItems(): TaskList {
-        const serialized = this.storage.get(QUEUE_NAME);
+        return this.provider.getTasks();
-        if (!Array.isArray(serialized)) {
-            return [];
-        }
-
-        const storedItems = serialized as Array<{ [key: string]: any }>;
-
-        return storedItems.map(i => {
-            const task = new Task(uniqId(), 0, '', {});
-            return Object.assign(task, i);
-        });
     }
 
     private flushItems(items: TaskList): void {
-        const normalized = items.sort((x, y) => x.ts - y.ts || x.id.localeCompare(y.id));
+        items.sort((x, y) => x.ts - y.ts || x.id.localeCompare(y.id));
-        this.storage.set(QUEUE_NAME, normalized);
+        this.provider.setTasks(items);
     }
 }

src/Scheduler.ts

@@ -3,7 +3,7 @@ import { UpgradeBuildingTask } from './Task/UpgradeBuildingTask';
 import { ImmutableTaskList, Task, TaskId, TaskQueue } from './Queue/TaskQueue';
 import { SendOnAdventureTask } from './Task/SendOnAdventureTask';
 import { BalanceHeroResourcesTask } from './Task/BalanceHeroResourcesTask';
-import { ConsoleLogger, Logger } from './Logger';
+import { Logger } from './Logger';
 import { BuildBuildingTask } from './Task/BuildBuildingTask';
 import { GrabVillageState } from './Task/GrabVillageState';
 import { ActionQueue, Action, ImmutableActionList } from './Queue/ActionQueue';
@@ -18,10 +18,10 @@ export class Scheduler {
     private actionQueue: ActionQueue;
     private logger: Logger;
 
-    constructor() {
+    constructor(taskQueue: TaskQueue, actionQueue: ActionQueue, logger: Logger) {
-        this.taskQueue = new TaskQueue();
+        this.taskQueue = taskQueue;
-        this.actionQueue = new ActionQueue();
+        this.actionQueue = actionQueue;
-        this.logger = new ConsoleLogger(this.constructor.name);
+        this.logger = logger;
 
         // this.taskQueue.push(GrabVillageState.name, {}, timestamp());
         // this.taskQueue.push(UpdateResourceContracts.name, {}, timestamp());

src/index.js

@@ -1,26 +1,24 @@
 import { ConsoleLogger } from './Logger';
 import { ModeDetector } from './ModeDetector';
-import { Scheduler } from './Scheduler';
-import { Executor } from './Executor';
-import { ControlPanel } from './ControlPanel';
 import TxtVersion from '!!raw-loader!./version.txt';
+import { Container } from './Container';
 
 function main() {
     const logger = new ConsoleLogger('Travian');
 
     logger.log('TRAVIAN AUTOMATION', TxtVersion);
 
+    const container = new Container(TxtVersion);
     const modeDetector = new ModeDetector();
-    const scheduler = new Scheduler();
 
     if (modeDetector.isAuto()) {
         modeDetector.setAuto();
         logger.log('AUTO MANAGEMENT ON');
-        const executor = new Executor(TxtVersion, scheduler);
+        const executor = container.executor;
         executor.run();
     } else {
         logger.log('NORMAL MODE');
-        const controlPanel = new ControlPanel(TxtVersion, scheduler);
+        const controlPanel = container.controlPanel;
         controlPanel.run();
     }
 }