md-abu-kayser/js-solution-vault
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.
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 & AppsREADME.md
OriginalJS SolutionVault
Interactive JavaScript Problem-Solving Workspace
Practice 136+ JavaScript problems through executable inputs, searchable categories, readable solver implementations, and Gemini-powered explanations.
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
For collaboration, technical discussion, portfolio reviews, or professional opportunities, please reach out through GitHub or email.
Practice. Execute. Understand. Improve.
Built with React, TypeScript, Vite, and a curiosity for better JavaScript.