@noego/ioc 0.0.2

package/dist/cjs/index.d.ts

@@ -0,0 +1,16 @@
+import 'reflect-metadata';
+import { createContainer } from "./framework/implementation/Container";
+import { Container } from "./framework/implementation/Container";
+import { LoadAs } from "./framework/implementation/LoadAs";
+import { Parameter } from "./framework/implementation/Parameter";
+import { IContainer } from "./framework/interface/Container";
+import { NotAClassDefinitionError, ParameterNotFoundError, DependencyNotFoundError, InstanceNotCreatedError, CircularDependencyError } from "./framework/errors/ContainerErrors";
+import { Component, Inject } from "./framework/decorators/index";
+export { IContainer };
+export { LoadAs };
+export { Parameter };
+export { Container };
+export { NotAClassDefinitionError, ParameterNotFoundError, DependencyNotFoundError, InstanceNotCreatedError, CircularDependencyError };
+export { Component, Inject };
+export { createContainer } from "./framework/implementation/Container";
+export default createContainer;

package/dist/cjs/index.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createContainer = exports.Inject = exports.Component = exports.CircularDependencyError = exports.InstanceNotCreatedError = exports.DependencyNotFoundError = exports.ParameterNotFoundError = exports.NotAClassDefinitionError = exports.Container = exports.Parameter = exports.LoadAs = void 0;
+require("reflect-metadata");
+const Container_1 = require("./framework/implementation/Container");
+const Container_2 = require("./framework/implementation/Container");
+Object.defineProperty(exports, "Container", { enumerable: true, get: function () { return Container_2.Container; } });
+const LoadAs_1 = require("./framework/implementation/LoadAs");
+Object.defineProperty(exports, "LoadAs", { enumerable: true, get: function () { return LoadAs_1.LoadAs; } });
+const Parameter_1 = require("./framework/implementation/Parameter");
+Object.defineProperty(exports, "Parameter", { enumerable: true, get: function () { return Parameter_1.Parameter; } });
+const ContainerErrors_1 = require("./framework/errors/ContainerErrors");
+Object.defineProperty(exports, "NotAClassDefinitionError", { enumerable: true, get: function () { return ContainerErrors_1.NotAClassDefinitionError; } });
+Object.defineProperty(exports, "ParameterNotFoundError", { enumerable: true, get: function () { return ContainerErrors_1.ParameterNotFoundError; } });
+Object.defineProperty(exports, "DependencyNotFoundError", { enumerable: true, get: function () { return ContainerErrors_1.DependencyNotFoundError; } });
+Object.defineProperty(exports, "InstanceNotCreatedError", { enumerable: true, get: function () { return ContainerErrors_1.InstanceNotCreatedError; } });
+Object.defineProperty(exports, "CircularDependencyError", { enumerable: true, get: function () { return ContainerErrors_1.CircularDependencyError; } });
+const index_1 = require("./framework/decorators/index");
+Object.defineProperty(exports, "Component", { enumerable: true, get: function () { return index_1.Component; } });
+Object.defineProperty(exports, "Inject", { enumerable: true, get: function () { return index_1.Inject; } });
+var Container_3 = require("./framework/implementation/Container");
+Object.defineProperty(exports, "createContainer", { enumerable: true, get: function () { return Container_3.createContainer; } });
+exports.default = Container_1.createContainer;
+//# sourceMappingURL=index.js.map

package/dist/cjs/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../index.ts"],"names":[],"mappings":";;;AAAA,4BAA0B;AAC1B,oEAAsE;AACtE,oEAAgE;AAUvD,0FAVA,qBAAS,OAUA;AATlB,8DAA0D;AAOjD,uFAPA,eAAM,OAOA;AANf,oEAAgE;AAOvD,0FAPA,qBAAS,OAOA;AALlB,wEAAgL;AAOvK,yGAPA,0CAAwB,OAOA;AAAE,uGAPA,wCAAsB,OAOA;AAAE,wGAPA,yCAAuB,OAOA;AAAE,wGAPA,yCAAuB,OAOA;AAAE,wGAPA,yCAAuB,OAOA;AANpI,wDAAgE;AAOvD,0FAPA,iBAAS,OAOA;AAAE,uFAPA,cAAM,OAOA;AAC1B,kEAAsE;AAA7D,4GAAA,eAAe,OAAA;AACxB,kBAAe,2BAAe,CAAA"}

