fix: spaces -> tabs

Author: thebongy

.editorconfig

@@ -1,13 +1,13 @@
 #root = true
 
 [*]
-indent_style = space
+indent_style = tab
 end_of_line = lf
 charset = utf-8
 trim_trailing_whitespace = true
 insert_final_newline = true
 max_line_length = 100
-indent_size = 2
+indent_size = 4
 
 [*.md]
 trim_trailing_whitespace = false

src/constants.ts

@@ -1,18 +1,18 @@
 export const constants = {
-    requestType: {
-        moduleRegistration: 'moduleRegistration',
-        functionCall: 'functionCall',
-        registerHook: 'registerHook',
-        triggerHook: 'triggerHook',
-        declareFunction: 'declareFunction',
-    },
-    responseType: {
-        moduleRegistered: 'moduleRegistered',
-        functionResponse: 'functionResponse',
-        hookRegistered: 'hookRegistered',
-        hookTriggered: 'hookTriggered',
-        functionDeclared: 'functionDeclared'
-    }
+	requestType: {
+		moduleRegistration: 'moduleRegistration',
+		functionCall: 'functionCall',
+		registerHook: 'registerHook',
+		triggerHook: 'triggerHook',
+		declareFunction: 'declareFunction',
+	},
+	responseType: {
+		moduleRegistered: 'moduleRegistered',
+		functionResponse: 'functionResponse',
+		hookRegistered: 'hookRegistered',
+		hookTriggered: 'hookTriggered',
+		functionDeclared: 'functionDeclared'
+	}
 };
 
 export default constants;

src/gotham-node.ts

@@ -2,44 +2,44 @@ import { Protocol, Dependency, FnArgs } from "./protocol/protocol";
 import { GothamConnection, SocketConnection } from './protocol/GothamConnection';
 
 export class GothamModule {
-    protocol: Protocol
-    constructor(connection: GothamConnection) {
-        this.protocol = new Protocol(connection);
-    }
+	protocol: Protocol
+	constructor(connection: GothamConnection) {
+		this.protocol = new Protocol(connection);
+	}
 
-    async initialize(moduleId: string, version: string, deps: Dependency) {
-        // Setup Connection only when initialize called?
-        await this.protocol.connect();
-        return await this.protocol.sendRequest(
-            this.protocol.initialize(moduleId, version, deps),
-        );
-    }
+	async initialize(moduleId: string, version: string, deps: Dependency) {
+		// Setup Connection only when initialize called?
+		await this.protocol.connect();
+		return await this.protocol.sendRequest(
+			this.protocol.initialize(moduleId, version, deps),
+		);
+	}
 
-    async declareFunction(fnName: string, fn: Function) {
-        return await this.protocol.sendRequest(
-            this.protocol.declareFunction(fnName, fn)
-        );
-    }
+	async declareFunction(fnName: string, fn: Function) {
+		return await this.protocol.sendRequest(
+			this.protocol.declareFunction(fnName, fn)
+		);
+	}
 
-    async functionCall(fnNmame: string, args: FnArgs) {
-        return await this.protocol.sendRequest(
-            this.protocol.callFunction(fnNmame, args)
-        );
-    }
+	async functionCall(fnNmame: string, args: FnArgs) {
+		return await this.protocol.sendRequest(
+			this.protocol.callFunction(fnNmame, args)
+		);
+	}
 
-    async registerHook(hook: string, cb: Function) {
-        return await this.protocol.sendRequest(
-            this.protocol.registerHook(hook, cb)
-        );
-    }
+	async registerHook(hook: string, cb: Function) {
+		return await this.protocol.sendRequest(
+			this.protocol.registerHook(hook, cb)
+		);
+	}
 
-    async triggerHook(hook: string) {
-        return await this.protocol.sendRequest(
-            this.protocol.triggerHook(hook)
-        );
-    }
+	async triggerHook(hook: string) {
+		return await this.protocol.sendRequest(
+			this.protocol.triggerHook(hook)
+		);
+	}
 
-    async close() {
-        return await this.protocol.close();
-    }
+	async close() {
+		return await this.protocol.close();
+	}
 }

src/protocol/GothamConnection.ts

@@ -2,51 +2,50 @@ import * as net from 'net';
 
 type dataListenerFn = (data: any) => any;
 export abstract class GothamConnection {
-    dataListener: dataListenerFn = (data) => {};
-
-    abstract async setupConnection(): Promise<any>;
-    abstract async closeConnection(): Promise<any>;
-    abstract setupDataListener(dataListener: dataListenerFn): any;
-    abstract async send(message: object): Promise<void>;
+	dataListener: dataListenerFn = (data) => { };
+	abstract async setupConnection(): Promise<any>;
+	abstract async closeConnection(): Promise<any>;
+	abstract setupDataListener(dataListener: dataListenerFn): any;
+	abstract async send(message: object): Promise<void>;
 }
 
 
 
 export class SocketConnection extends GothamConnection {
-    client!: net.Socket;
-    sockPath: string;
-    constructor(sockPath: string) {
-        super();
-        this.sockPath = sockPath;
-    }
-
-    async setupConnection() {
-        return new Promise((resolve, reject) => {
-            this.client = net.createConnection(this.sockPath);
-            this.client.on('connect', () => {
-                // console.log(`Connected to ${this.sockPath}!`);
-                resolve();
-            });
-        });
-    }
-
-    async closeConnection() {
-        this.client.destroy();
-    }
-
-    setupDataListener(dataListener: dataListenerFn) {
-        this.dataListener = (data: Buffer) => {
-            const parsed = JSON.parse(data.toString('utf-8'));
-            // console.log("Socket Received Data:");
-            // console.log(parsed);
-            dataListener(parsed);
-        };
-        this.client.on('data', this.dataListener);
-    }
-
-    async send(message: object) {
-        // console.log("Socker Sending data:");
-        // console.log(message);
-        this.client.write(JSON.stringify(message) + '\n');
-    }
+	client!: net.Socket;
+	sockPath: string;
+	constructor(sockPath: string) {
+		super();
+		this.sockPath = sockPath;
+	}
+
+	async setupConnection() {
+		return new Promise((resolve, reject) => {
+			this.client = net.createConnection(this.sockPath);
+			this.client.on('connect', () => {
+				// console.log(`Connected to ${this.sockPath}!`);
+				resolve();
+			});
+		});
+	}
+
+	async closeConnection() {
+		this.client.destroy();
+	}
+
+	setupDataListener(dataListener: dataListenerFn) {
+		this.dataListener = (data: Buffer) => {
+			const parsed = JSON.parse(data.toString('utf-8'));
+			// console.log("Socket Received Data:");
+			// console.log(parsed);
+			dataListener(parsed);
+		};
+		this.client.on('data', this.dataListener);
+	}
+
+	async send(message: object) {
+		// console.log("Socker Sending data:");
+		// console.log(message);
+		this.client.write(JSON.stringify(message) + '\n');
+	}
 }