epam-short-track

Task 4. TS-Custom-lodash

Folder Name	Branch	Score	Coefficient
/ts-custom-lodash	ts-custom-lodash	300	0.7

Task Description

Your task is to implement ‘custom’ version of lodash library following next requirements:

1. Usage of methods from Array.prototype.* or Object.prototype.* is strictly forbidden.
2. You can create your own additional service functions (if needed).
3. You should use ES6+ features (any feature which supported by latest stable Chrome).
4. Lodash chain is out of scope
5. Please reuse as much of your code as possible

Requirements

• Create a folder named ts-custom-lodash.
• Install TypeScript, ESLint and Prettier as dev dependencies. You can use the following article Setting Up ESLint and Prettier for a TypeScript Project.
• Configure your project to use TypeScript, ESLint and Prettier.
• Add a TypeScript configuration file with (tsconfig.json):

  {
  "compilerOptions": {
    "rootDir": "./lib",
    "outDir": "./dist",
  
    "module": "system",
    "target": "es2015",
  
    "sourceMap": true,
    "declaration": true,
    "declarationMap": true,
  
    "noUncheckedIndexedAccess": true,
    "exactOptionalPropertyTypes": true,
  
    "strict": true,
    "noImplicitAny": true,
    "removeComments": true,
    "skipLibCheck": true
  }
  }
  

• Add a ESLint for TypeScript configuration file with the no-explicit-any rule enabled (eslint.config.mjs). There must be no ESLint errors. ```ts import tseslint from “@typescript-eslint/eslint-plugin”; import tsparser from “@typescript-eslint/parser”; import prettierPlugin from “eslint-plugin-prettier”; import prettierConfig from “eslint-config-prettier”;

export default [ { files: [“*/.ts”],

    languageOptions: {
        parser: tsparser,
        sourceType: "module",
    },

    plugins: {
        "@typescript-eslint": tseslint,
        prettier: prettierPlugin,
    },

    rules: {
        ...tseslint.configs.recommended.rules,
        ...prettierConfig.rules,
        "@typescript-eslint/no-unused-vars": "warn",
        "@typescript-eslint/no-explicit-any": "error",
        "no-console": "warn",
        semi: ["error", "always"],
        "no-warning-comments": [
            "warn",
            { terms: ["todo", "fixme", "xxx"], location: "anywhere" },
        ],
        "no-inline-comments": "warn",
        quotes: ["error", "double"],
        "prettier/prettier": "error",
    },
}, ]; ``` - Add a Prettier configuration file (`.prettierrc.json`). ```json {   "semi": true,   "singleQuote": false,   "tabWidth": 2,   "trailingComma": "all",   "printWidth": 100,   "arrowParens": "always" } ``` - Add scripts to `package.json`: ```json {   "name": "ts-custom-lodash",   "version": "1.0.0",   "main": "index.js",   "scripts": {
"lint": "npx eslint .",
"lint-fix": "npx eslint . --fix",
"prettier": "npx prettier --write ."   },   "keywords": [],   "author": "",   "license": "ISC",   "description": "",   "devDependencies": {
"@typescript-eslint/eslint-plugin": "^8.49.0",
"@typescript-eslint/parser": "^8.49.0",
"eslint": "^9.39.1",
"eslint-config-prettier": "^10.1.8",
"eslint-plugin-prettier": "^5.5.4",
"prettier": "^3.7.4",
"ts-node": "^10.9.2",
"typescript": "^5.9.3",
"typescript-eslint": "^8.49.0"   } } ``` ### Implementation Details

• Each function must be implemented in ts-custom-lodash/lib folder in a separate .ts file named after the function (e.g., chunk.ts, compact.ts, etc.).
• Create a utils folder for reusable helper functions.
• Add a types.ts or interfaces.ts file for shared types.
• The index.ts file in the ts-custom-lodash/lib folder must export all functions as follows:

  export { chunk } from './chunk';
  export { compact } from './compact';
  // ...etc for all functions
  

• Do not use the any type anywhere.
• Do not use any methods from Array.prototype.* or Object.prototype.*.
• Reuse your code as much as possible.
• Implement the following functions:

Implement for use cases where the arguments are Arrays:

• chunk
• compact
• drop
• dropWhile
• take
• filter
• find
• includes
• map
• zip

Implement for use cases where the arguments are Objects:

• merge
• omit
• omitBy
• pick
• pickBy
• toPairs

***Implement for all use cases from the docs:

• filter

---

Pull Request Requirements

Your Pull Request must include:

• Task URL.
• Submission Date / Deadline Date.
• Your self-check of the task’s completion using checkboxes.
• Any comments explaining your implementation decisions (if necessary).

