How sayantanmpaul/artistry-atlas works
Project Type & Purpose
• It is a Next.js web application bootstrapped with create‑next‑app.
• The project appears to be a portfolio or personal website that features both a client-facing experience (with pages like “learning”, “projects”, “work”, “technologies”, etc.) and an administrator section for managing content.
• There is integration with Sanity (a headless CMS) for managing dynamic content (as seen in the “sanity” directory and associated schemas).
File Structure
• The “app” folder is central – it contains distinct subdirectories for “(administrator)” and “(client)”. This routing segmentation indicates two different user flows: an admin interface and a public client interface.
• The “app” folder holds global layouts (layout.tsx, globals.css, page-wrapper.tsx), shared utility functions, and modular sections (such as “about-section”, “learning-section”, etc.) which are then pieced together across pages.
• The “components” folder provides reusable UI components (e.g., navigation, footer, preloader, theme switch) and even a nested “ui” subfolder, suggesting a component-driven design.
• Integration with Sanity is evident in the “sanity” folder (which includes configuration files, schema definitions for pages such as “about”, “education”, “experience”, etc.) and its supporting lib files for client interactions.
• Other directories like “constant”, “lib”, “types”, and configuration files (e.g., tailwind.config.ts, next.config.mjs) indicate standard dependency management, styling, and type safety elements.
Key Components
a. Client Interface:
• Primary public-facing pages: landing page (app/page.tsx), specific client pages (learning, projects, linktree, work, technologies) and corresponding sections assembled in “app/sections”.
• Role of shared UI components (in the “components” directory) that are integrated within these pages.
• Routing and layout management provided by the “app/layout.tsx” and related files.
b. Administrator Interface:
• Admin area under “app/(administrator)/admin” which universally handles administrative tasks (using dynamic routes like [[...index]] and layout files).
• That this part of the app is likely separate from the client route and is intended for content/admin management.
c. CMS Integration:
• Sanity as an external or integrated CMS component.
• Schemas (e.g., about, education, experience, links, projects, tools) and client libraries that allow the Next.js app to query and update content.
d. Shared Utilities & Global Services:
• “app/utils” and “lib” directories which contain helper functions and logic used across the app.
• Mention configuration files and utilities (like provider.tsx for context providers, animate.ts for transitions).
e. External Services & Deployment:
• External dependencies and services: Next.js framework itself, Vercel deployment pipeline (as suggested in the README), Tailwind CSS for styling, and possibly external APIs coming from Sanity.
Relationships & Interactions
• That the “app” folder is the hub where various routes and layouts come together.
• That utility modules and shared components provide services and UI consistency to both interfaces.
• That global configuration files (like next.config.mjs and tailwind.config.ts) underpin overall app behavior and styling.
Important Architectural Patterns/Design Principles
• A clear separation of concerns: distinct routing for admin vs. client, modular components (separation between views and reusable components), and integration with a headless CMS.
• Utilization of Next.js’s file-based routing (using the “app” folder structure) to handle dynamic layouts and lazy loading.
• Adoption of component-driven design with reusable UI elements.
• Incorporation of micro-frontends in a sense of mixing various page sections assembled from smaller components.
Specific Elements
• Clear labels for each main component (e.g., “Client Interface,” “Administrator Dashboard,” “CMS (Sanity),” “Global UI Components,” “Utilities & Services”).
• Notations for architectural patterns like “Next.js file-based routing”, “Component-driven UI”, and integrations such as “Tailwind CSS” and “Sanity”.