package/dist/cjs/jest.config.d.ts

@@ -0,0 +1,3 @@
+import type { JestConfigWithTsJest } from 'ts-jest';
+declare const jestConfig: JestConfigWithTsJest;
+export default jestConfig;

package/dist/cjs/jest.config.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const jestConfig = {
+    preset: 'ts-jest',
+    testEnvironment: 'node',
+    testPathIgnorePatterns: ['/node_modules/', '/dist/'],
+};
+exports.default = jestConfig;
+//# sourceMappingURL=jest.config.js.map

package/dist/cjs/jest.config.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"jest.config.js","sourceRoot":"","sources":["../../jest.config.ts"],"names":[],"mappings":";;AAEA,MAAM,UAAU,GAAyB;IACvC,MAAM,EAAE,SAAS;IACjB,eAAe,EAAE,MAAM;IACvB,sBAAsB,EAAE,CAAC,gBAAgB,EAAE,QAAQ,CAAC;CACrD,CAAC;AAEF,kBAAe,UAAU,CAAC"}

package/dist/esm/index.d.ts

@@ -0,0 +1,16 @@
+import 'reflect-metadata';
+import { createContainer } from "./framework/implementation/Container";
+import { Container } from "./framework/implementation/Container";
+import { LoadAs } from "./framework/implementation/LoadAs";
+import { Parameter } from "./framework/implementation/Parameter";
+import { IContainer } from "./framework/interface/Container";
+import { NotAClassDefinitionError, ParameterNotFoundError, DependencyNotFoundError, InstanceNotCreatedError, CircularDependencyError } from "./framework/errors/ContainerErrors";
+import { Component, Inject } from "./framework/decorators/index";
+export { IContainer };
+export { LoadAs };
+export { Parameter };
+export { Container };
+export { NotAClassDefinitionError, ParameterNotFoundError, DependencyNotFoundError, InstanceNotCreatedError, CircularDependencyError };
+export { Component, Inject };
+export { createContainer } from "./framework/implementation/Container";
+export default createContainer;

package/dist/esm/index.js

@@ -0,0 +1,15 @@
+import 'reflect-metadata';
+import { createContainer } from "./framework/implementation/Container";
+import { Container } from "./framework/implementation/Container";
+import { LoadAs } from "./framework/implementation/LoadAs";
+import { Parameter } from "./framework/implementation/Parameter";
+import { NotAClassDefinitionError, ParameterNotFoundError, DependencyNotFoundError, InstanceNotCreatedError, CircularDependencyError } from "./framework/errors/ContainerErrors";
+import { Component, Inject } from "./framework/decorators/index";
+export { LoadAs };
+export { Parameter };
+export { Container };
+export { NotAClassDefinitionError, ParameterNotFoundError, DependencyNotFoundError, InstanceNotCreatedError, CircularDependencyError };
+export { Component, Inject };
+export { createContainer } from "./framework/implementation/Container";
+export default createContainer;
+//# sourceMappingURL=index.js.map

package/dist/esm/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../index.ts"],"names":[],"mappings":"AAAA,OAAO,kBAAkB,CAAC;AAC1B,OAAO,EAAE,eAAe,EAAE,MAAM,sCAAsC,CAAA;AACtE,OAAO,EAAE,SAAS,EAAE,MAAM,sCAAsC,CAAA;AAChE,OAAO,EAAE,MAAM,EAAE,MAAM,mCAAmC,CAAA;AAC1D,OAAO,EAAE,SAAS,EAAE,MAAM,sCAAsC,CAAA;AAEhE,OAAO,EAAE,wBAAwB,EAAE,sBAAsB,EAAE,uBAAuB,EAAE,uBAAuB,EAAE,uBAAuB,EAAE,MAAM,oCAAoC,CAAA;AAChL,OAAO,EAAE,SAAS,EAAE,MAAM,EAAE,MAAM,8BAA8B,CAAA;AAGhE,OAAO,EAAE,MAAM,EAAE,CAAA;AACjB,OAAO,EAAE,SAAS,EAAE,CAAA;AACpB,OAAO,EAAE,SAAS,EAAE,CAAA;AACpB,OAAO,EAAE,wBAAwB,EAAE,sBAAsB,EAAE,uBAAuB,EAAE,uBAAuB,EAAE,uBAAuB,EAAE,CAAA;AACtI,OAAO,EAAE,SAAS,EAAE,MAAM,EAAE,CAAA;AAC5B,OAAO,EAAE,eAAe,EAAE,MAAM,sCAAsC,CAAA;AACtE,eAAe,eAAe,CAAA"}

