How esai-keshav/annamalai-university-cgpa works
1. This repository is a small client-side application for an “Annamalai University CGPA calculator.” The architecture is that of a static single-page app rather than a multi-service system.
2. The runtime stack is React with Vite. src/main.jsx is the application bootstrap point, and src/App.jsx is the top-level UI component that likely contains the calculator logic and screen composition.
3. index.html is the single HTML host page. Vite injects the React bundle into this page, so the browser loads one app shell and the rest of the experience is rendered client-side.
4. src/index.css provides global styling for the app. This suggests the UI is styled centrally rather than through a larger component library or CSS framework visible in the repo tree.
5. src/assets and public are the static asset boundaries. src/assets is for imports managed by the module bundler, while public is for files served directly without bundling, which is typical for icons, images, or other static resources.
6. There is no evidence of a backend, database, or API layer in the repository tree. That means the calculator likely performs its computations entirely in the browser and does not depend on server-side state.
7. The core data flow is likely user input → calculator state in App.jsx → CGPA computation → rendered result in the same React tree. For an architecture diagram, the main interactive boundary is the UI component, not an external service.
8. vite.config.js defines build and dev-server behavior. This matters because the app is packaged as a front-end bundle and probably deployed as static files.
9. eslint.config.js indicates a linting layer for code quality and consistency during development. It is part of the tooling boundary rather than the runtime architecture.
10. The .github/workflows/deploy.yml file shows automated deployment in CI/CD. The app is likely built and published from GitHub Actions to a static host, which is the only infrastructure component visible in the repo.
11. package.json and package-lock.json define the Node.js dependency and build toolchain. Even though the app is browser-facing, Node is the build-time runtime used to install dependencies, lint, and bundle the app.
12. In summary, the system architecture is: static hosting/CD pipeline at the edge, Vite build layer in the middle, and a React single-page calculator UI at the core, with all CGPA logic and state contained on the client side.
Main entry points: App.jsx Calculator · package.json Dependencies · vite.config.js Vite config · deploy.yml Deploy
Components 10
Runtime UI
Client-side app shell and React calculator
- App shell · Single HTML entry point that mounts the React bundle
index.html - Bootstrap · Starts the React app and renders the top-level component
src/main.jsx - Calculator · Top-level UI and CGPA calculation state/logic
src/App.jsx - Global styles · Shared app-wide styling
src/index.css - Bundled assets · Images and other imports handled by the module bundler
src/assets - Public files · Files served directly without bundling
public
Build Tooling
Vite, linting, and Node package setup
- Vite config · Dev server and production bundle settings
vite.config.js - Dependencies · Project scripts and build-time dependencies
package.json - Lint rules · Code style and quality enforcement
eslint.config.js
Delivery
Static hosting and CI deployment
- Deploy · Automated build and publish pipeline
.github/workflows/deploy.yml
Connections 11
- Deploy → Vite config: builds with · CI uses the Vite build setup
- Deploy → Dependencies: installs · Workflow relies on Node dependencies and scripts
- Vite config → App shell: serves · Vite uses the HTML entry as the app shell
- App shell → Bootstrap: loads · Browser loads the React bundle into the host page
- Bootstrap → Calculator: mounts · Bootstrap renders the top-level calculator component
- Calculator → Global styles: styles · UI uses the global stylesheet
- Calculator → Bundled assets: imports · Component may consume bundled static assets
- Calculator → Public files: references · App can use directly served static files
- Calculator → Calculator: computes · Client-side state and CGPA calculation stay within the UI
- Dependencies → Vite config: drives · Scripts and dependencies support the Vite toolchain
- Dependencies → Lint rules: supports · Project metadata and scripts support linting