Skip to content
Projects

md-abu-kayser/js-solution-vault has 105 GitHub stars and 1 forks. GitHot measured 0 stars in 24 hours. Last checked 2026-11-16 19:47 UTC. Last push 2026-09-13.

How these counts are measured

Measured star growth

in 24h
0
in 7 days
Update delayed
in 15 days
Update delayed
in 1 month
Update delayed

Net star changes over overlapping periods, not daily totals. Missing measurements are left blank. Stars measure attention, not software quality.

About

World-class library of 136+ JavaScript & TypeScript problems with clean, tested solutions, interactive examples, and in-depth explanations.

Web & Apps

README.md

Original

JS SolutionVault

Interactive JavaScript Problem-Solving Workspace

Practice 136+ JavaScript problems through executable inputs, searchable categories, readable solver implementations, and Gemini-powered explanations.

GitHub Repository React Official Docs TypeScript Official Docs Vite Official Docs MIT License Problems


Overview

JS SolutionVault is an interactive JavaScript problem-solving application built with React, TypeScript, and Vite.

Instead of presenting problems as static code snippets, it gives users a complete practice loop:

Choose a problem
      ↓
Enter input
      ↓
Run the solver
      ↓
Inspect the implementation
      ↓
Read the explanation
      ↓
Ask AI for deeper understanding

The project is designed to demonstrate both problem-solving ability and modern frontend engineering practices.


Why It Exists

Most programming-practice repositories stop at:

Problem → Solution

JS SolutionVault extends that into:

Problem → Execute → Inspect → Understand → Improve

The goal is simple:

Make JavaScript practice executable, understandable, and reusable.


Core Features

Interactive Problem Solving

Each problem provides:

  • Structured input controls
  • Executable solver logic
  • Immediate results
  • Readable source code
  • Copy-to-clipboard support

Search & Categories

Users can discover problems through:

  • Title-based search
  • Category navigation
  • Problem counts
  • Debounced filtering

Search currently uses a 300 ms debounce to avoid unnecessary filtering while typing.

AI-Powered Explanations

Selected problems and their solver implementations can be sent through the Gemini integration to generate Markdown explanations.

The external AI logic is isolated behind:

src/services/geminiService.ts

This keeps provider-specific logic separate from UI and problem-domain code.

Responsive UI

The application is designed for:

  • Desktop
  • Tablet
  • Mobile

The desktop navigation adapts into a mobile drawer while maintaining the same information architecture.

Theme Support

Supported themes:

  • Light
  • Dark
  • System

Problem Categories

Category Focus
Arrays Searching, transformation, aggregation, sorting
Strings Manipulation, validation, string processing
Calculators Arithmetic and numeric utilities
Checkers Validation and classification
Converters Format and unit conversion
Advanced More involved JavaScript logic

The catalog is organized around a shared problem model rather than separate UI implementations.


Architecture

JS SolutionVault follows a data-driven architecture:

React UI
   │
   ▼
Problem Metadata
   │
   ▼
Solver Logic
   │
   ├──► Explanations
   │
   └──► Gemini Service

The main responsibilities are separated into:

Layer Responsibility
UI Rendering, navigation, interaction
Problem Metadata Titles, categories, inputs, actions
Solver Layer Executable problem-solving logic
Explanation Layer Educational content
Service Layer External API integration
Hooks Reusable interaction behavior

This separation keeps the application easier to extend and maintain.


Data-Driven Problem Model

Problems follow a shared contract so the same UI can support many different exercises.

interface Problem {
  title: string;
  category: Category;
  solverName?: string;
  inputs: ProblemInput[];
  buttonText: string;
  solver: (inputs: Record<string, string>) => string;
}

This means a new problem generally requires:

Add metadata
    +
Add solver
    +
Register problem

instead of creating a new React component for every exercise.


Repository Structure