---

Developer’s Diary

While working on this task, keep a developer’s diary. Write down the decisions you made, the approaches you considered, where you got stuck, and how you worked through it.

The diary is not graded. Its purpose is to help you understand your own work more deeply and to give your mentor a basis for a real conversation about the task.

The “Diary” folder can be placed in the root of the project.

---

Mentor Checklist

Maximum Score: 300 points

• Task implementation 100 points
• Mentor interview 200 points

Criteria	Points
The branch is named ts-custom-lodash	2
Commit messages follow RS School Git Convention	2
The ts-custom-lodash folder exists	2
The ts-custom-lodash/lib folder exists	2
Each function is in its own .ts files	2
The ts-custom-lodash/lib/utils folder with reusable helper functions implemented	2
Add a ts-custom-lodash/lib/types.ts or ts-custom-lodash/lib/interfaces.ts file for shared types	2
The ts-custom-lodash/lib/index.ts file import and export all functions	2
The code uses Types or Interfaces	2
The code uses Everyday Types	2
The code uses Generics	2
The code uses Union Types	2
The code uses Object Types	2
The code uses Function Types	2
The code follows clean code principles and maximizes code reuse	4
ESLint is configured for TypeScript, no-explicit-any is enabled, and there are no errors	2
The TypeScript config includes "noImplicitAny": true and "strict": true	2
The .prettierrc.json file added	2
The package.json file includes scripts: “lint”, “lint-fix”, “prettier”	2
All dependencies added as dev dependencies	2
Implemented for use cases where the argument is an array.:
chunk	3
compact	3
drop	3
dropWhile	3
take	3
filter	3
find	3
includes	3
map	3
zip	3
Implemented for use cases where the arguments are Objects
merge	3
omit	3
omitBy	3
pick	3
pickBy	3
toPairs	3
Implement for all use cases from the docs
filter	7
Pull Request description includes all required elements:
Task URL is included in the PR	1
Submission and Deadline Dates are included in the PR	1
Your self-check of the task’s completion using checkboxes is included in the PR	1
Penalty:
Less than 3 commits in the PR	-7
Commit after the deadline and before mentor review	-7
The solution includes any comments	-17
The solution includes console.log	-3
Code is not fully covered with types	-17
ESLint errors	-3
Use of the any type	-100
Do not use any methods from Array.prototype.* or Object.prototype.*	-100

Mentor Interview Topics

After submitting the task, your mentor will ask 4–5 questions from the areas below. Answers account for ~200 points of the total score, so make sure you can explain the concepts in your own words — not just recite a definition.

TypeScript type system

• What is the difference between type and interface in TypeScript? When would you prefer one over the other?
• What are generics and why are they useful? Walk through how you used generics in at least one function in your implementation.
• What is a union type? Give an example from your code where a union type was necessary.
• What does noImplicitAny: true enforce, and why is it important for code safety?
• What is noUncheckedIndexedAccess and what problem does it prevent?

Functional programming concepts

• What is a higher-order function? Which of the lodash functions you implemented are higher-order functions?
• What is the difference between map and filter in terms of input/output shape?
• What does find return when no element matches, and how did you type that return value?
• How does dropWhile differ from drop? What predicate logic does it rely on?

Array iteration without Array.prototype

• Why are Array.prototype methods forbidden in this task? What do you use instead?
• How do you iterate over an array without .forEach, .map, or .reduce?
• How did you implement chunk? What edge cases did you handle (e.g. size larger than array, empty array)?
• How does zip work when the input arrays have different lengths?

Object manipulation

• How do you iterate over an object’s keys without Object.prototype methods?
• What is the difference between pick and omit? How did you implement each?
• How do pickBy and omitBy use predicates? How did you type the predicate argument?

Code reuse and architecture

• Which utility helpers did you extract into the utils folder, and why?
• How did you structure shared types in types.ts / interfaces.ts? Give an example of a type used by multiple functions.
• What tradeoffs did you make between type safety and implementation complexity?

Tooling (TypeScript, ESLint, Prettier)

• What does tsconfig.json "module": "system" mean, and how does it affect your output?
• What does the no-explicit-any ESLint rule enforce, and how is it different from the TypeScript noImplicitAny compiler option?
• What is the purpose of declaration: true and declarationMap: true in tsconfig.json?

---

Notes

• Do not use any type anywhere.
• Do not use any methods from Array.prototype.* or Object.prototype.*.
• The solution must be well-structured, readable, and follow best practices.
• If any required element is missing or incorrect, points will be deducted accordingly.

This site is open source. Improve this page.