@gabrielrufino/cerebrum 2.0.7 → 2.1.1

package/dist/Aggregation/GroupBy.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GroupBy = void 0;
+class GroupBy {
+    constructor(items, key) {
+        this.items = items;
+        this.key = key;
+    }
+    execute() {
+        return this.items.reduce((accumulator, item) => {
+            const group = item[this.key];
+            if (!accumulator[group]) {
+                accumulator[group] = [];
+            }
+            accumulator[group].push(item);
+            return accumulator;
+        }, {});
+    }
+}
+exports.GroupBy = GroupBy;

package/dist/Aggregation/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./GroupBy"), exports);

package/dist/index.js

@@ -33,7 +33,8 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Sort = exports.Search = exports.NLP = exports.Math = void 0;
+exports.Sort = exports.Search = exports.NLP = exports.Math = exports.Aggregation = void 0;
+exports.Aggregation = __importStar(require("./Aggregation"));
 exports.Math = __importStar(require("./Math"));
 exports.NLP = __importStar(require("./NLP"));
 exports.Search = __importStar(require("./Search"));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gabrielrufino/cerebrum",
-  "version": "2.0.7",
+  "version": "2.1.1",
   "description": "Algorithms made in TypeScript",
   "main": "dist/index.js",
   "type": "module",