package/dist/esm/jest.config.d.ts

@@ -0,0 +1,3 @@
+import type { JestConfigWithTsJest } from 'ts-jest';
+declare const jestConfig: JestConfigWithTsJest;
+export default jestConfig;

package/dist/esm/jest.config.js

@@ -0,0 +1,7 @@
+const jestConfig = {
+    preset: 'ts-jest',
+    testEnvironment: 'node',
+    testPathIgnorePatterns: ['/node_modules/', '/dist/'],
+};
+export default jestConfig;
+//# sourceMappingURL=jest.config.js.map

package/dist/esm/jest.config.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"jest.config.js","sourceRoot":"","sources":["../../jest.config.ts"],"names":[],"mappings":"AAEA,MAAM,UAAU,GAAyB;IACvC,MAAM,EAAE,SAAS;IACjB,eAAe,EAAE,MAAM;IACvB,sBAAsB,EAAE,CAAC,gBAAgB,EAAE,QAAQ,CAAC;CACrD,CAAC;AAEF,eAAe,UAAU,CAAC"}

package/package.json

@@ -0,0 +1,41 @@
+{
+  "name": "@noego/ioc",
+  "version": "0.0.2",
+  "description": "A self contained IoC container for Node.js",
+  "main": "dist/cjs/index.js",
+  "types": "dist/index.d.ts",
+  "scripts": {
+    "test": "jest --silent",
+    "build:cjs": "tsc -p tsconfig.cjs.json",
+    "build:esm": "tsc -p tsconfig.esm.json",
+    "build": "npm run build:cjs && npm run build:esm",
+    "typecheck": "tsc -p tsconfig.cjs.json --noEmit"
+  },
+  "exports":{
+    ".": {
+      "require": "./dist/cjs/index.js",
+      "import": "./dist/esm/index.js"
+    },
+    "./package.json": "./package.json",
+    "./readme.md": "./readme.md"
+  },
+  "author": "Shavauhn Gabay",
+  "license": "ISC",
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@types/node": "^20.10.4",
+    "@types/randomstring": "^1.1.11",
+    "@types/reflect-metadata": "^0.0.5",
+    "randomstring": "^1.3.0",
+    "reflect-metadata": "^0.2.2"
+  },
+  "devDependencies": {
+    "@types/jest": "^29.5.14",
+    "jest": "^29.7.0",
+    "ts-jest": "^29.3.2",
+    "ts-node": "^10.9.2",
+    "typescript": "^5.8.3"
+  }
+}

package/readme.md

