abisan-custom-library 1.0.0

package/jest.config.cjs

@@ -0,0 +1,6 @@
+module.exports = {
+  preset: 'ts-jest',
+  testEnvironment: 'node',
+  roots: ['<rootDir>/test'],
+  testMatch: ['**/*.test.ts']
+};

package/package.json

@@ -0,0 +1,31 @@
+{
+  "name": "abisan-custom-library",
+  "version": "1.0.0",
+  "description": "",
+  "main": "index.js",
+  "scripts": {
+    "test": "jest",
+  "coverage": "jest --coverage",
+  "watch": "jest --watch"
+
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Abinashini31/Custom-Library.git"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "ISC",
+  "type": "commonjs",
+  "bugs": {
+    "url": "https://github.com/Abinashini31/Custom-Library/issues"
+  },
+  "homepage": "https://github.com/Abinashini31/Custom-Library#readme",
+  "devDependencies": {
+    "@types/jest": "^30.0.0",
+    "jest": "^30.3.0",
+    "ts-jest": "^29.4.9",
+    "ts-node": "^10.9.2",
+    "typescript": "^6.0.2"
+  }
+}

package/src/Extraction/pluck.ts

@@ -0,0 +1,46 @@
+// src/Extraction/pluck.ts
+
+type Path = string | string[];
+
+/**
+ * Polymorphic pluck:
+ * - "id" → simple property
+ * - "a.b.c" → deep path
+ * - ["id", "tags"] → multi-key pick
+ */
+export function pluck<T>(path: Path, data: T[]): any[] {
+  if (!Array.isArray(data) || data.length === 0) return [];
+
+  if (Array.isArray(path)) {
+    return multiPick(path, data);
+  }
+
+  if (typeof path === 'string' && path.includes('.')) {
+    return deepPick(path, data);
+  }
+
+  return simplePick(path as string, data);
+}
+
+/* ------------------ Helpers ------------------ */
+
+function simplePick<T>(key: string, data: T[]) {
+  return data.map(item => (item as any)?.[key]);
+}
+
+function deepPick<T>(path: string, data: T[]) {
+  const keys = path.split('.');
+
+  return data.map(obj =>
+    keys.reduce((acc: any, key) => acc?.[key], obj)
+  );
+}
+
+function multiPick<T>(keys: string[], data: T[]) {
+  return data.map(obj =>
+    keys.reduce((acc: any, key) => {
+      acc[key] = (obj as any)?.[key];
+      return acc;
+    }, {})
+  );
+}

package/src/Foundation/foundation/every.ts

@@ -0,0 +1,11 @@
+export function every<T>(
+  fn: (value: T, index: number, arr: readonly T[]) => boolean,
+  arr: readonly T[]
+): boolean {
+  for (let i = 0; i < arr.length; i++) {
+    if (!fn(arr[i], i, arr)) {
+      return false;
+    }
+  }
+  return true;
+}

package/src/Foundation/foundation/filter.ts

@@ -0,0 +1,16 @@
+export function filter<T>(
+  fn: (value: T, index: number, arr: readonly T[]) => boolean,
+  arr: readonly T[] | null | undefined
+): T[] {
+  if (!arr) return [];
+
+  const result: T[] = [];
+
+  for (let i = 0; i < arr.length; i++) {
+    if (fn(arr[i], i, arr)) {
+      result.push(arr[i]);
+    }
+  }
+
+  return result;
+}

package/src/Foundation/foundation/map.ts

@@ -0,0 +1,14 @@
+export function map<T, R>(
+  fn: (item: T, index: number) => R,
+  arr: T[]
+): R[] {
+  if (!Array.isArray(arr)) return [];
+
+  const result: R[] = [];
+
+  for (let i = 0; i < arr.length; i++) {
+    result.push(fn(arr[i], i));
+  }
+
+  return result;
+}

package/src/Foundation/foundation/reduce.ts

@@ -0,0 +1,26 @@
+export function reduce<T, U>(
+  fn: (acc: U, val: T, index: number, arr: T[]) => U,
+  initial: U,
+  arr: T[]
+): U {
+  let acc = initial;
+
+  for (let i = 0; i < arr.length; i++) {
+    acc = fn(acc, arr[i], i, arr);
+  }
+
+  return acc;
+}
+export function reduceRight<T, U>(
+  fn: (acc: U, val: T, index: number, arr: T[]) => U,
+  initial: U,
+  arr: T[]
+): U {
+  let acc = initial;
+
+  for (let i = arr.length - 1; i >= 0; i--) {
+    acc = fn(acc, arr[i], i, arr);
+  }
+
+  return acc;
+}

package/src/Foundation/foundation/reduceright.ts

@@ -0,0 +1,13 @@
+export function reduceRight<T, U>(
+  fn: (acc: U, val: T, index: number, arr: readonly T[]) => U,
+  initial: U,
+  arr: readonly T[]
+): U {
+  let acc = initial;
+
+  for (let i = arr.length - 1; i >= 0; i--) {
+    acc = fn(acc, arr[i], i, arr as T[]);
+  }
+
+  return acc;
+}

package/src/Foundation/foundation/some.ts

@@ -0,0 +1,11 @@
+export function some<T>(
+  fn: (value: T, index: number, arr: readonly T[]) => boolean,
+  arr: readonly T[]
+): boolean {
+  for (let i = 0; i < arr.length; i++) {
+    if (fn(arr[i], i, arr)) {
+      return true;
+    }
+  }
+  return false;
+}

package/src/Lens/lens.ts

@@ -0,0 +1,15 @@
+import { getDeep, setDeep } from './utils';
+
+export type Lens = {
+  get: (obj: any) => any;
+  set: (value: any, obj: any) => any;
+};
+
+export function lens(path: string): Lens {
+  const keys = path ? path.split('.') : [];
+
+  return {
+    get: (obj: any) => getDeep(obj, keys),
+    set: (value: any, obj: any) => setDeep(obj, keys, value)
+  };
+}

package/src/Lens/set.ts

@@ -0,0 +1,5 @@
+import { Lens } from './lens';
+
+export function set(lensObj: Lens, value: any, obj: any) {
+  return lensObj.set(value, obj);
+}

package/src/Lens/utils.ts

@@ -0,0 +1,16 @@
+export function getDeep(obj: any, keys: string[]) {
+  return keys.reduce((acc, key) => acc?.[key], obj);
+}
+
+export function setDeep(obj: any, keys: string[], value: any): any {
+  if (keys.length === 0) return value;
+
+  const [first, ...rest] = keys;
+
+  return {
+    ...obj,
+    [first]: rest.length
+      ? setDeep(obj?.[first] ?? {}, rest, value)
+      : value
+  };
+}

package/src/Lens/view.ts

@@ -0,0 +1,5 @@
+import { Lens } from './lens';
+
+export function view(lensObj: Lens, obj: any) {
+  return lensObj.get(obj);
+}

package/src/Search/findByKeyValue.ts

@@ -0,0 +1,12 @@
+export function findByKeyValue<T>(
+  arr: T[],
+  key: keyof T,
+  value: any
+): T | undefined {
+  for (let i = 0; i < arr.length; i++) {
+    if (arr[i][key] === value) {
+      return arr[i];
+    }
+  }
+  return undefined;
+}

package/src/Search/findByPredicate.ts

@@ -0,0 +1,11 @@
+export function findByPredicate<T>(
+  arr: T[],
+  fn: (value: T, index: number, arr: T[]) => boolean
+): T | undefined {
+  for (let i = 0; i < arr.length; i++) {
+    if (fn(arr[i], i, arr)) {
+      return arr[i];
+    }
+  }
+  return undefined;
+}

package/src/index.ts

@@ -0,0 +1,15 @@
+export { map } from "./Foundation/foundation/map";
+export { filter } from "./Foundation/foundation/filter";
+export { reduce } from "./Foundation/foundation/reduce";
+export { reduceRight } from "./Foundation/foundation/reduceright";
+export { some } from "./Foundation/foundation/some";
+export { every } from "./Foundation/foundation/every";
+
+export { findByPredicate } from "./Search/findByPredicate";
+export { findByKeyValue } from "./Search/findByKeyValue";
+
+export { pluck } from "./Extraction/pluck";
+
+export { lens } from "./Lens/lens";
+export { view } from "./Lens/view";
+export { set } from "./Lens/set";

package/test/every.test.ts

@@ -0,0 +1,40 @@
+import { every } from "../src/Foundation/foundation/every";
+
+describe("every", () => {
+  test("returns true if all elements satisfy condition", () => {
+    const result = every((x) => x > 0, [1, 2, 3, 4]);
+    expect(result).toBe(true);
+  });
+
+  test("returns false if any element fails condition", () => {
+    const result = every((x) => x > 0, [1, -2, 3]);
+    expect(result).toBe(false);
+  });
+
+  test("works with objects (all true)", () => {
+    const users = [
+      { active: true },
+      { active: true },
+      { active: true }
+    ];
+
+    const result = every((u) => u.active === true, users);
+    expect(result).toBe(true);
+  });
+
+  test("works with objects (one false)", () => {
+    const users = [
+      { active: true },
+      { active: false },
+      { active: true }
+    ];
+
+    const result = every((u) => u.active === true, users);
+    expect(result).toBe(false);
+  });
+
+  test("empty array returns true (JS behavior)", () => {
+    const result = every((x) => x > 0, []);
+    expect(result).toBe(true);
+  });
+});

package/test/filter.test.ts

@@ -0,0 +1,45 @@
+
+import { filter } from "../src/Foundation/foundation/filter";
+ 
+describe("filter()", () => {
+ 
+  test("filters values correctly", () => {
+
+    const arr = [1, 2, 3, 4];
+ 
+    const result = filter(x => x > 2, arr);
+ 
+    expect(result).toEqual([3, 4]);
+
+  });
+ 
+  test("returns empty array if no match", () => {
+
+    const arr = [1, 2];
+ 
+    const result = filter(x => x > 5, arr);
+ 
+    expect(result).toEqual([]);
+
+  });
+ 
+  test("handles empty array", () => {
+
+    expect(filter(x => x, [])).toEqual([]);
+
+  });
+ 
+  test("does not mutate original array", () => {
+
+    const arr = [1, 2, 3];
+
+    const copy = [...arr];
+ 
+    filter(x => x > 1, arr);
+ 
+    expect(arr).toEqual(copy);
+
+  });
+ 
+});
+ 

package/test/findByKeyValue.test.ts

@@ -0,0 +1,29 @@
+import { findByKeyValue } from "../src/Search/findByKeyValue";
+
+describe("findByKeyValue", () => {
+  const users = [
+    { id: 1, username: "vishnu_dev", active: true },
+    { id: 2, username: "john_doe", active: false },
+    { id: 3, username: "alice", active: true }
+  ];
+
+  test("finds user by username", () => {
+    const result = findByKeyValue(users, "username", "john_doe");
+    expect(result).toEqual({ id: 2, username: "john_doe", active: false });
+  });
+
+  test("finds user by id", () => {
+    const result = findByKeyValue(users, "id", 3);
+    expect(result).toEqual({ id: 3, username: "alice", active: true });
+  });
+
+  test("returns undefined if key-value not found", () => {
+    const result = findByKeyValue(users, "username", "not_exist");
+    expect(result).toBeUndefined();
+  });
+
+  test("works with empty array", () => {
+    const result = findByKeyValue([], "id", 1);
+    expect(result).toBeUndefined();
+  });
+});

package/test/findByPredicate.test.ts

@@ -0,0 +1,29 @@
+import { findByPredicate } from "../src/Search/findByPredicate";
+
+describe("findByPredicate", () => {
+  const users = [
+    { id: 1, username: "vishnu_dev", active: true },
+    { id: 2, username: "john_doe", active: false },
+    { id: 3, username: "alice", active: true }
+  ];
+
+  test("finds user by predicate match", () => {
+    const result = findByPredicate(users, (u) => u.id === 1);
+    expect(result).toEqual({ id: 1, username: "vishnu_dev", active: true });
+  });
+
+  test("returns undefined if no match", () => {
+    const result = findByPredicate(users, (u) => u.id === 999);
+    expect(result).toBeUndefined();
+  });
+
+  test("finds first active user", () => {
+    const result = findByPredicate(users, (u) => u.active === true);
+    expect(result).toEqual({ id: 1, username: "vishnu_dev", active: true });
+  });
+
+  test("works with empty array", () => {
+    const result = findByPredicate([], (u: any) => u.id === 1);
+    expect(result).toBeUndefined();
+  });
+});

package/test/lens.test.ts

@@ -0,0 +1,99 @@
+// test/lens.test.ts
+
+import { lens } from '../src/Lens/lens';
+import { view } from '../src/Lens/view';
+import { set } from '../src/Lens/set';
+
+describe('Lens (split modules)', () => {
+  const user = {
+    id: 1,
+    profile: {
+      settings: {
+        theme: 'light'
+      }
+    }
+  };
+
+  /* ------------------ VIEW ------------------ */
+
+  it('should view deep value', () => {
+    const l = lens('profile.settings.theme');
+
+    expect(view(l, user)).toBe('light');
+  });
+
+  it('should return undefined for missing path', () => {
+    const l = lens('profile.settings.lang');
+
+    expect(view(l, user)).toBeUndefined();
+  });
+
+  it('should handle null safely', () => {
+    const l = lens('a.b.c');
+
+    // @ts-ignore
+    expect(view(l, null)).toBeUndefined();
+  });
+
+  /* ------------------ SET ------------------ */
+
+  it('should update value immutably', () => {
+    const l = lens('profile.settings.theme');
+
+    const updated = set(l, 'dark', user);
+
+    expect(updated.profile.settings.theme).toBe('dark');
+    expect(user.profile.settings.theme).toBe('light'); // unchanged
+  });
+
+  it('should create missing path', () => {
+    const l = lens('profile.preferences.language');
+
+    const updated = set(l, 'en', user);
+
+    expect(updated.profile.preferences.language).toBe('en');
+  });
+
+  it('should not mutate original object', () => {
+    const copy = JSON.parse(JSON.stringify(user));
+
+    const l = lens('profile.settings.theme');
+    set(l, 'dark', user);
+
+    expect(user).toEqual(copy);
+  });
+
+  it('should preserve other fields', () => {
+    const l = lens('profile.settings.theme');
+
+    const updated = set(l, 'dark', user);
+
+    expect(updated.id).toBe(1);
+  });
+
+  it('should work with empty object', () => {
+    const l = lens('a.b.c');
+
+    const result = set(l, 10, {});
+
+    expect(result).toEqual({
+      a: { b: { c: 10 } }
+    });
+  });
+
+  /* ------------------ EMPTY PATH ------------------ */
+
+  it('should replace entire object when path is empty', () => {
+    const l = lens('');
+
+    const result = set(l, { x: 1 }, { a: 1 });
+
+    expect(result).toEqual({ x: 1 });
+  });
+
+  it('should return entire object on view when path is empty', () => {
+    const l = lens('');
+
+    expect(view(l, user)).toEqual(user);
+  });
+});

package/test/map.test.ts

@@ -0,0 +1,38 @@
+import { map } from "../src/Foundation/foundation/map";
+
+describe("map()", () => {
+
+  test("transforms values correctly", () => {
+    const arr = [1, 2, 3, 4];
+
+    const result = map(x => x * 2, arr);
+
+    expect(result).toEqual([2, 4, 6, 8]);
+  });
+
+  test("returns empty array if input is empty", () => {
+    const arr: number[] = [];
+
+    const result = map(x => x * 2, arr);
+
+    expect(result).toEqual([]);
+  });
+
+  test("does not mutate original array", () => {
+    const arr = [1, 2, 3];
+    const copy = [...arr];
+
+    map(x => x * 2, arr);
+
+    expect(arr).toEqual(copy);
+  });
+
+  test("passes index correctly", () => {
+    const arr = [10, 20, 30];
+
+    const result = map((x, i) => i, arr);
+
+    expect(result).toEqual([0, 1, 2]);
+  });
+
+});

package/test/pluck.test.ts

@@ -0,0 +1,87 @@
+// test/pluck.test.ts
+
+import { pluck } from '../src/Extraction/pluck';
+
+describe('pluck utility', () => {
+  const data = [
+    { id: 1, info: { email: 'v@test.com' }, tags: ['dev'] },
+    { id: 2, info: { email: 'a@test.com' }, tags: ['hr'] }
+  ];
+
+  /* ------------------ Simple Property ------------------ */
+
+  it('should extract simple property', () => {
+    const result = pluck('id', data);
+    expect(result).toEqual([1, 2]);
+  });
+
+  /* ------------------ Deep Path ------------------ */
+
+  it('should extract deep path using dot notation', () => {
+    const result = pluck('info.email', data);
+    expect(result).toEqual(['v@test.com', 'a@test.com']);
+  });
+
+  /* ------------------ Multi Key ------------------ */
+
+  it('should extract multiple keys', () => {
+    const result = pluck(['id', 'tags'], data);
+
+    expect(result).toEqual([
+      { id: 1, tags: ['dev'] },
+      { id: 2, tags: ['hr'] }
+    ]);
+  });
+
+  /* ------------------ Edge Cases ------------------ */
+
+  it('should return empty array for empty input', () => {
+    expect(pluck('id', [])).toEqual([]);
+  });
+
+  it('should handle null/undefined safely', () => {
+    // @ts-ignore
+    expect(pluck('id', null)).toEqual([]);
+    // @ts-ignore
+    expect(pluck('id', undefined)).toEqual([]);
+  });
+
+  it('should handle missing keys gracefully', () => {
+    const result = pluck('nonexistent', data);
+    expect(result).toEqual([undefined, undefined]);
+  });
+
+  it('should handle deep missing paths', () => {
+    const result = pluck('info.phone.number', data);
+    expect(result).toEqual([undefined, undefined]);
+  });
+
+  it('should handle multi-pick with missing keys', () => {
+    const result = pluck(['id', 'missing'], data);
+
+    expect(result).toEqual([
+      { id: 1, missing: undefined },
+      { id: 2, missing: undefined }
+    ]);
+  });
+
+  /* ------------------ Immutability ------------------ */
+
+  it('should not mutate original data (simple)', () => {
+    const copy = JSON.parse(JSON.stringify(data));
+    pluck('id', data);
+    expect(data).toEqual(copy);
+  });
+
+  it('should not mutate original data (deep)', () => {
+    const copy = JSON.parse(JSON.stringify(data));
+    pluck('info.email', data);
+    expect(data).toEqual(copy);
+  });
+
+  it('should not mutate original data (multi)', () => {
+    const copy = JSON.parse(JSON.stringify(data));
+    pluck(['id', 'tags'], data);
+    expect(data).toEqual(copy);
+  });
+});

package/test/reduce.test.ts

@@ -0,0 +1,25 @@
+import { reduce } from "../src/Foundation/foundation/reduce";
+
+
+describe("reduce", () => {
+  test("sum of numbers", () => {
+    const result = reduce((acc, val) => acc + val, 0, [1, 2, 3, 4]);
+    expect(result).toBe(10);
+  });
+
+  test("subtract left to right", () => {
+    const result = reduce((acc, val) => acc - val, 100, [10, 5]);
+    // (100 - 10) - 5 = 85
+    expect(result).toBe(85);
+  });
+
+  test("empty array returns initial value", () => {
+    const result = reduce((acc, val) => acc + val, 10, []);
+    expect(result).toBe(10);
+  });
+
+  test("works with strings", () => {
+    const result = reduce((acc, val) => acc + val, "", ["a", "b", "c"]);
+    expect(result).toBe("abc");
+  });
+});

package/test/reduceRight.test.ts

@@ -0,0 +1,25 @@
+import { reduceRight } from "../src/Foundation/foundation/reduceright";
+
+
+describe("reduceRight", () => {
+  test("subtract right to left", () => {
+    const result = reduceRight((acc, val) => acc - val, 100, [10, 5]);
+    // (100 - 5) - 10 = 85
+    expect(result).toBe(85);
+  });
+
+  test("concatenation right to left", () => {
+    const result = reduceRight((acc, val) => acc + val, "", ["a", "b", "c"]);
+    expect(result).toBe("cba");
+  });
+
+  test("single element array", () => {
+    const result = reduceRight((acc, val) => acc + val, 10, [5]);
+    expect(result).toBe(15);
+  });
+
+  test("empty array returns initial value", () => {
+    const result = reduceRight((acc, val) => acc + val, 0, []);
+    expect(result).toBe(0);
+  });
+});

package/test/some.test.ts

@@ -0,0 +1,24 @@
+import { some } from "../src/Foundation/foundation/some";
+
+describe("some", () => {
+  test("returns true if any element matches condition", () => {
+    const users = [
+      { role: "user" },
+      { role: "admin" },
+      { role: "guest" }
+    ];
+
+    const result = some((u) => u.role === "admin", users);
+    expect(result).toBe(true);
+  });
+
+  test("returns false if no element matches", () => {
+    const result = some((x) => x > 10, [1, 2, 3]);
+    expect(result).toBe(false);
+  });
+
+  test("empty array returns false", () => {
+    const result = some((x) => x > 0, []);
+    expect(result).toBe(false);
+  });
+});

package/tsconfig.json

@@ -0,0 +1,14 @@
+{
+  "compilerOptions": {
+    "target": "ES2020",
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "outDir": "dist",
+    "rootDir": "src",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "types": ["jest"]
+  },
+  "include": ["src"]
+}