@@ -16,14 +16,14 @@
   "author": "Gabriel Rufino <contato@gabrielrufino.com>",
   "license": "UNLICENSED",
   "devDependencies": {
-    "@antfu/eslint-config": "^4.14.1",
+    "@antfu/eslint-config": "^4.19.0",
     "@commitlint/cli": "^19.8.1",
     "@commitlint/config-conventional": "^19.8.1",
     "@faker-js/faker": "^8.4.1",
-    "@vitest/coverage-v8": "^3.2.3",
-    "eslint": "^9.29.0",
+    "@vitest/coverage-v8": "^3.2.4",
+    "eslint": "^9.32.0",
     "husky": "^9.1.7",
-    "typescript": "^5.8.3",
+    "typescript": "^5.9.2",
     "vitest": "^3.0.5"
   },
   "funding": [

package/src/Aggregation/GroupBy.spec.ts

@@ -0,0 +1,129 @@
+import { describe, expect, it } from 'vitest'
+import { GroupBy } from './GroupBy'
+
+describe('groupBy', () => {
+  interface Person {
+    name: string
+    age: number
+    department: string
+    salary: number
+  }
+
+  const people: Person[] = [
+    { name: 'Alice', age: 30, department: 'Engineering', salary: 100000 },
+    { name: 'Bob', age: 25, department: 'Engineering', salary: 80000 },
+    { name: 'Charlie', age: 35, department: 'Marketing', salary: 70000 },
+    { name: 'Diana', age: 28, department: 'Marketing', salary: 75000 },
+    { name: 'Eve', age: 32, department: 'Engineering', salary: 90000 },
+    { name: 'Frank', age: 40, department: 'Sales', salary: 85000 },
+  ]
+
+  it('should group items by department', () => {
+    const groupBy = new GroupBy(people, 'department')
+    const result = groupBy.execute()
+
+    expect(result).toHaveProperty('Engineering')
+    expect(result).toHaveProperty('Marketing')
+    expect(result).toHaveProperty('Sales')
+
+    // eslint-disable-next-line dot-notation
+    expect(result['Engineering']).toHaveLength(3)
+    // eslint-disable-next-line dot-notation
+    expect(result['Marketing']).toHaveLength(2)
+    // eslint-disable-next-line dot-notation
+    expect(result['Sales']).toHaveLength(1)
+
+    // eslint-disable-next-line dot-notation
+    expect(result['Engineering']).toEqual([
+      { name: 'Alice', age: 30, department: 'Engineering', salary: 100000 },
+      { name: 'Bob', age: 25, department: 'Engineering', salary: 80000 },
+      { name: 'Eve', age: 32, department: 'Engineering', salary: 90000 },
+    ])
+  })
+
+  it('should group items by age', () => {
+    const groupBy = new GroupBy(people, 'age')
+    const result = groupBy.execute()
+
+    expect(result).toHaveProperty('30')
+    expect(result).toHaveProperty('25')
+    expect(result).toHaveProperty('35')
+    expect(result).toHaveProperty('28')
+    expect(result).toHaveProperty('32')
+    expect(result).toHaveProperty('40')
+
+    expect(result['30']).toHaveLength(1)
+    expect(result['25']).toHaveLength(1)
+    expect(result['30'][0]).toEqual({ name: 'Alice', age: 30, department: 'Engineering', salary: 100000 })
+  })
+
+  it('should handle empty array', () => {
+    const groupBy = new GroupBy([], 'department')
+    const result = groupBy.execute()
+
+    expect(result).toEqual({})
+  })
+
+  it('should handle single item', () => {
+    const singlePerson = [{ name: 'John', age: 30, department: 'IT', salary: 50000 }]
+    const groupBy = new GroupBy(singlePerson, 'department')
+    const result = groupBy.execute()
+
+    expect(result).toHaveProperty('IT')
+    // eslint-disable-next-line dot-notation
+    expect(result['IT']).toHaveLength(1)
+    // eslint-disable-next-line dot-notation
+    expect(result['IT'][0]).toEqual({ name: 'John', age: 30, department: 'IT', salary: 50000 })
+  })
+
+  it('should handle all items having same group key', () => {
+    const sameDepartment = [
+      { name: 'Alice', age: 30, department: 'Engineering', salary: 100000 },
+      { name: 'Bob', age: 25, department: 'Engineering', salary: 80000 },
+      { name: 'Charlie', age: 35, department: 'Engineering', salary: 70000 },
+    ]
+
+    const groupBy = new GroupBy(sameDepartment, 'department')
+    const result = groupBy.execute()
+
+    expect(result).toHaveProperty('Engineering')
+    // eslint-disable-next-line dot-notation
+    expect(result['Engineering']).toHaveLength(3)
+    expect(Object.keys(result)).toHaveLength(1)
+  })
+
+  it('should work with different data types', () => {
+    interface Product {
+      id: number
+      name: string
+      category: string
+      inStock: boolean
+    }
+
+    const products: Product[] = [
+      { id: 1, name: 'Laptop', category: 'Electronics', inStock: true },
+      { id: 2, name: 'Book', category: 'Education', inStock: false },
+      { id: 3, name: 'Mouse', category: 'Electronics', inStock: true },
+      { id: 4, name: 'Pen', category: 'Education', inStock: true },
+    ]
+
+    const groupBy = new GroupBy(products, 'inStock')
+    const result = groupBy.execute()
+
+    expect(result).toHaveProperty('true')
+    expect(result).toHaveProperty('false')
+    // eslint-disable-next-line dot-notation
+    expect(result['true']).toHaveLength(3)
+    // eslint-disable-next-line dot-notation
+    expect(result['false']).toHaveLength(1)
+  })
+
+  it('should preserve original object references', () => {
+    const originalPerson = people[0]
+    const groupBy = new GroupBy(people, 'department')
+    const result = groupBy.execute()
+
+    // eslint-disable-next-line dot-notation
+    expect(result['Engineering'][0]).toBe(originalPerson)
+  })
+})

package/src/Aggregation/GroupBy.ts

@@ -0,0 +1,17 @@
+export class GroupBy<T extends Record<string, any>> {
+  constructor(
+    private readonly items: Array<T>,
+    private readonly key: keyof T,
+  ) {}
+
+  public execute(): Record<string, Array<T>> {
+    return this.items.reduce((accumulator, item) => {
+      const group = item[this.key]
+      if (!accumulator[group]) {
+        accumulator[group] = []
+      }
+      accumulator[group].push(item)
+      return accumulator
+    }, {} as Record<string, Array<T>>)
+  }
+}

package/src/Aggregation/index.ts

@@ -0,0 +1 @@
+export * from './GroupBy'

package/src/index.ts

@@ -1,3 +1,4 @@
+export * as Aggregation from './Aggregation'
 export * as Math from './Math'
 export * as NLP from './NLP'
 export * as Search from './Search'