@@ -0,0 +1,566 @@
+# @noego/ioc
+
+A lightweight, flexible Inversion of Control (IoC) container for Node.js and TypeScript applications, providing support for multiple dependency lifetime scopes, parameter injection, and both class and function registration with full type safety.
+
+## Features
+
+ **Dual Module Support**: Compatible with CommonJS and ES Modules
+ **TypeScript & Typings**: Built in TypeScript with bundled declaration files
+
+- **Multiple Lifetime Scopes**: Support for Singleton, Transient, and Scoped dependencies
+- **Class & Function Registration**: Register both classes and functions as dependencies
+- **Parameter Injection**: Inject parameter values at resolution time
+- **Container Extension**: Create child containers that inherit parent registrations
+- **Decorator Support**: Use @Component and @Inject decorators for clean, declarative DI
+- **TypeScript Support**: Built with full TypeScript support for type safety
+- **Async Resolution**: Support for asynchronous dependency resolution
+- **Lightweight**: Small footprint with minimal external dependencies
+
+## Installation
+
+```bash
+npm install @noego/ioc
+# or
+yarn add @noego/ioc
+```
+
+If you want to use decorators, also install reflect-metadata:
+
+```bash
+npm install reflect-metadata
+# or
+yarn add reflect-metadata
+```
+
+And configure TypeScript for decorator support in tsconfig.json:
+
+```json
+{
+  "compilerOptions": {
+    "experimentalDecorators": true,
+    "emitDecoratorMetadata": true,
+    "module": "ESNext",
+    "moduleResolution": "node",
+    "target": "ESNext"
+  }
+}
+```
+
+### Quick Start
+Follow these minimal steps to get @noego/ioc working in a TypeScript project:
+
+1. Install packages:
+   ```bash
+   npm install @noego/ioc reflect-metadata
+   ```
+
+2. Configure `tsconfig.json`:
+   ```json
+   {
+     "compilerOptions": {
+       "experimentalDecorators": true,
+       "emitDecoratorMetadata": true,
+       "module": "ESNext",
+       "moduleResolution": "node",
+       "target": "ESNext"
+     },
+     "include": ["src"]
+   }
+   ```
+
+3. Create an entry file (`index.ts`):
+   ```typescript
+   import 'reflect-metadata';
+   import createContainer, { Component } from '@noego/ioc';
+
+   @Component()
+   class ExampleService {}
+
+   async function bootstrap() {
+     const container = createContainer();
+     container.registerClass(ExampleService);
+     const svc = await container.instance(ExampleService);
+     console.log('Service instance:', svc);
+   }
+
+   bootstrap();
+   ```
+
+4. Run the entry file:
+   ```bash
+   npx ts-node index.ts
+   ```
+
+## Getting Started
+
+### Using manual registration:
+
+```typescript
+import createContainer from "@noego/ioc";
+
+// Create a container
+const container = createContainer();
+
+// Register your dependencies
+container.registerClass(Database);
+container.registerClass(UserRepository, { param: [Database] });
+
+// Resolve and use
+async function main() {
+  const repo = await container.instance(UserRepository);
+  const users = repo.getUsers();
+}
+
+main();
+```
+
+### Using decorators:
+
+```typescript
+import createContainer, { Component, Inject } from "@noego/ioc";
+import 'reflect-metadata'; // Required when using decorators
+
+@Component({ scope: LoadAs.Singleton })
+class Database {
+  connect() {
+    return "Connected to DB";
+  }
+}
+
+@Component()
+class UserRepository {
+  constructor(private db: Database) {}
+  
+  getUsers() {
+    this.db.connect();
+    return ["User1", "User2"];
+  }
+}
+
+// Create container and register classes
+const container = createContainer();
+container.registerClass(Database);
+container.registerClass(UserRepository);
+
+// Resolve and use
+async function main() {
+  const repo = await container.instance(UserRepository);
+  const users = repo.getUsers();
+}
+
+main();
+```
+
+## Usage
+
+### Basic Usage
+
+```typescript
+import createContainer from "@noego/ioc";
+
+// Create a container
+const container = createContainer();
+
+// Define classes
+class Database {
+  connect() {
+    return "Connected to DB";
+  }
+}
+
+class UserRepository {
+  constructor(private db: Database) {}
+  
+  getUsers() {
+    this.db.connect();
+    return ["User1", "User2"];
+  }
+}
+
+class UserService {
+  constructor(private repo: UserRepository) {}
+  
+  getAllUsers() {
+    return this.repo.getUsers();
+  }
+}
+
+// Register dependencies
+container.registerClass(Database);
+container.registerClass(UserRepository, { param: [Database] });
+container.registerClass(UserService, { param: [UserRepository] });
+
+// Resolve dependencies
+async function run() {
+  const userService = await container.instance(UserService);
+  const users = userService.getAllUsers();
+  console.log(users); // ["User1", "User2"]
+}
+
+run();
+```
+
+### Lifetime Scopes
+
+The container supports three different lifetime scopes:
+
+1. **Transient** (default): A new instance is created every time the dependency is resolved
+2. **Singleton**: Only one instance is created and reused throughout the application
+3. **Scoped**: A single instance is created per container scope
+
+```typescript
+import { LoadAs } from "@noego/ioc";
+
+// Register a singleton
+container.registerClass(Database, { loadAs: LoadAs.Singleton });
+
+// Register a scoped dependency
+container.registerClass(UserRepository, { 
+  param: [Database],
+  loadAs: LoadAs.Scoped 
+});
+```
+
+### Parameter Injection
+
+You can inject parameter values at resolution time:
+
+```typescript
+import { Parameter } from "@noego/ioc";
+
+class User {
+  constructor(public id: number, public name: string) {}
+}
+
+// Create parameters
+const USER_ID = Parameter.create();
+const USER_NAME = Parameter.create();
+
+// Register with parameters
+container.registerClass(User, { param: [USER_ID, USER_NAME] });
+
+// Resolve with parameter values
+async function createUser() {
+  const user = await container.instance(User, [
+    USER_ID.value(1),
+    USER_NAME.value("John")
+  ]);
+  
+  console.log(user.id, user.name); // 1, "John"
+}
+```
+
+### Function Registration
+
+You can also register functions as dependencies:
+
+```typescript
+function createLogger(prefix: string) {
+  return {
+    log: (message: string) => console.log(`${prefix}: ${message}`)
+  };
+}
+
+const PREFIX = Parameter.create();
+
+// Register function
+container.registerFunction("logger", createLogger, { 
+  param: [PREFIX] 
+});
+
+// Resolve function
+async function useLogger() {
+  const logger = await container.get("logger", [PREFIX.value("APP")]);
+  logger.log("Application started"); // "APP: Application started"
+}
+```
+
+### Using Decorators
+
+The container supports decorator-based dependency injection using `@Component` and `@Inject`.
+
+#### Setup
+
+First, ensure TypeScript is configured to support decorators:
+
+```json
+// tsconfig.json
+{
+  "compilerOptions": {
+    "experimentalDecorators": true,
+    "emitDecoratorMetadata": true,
+    // other options...
+  }
+}
+```
+
+Also, import `reflect-metadata` once at your application's entry point:
+
+```typescript
+// index.ts or main.ts
+import 'reflect-metadata';
+// ... rest of your code
+```
+
+#### Component Decorator
+
+Use `@Component` to mark a class as a component with an optional scope:
+
+```typescript
+import { Component, LoadAs } from '@noego/ioc';
+
+@Component()  // Default is Transient
+class UserService {
+  // ...
+}
+
+@Component({ scope: LoadAs.Singleton })
+class DatabaseService {
+  // ...
+}
+
+@Component({ scope: LoadAs.Scoped })
+class RequestContext {
+  // ...
+}
+```
+
+#### Inject Decorator
+
+Use `@Inject` to specify tokens for interface dependencies or to override constructor parameter types:
+
+```typescript
+import { Component, Inject } from '@noego/ioc';
+
+// Define an interface
+interface ILogger {
+  log(message: string): void;
+}
+
+// Create a token for the interface
+const LoggerToken = Symbol('ILogger');
+
+// Implement the interface
+@Component({ scope: LoadAs.Singleton })
+class ConsoleLogger implements ILogger {
+  log(message: string) {
+    console.log(message);
+  }
+}
+
+// Use @Inject to specify which implementation to use
+@Component()
+class UserService {
+  constructor(
+    // Use @Inject with a token
+    @Inject(LoggerToken) private logger: ILogger,
+    
+    // Regular parameter - resolved by type
+    private database: DatabaseService
+  ) {}
+  
+  createUser() {
+    this.logger.log('Creating user...');
+    // ...
+  }
+}
+
+// Register
+const container = createContainer();
+container.registerClass(DatabaseService);
+container.registerClass(ConsoleLogger);
+container.registerFunction(LoggerToken, () => container.instance(ConsoleLogger));
+container.registerClass(UserService);
+
+// Resolve
+const service = await container.instance(UserService);
+```
+
+#### Override Priority
+
+Manual registration options take precedence over decorators:
+
+1. Manually defined parameters in `registerClass({ param: [...] })` override constructor parameter types and `@Inject` annotations.
+2. Manually defined scope in `registerClass({ loadAs: ... })` overrides `@Component({ scope: ... })`.
+
+This allows you to change behavior at registration time without modifying the decorated class.
+
+### Extending Containers
+
+You can create a child container that inherits all the registrations from the parent but allows overriding:
+
+```typescript
+// Create parent container
+const parentContainer = createContainer();
+parentContainer.registerClass(Database);
+
+// Create child container
+const childContainer = parentContainer.extend();
+
+// Override in child container
+childContainer.registerClass(Database, { /* different configuration */ });
+
+// Parent container still uses the original registration
+// Child container uses the new registration
+```
+
+## API Reference
+
+### Container
+
+- `createContainer()`: Creates a new IoC container
+- `registerClass<T>(classDefinition, options?)`: Register a class
+- `registerFunction(label, function, options?)`: Register a function
+- `instance<T>(classDefinition, params?)`: Resolve a class instance
+- `get<T>(label, params?)`: Resolve a dependency by key
+- `extend()`: Create a child container
+
+### Decorators
+
+- `@Component(options?)`: Mark a class as container-managed
+- `@Inject(token)`: Specify a token for a constructor parameter
+
+### Options
+
+```typescript
+interface ContainerOptions {
+  param?: any[];      // Dependencies or parameters
+  loadAs?: LoadAs;    // Lifetime scope
+}
+```
+
+### LoadAs Enum
+
+```typescript
+enum LoadAs {
+  Singleton,  // Single instance throughout application
+  Scoped,     // Single instance per container scope
+  Transient   // New instance each time
+}
+```
+
+### Parameter
+
+- `Parameter.create()`: Create a new parameter
+- `parameter.value(value)`: Create a parameter value
+
+### Component Options
+
+```typescript
+interface ComponentOptions {
+  scope?: LoadAs;  // Lifetime scope
+}
+```
+
+## Real-World Use Cases
+
+### Express Application
+
+```typescript
+import express from 'express';
+import createContainer, { LoadAs } from '@noego/ioc';
+
+// Create services
+class ConfigService {
+  getConfig() {
+    return { port: 3000 };
+  }
+}
+
+class DatabaseService {
+  constructor(private config: ConfigService) {}
+  
+  connect() {
+    console.log('Connected to database');
+    return {};
+  }
+}
+
+class UserRepository {
+  constructor(private db: DatabaseService) {}
+  
+  findAll() {
+    return [{ id: 1, name: 'User 1' }];
+  }
+}
+
+class UserController {
+  constructor(private repo: UserRepository) {}
+  
+  getUsers(req, res) {
+    const users = this.repo.findAll();
+    res.json(users);
+  }
+}
+
+// Setup container
+const container = createContainer();
+container.registerClass(ConfigService, { loadAs: LoadAs.Singleton });
+container.registerClass(DatabaseService, { param: [ConfigService], loadAs: LoadAs.Singleton });
+container.registerClass(UserRepository, { param: [DatabaseService] });
+container.registerClass(UserController, { param: [UserRepository] });
+
+// Create express app
+const app = express();
+
+// Setup routes using the container
+app.get('/users', async (req, res) => {
+  const controller = await container.instance(UserController);
+  controller.getUsers(req, res);
+});
+
+// Start server
+async function bootstrap() {
+  const config = await container.instance(ConfigService);
+  app.listen(config.getConfig().port, () => {
+    console.log(`Server running on port ${config.getConfig().port}`);
+  });
+}
+
+bootstrap();
+```
+
+## Running Tests
+
+The project uses Jest for testing. To run tests:
+
+```bash
+npm test
+```
+
+## License
+
+ISC
+
+## Contributing
+
+Contributions are welcome! Here's how you can contribute to this project:
+
+1. Fork the repository
+2. Create your feature branch (`git checkout -b feature/amazing-feature`)
+3. Install dependencies (`npm install`)
+4. Make your changes
+5. Run tests to ensure everything works (`npm test`)
+6. Commit your changes (`git commit -m 'Add some amazing feature'`)
+7. Push to the branch (`git push origin feature/amazing-feature`)
+8. Open a Pull Request
+
+### Development Setup
+
+1. Clone the repository:
+   ```bash
+   git clone <repository-url>
+   cd ioc
+   ```
+
+2. Install dependencies:
+   ```bash
+   npm install
+   ```
+
+3. Run tests:
+   ```bash
+   npm test
+   ```
+
+Please make sure to update tests as appropriate and follow the existing code style.