js-solution-vault/
│
├── public/
│
├── src/
│   ├── components/
│   │   ├── Header.tsx
│   │   ├── Footer.tsx
│   │   ├── ProblemGrid.tsx
│   │   ├── ProblemCard.tsx
│   │   ├── MarkdownRenderer.tsx
│   │   ├── ThemeSwitcher.tsx
│   │   └── icons/
│   │
│   ├── hooks/
│   │   └── useDebounce.ts
│   │
│   ├── problems/
│   │   ├── arrays/
│   │   │   ├── problems.ts
│   │   │   ├── solvers.ts
│   │   │   └── explanations.ts
│   │   ├── strings/
│   │   ├── calculators/
│   │   ├── checkers/
│   │   ├── converters/
│   │   ├── advanced/
│   │   └── index.ts
│   │
│   ├── services/
│   │   └── geminiService.ts
│   │
│   ├── App.tsx
│   ├── index.tsx
│   └── types.ts
│
├── package.json
├── tsconfig.json
├── vite.config.ts
├── LICENSE
└── README.md

Problem Module Convention

Each category follows a predictable structure:

src/problems/<category>/
├── problems.ts
├── solvers.ts
└── explanations.ts

problems.ts

Defines problem metadata and input configuration.

solvers.ts

Contains executable, UI-independent solution logic.

A solver should ideally:

  • Validate input
  • Execute the required algorithm
  • Handle relevant edge cases
  • Return a predictable result

explanations.ts

Contains educational content covering the approach, reasoning, JavaScript concepts, and relevant edge cases.


Adding a New Problem

A typical new problem follows this flow:

1. Create solver
2. Add problem metadata
3. Add explanation
4. Register problem
5. Run validation

Example solver:

export const solveFactorial = (inputs: Record<string, string>): string => {
  const number = Number(inputs.number);

  if (!Number.isInteger(number) || number < 0) {
    throw new Error("Enter a non-negative integer.");
  }

  let result = 1;

  for (let current = 2; current <= number; current += 1) {
    result *= current;
  }

  return `Factorial: ${result}`;
};

After registration, the existing problem UI can render and execute it without introducing another React component.


Tech Stack

Technology Purpose
React 19 Component-based user interface
TypeScript 5.8 Type safety and domain contracts
Vite 6 Development and production tooling
Tailwind CSS UI styling
@google/genai Gemini-powered explanations
ESLint Code quality
Prettier Formatting

Getting Started

Prerequisites

  • Node.js 18+
  • npm 9+
  • Git

Clone the repository:

git clone https://github.com/md-abu-kayser/js-solution-vault.git

Enter the project:

cd js-solution-vault

Install dependencies:

npm install

Environment Configuration

Create:

.env.local

Add:

VITE_GEMINI_API_KEY=your_gemini_api_key

Security Note

VITE_ variables are exposed to the frontend bundle and should not be treated as private server-side secrets.

For a production system requiring credential protection, a safer architecture is:

Browser
   ↓
Backend API
   ↓
Gemini

rather than calling the provider directly from the browser.

Never commit real credentials to Git.


Development

Start the development server:

npm run dev

Vite will print the local development URL in the terminal.


Production Build

Create a production build:

npm run build

Preview the production build:

npm run preview

The build output is generated in:

dist/

Available Scripts

Command Purpose
npm run dev Start development server
npm run build Type-check and create production build
npm run preview Preview the production build

Quality Standards

The project is built around a few core engineering principles:

UI State
   ≠
Problem Data
   ≠
Solver Logic
   ≠
External Services

Solver Expectations

Solvers should be:

  • Deterministic
  • Readable
  • Independently testable
  • UI-independent
  • Explicit about invalid input
  • Robust against relevant edge cases

Error Handling

Invalid user input should fail clearly.

Example:

if (!Number.isInteger(number) || number < 0) {
  throw new Error("Enter a non-negative integer.");
}

The application should prefer actionable feedback over silent failures.


Testing Direction

The architecture naturally supports solver-level testing without mounting the React application.

Example:

import { describe, expect, it } from "vitest";
import { solveYourProblem } from "../src/problems/arrays/solvers";

