revert

dist/container.d.ts

@@ -1,5 +1,10 @@
 export default class Container {
     private services;
+<<<<<<< HEAD
     set<T>(type: new (...args: any[]) => T, instance: T): void;
     get<T>(type: new (...args: any[]) => T): T;
+=======
+    register<T>(name: string, factory: () => T): void;
+    resolve<T>(name: string): T;
+>>>>>>> 277f5a3 (test)
 }

dist/container.js

@@ -2,6 +2,7 @@ export default class Container {
     constructor() {
         this.services = new Map();
     }
+<<<<<<< HEAD
     set(type, instance) {
         this.services.set(type, instance);
     }
@@ -10,5 +11,15 @@ export default class Container {
         if (!instance)
             throw new Error(`Service of type "${type.name}" not found.`);
         return instance;
+=======
+    register(name, factory) {
+        this.services.set(name, factory);
+    }
+    resolve(name) {
+        const factory = this.services.get(name);
+        if (!factory)
+            throw new Error(`Service "${name}" not found.`);
+        return factory();
+>>>>>>> 277f5a3 (test)
     }
 }

dist/index.d.ts

@@ -7,8 +7,13 @@ export default class Flummpress {
     private middleware;
     router: Router;
     constructor();
+<<<<<<< HEAD
     use<T>(plugin: new (...args: any[]) => T | Router | Handler, factory?: () => T): this;
     get<T>(type: new (...args: any[]) => T): T;
+=======
+    use<T>(nameOrRouter: string | Router, factory?: () => T): this;
+    resolve<T>(name: string): T;
+>>>>>>> 277f5a3 (test)
     private processPipeline;
     listen(...args: any[]): this;
     private parseRequest;

dist/index.js

@@ -20,6 +20,7 @@ export default class Flummpress {
         this.router = new Router();
         this.middleware = [];
     }
+<<<<<<< HEAD
     use(plugin, factory) {
         if (typeof plugin === "function" && factory)
             this.container.set(plugin, factory());
@@ -31,15 +32,27 @@ export default class Flummpress {
             else
                 throw new TypeError("Invalid plugin provided to use()");
         }
+=======
+    use(nameOrRouter, factory) {
+        if (typeof nameOrRouter === "string" && factory)
+            this.container.register(nameOrRouter, factory);
+        else if (nameOrRouter instanceof Router)
+            this.router.use(nameOrRouter);
+>>>>>>> 277f5a3 (test)
         else
             throw new TypeError("Invalid arguments provided to use()");
         return this;
     }
+<<<<<<< HEAD
     get(type) {
         const instance = this.container.get(type);
         if (!instance)
             throw new Error(`Service of type "${type.name}" not found.`);
         return instance;
+=======
+    resolve(name) {
+        return this.container.resolve(name);
+>>>>>>> 277f5a3 (test)
     }
     processPipeline(handlers, req, res) {
         return __awaiter(this, void 0, void 0, function* () {

src/container.ts

@@ -1,4 +1,5 @@
 export default class Container {
+<<<<<<< HEAD
   private services: Map<Function, any> = new Map();
 
   set<T>(type: new (...args: any[]) => T, instance: T): void {
@@ -10,5 +11,18 @@ export default class Container {
     if(!instance)
       throw new Error(`Service of type "${type.name}" not found.`);
     return instance;
+=======
+  private services: Map<string, () => any> = new Map();
+
+  register<T>(name: string, factory: () => T): void {
+    this.services.set(name, factory);
+  }
+
+  resolve<T>(name: string): T {
+    const factory = this.services.get(name);
+    if(!factory)
+      throw new Error(`Service "${name}" not found.`);
+    return factory();
+>>>>>>> 277f5a3 (test)
   }
 }

src/index.ts

@@ -20,6 +20,7 @@ export default class Flummpress {
     this.middleware = [];
   }
 
+<<<<<<< HEAD
   public use<T>(plugin: new (...args: any[]) => T | Router | Handler, factory?: () => T): this {
     if(typeof plugin === "function" && factory)
       this.container.set(plugin, factory());
@@ -33,7 +34,27 @@ export default class Flummpress {
     }
     else
       throw new TypeError("Invalid arguments provided to use()");
+=======
+  /*public use(plugin: Router | Handler): this {
+    if(plugin instanceof Router)
+      this.router.use(plugin);
+    else if(typeof plugin === "function")
+      this.middleware.push(plugin);
+>>>>>>> 277f5a3 (test)
     return this;
+  }*/
+
+  public use<T>(nameOrRouter: string | Router, factory?: () => T): this {
+    if(typeof nameOrRouter === "string" && factory)
+      this.container.register(nameOrRouter, factory);
+    else if(nameOrRouter instanceof Router)
+      this.router.use(nameOrRouter);
+    else
+      throw new TypeError("Invalid arguments provided to use()");
+    return this;
+  }
+  public resolve<T>(name: string): T {
+    return this.container.resolve(name);
   }
   public get<T>(type: new (...args: any[]) => T): T {
     const instance = this.container.get(type);

src/router.ts

@@ -25,10 +25,14 @@ export interface Response extends ServerResponse {
 export type Handler = (req: Request, res: Response, next?: () => void) => void | Promise<void>;
 
 export default class Router {
+<<<<<<< HEAD
   private routes: Array<{
     path: string | RegExp;
     methods: { [method: string]: Handler[] }
   }> = [];
+=======
+  private routes: Array<{ path: string | RegExp; methods: { [method: string]: Handler[] } }> = [];
+>>>>>>> 277f5a3 (test)
   private mimes: Map<string, string>;
 
   constructor() {