describe("solveYourProblem", () => {
  it("returns the expected result", () => {
    expect(solveYourProblem({ value: "10" })).toBe("expected");
  });
});

Recommended validation flow:

Type Check
    ↓
Lint
    ↓
Unit Tests
    ↓
Production Build

Only enable commands that are actually configured in package.json.


Performance

The current implementation already uses practical frontend patterns such as:

  • Debounced search
  • Reusable rendering components
  • Data-driven problem definitions
  • Separated service integrations

Potential future improvements include:

Lazy-loaded categories
      ↓
Smaller content modules
      ↓
Optimized search
      ↓
Memoized derived data
      ↓
Large-list virtualization

These are future optimization opportunities, not assumptions about the current implementation.


Deployment

The application produces a static Vite build and can be deployed to platforms such as:

  • GitHub Pages
  • Vercel
  • Netlify
  • Cloudflare Pages

Typical deployment flow:

Git Push
   ↓
Install Dependencies
   ↓
Build
   ↓
Deploy dist/

Contribution

Contributions should be focused, understandable, and easy to review.

Recommended branch names:

feature/add-recursion-problems
fix/search-filter
refactor/problem-model
docs/readme-update
test/solver-coverage

Recommended commit style:

feat(problems): add recursion problems
fix(search): correct debounced filtering
refactor(solvers): normalize input handling
docs(readme): improve architecture documentation
test(solvers): add edge case coverage
chore(deps): update frontend dependencies
ci(github): add build validation

Before opening a pull request:

✓ Solver works
✓ Inputs are validated
✓ Explanation is included
✓ Search works
✓ UI remains responsive
✓ Build passes
✓ Documentation is updated when needed
✓ No secrets are committed

Roadmap

The project is designed to evolve from a problem library into a more complete learning platform.

Learning

  • Difficulty metadata
  • Tags
  • Complexity analysis
  • Multiple solution strategies
  • Progress tracking
  • Favorites
  • Practice sessions
  • Learning streaks

Engineering

  • Automated solver tests
  • CI validation
  • Build checks
  • Automated deployment
  • Solver benchmarks

AI

  • Structured explanations
  • Progressive hints
  • Better problem-aware prompting
  • Solution comparison
  • Server-side AI proxy

Long term:

Problem Library
      ↓
User Attempts
      ↓
Progress Tracking
      ↓
Skill Model
      ↓
Personalized Practice
      ↓
AI Coaching

What This Project Demonstrates

From an engineering and portfolio perspective, JS SolutionVault demonstrates:

Frontend Engineering

  • React component architecture
  • Responsive UI design
  • Search and filtering
  • Theme management
  • Reusable components

TypeScript

  • Shared domain contracts
  • Typed problem metadata
  • Typed solver boundaries
  • Configuration-driven UI

Software Architecture

  • Separation of UI and domain logic
  • Independent solver functions
  • Centralized problem registration
  • External service abstraction

AI Integration

  • Gemini service isolation
  • Context-aware explanations
  • Markdown rendering for generated content

Developer Experience

  • Predictable repository structure
  • Consistent content conventions
  • Reproducible local setup
  • Contribution-friendly workflow

Why It Matters

JS SolutionVault is intentionally more than a collection of JavaScript answers.

It combines:

JavaScript Problem Solving
        +
TypeScript
        +
React
        +
Interactive UX
        +
AI Integration
        +
Software Architecture

The result is a practical demonstration of how a problem-solving platform can be designed as a maintainable frontend application rather than a static collection of snippets.


Documentation Resources

JavaScript

TypeScript

React

Vite

Styling

AI

Tooling


License

This project is licensed under the MIT License.

See LICENSE for the complete license text.


Maintainer

Md Abu Kayser

Frontend / Full-Stack Web Developer

GitHub • Email

For collaboration, technical discussion, portfolio reviews, or professional opportunities, please reach out through GitHub or email.


⬆ Back to top

Practice. Execute. Understand. Improve.

Built with React, TypeScript, Vite, and a curiosity for better JavaScript.