From 3467dbcf03a9b11634cc4eb711b3fa12bd5f01bf Mon Sep 17 00:00:00 2001 From: DJP Date: Mon, 23 Feb 2026 20:20:58 -0500 Subject: [PATCH] =?UTF-8?q?Initial=20commit=20=E2=80=94=20OliVAS=20visual?= =?UTF-8?q?=20attention=20analysis=20platform?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Full-stack application for predicting where humans look in images using DeepGaze saliency models. Includes heatmap overlays, gaze sequence prediction, hotspot detection, AOI analysis, rule-based insights, optional Claude AI design analysis, and professional PDF report generation. Co-Authored-By: Claude Opus 4.6 --- .env.example | 15 + .gitignore | 47 + .python-version | 1 + LICENSE | 21 + Makefile | 58 + README.md | 215 + backend/=0.40 | 1 + backend/Dockerfile | 18 + backend/alembic.ini | 36 + backend/app/__init__.py | 0 backend/app/api/__init__.py | 0 backend/app/api/endpoints/__init__.py | 0 backend/app/api/endpoints/analysis.py | 452 ++ backend/app/api/endpoints/aoi.py | 105 + backend/app/api/endpoints/comparison.py | 145 + backend/app/api/endpoints/health.py | 14 + backend/app/api/endpoints/projects.py | 141 + backend/app/api/endpoints/reports.py | 89 + backend/app/api/router.py | 12 + backend/app/config.py | 30 + backend/app/core/__init__.py | 0 backend/app/core/exceptions.py | 18 + backend/app/db/__init__.py | 0 backend/app/db/migrations/env.py | 57 + backend/app/db/migrations/script.py.mako | 26 + .../versions/2f6f70f606a1_initial_schema.py | 97 + backend/app/db/session.py | 16 + backend/app/dependencies.py | 12 + backend/app/main.py | 47 + backend/app/models/__init__.py | 0 backend/app/models/analysis.py | 39 + backend/app/models/aoi.py | 26 + backend/app/models/base.py | 5 + backend/app/models/comparison.py | 23 + backend/app/models/project.py | 27 + backend/app/schemas/__init__.py | 0 backend/app/schemas/analysis.py | 52 + backend/app/schemas/aoi.py | 35 + backend/app/schemas/project.py | 35 + backend/app/schemas/report.py | 7 + backend/app/services/__init__.py | 0 backend/app/services/ai_insights.py | 158 + backend/app/services/aoi_analysis.py | 47 + .../app/services/fonts/Montserrat-Bold.ttf | Bin 0 -> 454864 bytes .../app/services/fonts/Montserrat-Regular.ttf | Bin 0 -> 445928 bytes .../services/fonts/Montserrat-SemiBold.ttf | Bin 0 -> 454716 bytes backend/app/services/gaze_sequence.py | 42 + backend/app/services/heatmap.py | 26 + backend/app/services/image_processing.py | 24 + backend/app/services/insights.py | 200 + backend/app/services/report_generator.py | 439 ++ backend/app/services/saliency/__init__.py | 0 backend/app/services/saliency/base.py | 19 + backend/app/services/saliency/deepgaze.py | 93 + .../app/services/saliency/model_manager.py | 55 + backend/app/services/storage.py | 44 + backend/pyproject.toml | 45 + backend/tests/__init__.py | 0 backend/tests/conftest.py | 51 + backend/tests/test_analysis.py | 94 + docker-compose.dev.yml | 16 + docker-compose.yml | 42 + frontend/.gitignore | 24 + frontend/Dockerfile | 13 + frontend/README.md | 73 + frontend/eslint.config.js | 23 + frontend/index.html | 16 + frontend/nginx.conf | 18 + frontend/package-lock.json | 4364 +++++++++++++++++ frontend/package.json | 39 + frontend/public/vite.svg | 1 + frontend/src/App.tsx | 27 + frontend/src/api/analysis.ts | 83 + frontend/src/api/client.ts | 25 + frontend/src/api/projects.ts | 37 + frontend/src/api/reports.ts | 23 + frontend/src/assets/react.svg | 1 + .../src/components/analysis/GazeSequence.tsx | 95 + .../components/analysis/HeatmapControls.tsx | 68 + .../components/analysis/HeatmapOverlay.tsx | 185 + .../src/components/analysis/HotspotList.tsx | 61 + .../src/components/analysis/InsightsPanel.tsx | 99 + frontend/src/components/aoi/AOICanvas.tsx | 334 ++ frontend/src/components/aoi/AOIResults.tsx | 91 + frontend/src/components/common/Button.tsx | 64 + frontend/src/components/common/Card.tsx | 23 + .../src/components/common/LoadingSpinner.tsx | 40 + frontend/src/components/layout/AppLayout.tsx | 24 + frontend/src/components/layout/Header.tsx | 77 + frontend/src/components/layout/Sidebar.tsx | 80 + frontend/src/components/upload/DropZone.tsx | 96 + .../src/components/upload/UploadPreview.tsx | 51 + frontend/src/globals.css | 13 + frontend/src/hooks/useAnalysis.ts | 27 + frontend/src/hooks/useProjects.ts | 63 + frontend/src/hooks/useUpload.ts | 48 + frontend/src/main.tsx | 26 + frontend/src/pages/About.tsx | 468 ++ frontend/src/pages/AnalysisView.tsx | 274 ++ frontend/src/pages/ComparisonView.tsx | 175 + frontend/src/pages/Dashboard.tsx | 174 + frontend/src/pages/Help.tsx | 230 + frontend/src/pages/NewAnalysis.tsx | 338 ++ frontend/src/pages/ProjectDetail.tsx | 154 + frontend/src/stores/analysisStore.ts | 97 + frontend/src/stores/uiStore.ts | 23 + frontend/src/types/analysis.ts | 81 + frontend/src/types/aoi.ts | 19 + frontend/src/types/project.ts | 19 + frontend/tsconfig.app.json | 28 + frontend/tsconfig.json | 7 + frontend/tsconfig.node.json | 26 + frontend/vite.config.ts | 16 + 113 files changed, 11778 insertions(+) create mode 100644 .env.example create mode 100644 .gitignore create mode 100644 .python-version create mode 100644 LICENSE create mode 100644 Makefile create mode 100644 README.md create mode 100644 backend/=0.40 create mode 100644 backend/Dockerfile create mode 100644 backend/alembic.ini create mode 100644 backend/app/__init__.py create mode 100644 backend/app/api/__init__.py create mode 100644 backend/app/api/endpoints/__init__.py create mode 100644 backend/app/api/endpoints/analysis.py create mode 100644 backend/app/api/endpoints/aoi.py create mode 100644 backend/app/api/endpoints/comparison.py create mode 100644 backend/app/api/endpoints/health.py create mode 100644 backend/app/api/endpoints/projects.py create mode 100644 backend/app/api/endpoints/reports.py create mode 100644 backend/app/api/router.py create mode 100644 backend/app/config.py create mode 100644 backend/app/core/__init__.py create mode 100644 backend/app/core/exceptions.py create mode 100644 backend/app/db/__init__.py create mode 100644 backend/app/db/migrations/env.py create mode 100644 backend/app/db/migrations/script.py.mako create mode 100644 backend/app/db/migrations/versions/2f6f70f606a1_initial_schema.py create mode 100644 backend/app/db/session.py create mode 100644 backend/app/dependencies.py create mode 100644 backend/app/main.py create mode 100644 backend/app/models/__init__.py create mode 100644 backend/app/models/analysis.py create mode 100644 backend/app/models/aoi.py create mode 100644 backend/app/models/base.py create mode 100644 backend/app/models/comparison.py create mode 100644 backend/app/models/project.py create mode 100644 backend/app/schemas/__init__.py create mode 100644 backend/app/schemas/analysis.py create mode 100644 backend/app/schemas/aoi.py create mode 100644 backend/app/schemas/project.py create mode 100644 backend/app/schemas/report.py create mode 100644 backend/app/services/__init__.py create mode 100644 backend/app/services/ai_insights.py create mode 100644 backend/app/services/aoi_analysis.py create mode 100644 backend/app/services/fonts/Montserrat-Bold.ttf create mode 100644 backend/app/services/fonts/Montserrat-Regular.ttf create mode 100644 backend/app/services/fonts/Montserrat-SemiBold.ttf create mode 100644 backend/app/services/gaze_sequence.py create mode 100644 backend/app/services/heatmap.py create mode 100644 backend/app/services/image_processing.py create mode 100644 backend/app/services/insights.py create mode 100644 backend/app/services/report_generator.py create mode 100644 backend/app/services/saliency/__init__.py create mode 100644 backend/app/services/saliency/base.py create mode 100644 backend/app/services/saliency/deepgaze.py create mode 100644 backend/app/services/saliency/model_manager.py create mode 100644 backend/app/services/storage.py create mode 100644 backend/pyproject.toml create mode 100644 backend/tests/__init__.py create mode 100644 backend/tests/conftest.py create mode 100644 backend/tests/test_analysis.py create mode 100644 docker-compose.dev.yml create mode 100644 docker-compose.yml create mode 100644 frontend/.gitignore create mode 100644 frontend/Dockerfile create mode 100644 frontend/README.md create mode 100644 frontend/eslint.config.js create mode 100644 frontend/index.html create mode 100644 frontend/nginx.conf create mode 100644 frontend/package-lock.json create mode 100644 frontend/package.json create mode 100644 frontend/public/vite.svg create mode 100644 frontend/src/App.tsx create mode 100644 frontend/src/api/analysis.ts create mode 100644 frontend/src/api/client.ts create mode 100644 frontend/src/api/projects.ts create mode 100644 frontend/src/api/reports.ts create mode 100644 frontend/src/assets/react.svg create mode 100644 frontend/src/components/analysis/GazeSequence.tsx create mode 100644 frontend/src/components/analysis/HeatmapControls.tsx create mode 100644 frontend/src/components/analysis/HeatmapOverlay.tsx create mode 100644 frontend/src/components/analysis/HotspotList.tsx create mode 100644 frontend/src/components/analysis/InsightsPanel.tsx create mode 100644 frontend/src/components/aoi/AOICanvas.tsx create mode 100644 frontend/src/components/aoi/AOIResults.tsx create mode 100644 frontend/src/components/common/Button.tsx create mode 100644 frontend/src/components/common/Card.tsx create mode 100644 frontend/src/components/common/LoadingSpinner.tsx create mode 100644 frontend/src/components/layout/AppLayout.tsx create mode 100644 frontend/src/components/layout/Header.tsx create mode 100644 frontend/src/components/layout/Sidebar.tsx create mode 100644 frontend/src/components/upload/DropZone.tsx create mode 100644 frontend/src/components/upload/UploadPreview.tsx create mode 100644 frontend/src/globals.css create mode 100644 frontend/src/hooks/useAnalysis.ts create mode 100644 frontend/src/hooks/useProjects.ts create mode 100644 frontend/src/hooks/useUpload.ts create mode 100644 frontend/src/main.tsx create mode 100644 frontend/src/pages/About.tsx create mode 100644 frontend/src/pages/AnalysisView.tsx create mode 100644 frontend/src/pages/ComparisonView.tsx create mode 100644 frontend/src/pages/Dashboard.tsx create mode 100644 frontend/src/pages/Help.tsx create mode 100644 frontend/src/pages/NewAnalysis.tsx create mode 100644 frontend/src/pages/ProjectDetail.tsx create mode 100644 frontend/src/stores/analysisStore.ts create mode 100644 frontend/src/stores/uiStore.ts create mode 100644 frontend/src/types/analysis.ts create mode 100644 frontend/src/types/aoi.ts create mode 100644 frontend/src/types/project.ts create mode 100644 frontend/tsconfig.app.json create mode 100644 frontend/tsconfig.json create mode 100644 frontend/tsconfig.node.json create mode 100644 frontend/vite.config.ts diff --git a/.env.example b/.env.example new file mode 100644 index 0000000..ee273ba --- /dev/null +++ b/.env.example @@ -0,0 +1,15 @@ +# Database +DATABASE_URL=postgresql+asyncpg://olivas:olivas@localhost:5453/olivas + +# Storage +UPLOAD_DIR=./data/uploads + +# ML Model +DEVICE=auto # auto | cpu | cuda + +# CORS +CORS_ORIGINS=http://localhost:1577 + +# Server +BACKEND_HOST=0.0.0.0 +BACKEND_PORT=8000 diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..5767390 --- /dev/null +++ b/.gitignore @@ -0,0 +1,47 @@ +# Python +__pycache__/ +*.py[cod] +*$py.class +*.so +.venv/ +*.egg-info/ +dist/ +build/ +*.egg + +# Node +node_modules/ +dist/ +.cache/ + +# Environment +.env +.env.local +.env.*.local + +# IDE +.vscode/ +.idea/ +*.swp +*.swo +*~ + +# OS +.DS_Store +Thumbs.db + +# Data +backend/data/ +backend/uploads/ +*.npy + +# Docker +docker-compose.override.yml + +# Testing +.coverage +htmlcov/ +.pytest_cache/ + +# Build artifacts +*.log diff --git a/.python-version b/.python-version new file mode 100644 index 0000000..e4fba21 --- /dev/null +++ b/.python-version @@ -0,0 +1 @@ +3.12 diff --git a/LICENSE b/LICENSE new file mode 100644 index 0000000..b0d7c38 --- /dev/null +++ b/LICENSE @@ -0,0 +1,21 @@ +MIT License + +Copyright (c) 2026 OLIVER + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. diff --git a/Makefile b/Makefile new file mode 100644 index 0000000..4b07ef9 --- /dev/null +++ b/Makefile @@ -0,0 +1,58 @@ +.PHONY: setup setup-backend setup-frontend dev dev-backend dev-frontend db-up db-migrate test clean + +# ─── Setup ─────────────────────────────────────────────────────────── +setup: setup-backend setup-frontend + +setup-backend: + cd backend && python3.12 -m venv .venv + cd backend && .venv/bin/pip install --upgrade pip + cd backend && .venv/bin/pip install -e ".[dev]" + cd backend && .venv/bin/pip install "deepgaze-pytorch @ git+https://github.com/matthias-k/DeepGaze.git" + +setup-frontend: + cd frontend && npm install + +# ─── Database ──────────────────────────────────────────────────────── +db-up: + docker compose up -d postgres + +db-migrate: + cd backend && .venv/bin/alembic upgrade head + +db-revision: + cd backend && .venv/bin/alembic revision --autogenerate -m "$(msg)" + +# ─── Development ───────────────────────────────────────────────────── +dev: db-up dev-backend dev-frontend + +dev-backend: + cd backend && .venv/bin/uvicorn app.main:app --host 0.0.0.0 --port 8000 --reload + +dev-frontend: + cd frontend && npm run dev + +# ─── Docker ────────────────────────────────────────────────────────── +docker-up: + docker compose up --build + +docker-down: + docker compose down + +# ─── Testing ───────────────────────────────────────────────────────── +test: + cd backend && .venv/bin/pytest -v + +test-backend: + cd backend && .venv/bin/pytest -v + +# ─── Utilities ─────────────────────────────────────────────────────── +lint: + cd backend && .venv/bin/ruff check app/ tests/ + +lint-fix: + cd backend && .venv/bin/ruff check --fix app/ tests/ + +clean: + find . -type d -name __pycache__ -exec rm -rf {} + 2>/dev/null || true + find . -type d -name .pytest_cache -exec rm -rf {} + 2>/dev/null || true + rm -rf backend/.venv frontend/node_modules diff --git a/README.md b/README.md new file mode 100644 index 0000000..29651d7 --- /dev/null +++ b/README.md @@ -0,0 +1,215 @@ +# OliVAS — Open-Source Visual Attention Software + +**OliVAS** (OLIVER Visual Attention Suite) is an open-source web application that predicts where humans will look in an image during the first 3-5 seconds of viewing. Built for creative teams, designers, and marketers at OLIVER, it provides saliency heatmaps, gaze sequence predictions, hotspot analysis, and actionable design insights — all without needing physical eye-tracking hardware. + +## Features + +- **Saliency Heatmap** — Interactive heatmap overlay showing predicted attention intensity with adjustable opacity and colormap (Jet, Viridis, Inferno, etc.) +- **Gaze Sequence Prediction** — Numbered fixation points showing the predicted order viewers will scan the image +- **Hotspot Detection** — Top 5 attention regions ranked by intensity with bounding boxes +- **Attention Score** — Overall 0-100 concentration score measuring how focused or diffuse the predicted attention is +- **Areas of Interest (AOI)** — Draw rectangles over design elements to measure attention %, area %, and attention density +- **Rule-Based Insights** — Automatic analysis of attention concentration, focal dominance, gaze entry point, spatial balance, edge risk, and drop-off +- **AI Design Analysis** — Optional Claude Sonnet 4.6-powered insights that reference specific visual elements in your design with actionable recommendations +- **PDF Reports** — Professional downloadable reports with Montserrat typography, all visualizations, metrics, and insights (both rule-based and AI) +- **Multi-Model Support** — Choose between DeepGaze I, DeepGaze IIE (recommended), and DeepGaze III +- **Project Organization** — Group analyses into projects for easy management +- **Comparison View** — Side-by-side comparison of two analyses with metrics + +## Tech Stack + +| Layer | Technology | +|-------|-----------| +| **Frontend** | React 18, TypeScript, Vite, Tailwind CSS, Zustand, React Router | +| **Backend** | FastAPI, Python 3.12, SQLAlchemy (async), Pydantic v2 | +| **Database** | PostgreSQL 16 | +| **ML Models** | DeepGaze I / IIE / III via [deepgaze_pytorch](https://github.com/matthias-k/DeepGaze) | +| **AI Insights** | Anthropic Claude Sonnet 4.6 (optional) | +| **PDF Generation** | ReportLab with Montserrat font | +| **Deployment** | Docker Compose | + +## Prerequisites + +- Python 3.12+ +- Node.js 18+ +- Docker & Docker Compose (for PostgreSQL) +- Git + +## Quick Start + +### 1. Clone the repository + +```bash +git clone git@bitbucket.org:zlalani/olivas.git +cd olivas +``` + +### 2. Start PostgreSQL + +```bash +docker compose up -d postgres +``` + +This starts PostgreSQL on port **5453** with database `olivas`. + +### 3. Set up the backend + +```bash +cd backend +python3.12 -m venv .venv +.venv/bin/pip install --upgrade pip +.venv/bin/pip install -e ".[dev]" +.venv/bin/pip install "deepgaze-pytorch @ git+https://github.com/matthias-k/DeepGaze.git" +``` + +### 4. Configure environment (optional) + +Create `backend/.env` for optional settings: + +```env +# Required for AI Design Analysis feature (optional) +ANTHROPIC_API_KEY=sk-ant-your-key-here + +# Defaults (change if needed) +DATABASE_URL=postgresql+asyncpg://olivas:olivas@localhost:5453/olivas +DEVICE=auto +CORS_ORIGINS=http://localhost:1577 +``` + +### 5. Start the backend + +```bash +cd backend +.venv/bin/uvicorn app.main:app --host 0.0.0.0 --port 8000 --reload +``` + +The backend will load all DeepGaze models on startup (this may take 30-60 seconds on first run as model weights are downloaded). + +### 6. Set up and start the frontend + +```bash +cd frontend +npm install +npm run dev +``` + +### 7. Open the app + +Navigate to **http://localhost:1577** in your browser. + +## Using the Makefile + +For convenience, the project includes a Makefile: + +```bash +make setup # Install all backend + frontend dependencies +make dev-backend # Start backend with hot reload +make dev-frontend # Start frontend dev server +make db-up # Start PostgreSQL container +make test # Run backend tests +make lint # Run ruff linter +make lint-fix # Auto-fix linting issues +make clean # Remove caches and virtual environments +``` + +## Docker Compose (Full Stack) + +To run everything in Docker: + +```bash +docker compose up --build +``` + +This starts PostgreSQL, the backend API, and the frontend. Access the app at **http://localhost:1577**. + +## Project Structure + +``` +olivas/ +├── backend/ +│ ├── app/ +│ │ ├── api/endpoints/ # FastAPI route handlers +│ │ ├── db/ # Database session & connection +│ │ ├── models/ # SQLAlchemy ORM models +│ │ ├── schemas/ # Pydantic request/response schemas +│ │ ├── services/ +│ │ │ ├── saliency/ # DeepGaze model manager & inference +│ │ │ ├── ai_insights.py # Claude AI integration +│ │ │ ├── insights.py # Rule-based insights engine +│ │ │ ├── report_generator.py # PDF report generation +│ │ │ ├── heatmap.py # Heatmap overlay generation +│ │ │ ├── gaze_sequence.py # Gaze sequence extraction +│ │ │ ├── image_processing.py # Image resize & upscale +│ │ │ └── storage.py # File storage abstraction +│ │ ├── config.py # App settings (env vars) +│ │ └── main.py # FastAPI app entry point +│ └── pyproject.toml +├── frontend/ +│ ├── src/ +│ │ ├── api/ # Axios API client & endpoints +│ │ ├── components/ +│ │ │ ├── analysis/ # Heatmap, gaze, hotspots, insights +│ │ │ ├── aoi/ # Area of Interest canvas & results +│ │ │ ├── common/ # Button, Card, LoadingSpinner +│ │ │ └── layout/ # Header, Sidebar, AppLayout +│ │ ├── hooks/ # React Query hooks +│ │ ├── pages/ # Dashboard, NewAnalysis, AnalysisView, Help, About +│ │ ├── stores/ # Zustand state management +│ │ └── types/ # TypeScript interfaces +│ └── package.json +├── docker-compose.yml # Production Docker setup +├── docker-compose.dev.yml # Development Docker overrides +├── Makefile # Development shortcuts +└── LICENSE # MIT License +``` + +## Saliency Models + +OliVAS uses the [DeepGaze](https://github.com/matthias-k/DeepGaze) family of saliency prediction models: + +| Model | Architecture | Best For | Reference | +|-------|-------------|----------|-----------| +| **DeepGaze IIE** (recommended) | ResNet + DenseNet ensemble | Best accuracy on benchmarks | [Linardos et al., ICCV 2021](https://arxiv.org/abs/2105.12441) | +| **DeepGaze III** | Transformer-based | Complex layouts with many elements | [Kummerer et al., J. Vision 2022](https://doi.org/10.1167/jov.22.5.7) | +| **DeepGaze I** | AlexNet features | Quick preliminary analysis | [Kummerer et al., ICLR 2015](https://arxiv.org/abs/1411.1045) | + +These models are trained on thousands of real eye-tracking experiments and are among the top-performing models on the [MIT/Tubingen Saliency Benchmark](https://saliency.tuebingen.ai/). + +## AI Design Analysis + +When an Anthropic API key is configured, OliVAS can send the original image and heatmap overlay to **Claude Sonnet 4.6** for context-aware design analysis. The AI references specific visual elements in your design and provides actionable recommendations. + +- Cost per analysis is tracked and displayed (typically $0.01-0.05 per image) +- AI insights are saved to the database and included in PDF reports +- This feature is entirely optional — rule-based insights always work without an API key + +## API Endpoints + +| Method | Endpoint | Description | +|--------|---------|-------------| +| `POST` | `/api/projects` | Create a new project | +| `GET` | `/api/projects` | List all projects | +| `POST` | `/api/projects/{id}/analyses` | Upload image and start analysis | +| `GET` | `/api/analyses/{id}` | Get analysis details + insights | +| `GET` | `/api/analyses/{id}/status` | Poll analysis status | +| `GET` | `/api/analyses/{id}/images/{type}` | Get analysis images | +| `POST` | `/api/analyses/{id}/ai-insights` | Generate AI insights (on-demand) | +| `GET` | `/api/analyses/{id}/report` | Download PDF report | +| `POST` | `/api/analyses/{id}/aois` | Create Areas of Interest | +| `DELETE` | `/api/analyses/{id}` | Delete an analysis | + +## Academic References + +- Kummerer, M., Theis, L., & Bethge, M. (2015). "Deep Gaze I: Boosting Saliency Prediction with Feature Maps Trained on ImageNet." *ICLR 2015*. [arXiv:1411.1045](https://arxiv.org/abs/1411.1045) +- Kummerer, M., Wallis, T.S.A., & Bethge, M. (2016). "DeepGaze II: Reading fixations from deep features trained on object recognition." [arXiv:1610.01563](https://arxiv.org/abs/1610.01563) +- Linardos, A., Kummerer, M., Press, O., & Bethge, M. (2021). "DeepGaze IIE: Calibrated prediction in and out-of-domain for state-of-the-art saliency modeling." *ICCV 2021*. [arXiv:2105.12441](https://arxiv.org/abs/2105.12441) +- Kummerer, M., Bethge, M., & Wallis, T.S.A. (2022). "DeepGaze III: Modeling free-viewing human scanpaths with deep learning." *Journal of Vision*, 22(5):7. [DOI:10.1167/jov.22.5.7](https://doi.org/10.1167/jov.22.5.7) +- Itti, L., Koch, C., & Niebur, E. (1998). "A Model of Saliency-Based Visual Attention for Rapid Scene Analysis." *IEEE TPAMI*, 20(11), 1254-1259. [DOI:10.1109/34.730558](https://doi.org/10.1109/34.730558) + +## License + +MIT License. See [LICENSE](LICENSE) for details. + +--- + +Built with care by **OLIVER** creative teams. diff --git a/backend/=0.40 b/backend/=0.40 new file mode 100644 index 0000000..c8c6c93 --- /dev/null +++ b/backend/=0.40 @@ -0,0 +1 @@ +(eval):1: command not found: pip diff --git a/backend/Dockerfile b/backend/Dockerfile new file mode 100644 index 0000000..7c8ce02 --- /dev/null +++ b/backend/Dockerfile @@ -0,0 +1,18 @@ +FROM python:3.12-slim + +WORKDIR /app + +RUN apt-get update && apt-get install -y --no-install-recommends \ + libgl1-mesa-glx libglib2.0-0 curl git && \ + rm -rf /var/lib/apt/lists/* + +COPY pyproject.toml . +RUN pip install --no-cache-dir -e . && \ + pip install --no-cache-dir "deepgaze-pytorch @ git+https://github.com/matthias-k/DeepGaze.git" + +COPY . . + +RUN mkdir -p data/uploads + +EXPOSE 8000 +CMD ["uvicorn", "app.main:app", "--host", "0.0.0.0", "--port", "8000"] diff --git a/backend/alembic.ini b/backend/alembic.ini new file mode 100644 index 0000000..0eec43b --- /dev/null +++ b/backend/alembic.ini @@ -0,0 +1,36 @@ +[alembic] +script_location = app/db/migrations +sqlalchemy.url = postgresql+asyncpg://olivas:olivas@localhost:5453/olivas + +[loggers] +keys = root,sqlalchemy,alembic + +[handlers] +keys = console + +[formatters] +keys = generic + +[logger_root] +level = WARN +handlers = console + +[logger_sqlalchemy] +level = WARN +handlers = +qualname = sqlalchemy.engine + +[logger_alembic] +level = INFO +handlers = +qualname = alembic + +[handler_console] +class = StreamHandler +args = (sys.stderr,) +level = NOTSET +formatter = generic + +[formatter_generic] +format = %(levelname)-5.5s [%(name)s] %(message)s +datefmt = %H:%M:%S diff --git a/backend/app/__init__.py b/backend/app/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/backend/app/api/__init__.py b/backend/app/api/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/backend/app/api/endpoints/__init__.py b/backend/app/api/endpoints/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/backend/app/api/endpoints/analysis.py b/backend/app/api/endpoints/analysis.py new file mode 100644 index 0000000..452a7ac --- /dev/null +++ b/backend/app/api/endpoints/analysis.py @@ -0,0 +1,452 @@ +import io + +from fastapi import APIRouter, BackgroundTasks, Depends, Header, HTTPException, UploadFile, Form +from fastapi.responses import StreamingResponse +from PIL import Image +from sqlalchemy import select +from sqlalchemy.ext.asyncio import AsyncSession + +from app.db.session import get_db +from app.dependencies import get_user_id +from app.models.analysis import Analysis +from app.models.project import Project +from app.schemas.analysis import AnalysisDetail, AnalysisStatus, AnalysisSummary +from app.services.storage import storage + +router = APIRouter(tags=["analysis"]) + +ALLOWED_FORMATS = {"JPEG", "PNG", "TIFF", "WEBP", "BMP"} +MAX_FILE_SIZE = 50 * 1024 * 1024 # 50MB + + +@router.post("/projects/{project_id}/analyses", response_model=AnalysisStatus, status_code=202) +async def create_analysis( + project_id: str, + file: UploadFile, + background_tasks: BackgroundTasks, + name: str | None = Form(None), + model: str = Form("deepgaze_iie"), + db: AsyncSession = Depends(get_db), + x_user_id: str | None = Header(None), +): + user_id = get_user_id(x_user_id) + + # Verify project belongs to user + stmt = select(Project).where(Project.id == project_id, Project.user_id == user_id) + result = await db.execute(stmt) + project = result.scalar_one_or_none() + if not project: + raise HTTPException(status_code=404, detail="Project not found") + + # Read and validate image + image_data = await file.read() + if len(image_data) > MAX_FILE_SIZE: + raise HTTPException(status_code=413, detail="File too large (max 50MB)") + + try: + image = Image.open(io.BytesIO(image_data)) + image.verify() + image = Image.open(io.BytesIO(image_data)) # re-open after verify + except Exception: + raise HTTPException(status_code=400, detail="Invalid image file") + + if image.format not in ALLOWED_FORMATS: + raise HTTPException( + status_code=400, + detail=f"Unsupported format: {image.format}. Allowed: {', '.join(ALLOWED_FORMATS)}", + ) + + # Create analysis record + analysis = Analysis( + project_id=project_id, + user_id=user_id, + name=name or file.filename or "Untitled", + model_used=model, + status="pending", + original_filename=file.filename or "upload", + image_width=image.width, + image_height=image.height, + file_format=image.format or "PNG", + storage_path=str(storage.base_dir), + ) + db.add(analysis) + await db.flush() + await db.refresh(analysis) + + # Save original image + await storage.save_bytes(image_data, analysis.id, "original.png") + + # Save thumbnail + thumb = image.copy() + thumb.thumbnail((400, 400)) + thumb_buffer = io.BytesIO() + thumb.save(thumb_buffer, format="PNG") + await storage.save_bytes(thumb_buffer.getvalue(), analysis.id, "thumbnail.png") + + analysis_id = analysis.id + + # Commit now so the background thread can see the record + await db.commit() + + # Queue background processing (sync function runs in threadpool) + background_tasks.add_task(run_analysis_pipeline, analysis_id, image_data, model) + + return AnalysisStatus(id=analysis_id, status="pending") + + +def run_analysis_pipeline(analysis_id: str, image_data: bytes, model_name: str): + """Background task: full saliency analysis pipeline. Runs sync in threadpool.""" + import asyncio + import logging + import numpy as np + from app.services.saliency.model_manager import model_manager + from app.services.image_processing import prepare_for_inference, upscale_saliency + from app.services.heatmap import generate_heatmap_overlay, generate_standalone_heatmap + from app.services.gaze_sequence import extract_gaze_sequence + + logger = logging.getLogger("olivas.pipeline") + + # Use sync DB connection for background thread + from sqlalchemy import create_engine + from sqlalchemy.orm import Session + from app.config import settings + + sync_url = settings.DATABASE_URL.replace("+asyncpg", "").replace("postgresql://", "postgresql+psycopg2://") + # Use psycopg2 if available, otherwise fallback + try: + sync_engine = create_engine(settings.DATABASE_URL.replace("+asyncpg", "+psycopg2")) + except Exception: + sync_engine = create_engine(settings.DATABASE_URL.replace("+asyncpg", "")) + + try: + with Session(sync_engine) as db: + analysis = db.get(Analysis, analysis_id) + analysis.status = "processing" + db.commit() + + logger.info(f"Starting analysis {analysis_id}") + image = Image.open(io.BytesIO(image_data)).convert("RGB") + + # 1. Resize for inference + resized, scale = prepare_for_inference(image) + logger.info(f"Image resized: {image.size} -> {resized.size}") + + # 2. Run saliency model + logger.info(f"Running {model_name} inference...") + saliency = model_manager.predict(resized, model_name) + logger.info("Inference complete") + + # 3. Upscale to original dimensions + saliency_full = upscale_saliency(saliency, image.height, image.width) + + # 4. Save raw saliency as .npy + np.save(str(storage.get_path(analysis_id, "saliency_raw.npy")), saliency_full) + + # 5. Save saliency as grayscale PNG + saliency_uint8 = (saliency_full * 255).astype(np.uint8) + saliency_img = Image.fromarray(saliency_uint8, mode="L") + buf = io.BytesIO() + saliency_img.save(buf, format="PNG") + with open(storage.get_path(analysis_id, "saliency_gray.png"), "wb") as f: + f.write(buf.getvalue()) + + # 6. Generate heatmap overlay + heatmap_overlay = generate_heatmap_overlay(image, saliency_full) + buf = io.BytesIO() + heatmap_overlay.save(buf, format="PNG") + with open(storage.get_path(analysis_id, "heatmap_overlay.png"), "wb") as f: + f.write(buf.getvalue()) + + # 7. Generate standalone heatmap + heatmap_standalone = generate_standalone_heatmap(saliency_full) + buf = io.BytesIO() + heatmap_standalone.save(buf, format="PNG") + with open(storage.get_path(analysis_id, "heatmap_standalone.png"), "wb") as f: + f.write(buf.getvalue()) + + # 8. Extract gaze sequence + gaze_seq = extract_gaze_sequence(saliency_full, num_fixations=5) + + # 9. Compute overall attention score + # Normalize saliency to a proper probability distribution + sal_sum = saliency_full.sum() + if sal_sum > 0: + prob_dist = saliency_full / sal_sum + prob_dist = prob_dist[prob_dist > 0] # remove zeros for log + entropy = -np.sum(prob_dist * np.log2(prob_dist)) + max_entropy = np.log2(saliency_full.size) + concentration = (1 - entropy / max_entropy) * 100 + overall_score = round(float(np.clip(concentration, 0, 100)), 1) + else: + overall_score = 0.0 + + # 10. Extract hotspots + hotspots = _extract_hotspots(saliency_full, num_hotspots=5) + + # 11. Generate gaze sequence image + gaze_img = _draw_gaze_sequence(image, gaze_seq) + buf = io.BytesIO() + gaze_img.save(buf, format="PNG") + with open(storage.get_path(analysis_id, "gaze_sequence.png"), "wb") as f: + f.write(buf.getvalue()) + + # Update DB + analysis.status = "completed" + analysis.gaze_sequence = gaze_seq + analysis.hotspots = hotspots + analysis.overall_score = overall_score + db.commit() + logger.info(f"Analysis {analysis_id} completed (score={overall_score})") + + except Exception as e: + logger.error(f"Analysis {analysis_id} failed: {e}", exc_info=True) + try: + with Session(sync_engine) as db: + analysis = db.get(Analysis, analysis_id) + if analysis: + analysis.status = "failed" + db.commit() + except Exception: + pass + + +def _extract_hotspots(saliency, num_hotspots=5): + import numpy as np + from scipy.ndimage import gaussian_filter + + sal = saliency.copy() + h, w = sal.shape + hotspots = [] + radius = int(max(h, w) * 0.08) + + for i in range(num_hotspots): + smoothed = gaussian_filter(sal, sigma=max(h, w) * 0.015) + peak_idx = np.unravel_index(np.argmax(smoothed), smoothed.shape) + y, x = int(peak_idx[0]), int(peak_idx[1]) + intensity = float(saliency[y, x]) + + # Bounding box around hotspot + x1 = max(0, x - radius) + y1 = max(0, y - radius) + x2 = min(w, x + radius) + y2 = min(h, y + radius) + + hotspots.append({ + "rank": i + 1, + "center_x": x, + "center_y": y, + "x": x1, + "y": y1, + "width": x2 - x1, + "height": y2 - y1, + "intensity": round(intensity, 4), + }) + + # Inhibition of return + yy, xx = np.ogrid[:h, :w] + mask = (xx - x) ** 2 + (yy - y) ** 2 <= radius ** 2 + sal[mask] = 0.0 + + return hotspots + + +def _draw_gaze_sequence(image, gaze_seq): + from PIL import ImageDraw, ImageFont + + img = image.copy() + draw = ImageDraw.Draw(img) + + font = ImageFont.load_default(size=24) + + colors = ["#FF4444", "#FF8800", "#FFCC00", "#44CC44", "#4488FF"] + + for i, point in enumerate(gaze_seq): + x, y = point["x"], point["y"] + color = colors[i % len(colors)] + r = 25 + + # Draw circle + draw.ellipse([x - r, y - r, x + r, y + r], outline=color, width=3) + draw.text((x - 6, y - 12), str(point["rank"]), fill=color, font=font) + + # Draw line to next point + if i < len(gaze_seq) - 1: + nx, ny = gaze_seq[i + 1]["x"], gaze_seq[i + 1]["y"] + draw.line([x, y, nx, ny], fill=color, width=2) + + return img + + +@router.get("/analyses/ai-insights-available") +async def check_ai_insights_available(): + """Check if AI insights are available (API key configured).""" + from app.services.ai_insights import is_available + return {"available": is_available()} + + +@router.get("/analyses/{analysis_id}", response_model=AnalysisDetail) +async def get_analysis( + analysis_id: str, + db: AsyncSession = Depends(get_db), + x_user_id: str | None = Header(None), +): + user_id = get_user_id(x_user_id) + stmt = select(Analysis).where(Analysis.id == analysis_id, Analysis.user_id == user_id) + result = await db.execute(stmt) + analysis = result.scalar_one_or_none() + if not analysis: + raise HTTPException(status_code=404, detail="Analysis not found") + + # Generate insights for completed analyses + insights = None + if analysis.status == "completed": + from app.services.insights import generate_insights + insights = generate_insights(analysis) + + return AnalysisDetail( + id=analysis.id, + name=analysis.name, + model_used=analysis.model_used, + status=analysis.status, + original_filename=analysis.original_filename, + image_width=analysis.image_width, + image_height=analysis.image_height, + file_format=analysis.file_format, + overall_score=analysis.overall_score, + created_at=analysis.created_at, + gaze_sequence=analysis.gaze_sequence, + hotspots=analysis.hotspots, + insights=insights, + ai_insights=analysis.ai_insights, + ai_cost_usd=analysis.ai_cost_usd, + ) + + +@router.get("/analyses/{analysis_id}/status", response_model=AnalysisStatus) +async def get_analysis_status( + analysis_id: str, + db: AsyncSession = Depends(get_db), + x_user_id: str | None = Header(None), +): + user_id = get_user_id(x_user_id) + stmt = select(Analysis).where(Analysis.id == analysis_id, Analysis.user_id == user_id) + result = await db.execute(stmt) + analysis = result.scalar_one_or_none() + if not analysis: + raise HTTPException(status_code=404, detail="Analysis not found") + return AnalysisStatus(id=analysis.id, status=analysis.status) + + +@router.get("/analyses/{analysis_id}/images/{image_type}") +async def get_analysis_image( + analysis_id: str, + image_type: str, + db: AsyncSession = Depends(get_db), + x_user_id: str | None = Header(None), +): + user_id = get_user_id(x_user_id) + stmt = select(Analysis).where(Analysis.id == analysis_id, Analysis.user_id == user_id) + result = await db.execute(stmt) + analysis = result.scalar_one_or_none() + if not analysis: + raise HTTPException(status_code=404, detail="Analysis not found") + + file_map = { + "original": "original.png", + "thumbnail": "thumbnail.png", + "heatmap": "heatmap_overlay.png", + "heatmap-standalone": "heatmap_standalone.png", + "saliency-raw": "saliency_gray.png", + "gaze-sequence": "gaze_sequence.png", + } + + filename = file_map.get(image_type) + if not filename: + raise HTTPException(status_code=400, detail=f"Unknown image type: {image_type}") + + if not storage.exists(analysis_id, filename): + raise HTTPException(status_code=404, detail=f"Image not yet available") + + data = await storage.load_bytes(analysis_id, filename) + return StreamingResponse(io.BytesIO(data), media_type="image/png") + + +@router.post("/analyses/{analysis_id}/ai-insights") +async def generate_ai_insights_endpoint( + analysis_id: str, + db: AsyncSession = Depends(get_db), + x_user_id: str | None = Header(None), +): + """Generate AI-powered insights for a completed analysis using Claude.""" + from app.services.ai_insights import generate_ai_insights, is_available + + if not is_available(): + raise HTTPException(status_code=503, detail="AI insights not configured (missing API key)") + + user_id = get_user_id(x_user_id) + stmt = select(Analysis).where(Analysis.id == analysis_id, Analysis.user_id == user_id) + result = await db.execute(stmt) + analysis = result.scalar_one_or_none() + if not analysis: + raise HTTPException(status_code=404, detail="Analysis not found") + + if analysis.status != "completed": + raise HTTPException(status_code=400, detail="Analysis is not yet completed") + + # Load images + try: + original_bytes = await storage.load_bytes(analysis_id, "original.png") + heatmap_bytes = await storage.load_bytes(analysis_id, "heatmap_overlay.png") + except FileNotFoundError: + raise HTTPException(status_code=404, detail="Analysis images not found") + + metadata = { + "overall_score": analysis.overall_score, + "hotspots": analysis.hotspots or [], + "gaze_sequence": analysis.gaze_sequence or [], + "image_width": analysis.image_width, + "image_height": analysis.image_height, + } + + try: + result = generate_ai_insights(metadata, original_bytes, heatmap_bytes) + + # Save to DB + analysis.ai_insights = result["insights"] + analysis.ai_cost_usd = result["cost_usd"] + await db.flush() + + # Invalidate cached PDF so next download includes AI insights + if storage.exists(analysis_id, "report.pdf"): + import os + try: + os.remove(storage.get_path(analysis_id, "report.pdf")) + except OSError: + pass + + return { + "insights": result["insights"], + "cost_usd": result["cost_usd"], + "input_tokens": result["input_tokens"], + "output_tokens": result["output_tokens"], + } + except RuntimeError as e: + raise HTTPException(status_code=502, detail=str(e)) + + +@router.delete("/analyses/{analysis_id}", status_code=204) +async def delete_analysis( + analysis_id: str, + db: AsyncSession = Depends(get_db), + x_user_id: str | None = Header(None), +): + user_id = get_user_id(x_user_id) + stmt = select(Analysis).where(Analysis.id == analysis_id, Analysis.user_id == user_id) + result = await db.execute(stmt) + analysis = result.scalar_one_or_none() + if not analysis: + raise HTTPException(status_code=404, detail="Analysis not found") + + await storage.delete_analysis(analysis_id) + await db.delete(analysis) + await db.commit() diff --git a/backend/app/api/endpoints/aoi.py b/backend/app/api/endpoints/aoi.py new file mode 100644 index 0000000..a7b598a --- /dev/null +++ b/backend/app/api/endpoints/aoi.py @@ -0,0 +1,105 @@ +import numpy as np +from fastapi import APIRouter, Depends, Header, HTTPException +from sqlalchemy import select +from sqlalchemy.ext.asyncio import AsyncSession + +from app.db.session import get_db +from app.dependencies import get_user_id +from app.models.analysis import Analysis +from app.models.aoi import AOI +from app.schemas.aoi import AOICreate, AOIResult, AOIUpdate +from app.services.aoi_analysis import compute_aoi_attention +from app.services.storage import storage + +router = APIRouter(tags=["aoi"]) + + +@router.post("/analyses/{analysis_id}/aois", response_model=list[AOIResult], status_code=201) +async def create_aois( + analysis_id: str, + body: AOICreate, + db: AsyncSession = Depends(get_db), + x_user_id: str | None = Header(None), +): + user_id = get_user_id(x_user_id) + stmt = select(Analysis).where(Analysis.id == analysis_id, Analysis.user_id == user_id) + result = await db.execute(stmt) + analysis = result.scalar_one_or_none() + if not analysis: + raise HTTPException(status_code=404, detail="Analysis not found") + + if analysis.status != "completed": + raise HTTPException(status_code=400, detail="Analysis not yet completed") + + # Load saliency map + npy_path = storage.get_path(analysis_id, "saliency_raw.npy") + if not npy_path.exists(): + raise HTTPException(status_code=400, detail="Saliency data not available") + + saliency = np.load(str(npy_path)) + + regions = [r.model_dump() for r in body.regions] + attention_results = compute_aoi_attention(saliency, regions) + + aoi_records = [] + for region, att in zip(body.regions, attention_results): + aoi = AOI( + analysis_id=analysis_id, + label=region.label, + x=region.x, + y=region.y, + width=region.width, + height=region.height, + attention_pct=att["attention_pct"], + area_pct=att["area_pct"], + attention_density=att["attention_density"], + ) + db.add(aoi) + aoi_records.append(aoi) + + await db.flush() + for aoi in aoi_records: + await db.refresh(aoi) + + return [AOIResult.model_validate(aoi) for aoi in aoi_records] + + +@router.get("/analyses/{analysis_id}/aois", response_model=list[AOIResult]) +async def list_aois( + analysis_id: str, + db: AsyncSession = Depends(get_db), + x_user_id: str | None = Header(None), +): + user_id = get_user_id(x_user_id) + stmt = select(Analysis).where(Analysis.id == analysis_id, Analysis.user_id == user_id) + result = await db.execute(stmt) + analysis = result.scalar_one_or_none() + if not analysis: + raise HTTPException(status_code=404, detail="Analysis not found") + + aoi_stmt = select(AOI).where(AOI.analysis_id == analysis_id) + aoi_result = await db.execute(aoi_stmt) + aois = aoi_result.scalars().all() + return [AOIResult.model_validate(aoi) for aoi in aois] + + +@router.delete("/analyses/{analysis_id}/aois/{aoi_id}", status_code=204) +async def delete_aoi( + analysis_id: str, + aoi_id: str, + db: AsyncSession = Depends(get_db), + x_user_id: str | None = Header(None), +): + user_id = get_user_id(x_user_id) + # Verify analysis ownership + stmt = select(Analysis).where(Analysis.id == analysis_id, Analysis.user_id == user_id) + result = await db.execute(stmt) + if not result.scalar_one_or_none(): + raise HTTPException(status_code=404, detail="Analysis not found") + + aoi_stmt = select(AOI).where(AOI.id == aoi_id, AOI.analysis_id == analysis_id) + aoi_result = await db.execute(aoi_stmt) + aoi = aoi_result.scalar_one_or_none() + if not aoi: + raise HTTPException(status_code=404, detail="AOI not found") + await db.delete(aoi) diff --git a/backend/app/api/endpoints/comparison.py b/backend/app/api/endpoints/comparison.py new file mode 100644 index 0000000..94be9ef --- /dev/null +++ b/backend/app/api/endpoints/comparison.py @@ -0,0 +1,145 @@ +from fastapi import APIRouter, Depends, Header, HTTPException +from sqlalchemy import select +from sqlalchemy.ext.asyncio import AsyncSession + +from app.db.session import get_db +from app.dependencies import get_user_id +from app.models.analysis import Analysis +from app.models.comparison import Comparison +from app.models.project import Project + +router = APIRouter(tags=["comparison"]) + + +class ComparisonCreate: + pass + + +from pydantic import BaseModel + + +class ComparisonCreateBody(BaseModel): + name: str + analysis_ids: list[str] + + +class ComparisonResponse(BaseModel): + id: str + name: str + analyses: list[dict] + comparison_data: dict | None = None + + model_config = {"from_attributes": True} + + +@router.post( + "/projects/{project_id}/comparisons", response_model=ComparisonResponse, status_code=201 +) +async def create_comparison( + project_id: str, + body: ComparisonCreateBody, + db: AsyncSession = Depends(get_db), + x_user_id: str | None = Header(None), +): + user_id = get_user_id(x_user_id) + + # Verify project + stmt = select(Project).where(Project.id == project_id, Project.user_id == user_id) + result = await db.execute(stmt) + if not result.scalar_one_or_none(): + raise HTTPException(status_code=404, detail="Project not found") + + if len(body.analysis_ids) < 2: + raise HTTPException(status_code=400, detail="Need at least 2 analyses to compare") + + # Fetch analyses + analyses_stmt = select(Analysis).where( + Analysis.id.in_(body.analysis_ids), + Analysis.user_id == user_id, + Analysis.status == "completed", + ) + analyses_result = await db.execute(analyses_stmt) + analyses = analyses_result.scalars().all() + + if len(analyses) != len(body.analysis_ids): + raise HTTPException( + status_code=400, detail="Some analyses not found or not completed" + ) + + # Build comparison data + analyses_data = [] + winner_id = None + max_score = -1 + + for a in analyses: + data = { + "analysis_id": a.id, + "name": a.name, + "overall_score": a.overall_score, + "top_fixation": a.gaze_sequence[0] if a.gaze_sequence else None, + } + analyses_data.append(data) + if a.overall_score and a.overall_score > max_score: + max_score = a.overall_score + winner_id = a.id + + comparison_data = { + "winner": winner_id, + "score_delta": round(max_score - min(a.overall_score or 0 for a in analyses), 1), + } + + comparison = Comparison( + project_id=project_id, + user_id=user_id, + name=body.name, + analysis_ids=body.analysis_ids, + comparison_data=comparison_data, + ) + db.add(comparison) + await db.flush() + await db.refresh(comparison) + + return ComparisonResponse( + id=comparison.id, + name=comparison.name, + analyses=analyses_data, + comparison_data=comparison_data, + ) + + +@router.get("/comparisons/{comparison_id}", response_model=ComparisonResponse) +async def get_comparison( + comparison_id: str, + db: AsyncSession = Depends(get_db), + x_user_id: str | None = Header(None), +): + user_id = get_user_id(x_user_id) + stmt = select(Comparison).where( + Comparison.id == comparison_id, Comparison.user_id == user_id + ) + result = await db.execute(stmt) + comparison = result.scalar_one_or_none() + if not comparison: + raise HTTPException(status_code=404, detail="Comparison not found") + + # Fetch the analyses for display + analyses_stmt = select(Analysis).where(Analysis.id.in_(comparison.analysis_ids)) + analyses_result = await db.execute(analyses_stmt) + analyses = analyses_result.scalars().all() + + analyses_data = [ + { + "analysis_id": a.id, + "name": a.name, + "overall_score": a.overall_score, + "top_fixation": a.gaze_sequence[0] if a.gaze_sequence else None, + } + for a in analyses + ] + + return ComparisonResponse( + id=comparison.id, + name=comparison.name, + analyses=analyses_data, + comparison_data=comparison.comparison_data, + ) diff --git a/backend/app/api/endpoints/health.py b/backend/app/api/endpoints/health.py new file mode 100644 index 0000000..81956e8 --- /dev/null +++ b/backend/app/api/endpoints/health.py @@ -0,0 +1,14 @@ +from fastapi import APIRouter + +router = APIRouter() + + +@router.get("/health") +async def health_check(): + from app.services.saliency.model_manager import model_manager + + loaded = list(model_manager.models.keys()) if model_manager.models else [] + return { + "status": "ok", + "models_loaded": loaded, + } diff --git a/backend/app/api/endpoints/projects.py b/backend/app/api/endpoints/projects.py new file mode 100644 index 0000000..a4fc915 --- /dev/null +++ b/backend/app/api/endpoints/projects.py @@ -0,0 +1,141 @@ +from fastapi import APIRouter, Depends, Header, HTTPException +from sqlalchemy import func, select +from sqlalchemy.ext.asyncio import AsyncSession +from sqlalchemy.orm import selectinload + +from app.db.session import get_db +from app.dependencies import get_user_id +from app.models.analysis import Analysis +from app.models.project import Project +from app.schemas.project import ProjectCreate, ProjectDetail, ProjectSummary, ProjectUpdate + +router = APIRouter(prefix="/projects", tags=["projects"]) + + +@router.post("", response_model=ProjectSummary, status_code=201) +async def create_project( + body: ProjectCreate, + db: AsyncSession = Depends(get_db), + x_user_id: str | None = Header(None), +): + user_id = get_user_id(x_user_id) + project = Project(user_id=user_id, name=body.name, description=body.description) + db.add(project) + await db.flush() + await db.refresh(project) + return ProjectSummary( + id=project.id, + name=project.name, + description=project.description, + analysis_count=0, + created_at=project.created_at, + updated_at=project.updated_at, + ) + + +@router.get("", response_model=list[ProjectSummary]) +async def list_projects( + page: int = 1, + per_page: int = 20, + db: AsyncSession = Depends(get_db), + x_user_id: str | None = Header(None), +): + user_id = get_user_id(x_user_id) + offset = (page - 1) * per_page + + stmt = ( + select( + Project, + func.count(Analysis.id).label("analysis_count"), + ) + .outerjoin(Analysis) + .where(Project.user_id == user_id) + .group_by(Project.id) + .order_by(Project.updated_at.desc()) + .offset(offset) + .limit(per_page) + ) + result = await db.execute(stmt) + rows = result.all() + + return [ + ProjectSummary( + id=p.id, + name=p.name, + description=p.description, + analysis_count=count, + created_at=p.created_at, + updated_at=p.updated_at, + ) + for p, count in rows + ] + + +@router.get("/{project_id}", response_model=ProjectDetail) +async def get_project( + project_id: str, + db: AsyncSession = Depends(get_db), + x_user_id: str | None = Header(None), +): + user_id = get_user_id(x_user_id) + stmt = ( + select(Project) + .options(selectinload(Project.analyses)) + .where(Project.id == project_id, Project.user_id == user_id) + ) + result = await db.execute(stmt) + project = result.scalar_one_or_none() + if not project: + raise HTTPException(status_code=404, detail="Project not found") + return project + + +@router.put("/{project_id}", response_model=ProjectSummary) +async def update_project( + project_id: str, + body: ProjectUpdate, + db: AsyncSession = Depends(get_db), + x_user_id: str | None = Header(None), +): + user_id = get_user_id(x_user_id) + stmt = select(Project).where(Project.id == project_id, Project.user_id == user_id) + result = await db.execute(stmt) + project = result.scalar_one_or_none() + if not project: + raise HTTPException(status_code=404, detail="Project not found") + + if body.name is not None: + project.name = body.name + if body.description is not None: + project.description = body.description + + await db.flush() + await db.refresh(project) + + count_stmt = select(func.count(Analysis.id)).where(Analysis.project_id == project_id) + count_result = await db.execute(count_stmt) + analysis_count = count_result.scalar() or 0 + + return ProjectSummary( + id=project.id, + name=project.name, + description=project.description, + analysis_count=analysis_count, + created_at=project.created_at, + updated_at=project.updated_at, + ) + + +@router.delete("/{project_id}", status_code=204) +async def delete_project( + project_id: str, + db: AsyncSession = Depends(get_db), + x_user_id: str | None = Header(None), +): + user_id = get_user_id(x_user_id) + stmt = select(Project).where(Project.id == project_id, Project.user_id == user_id) + result = await db.execute(stmt) + project = result.scalar_one_or_none() + if not project: + raise HTTPException(status_code=404, detail="Project not found") + await db.delete(project) diff --git a/backend/app/api/endpoints/reports.py b/backend/app/api/endpoints/reports.py new file mode 100644 index 0000000..ecf8b10 --- /dev/null +++ b/backend/app/api/endpoints/reports.py @@ -0,0 +1,89 @@ +import io +import logging + +from fastapi import APIRouter, Depends, Header, HTTPException +from fastapi.responses import StreamingResponse +from sqlalchemy import select +from sqlalchemy.ext.asyncio import AsyncSession +from sqlalchemy.orm import selectinload + +from app.db.session import get_db +from app.dependencies import get_user_id +from app.models.analysis import Analysis +from app.services.storage import storage + +router = APIRouter(tags=["reports"]) +logger = logging.getLogger("olivas.reports") + + +@router.get("/analyses/{analysis_id}/report") +async def download_report( + analysis_id: str, + db: AsyncSession = Depends(get_db), + x_user_id: str | None = Header(None), +): + user_id = get_user_id(x_user_id) + stmt = ( + select(Analysis) + .options(selectinload(Analysis.aois)) + .where(Analysis.id == analysis_id, Analysis.user_id == user_id) + ) + result = await db.execute(stmt) + analysis = result.scalar_one_or_none() + if not analysis: + raise HTTPException(status_code=404, detail="Analysis not found") + + if analysis.status != "completed": + raise HTTPException(status_code=400, detail="Analysis not yet completed") + + # Check if PDF already cached + if storage.exists(analysis_id, "report.pdf"): + data = await storage.load_bytes(analysis_id, "report.pdf") + else: + from app.services.report_generator import generate_report + + # Load images for the report + try: + original_data = await storage.load_bytes(analysis_id, "original.png") + except FileNotFoundError: + raise HTTPException(status_code=404, detail="Original image not found") + + try: + heatmap_data = await storage.load_bytes(analysis_id, "heatmap_overlay.png") + except FileNotFoundError: + raise HTTPException(status_code=404, detail="Heatmap image not yet generated") + + try: + gaze_data = await storage.load_bytes(analysis_id, "gaze_sequence.png") + except FileNotFoundError: + raise HTTPException(status_code=404, detail="Gaze sequence image not yet generated") + + # Generate rule-based insights + from app.services.insights import generate_insights + rule_insights = generate_insights(analysis) if analysis.status == "completed" else [] + + try: + data = generate_report( + analysis=analysis, + original_image=original_data, + heatmap_image=heatmap_data, + gaze_image=gaze_data, + aois=list(analysis.aois), + rule_insights=rule_insights, + ai_insights=analysis.ai_insights, + ai_cost_usd=analysis.ai_cost_usd, + ) + except Exception as e: + logger.error(f"Report generation failed for {analysis_id}: {e}", exc_info=True) + raise HTTPException(status_code=500, detail=f"Report generation failed: {str(e)}") + + await storage.save_bytes(data, analysis_id, "report.pdf") + + safe_name = analysis.name.replace(" ", "_").replace("/", "_") + return StreamingResponse( + io.BytesIO(data), + media_type="application/pdf", + headers={ + "Content-Disposition": f'attachment; filename="olivas-report-{safe_name}.pdf"' + }, + ) diff --git a/backend/app/api/router.py b/backend/app/api/router.py new file mode 100644 index 0000000..4d4c6b9 --- /dev/null +++ b/backend/app/api/router.py @@ -0,0 +1,12 @@ +from fastapi import APIRouter + +from app.api.endpoints import analysis, aoi, comparison, health, projects, reports + +api_router = APIRouter(prefix="/api") + +api_router.include_router(health.router) +api_router.include_router(projects.router) +api_router.include_router(analysis.router) +api_router.include_router(aoi.router) +api_router.include_router(comparison.router) +api_router.include_router(reports.router) diff --git a/backend/app/config.py b/backend/app/config.py new file mode 100644 index 0000000..9253d23 --- /dev/null +++ b/backend/app/config.py @@ -0,0 +1,30 @@ +from pydantic_settings import BaseSettings + + +class Settings(BaseSettings): + DATABASE_URL: str = "postgresql+asyncpg://olivas:olivas@localhost:5453/olivas" + UPLOAD_DIR: str = "./data/uploads" + DEVICE: str = "auto" # auto | cpu | cuda + ANTHROPIC_API_KEY: str = "" + CORS_ORIGINS: str = "http://localhost:1577" + BACKEND_HOST: str = "0.0.0.0" + BACKEND_PORT: int = 8000 + + @property + def device(self) -> str: + if self.DEVICE == "auto": + try: + import torch + return "cuda" if torch.cuda.is_available() else "cpu" + except ImportError: + return "cpu" + return self.DEVICE + + @property + def cors_origins_list(self) -> list[str]: + return [o.strip() for o in self.CORS_ORIGINS.split(",")] + + model_config = {"env_file": ".env", "env_file_encoding": "utf-8"} + + +settings = Settings() diff --git a/backend/app/core/__init__.py b/backend/app/core/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/backend/app/core/exceptions.py b/backend/app/core/exceptions.py new file mode 100644 index 0000000..08de9b4 --- /dev/null +++ b/backend/app/core/exceptions.py @@ -0,0 +1,18 @@ +class OliVASError(Exception): + pass + + +class AnalysisNotFoundError(OliVASError): + pass + + +class ProjectNotFoundError(OliVASError): + pass + + +class ModelNotLoadedError(OliVASError): + pass + + +class ImageProcessingError(OliVASError): + pass diff --git a/backend/app/db/__init__.py b/backend/app/db/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/backend/app/db/migrations/env.py b/backend/app/db/migrations/env.py new file mode 100644 index 0000000..67b81d8 --- /dev/null +++ b/backend/app/db/migrations/env.py @@ -0,0 +1,57 @@ +import asyncio +from logging.config import fileConfig + +from alembic import context +from sqlalchemy import pool +from sqlalchemy.ext.asyncio import async_engine_from_config + +from app.models.base import Base +from app.models.project import Project # noqa: F401 +from app.models.analysis import Analysis # noqa: F401 +from app.models.aoi import AOI # noqa: F401 +from app.models.comparison import Comparison # noqa: F401 + +config = context.config +if config.config_file_name is not None: + fileConfig(config.config_file_name) + +target_metadata = Base.metadata + + +def run_migrations_offline() -> None: + url = config.get_main_option("sqlalchemy.url") + context.configure( + url=url, + target_metadata=target_metadata, + literal_binds=True, + dialect_opts={"paramstyle": "named"}, + ) + with context.begin_transaction(): + context.run_migrations() + + +def do_run_migrations(connection): + context.configure(connection=connection, target_metadata=target_metadata) + with context.begin_transaction(): + context.run_migrations() + + +async def run_async_migrations() -> None: + connectable = async_engine_from_config( + config.get_section(config.config_ini_section, {}), + prefix="sqlalchemy.", + poolclass=pool.NullPool, + ) + async with connectable.connect() as connection: + await connection.run_sync(do_run_migrations) + await connectable.dispose() + + +def run_migrations_online() -> None: + asyncio.run(run_async_migrations()) + + +if context.is_offline_mode(): + run_migrations_offline() +else: + run_migrations_online() diff --git a/backend/app/db/migrations/script.py.mako b/backend/app/db/migrations/script.py.mako new file mode 100644 index 0000000..fbc4b07 --- /dev/null +++ b/backend/app/db/migrations/script.py.mako @@ -0,0 +1,26 @@ +"""${message} + +Revision ID: ${up_revision} +Revises: ${down_revision | comma,n} +Create Date: ${create_date} + +""" +from typing import Sequence, Union + +from alembic import op +import sqlalchemy as sa +${imports if imports else ""} + +# revision identifiers, used by Alembic. +revision: str = ${repr(up_revision)} +down_revision: Union[str, None] = ${repr(down_revision)} +branch_labels: Union[str, Sequence[str], None] = ${repr(branch_labels)} +depends_on: Union[str, Sequence[str], None] = ${repr(depends_on)} + + +def upgrade() -> None: + ${upgrades if upgrades else "pass"} + + +def downgrade() -> None: + ${downgrades if downgrades else "pass"} diff --git a/backend/app/db/migrations/versions/2f6f70f606a1_initial_schema.py b/backend/app/db/migrations/versions/2f6f70f606a1_initial_schema.py new file mode 100644 index 0000000..b00af67 --- /dev/null +++ b/backend/app/db/migrations/versions/2f6f70f606a1_initial_schema.py @@ -0,0 +1,97 @@ +"""initial schema + +Revision ID: 2f6f70f606a1 +Revises: +Create Date: 2026-02-23 14:18:44.382856 + +""" +from typing import Sequence, Union + +from alembic import op +import sqlalchemy as sa + + +# revision identifiers, used by Alembic. +revision: str = '2f6f70f606a1' +down_revision: Union[str, None] = None +branch_labels: Union[str, Sequence[str], None] = None +depends_on: Union[str, Sequence[str], None] = None + + +def upgrade() -> None: + # ### commands auto generated by Alembic - please adjust! ### + op.create_table('projects', + sa.Column('id', sa.String(length=36), nullable=False), + sa.Column('user_id', sa.String(length=36), nullable=False), + sa.Column('name', sa.String(length=255), nullable=False), + sa.Column('description', sa.Text(), nullable=True), + sa.Column('created_at', sa.DateTime(), server_default=sa.text('now()'), nullable=False), + sa.Column('updated_at', sa.DateTime(), server_default=sa.text('now()'), nullable=False), + sa.PrimaryKeyConstraint('id') + ) + op.create_index(op.f('ix_projects_user_id'), 'projects', ['user_id'], unique=False) + op.create_table('analyses', + sa.Column('id', sa.String(length=36), nullable=False), + sa.Column('project_id', sa.String(length=36), nullable=False), + sa.Column('user_id', sa.String(length=36), nullable=False), + sa.Column('name', sa.String(length=255), nullable=False), + sa.Column('model_used', sa.String(length=50), nullable=False), + sa.Column('status', sa.String(length=20), nullable=False), + sa.Column('original_filename', sa.String(length=255), nullable=False), + sa.Column('image_width', sa.Integer(), nullable=False), + sa.Column('image_height', sa.Integer(), nullable=False), + sa.Column('file_format', sa.String(length=10), nullable=False), + sa.Column('storage_path', sa.String(length=512), nullable=False), + sa.Column('gaze_sequence', sa.JSON(), nullable=True), + sa.Column('hotspots', sa.JSON(), nullable=True), + sa.Column('overall_score', sa.Float(), nullable=True), + sa.Column('created_at', sa.DateTime(), server_default=sa.text('now()'), nullable=False), + sa.ForeignKeyConstraint(['project_id'], ['projects.id'], ), + sa.PrimaryKeyConstraint('id') + ) + op.create_index(op.f('ix_analyses_project_id'), 'analyses', ['project_id'], unique=False) + op.create_index(op.f('ix_analyses_user_id'), 'analyses', ['user_id'], unique=False) + op.create_table('comparisons', + sa.Column('id', sa.String(length=36), nullable=False), + sa.Column('project_id', sa.String(length=36), nullable=False), + sa.Column('user_id', sa.String(length=36), nullable=False), + sa.Column('name', sa.String(length=255), nullable=False), + sa.Column('analysis_ids', sa.JSON(), nullable=False), + sa.Column('comparison_data', sa.JSON(), nullable=True), + sa.Column('created_at', sa.DateTime(), server_default=sa.text('now()'), nullable=False), + sa.ForeignKeyConstraint(['project_id'], ['projects.id'], ), + sa.PrimaryKeyConstraint('id') + ) + op.create_index(op.f('ix_comparisons_project_id'), 'comparisons', ['project_id'], unique=False) + op.create_index(op.f('ix_comparisons_user_id'), 'comparisons', ['user_id'], unique=False) + op.create_table('aois', + sa.Column('id', sa.String(length=36), nullable=False), + sa.Column('analysis_id', sa.String(length=36), nullable=False), + sa.Column('label', sa.String(length=100), nullable=False), + sa.Column('x', sa.Integer(), nullable=False), + sa.Column('y', sa.Integer(), nullable=False), + sa.Column('width', sa.Integer(), nullable=False), + sa.Column('height', sa.Integer(), nullable=False), + sa.Column('attention_pct', sa.Float(), nullable=True), + sa.Column('area_pct', sa.Float(), nullable=True), + sa.Column('attention_density', sa.Float(), nullable=True), + sa.ForeignKeyConstraint(['analysis_id'], ['analyses.id'], ), + sa.PrimaryKeyConstraint('id') + ) + op.create_index(op.f('ix_aois_analysis_id'), 'aois', ['analysis_id'], unique=False) + # ### end Alembic commands ### + + +def downgrade() -> None: + # ### commands auto generated by Alembic - please adjust! ### + op.drop_index(op.f('ix_aois_analysis_id'), table_name='aois') + op.drop_table('aois') + op.drop_index(op.f('ix_comparisons_user_id'), table_name='comparisons') + op.drop_index(op.f('ix_comparisons_project_id'), table_name='comparisons') + op.drop_table('comparisons') + op.drop_index(op.f('ix_analyses_user_id'), table_name='analyses') + op.drop_index(op.f('ix_analyses_project_id'), table_name='analyses') + op.drop_table('analyses') + op.drop_index(op.f('ix_projects_user_id'), table_name='projects') + op.drop_table('projects') + # ### end Alembic commands ### diff --git a/backend/app/db/session.py b/backend/app/db/session.py new file mode 100644 index 0000000..7aa48af --- /dev/null +++ b/backend/app/db/session.py @@ -0,0 +1,16 @@ +from sqlalchemy.ext.asyncio import AsyncSession, async_sessionmaker, create_async_engine + +from app.config import settings + +engine = create_async_engine(settings.DATABASE_URL, echo=False) +async_session_factory = async_sessionmaker(engine, class_=AsyncSession, expire_on_commit=False) + + +async def get_db() -> AsyncSession: + async with async_session_factory() as session: + try: + yield session + await session.commit() + except Exception: + await session.rollback() + raise diff --git a/backend/app/dependencies.py b/backend/app/dependencies.py new file mode 100644 index 0000000..b4b00ce --- /dev/null +++ b/backend/app/dependencies.py @@ -0,0 +1,12 @@ +from sqlalchemy.ext.asyncio import AsyncSession + +from app.db.session import get_db + +# User ID header — placeholder for SSO integration. +# When SSO is added, this will extract user_id from the JWT/session token. +USER_ID_HEADER = "X-User-Id" +DEFAULT_USER_ID = "default" + + +def get_user_id(x_user_id: str | None = None) -> str: + return x_user_id or DEFAULT_USER_ID diff --git a/backend/app/main.py b/backend/app/main.py new file mode 100644 index 0000000..b197d9e --- /dev/null +++ b/backend/app/main.py @@ -0,0 +1,47 @@ +import logging +from contextlib import asynccontextmanager + +from fastapi import FastAPI +from fastapi.middleware.cors import CORSMiddleware + +from app.api.router import api_router +from app.config import settings + +logger = logging.getLogger("olivas") + + +@asynccontextmanager +async def lifespan(app: FastAPI): + # Startup: load ML models + logger.info(f"Starting OliVAS backend (device={settings.device})") + from app.services.saliency.model_manager import model_manager + + try: + model_manager.load_models(device=settings.device) + logger.info(f"Models loaded: {list(model_manager.models.keys())}") + except Exception as e: + logger.warning(f"Failed to load ML models: {e}. Analysis will fail until models load.") + + yield + + # Shutdown + model_manager.cleanup() + logger.info("OliVAS backend shut down") + + +app = FastAPI( + title="OliVAS", + description="Open-Source Visual Attention Software by OLIVER", + version="0.1.0", + lifespan=lifespan, +) + +app.add_middleware( + CORSMiddleware, + allow_origins=settings.cors_origins_list, + allow_credentials=True, + allow_methods=["*"], + allow_headers=["*"], +) + +app.include_router(api_router) diff --git a/backend/app/models/__init__.py b/backend/app/models/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/backend/app/models/analysis.py b/backend/app/models/analysis.py new file mode 100644 index 0000000..0c133aa --- /dev/null +++ b/backend/app/models/analysis.py @@ -0,0 +1,39 @@ +import uuid +from datetime import datetime + +from sqlalchemy import Float, ForeignKey, Integer, JSON, String, func +from sqlalchemy.orm import Mapped, mapped_column, relationship + +from app.models.base import Base + + +class Analysis(Base): + __tablename__ = "analyses" + + id: Mapped[str] = mapped_column( + String(36), primary_key=True, default=lambda: str(uuid.uuid4()) + ) + project_id: Mapped[str] = mapped_column(ForeignKey("projects.id"), index=True) + user_id: Mapped[str] = mapped_column(String(36), index=True) + name: Mapped[str] = mapped_column(String(255)) + model_used: Mapped[str] = mapped_column(String(50), default="deepgaze_iie") + status: Mapped[str] = mapped_column(String(20), default="pending") + + original_filename: Mapped[str] = mapped_column(String(255)) + image_width: Mapped[int] = mapped_column(Integer) + image_height: Mapped[int] = mapped_column(Integer) + file_format: Mapped[str] = mapped_column(String(10)) + storage_path: Mapped[str] = mapped_column(String(512)) + + gaze_sequence: Mapped[dict | None] = mapped_column(JSON, nullable=True) + hotspots: Mapped[dict | None] = mapped_column(JSON, nullable=True) + overall_score: Mapped[float | None] = mapped_column(Float, nullable=True) + ai_insights: Mapped[dict | None] = mapped_column(JSON, nullable=True) + ai_cost_usd: Mapped[float | None] = mapped_column(Float, nullable=True) + + created_at: Mapped[datetime] = mapped_column(server_default=func.now()) + + project: Mapped["Project"] = relationship(back_populates="analyses") # noqa: F821 + aois: Mapped[list["AOI"]] = relationship( # noqa: F821 + back_populates="analysis", cascade="all, delete-orphan" + ) diff --git a/backend/app/models/aoi.py b/backend/app/models/aoi.py new file mode 100644 index 0000000..9b20fa9 --- /dev/null +++ b/backend/app/models/aoi.py @@ -0,0 +1,26 @@ +import uuid + +from sqlalchemy import Float, ForeignKey, Integer, String +from sqlalchemy.orm import Mapped, mapped_column, relationship + +from app.models.base import Base + + +class AOI(Base): + __tablename__ = "aois" + + id: Mapped[str] = mapped_column( + String(36), primary_key=True, default=lambda: str(uuid.uuid4()) + ) + analysis_id: Mapped[str] = mapped_column(ForeignKey("analyses.id"), index=True) + label: Mapped[str] = mapped_column(String(100)) + x: Mapped[int] = mapped_column(Integer) + y: Mapped[int] = mapped_column(Integer) + width: Mapped[int] = mapped_column(Integer) + height: Mapped[int] = mapped_column(Integer) + + attention_pct: Mapped[float | None] = mapped_column(Float, nullable=True) + area_pct: Mapped[float | None] = mapped_column(Float, nullable=True) + attention_density: Mapped[float | None] = mapped_column(Float, nullable=True) + + analysis: Mapped["Analysis"] = relationship(back_populates="aois") # noqa: F821 diff --git a/backend/app/models/base.py b/backend/app/models/base.py new file mode 100644 index 0000000..fa2b68a --- /dev/null +++ b/backend/app/models/base.py @@ -0,0 +1,5 @@ +from sqlalchemy.orm import DeclarativeBase + + +class Base(DeclarativeBase): + pass diff --git a/backend/app/models/comparison.py b/backend/app/models/comparison.py new file mode 100644 index 0000000..941d8bb --- /dev/null +++ b/backend/app/models/comparison.py @@ -0,0 +1,23 @@ +import uuid +from datetime import datetime + +from sqlalchemy import ForeignKey, JSON, String, func +from sqlalchemy.orm import Mapped, mapped_column, relationship + +from app.models.base import Base + + +class Comparison(Base): + __tablename__ = "comparisons" + + id: Mapped[str] = mapped_column( + String(36), primary_key=True, default=lambda: str(uuid.uuid4()) + ) + project_id: Mapped[str] = mapped_column(ForeignKey("projects.id"), index=True) + user_id: Mapped[str] = mapped_column(String(36), index=True) + name: Mapped[str] = mapped_column(String(255)) + analysis_ids: Mapped[dict] = mapped_column(JSON) + comparison_data: Mapped[dict | None] = mapped_column(JSON, nullable=True) + created_at: Mapped[datetime] = mapped_column(server_default=func.now()) + + project: Mapped["Project"] = relationship(back_populates="comparisons") # noqa: F821 diff --git a/backend/app/models/project.py b/backend/app/models/project.py new file mode 100644 index 0000000..0be18ed --- /dev/null +++ b/backend/app/models/project.py @@ -0,0 +1,27 @@ +import uuid +from datetime import datetime + +from sqlalchemy import String, Text, func +from sqlalchemy.orm import Mapped, mapped_column, relationship + +from app.models.base import Base + + +class Project(Base): + __tablename__ = "projects" + + id: Mapped[str] = mapped_column( + String(36), primary_key=True, default=lambda: str(uuid.uuid4()) + ) + user_id: Mapped[str] = mapped_column(String(36), index=True) + name: Mapped[str] = mapped_column(String(255)) + description: Mapped[str | None] = mapped_column(Text, nullable=True) + created_at: Mapped[datetime] = mapped_column(server_default=func.now()) + updated_at: Mapped[datetime] = mapped_column(server_default=func.now(), onupdate=func.now()) + + analyses: Mapped[list["Analysis"]] = relationship( # noqa: F821 + back_populates="project", cascade="all, delete-orphan" + ) + comparisons: Mapped[list["Comparison"]] = relationship( # noqa: F821 + back_populates="project", cascade="all, delete-orphan" + ) diff --git a/backend/app/schemas/__init__.py b/backend/app/schemas/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/backend/app/schemas/analysis.py b/backend/app/schemas/analysis.py new file mode 100644 index 0000000..330c64f --- /dev/null +++ b/backend/app/schemas/analysis.py @@ -0,0 +1,52 @@ +from datetime import datetime + +from pydantic import BaseModel + + +class AnalysisSummary(BaseModel): + id: str + name: str + model_used: str + status: str + original_filename: str + image_width: int + image_height: int + overall_score: float | None = None + created_at: datetime + + model_config = {"from_attributes": True} + + +class GazePoint(BaseModel): + rank: int + x: int + y: int + x_pct: float + y_pct: float + probability: float + + +class Insight(BaseModel): + type: str # "info" | "success" | "warning" + title: str + description: str + + +class AnalysisDetail(AnalysisSummary): + file_format: str + gaze_sequence: list[GazePoint] | None = None + hotspots: list[dict] | None = None + insights: list[Insight] | None = None + ai_insights: list[Insight] | None = None + ai_cost_usd: float | None = None + aoi_count: int = 0 + + +class AnalysisCreate(BaseModel): + name: str | None = None + model: str = "deepgaze_iie" + + +class AnalysisStatus(BaseModel): + id: str + status: str diff --git a/backend/app/schemas/aoi.py b/backend/app/schemas/aoi.py new file mode 100644 index 0000000..8b03302 --- /dev/null +++ b/backend/app/schemas/aoi.py @@ -0,0 +1,35 @@ +from pydantic import BaseModel + + +class AOIRegion(BaseModel): + label: str + x: int + y: int + width: int + height: int + + +class AOICreate(BaseModel): + regions: list[AOIRegion] + + +class AOIResult(BaseModel): + id: str + label: str + x: int + y: int + width: int + height: int + attention_pct: float | None = None + area_pct: float | None = None + attention_density: float | None = None + + model_config = {"from_attributes": True} + + +class AOIUpdate(BaseModel): + label: str | None = None + x: int | None = None + y: int | None = None + width: int | None = None + height: int | None = None diff --git a/backend/app/schemas/project.py b/backend/app/schemas/project.py new file mode 100644 index 0000000..2bf73b5 --- /dev/null +++ b/backend/app/schemas/project.py @@ -0,0 +1,35 @@ +from datetime import datetime + +from pydantic import BaseModel + + +class ProjectCreate(BaseModel): + name: str + description: str | None = None + + +class ProjectUpdate(BaseModel): + name: str | None = None + description: str | None = None + + +class ProjectSummary(BaseModel): + id: str + name: str + description: str | None + analysis_count: int = 0 + created_at: datetime + updated_at: datetime + + model_config = {"from_attributes": True} + + +class ProjectDetail(ProjectSummary): + analyses: list["AnalysisSummary"] = [] + + model_config = {"from_attributes": True} + + +from app.schemas.analysis import AnalysisSummary # noqa: E402 + +ProjectDetail.model_rebuild() diff --git a/backend/app/schemas/report.py b/backend/app/schemas/report.py new file mode 100644 index 0000000..237c8f8 --- /dev/null +++ b/backend/app/schemas/report.py @@ -0,0 +1,7 @@ +from pydantic import BaseModel + + +class ReportRequest(BaseModel): + include_aois: bool = True + include_gaze_sequence: bool = True + include_hotspots: bool = True diff --git a/backend/app/services/__init__.py b/backend/app/services/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/backend/app/services/ai_insights.py b/backend/app/services/ai_insights.py new file mode 100644 index 0000000..315c3c3 --- /dev/null +++ b/backend/app/services/ai_insights.py @@ -0,0 +1,158 @@ +"""Claude-powered AI insights for saliency analysis.""" + +import base64 +import json +import logging + +import anthropic + +from app.config import settings + +logger = logging.getLogger("olivas.ai_insights") + +# Sonnet 4.6 pricing per million tokens +INPUT_COST_PER_M = 3.00 +OUTPUT_COST_PER_M = 15.00 + + +def is_available() -> bool: + """Check if AI insights are available (API key configured).""" + return bool(settings.ANTHROPIC_API_KEY) + + +def generate_ai_insights( + analysis_metadata: dict, + original_image_bytes: bytes, + heatmap_image_bytes: bytes, +) -> dict: + """ + Send the original image, heatmap overlay, and analysis metrics to Claude + and return actionable design insights with cost tracking. + + Returns: + dict with keys: insights (list[dict]), cost_usd (float), input_tokens (int), output_tokens (int) + """ + if not is_available(): + raise RuntimeError("ANTHROPIC_API_KEY is not configured") + + client = anthropic.Anthropic(api_key=settings.ANTHROPIC_API_KEY) + + original_b64 = base64.standard_b64encode(original_image_bytes).decode("utf-8") + heatmap_b64 = base64.standard_b64encode(heatmap_image_bytes).decode("utf-8") + + score = analysis_metadata.get("overall_score", 0) + hotspots = analysis_metadata.get("hotspots", []) + gaze_sequence = analysis_metadata.get("gaze_sequence", []) + width = analysis_metadata.get("image_width", 0) + height = analysis_metadata.get("image_height", 0) + + metrics_text = f"""Analysis Metrics: +- Image dimensions: {width} x {height} pixels +- Overall Attention Score: {score}/100 (higher = more concentrated attention) +- Number of hotspots detected: {len(hotspots)} +- Top hotspot location: ({hotspots[0]['center_x']}, {hotspots[0]['center_y']}) with intensity {hotspots[0]['intensity']:.4f} +- First gaze fixation point: ({gaze_sequence[0]['x']}, {gaze_sequence[0]['y']}) — this is where viewers look first +""" if hotspots and gaze_sequence else f"""Analysis Metrics: +- Image dimensions: {width} x {height} pixels +- Overall Attention Score: {score}/100 +""" + + prompt = f"""You are a visual attention and design expert analyzing an image using saliency prediction data. You have been given: +1. The original image +2. A heatmap overlay showing predicted visual attention (warm colors = high attention, cool colors = low attention) +3. Numerical metrics from the analysis + +{metrics_text} + +Based on the original image, the heatmap overlay, and the metrics, provide exactly 4 actionable design insights. Each insight should be specific to THIS image — reference actual visual elements you can see (logos, text, products, faces, backgrounds, etc.). + +For each insight, provide: +- "type": one of "success" (something working well), "info" (neutral observation or suggestion), or "warning" (potential issue) +- "title": a short heading (5-10 words) +- "description": 1-2 sentences of specific, actionable advice + +Respond with ONLY a JSON array of 4 insight objects. No other text, no markdown formatting, just the JSON array. + +Example format: +[ + {{"type": "success", "title": "Strong focal point on product", "description": "The product image captures the highest predicted attention, which aligns well with the likely design goal. The bright contrast against the background naturally draws the eye."}}, + {{"type": "warning", "title": "CTA button may be overlooked", "description": "The call-to-action button in the lower right receives minimal predicted attention. Consider increasing its size, contrast, or moving it closer to the primary focal area."}} +]""" + + try: + message = client.messages.create( + model="claude-sonnet-4-6", + max_tokens=1024, + messages=[ + { + "role": "user", + "content": [ + { + "type": "image", + "source": { + "type": "base64", + "media_type": "image/png", + "data": original_b64, + }, + }, + { + "type": "image", + "source": { + "type": "base64", + "media_type": "image/png", + "data": heatmap_b64, + }, + }, + { + "type": "text", + "text": prompt, + }, + ], + } + ], + ) + + # Extract token usage and compute cost + input_tokens = message.usage.input_tokens + output_tokens = message.usage.output_tokens + cost_usd = round( + (input_tokens / 1_000_000) * INPUT_COST_PER_M + + (output_tokens / 1_000_000) * OUTPUT_COST_PER_M, + 6, + ) + + response_text = message.content[0].text.strip() + + # Handle potential markdown code block wrapping + if response_text.startswith("```"): + response_text = response_text.split("\n", 1)[1] + if response_text.endswith("```"): + response_text = response_text[:-3].strip() + + insights = json.loads(response_text) + + # Validate structure + validated = [] + for item in insights[:5]: # cap at 5 + if isinstance(item, dict) and "type" in item and "title" in item and "description" in item: + if item["type"] not in ("success", "info", "warning"): + item["type"] = "info" + validated.append({ + "type": item["type"], + "title": str(item["title"]), + "description": str(item["description"]), + }) + + return { + "insights": validated, + "cost_usd": cost_usd, + "input_tokens": input_tokens, + "output_tokens": output_tokens, + } + + except anthropic.APIError as e: + logger.error(f"Anthropic API error: {e}") + raise RuntimeError(f"AI analysis failed: {e.message}") + except json.JSONDecodeError as e: + logger.error(f"Failed to parse AI response: {e}") + raise RuntimeError("AI returned an unexpected response format") diff --git a/backend/app/services/aoi_analysis.py b/backend/app/services/aoi_analysis.py new file mode 100644 index 0000000..4e62abd --- /dev/null +++ b/backend/app/services/aoi_analysis.py @@ -0,0 +1,47 @@ +import numpy as np + + +def compute_aoi_attention( + saliency: np.ndarray, + regions: list[dict], +) -> list[dict]: + """ + Compute attention metrics for user-defined regions. + + Returns list of dicts with attention_pct, area_pct, attention_density. + """ + h, w = saliency.shape + total_saliency = saliency.sum() + total_area = h * w + + if total_saliency == 0: + return [ + {"attention_pct": 0.0, "area_pct": 0.0, "attention_density": 0.0} + for _ in regions + ] + + results = [] + for region in regions: + rx, ry = region["x"], region["y"] + rw, rh = region["width"], region["height"] + + # Clamp to image bounds + x1 = max(0, rx) + y1 = max(0, ry) + x2 = min(w, rx + rw) + y2 = min(h, ry + rh) + + region_saliency = saliency[y1:y2, x1:x2].sum() + region_area = (x2 - x1) * (y2 - y1) + + attention_pct = (region_saliency / total_saliency) * 100 + area_pct = (region_area / total_area) * 100 + density = attention_pct / max(area_pct, 0.01) + + results.append({ + "attention_pct": round(float(attention_pct), 2), + "area_pct": round(float(area_pct), 2), + "attention_density": round(float(density), 2), + }) + + return results diff --git a/backend/app/services/fonts/Montserrat-Bold.ttf b/backend/app/services/fonts/Montserrat-Bold.ttf new file mode 100644 index 0000000000000000000000000000000000000000..a3dbde5aafb65e89eb351a2e6acd198d4e6b2f41 GIT binary patch literal 454864 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 literal 0 HcmV?d00001 diff --git a/backend/app/services/fonts/Montserrat-Regular.ttf b/backend/app/services/fonts/Montserrat-Regular.ttf new file mode 100644 index 0000000000000000000000000000000000000000..3ef210ab1107142c0aa19cb916ae38a5f99e86ba GIT binary patch literal 445928 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 E2Vs*0>;M1& literal 0 HcmV?d00001 diff --git a/backend/app/services/fonts/Montserrat-SemiBold.ttf b/backend/app/services/fonts/Montserrat-SemiBold.ttf new file mode 100644 index 0000000000000000000000000000000000000000..e36320fb70339b14a9077f637637d6a459301e20 GIT binary patch literal 454716 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%0ARXuTTG)WQ>lzTjvHR7lYyK7hCt zT!qbhS4W;>xRub>F_NL^;o{08Go*;WGAPZEsSckI$ z6mueS1^L{5jP}U)*Dyz+ElAGb!}Dv z`-PIh*9P}#4RF8GdTuK}W+H>IB_6-2 zyL1b)BJ5qfi!!u$oF{5Z01l+OU2eg_uxMHC#@z>N%Borq?JYMR+Qxd6hiV#IYFYEe z@2{w%eS`dN1AHy*<7;WL90;n{a6*g%)vJv(iU{V1-|8rAlpTTc7tE+8N1&8+fEba{ zD2<7~c}kq;gMP!3pC3j?k0D@Dj1GWLLR@qd32h9L4v?Z;3LiS3C{P_K7a8-p6d3G$ zGR4YGyC|6==wM6B-tuDQL!tnNA1<;f{<)%#`2-UkFuPu8;4PoRl}6t3DO~S+%clSz zV0{ve7tg0~eTTPviUG<`;_rZu!b=SF0Jpu-2JrnalTYE=r^WIq26V`$pf)Ajm&&JD z*oV*0rx>7mVdDMh^B3n+xb}Imd!dV1ez2#F3aGXWl_m)pFK=~BBKVOhf!PjhpyiHqE{4C40&bb+& zI8n79-f{&7D1KeN?=4rrm50Afu7E2~ddn4njMbs0E+i;4Lr6Breu_&)d;`=Y8Td05 z1;Z|*$~==Q)lodo&x=&2Dq5mqtR6*&^{i>vk%QHxCFKVzN=mB^&hFY*UT!?FjrA$t zsIIB5VZF*X@T(fXzrO82ZLKQrbmzIuzm3bIJEfm_<8ilV&Mo>3$t3Zf)7mpaGtuS) z?;+hpJaa~S#wGS0aalwk*Js@I6CtDB`g7LvJx~og=05R>NBnX+(K!vcnhjnSC=OID zR4?m^+Bz9pDPjI(6!MLoSLZdrf@MgDpjuvhk9XTg1;xqLNauCxbq^fgS++JQVZgET zFo<5_IOHfPuE=iev?nDLuvgyMb-rx(Rs;*gyf};3c-Sk#LtvR$mAjX9* z#HWHT4{GDlXovB%%-tjRa=xi?I0A%C1a+E97hn)R@WP4G3OHK<^C*x*ZXE%+i;oky z5nPH?gi!DiG#Ac1(6pf{z`jsNMnzItL(AT*g0zwRmWCCZF4=dmro5`<&c-~UCzWlp$Hl(M`^Wj{ZlOEaTqGst%=7*^ulI?6#P?5&`exG

NpoNwqp*l7Wr0(UH?mbvnhGM{t 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Β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 literal 0 HcmV?d00001 diff --git a/backend/app/services/gaze_sequence.py b/backend/app/services/gaze_sequence.py new file mode 100644 index 0000000..e3f3780 --- /dev/null +++ b/backend/app/services/gaze_sequence.py @@ -0,0 +1,42 @@ +import numpy as np +from scipy.ndimage import gaussian_filter + + +def extract_gaze_sequence( + saliency: np.ndarray, + num_fixations: int = 5, + inhibition_radius_fraction: float = 0.1, +) -> list[dict]: + """ + Extract predicted fixation sequence using iterative peak finding + with inhibition-of-return. + """ + sal = saliency.copy().astype(np.float64) + h, w = sal.shape + inhibition_radius = int(max(h, w) * inhibition_radius_fraction) + fixations = [] + + for rank in range(1, num_fixations + 1): + smoothed = gaussian_filter(sal, sigma=max(h, w) * 0.01) + if smoothed.max() < 1e-10: + break + + peak_idx = np.unravel_index(np.argmax(smoothed), smoothed.shape) + y, x = int(peak_idx[0]), int(peak_idx[1]) + prob = float(saliency[y, x]) + + fixations.append({ + "rank": rank, + "x": x, + "y": y, + "x_pct": round(x / w * 100, 1), + "y_pct": round(y / h * 100, 1), + "probability": round(prob, 4), + }) + + # Inhibition of return + yy, xx = np.ogrid[:h, :w] + mask = (xx - x) ** 2 + (yy - y) ** 2 <= inhibition_radius ** 2 + sal[mask] = 0.0 + + return fixations diff --git a/backend/app/services/heatmap.py b/backend/app/services/heatmap.py new file mode 100644 index 0000000..f8da9e0 --- /dev/null +++ b/backend/app/services/heatmap.py @@ -0,0 +1,26 @@ +import matplotlib +matplotlib.use("Agg") +import matplotlib.cm as cm +import numpy as np +from PIL import Image + + +def generate_heatmap_overlay( + original: Image.Image, + saliency: np.ndarray, + colormap: str = "jet", + alpha: float = 0.5, +) -> Image.Image: + """Generate heatmap blended over original image.""" + cmap = matplotlib.colormaps.get_cmap(colormap) + heatmap_rgba = cmap(saliency) + heatmap_rgb = (heatmap_rgba[:, :, :3] * 255).astype(np.uint8) + heatmap_img = Image.fromarray(heatmap_rgb).resize(original.size, Image.LANCZOS) + return Image.blend(original.convert("RGB"), heatmap_img, alpha) + + +def generate_standalone_heatmap(saliency: np.ndarray, colormap: str = "jet") -> Image.Image: + """Generate a pure heatmap image.""" + cmap = matplotlib.colormaps.get_cmap(colormap) + heatmap_rgba = cmap(saliency) + return Image.fromarray((heatmap_rgba[:, :, :3] * 255).astype(np.uint8)) diff --git a/backend/app/services/image_processing.py b/backend/app/services/image_processing.py new file mode 100644 index 0000000..ef9978f --- /dev/null +++ b/backend/app/services/image_processing.py @@ -0,0 +1,24 @@ +import numpy as np +from PIL import Image +from scipy.ndimage import zoom + +MAX_INFERENCE_SIZE = 1024 + + +def prepare_for_inference(image: Image.Image) -> tuple[Image.Image, float]: + """Resize for model input. Returns (resized_image, scale_factor).""" + w, h = image.size + scale = MAX_INFERENCE_SIZE / max(w, h) + if scale < 1.0: + new_size = (int(w * scale), int(h * scale)) + return image.resize(new_size, Image.LANCZOS), scale + return image, 1.0 + + +def upscale_saliency(saliency: np.ndarray, target_h: int, target_w: int) -> np.ndarray: + """Upscale saliency map to original image dimensions.""" + if saliency.shape == (target_h, target_w): + return saliency + h_scale = target_h / saliency.shape[0] + w_scale = target_w / saliency.shape[1] + return zoom(saliency, (h_scale, w_scale), order=1) diff --git a/backend/app/services/insights.py b/backend/app/services/insights.py new file mode 100644 index 0000000..f619cd2 --- /dev/null +++ b/backend/app/services/insights.py @@ -0,0 +1,200 @@ +"""Rule-based insights engine for visual attention analysis. + +Generates actionable text insights from analysis metrics — +no AI needed, just conditional logic on the computed data. +""" + + +def generate_insights(analysis) -> list[dict]: + """Generate insights from a completed analysis. + + Args: + analysis: Analysis ORM object with overall_score, hotspots, gaze_sequence, + image_width, image_height. + + Returns: + List of dicts with keys: type (info|success|warning), title, description. + """ + insights = [] + + score = analysis.overall_score + hotspots = analysis.hotspots or [] + gaze_seq = analysis.gaze_sequence or [] + w = analysis.image_width + h = analysis.image_height + + if score is None or not hotspots: + return insights + + # 1. Attention Concentration + if score >= 60: + insights.append({ + "type": "success", + "title": "Strong focal point", + "description": ( + f"Attention is highly concentrated (score {score:.0f}/100). " + "Most viewers will fixate on the same areas — your design has a clear visual hierarchy." + ), + }) + elif score >= 30: + insights.append({ + "type": "info", + "title": "Moderate attention spread", + "description": ( + f"Attention is moderately distributed (score {score:.0f}/100). " + "Viewers will notice several areas. Consider whether your primary message " + "is prominent enough to stand out." + ), + }) + else: + insights.append({ + "type": "warning", + "title": "Diffuse attention", + "description": ( + f"Attention is widely spread (score {score:.0f}/100). " + "No single element dominates — viewers may struggle to find your key message. " + "Consider increasing contrast, size, or whitespace around your hero element." + ), + }) + + # 2. Dominant Focal Point + if len(hotspots) >= 2: + top = hotspots[0]["intensity"] + second = hotspots[1]["intensity"] + if top > 0 and second > 0: + ratio = top / second + if ratio >= 3: + insights.append({ + "type": "success", + "title": "Clear dominant element", + "description": ( + f"The top hotspot is {ratio:.1f}x stronger than the second — " + "your design has one unmistakable focal point. This is ideal for " + "ads with a single hero product or CTA." + ), + }) + elif ratio >= 1.5: + insights.append({ + "type": "info", + "title": "Moderate focal dominance", + "description": ( + f"The top hotspot is {ratio:.1f}x stronger than the second. " + "There's a primary focus but competing elements may split attention." + ), + }) + else: + insights.append({ + "type": "warning", + "title": "Competing focal points", + "description": ( + "The top two hotspots have similar intensity — viewers' eyes will " + "bounce between them. If one element is your priority, consider " + "making it larger, brighter, or more isolated." + ), + }) + + # 3. Gaze Entry Point + if gaze_seq: + first = gaze_seq[0] + x_pct = first.get("x_pct", first["x"] / w * 100 if w else 50) + y_pct = first.get("y_pct", first["y"] / h * 100 if h else 50) + + if y_pct < 33: + v_zone = "top" + elif y_pct < 66: + v_zone = "middle" + else: + v_zone = "bottom" + + if x_pct < 33: + h_zone = "left" + elif x_pct < 66: + h_zone = "center" + else: + h_zone = "right" + + position = f"{v_zone}-{h_zone}" + + insights.append({ + "type": "info", + "title": f"First fixation: {position}", + "description": ( + f"Viewers are predicted to look at the {position} area first " + f"({x_pct:.0f}% from left, {y_pct:.0f}% from top). " + "Place your most important message or brand element here for maximum impact." + ), + }) + + # 4. Spatial Balance + if len(hotspots) >= 3: + quadrants = {"TL": 0, "TR": 0, "BL": 0, "BR": 0} + for hs in hotspots: + cx = hs.get("center_x", hs["x"]) + cy = hs.get("center_y", hs["y"]) + q_h = "L" if cx < w / 2 else "R" + q_v = "T" if cy < h / 2 else "B" + quadrants[q_v + q_h] += 1 + + max_q = max(quadrants.values()) + max_q_name = { + "TL": "top-left", "TR": "top-right", + "BL": "bottom-left", "BR": "bottom-right", + } + dominant = [k for k, v in quadrants.items() if v == max_q] + + if max_q >= 3: + zone = max_q_name[dominant[0]] + insights.append({ + "type": "warning", + "title": f"Attention clusters in {zone}", + "description": ( + f"{max_q} of {len(hotspots)} hotspots fall in the {zone} quadrant. " + "The opposite areas of your design may go largely unnoticed. " + "Consider rebalancing if key information is in the neglected zones." + ), + }) + + # 5. Edge Risk + edge_threshold = 0.10 # 10% from edge + edge_hotspots = [] + for hs in hotspots[:3]: # check top 3 + cx = hs.get("center_x", hs["x"]) + cy = hs.get("center_y", hs["y"]) + near_edge = ( + cx < w * edge_threshold + or cx > w * (1 - edge_threshold) + or cy < h * edge_threshold + or cy > h * (1 - edge_threshold) + ) + if near_edge: + edge_hotspots.append(hs["rank"]) + + if edge_hotspots: + ranks = ", ".join(f"#{r}" for r in edge_hotspots) + insights.append({ + "type": "warning", + "title": "Key attention near edge", + "description": ( + f"Hotspot {ranks} {'is' if len(edge_hotspots) == 1 else 'are'} close to the " + "image edge. When printed or cropped, this attention area may be partially cut off. " + "Consider adding safe margins around critical content." + ), + }) + + # 6. Attention Drop-off + if len(hotspots) >= 3: + intensities = [hs["intensity"] for hs in hotspots[:5]] + if intensities[0] > 0: + dropoff = intensities[-1] / intensities[0] + if dropoff < 0.2: + insights.append({ + "type": "info", + "title": "Steep attention drop-off", + "description": ( + f"Attention drops sharply from hotspot #1 ({intensities[0]:.0%}) to " + f"#{len(intensities)} ({intensities[-1]:.0%}). This means the design " + "has a very strong primary focus but secondary elements get little attention." + ), + }) + + return insights diff --git a/backend/app/services/report_generator.py b/backend/app/services/report_generator.py new file mode 100644 index 0000000..ef2e02d --- /dev/null +++ b/backend/app/services/report_generator.py @@ -0,0 +1,439 @@ +import io +import os +from datetime import datetime + +from PIL import Image as PILImage +from reportlab.lib import colors +from reportlab.lib.pagesizes import A4 +from reportlab.lib.styles import ParagraphStyle +from reportlab.lib.units import inch, mm +from reportlab.pdfbase import pdfmetrics +from reportlab.pdfbase.ttfonts import TTFont +from reportlab.platypus import ( + Image, + PageBreak, + Paragraph, + SimpleDocTemplate, + Spacer, + Table, + TableStyle, +) + +# ─── Colors ────────────────────────────────────────── +NAVY = colors.HexColor("#1a1a2e") +GOLD = colors.HexColor("#ffc407") +GOLD_LIGHT = colors.HexColor("#fff8e0") +LIGHT_GRAY = colors.HexColor("#f5f5f5") +MEDIUM_GRAY = colors.HexColor("#666666") +DARK_TEXT = colors.HexColor("#333333") +WHITE = colors.white +GREEN = colors.HexColor("#16a34a") +BLUE = colors.HexColor("#2563eb") +AMBER = colors.HexColor("#d97706") +PURPLE = colors.HexColor("#7c3aed") + +# ─── Register Montserrat fonts ────────────────────── +FONT_DIR = os.path.join(os.path.dirname(__file__), "fonts") + +pdfmetrics.registerFont(TTFont("Montserrat", os.path.join(FONT_DIR, "Montserrat-Regular.ttf"))) +pdfmetrics.registerFont(TTFont("Montserrat-Bold", os.path.join(FONT_DIR, "Montserrat-Bold.ttf"))) +pdfmetrics.registerFont(TTFont("Montserrat-SemiBold", os.path.join(FONT_DIR, "Montserrat-SemiBold.ttf"))) + +pdfmetrics.registerFontFamily( + "Montserrat", + normal="Montserrat", + bold="Montserrat-Bold", +) + + +def _bytes_to_image(data: bytes) -> io.BytesIO: + buf = io.BytesIO(data) + buf.seek(0) + return buf + + +def _make_styles(): + title = ParagraphStyle( + "Title", + fontName="Montserrat-Bold", + fontSize=32, + textColor=NAVY, + spaceAfter=6, + leading=38, + ) + subtitle = ParagraphStyle( + "Subtitle", + fontName="Montserrat", + fontSize=14, + textColor=GOLD, + spaceAfter=20, + leading=18, + ) + heading = ParagraphStyle( + "Heading", + fontName="Montserrat-Bold", + fontSize=18, + textColor=NAVY, + spaceBefore=12, + spaceAfter=8, + leading=22, + ) + subheading = ParagraphStyle( + "Subheading", + fontName="Montserrat-SemiBold", + fontSize=13, + textColor=NAVY, + spaceBefore=8, + spaceAfter=4, + leading=16, + ) + body = ParagraphStyle( + "Body", + fontName="Montserrat", + fontSize=10, + textColor=DARK_TEXT, + spaceAfter=6, + leading=14, + ) + body_small = ParagraphStyle( + "BodySmall", + fontName="Montserrat", + fontSize=9, + textColor=MEDIUM_GRAY, + spaceAfter=4, + leading=12, + ) + meta_label = ParagraphStyle( + "MetaLabel", + fontName="Montserrat-SemiBold", + fontSize=10, + textColor=MEDIUM_GRAY, + spaceAfter=2, + ) + meta_value = ParagraphStyle( + "MetaValue", + fontName="Montserrat-Bold", + fontSize=14, + textColor=NAVY, + spaceAfter=8, + ) + footer = ParagraphStyle( + "Footer", + fontName="Montserrat", + fontSize=8, + textColor=MEDIUM_GRAY, + alignment=1, # center + ) + return { + "title": title, + "subtitle": subtitle, + "heading": heading, + "subheading": subheading, + "body": body, + "body_small": body_small, + "meta_label": meta_label, + "meta_value": meta_value, + "footer": footer, + } + + +def _insight_type_label(t: str) -> tuple[str, colors.Color]: + return { + "success": ("STRENGTH", GREEN), + "warning": ("ATTENTION", AMBER), + "info": ("INSIGHT", BLUE), + }.get(t, ("INSIGHT", BLUE)) + + +def _build_insight_table(insights: list[dict], styles: dict, is_ai: bool = False) -> list: + """Build styled insight rows as ReportLab elements.""" + elements = [] + for insight in insights: + label_text, label_color = _insight_type_label(insight["type"]) + accent = PURPLE if is_ai else label_color + + # Build a mini table for each insight card + badge = f'{label_text}' + title = f'{insight["title"]}' + desc = f'{insight["description"]}' + + content = Paragraph(f"{badge}
{title}
{desc}", styles["body"]) + + t = Table( + [[content]], + colWidths=[170 * mm], + ) + t.setStyle(TableStyle([ + ("BACKGROUND", (0, 0), (-1, -1), GOLD_LIGHT if is_ai else LIGHT_GRAY), + ("LEFTPADDING", (0, 0), (-1, -1), 10), + ("RIGHTPADDING", (0, 0), (-1, -1), 10), + ("TOPPADDING", (0, 0), (-1, -1), 8), + ("BOTTOMPADDING", (0, 0), (-1, -1), 8), + ("ROUNDEDCORNERS", [4, 4, 4, 4]), + ("LINEBEFOREDECORCOLOR", (0, 0), (0, -1), accent), + # Left accent border + ("LINEBEFORE", (0, 0), (0, -1), 3, accent), + ])) + elements.append(t) + elements.append(Spacer(1, 4)) + + return elements + + +def generate_report( + analysis, + original_image: bytes, + heatmap_image: bytes, + gaze_image: bytes, + aois: list, + rule_insights: list[dict] | None = None, + ai_insights: list[dict] | None = None, + ai_cost_usd: float | None = None, +) -> bytes: + """Generate a professional PDF report for an analysis.""" + buffer = io.BytesIO() + doc = SimpleDocTemplate( + buffer, + pagesize=A4, + topMargin=20 * mm, + bottomMargin=20 * mm, + leftMargin=15 * mm, + rightMargin=15 * mm, + ) + + styles = _make_styles() + elements = [] + + # ─── Cover Page ────────────────────────────────────────── + elements.append(Spacer(1, 50)) + elements.append(Paragraph("OliVAS", styles["title"])) + elements.append(Paragraph("Visual Attention Analysis Report", styles["subtitle"])) + elements.append(Spacer(1, 8)) + + # Gold divider line + divider = Table([[""]], colWidths=[60 * mm], rowHeights=[2]) + divider.setStyle(TableStyle([ + ("BACKGROUND", (0, 0), (-1, -1), GOLD), + ("LEFTPADDING", (0, 0), (-1, -1), 0), + ("RIGHTPADDING", (0, 0), (-1, -1), 0), + ("TOPPADDING", (0, 0), (-1, -1), 0), + ("BOTTOMPADDING", (0, 0), (-1, -1), 0), + ])) + elements.append(divider) + elements.append(Spacer(1, 20)) + + # Metadata grid + meta_data = [ + ["ANALYSIS", "MODEL", "DATE", "IMAGE SIZE"], + [ + analysis.name, + analysis.model_used.replace("_", " ").title(), + datetime.now().strftime("%B %d, %Y"), + f"{analysis.image_width} x {analysis.image_height}", + ], + ] + meta_table = Table(meta_data, colWidths=[45 * mm] * 4) + meta_table.setStyle(TableStyle([ + ("FONTNAME", (0, 0), (-1, 0), "Montserrat-SemiBold"), + ("FONTSIZE", (0, 0), (-1, 0), 8), + ("TEXTCOLOR", (0, 0), (-1, 0), MEDIUM_GRAY), + ("FONTNAME", (0, 1), (-1, 1), "Montserrat-Bold"), + ("FONTSIZE", (0, 1), (-1, 1), 11), + ("TEXTCOLOR", (0, 1), (-1, 1), NAVY), + ("TOPPADDING", (0, 0), (-1, -1), 4), + ("BOTTOMPADDING", (0, 0), (-1, -1), 4), + ("VALIGN", (0, 0), (-1, -1), "TOP"), + ])) + elements.append(meta_table) + elements.append(Spacer(1, 10)) + + # Score badge + if analysis.overall_score is not None: + score = analysis.overall_score + score_color = GREEN if score >= 60 else (AMBER if score >= 30 else colors.HexColor("#ef4444")) + score_text = f'ATTENTION SCORE
{score:.0f} / 100' + elements.append(Paragraph(score_text, styles["body"])) + elements.append(Spacer(1, 10)) + + # Thumbnail on cover + max_width = 160 * mm + img = PILImage.open(io.BytesIO(original_image)) + aspect = img.width / img.height + img_width = min(max_width, 130 * mm) + img_height = img_width / aspect + if img_height > 90 * mm: + img_height = 90 * mm + img_width = img_height * aspect + elements.append(Image(_bytes_to_image(original_image), width=img_width, height=img_height)) + + elements.append(PageBreak()) + + # ─── Heatmap Page ──────────────────────────────────────── + elements.append(Paragraph("Attention Heatmap", styles["heading"])) + elements.append( + Paragraph( + "Areas highlighted in warm colors (red/yellow) indicate high predicted " + "attention during the first 3-5 seconds of viewing. Cool colors (blue) " + "indicate lower attention probability.", + styles["body"], + ) + ) + elements.append(Spacer(1, 8)) + elements.append(Image(_bytes_to_image(heatmap_image), width=img_width, height=img_height)) + + elements.append(PageBreak()) + + # ─── Gaze Sequence Page ────────────────────────────────── + elements.append(Paragraph("Predicted Gaze Sequence", styles["heading"])) + elements.append( + Paragraph( + "Numbered points show the predicted order in which viewers will " + "fixate on different areas of the design. Point #1 is where the eye " + "lands first.", + styles["body"], + ) + ) + elements.append(Spacer(1, 8)) + elements.append(Image(_bytes_to_image(gaze_image), width=img_width, height=img_height)) + + if analysis.gaze_sequence: + elements.append(Spacer(1, 10)) + elements.append(Paragraph("Fixation Details", styles["subheading"])) + table_data = [["#", "Position", "From Left", "From Top", "Probability"]] + for point in analysis.gaze_sequence: + table_data.append([ + str(point["rank"]), + f"({point['x']}, {point['y']})", + f"{point['x_pct']:.1f}%", + f"{point['y_pct']:.1f}%", + f"{point['probability']:.1%}", + ]) + t = Table(table_data, colWidths=[25, 80, 60, 60, 70]) + t.setStyle(TableStyle([ + ("BACKGROUND", (0, 0), (-1, 0), NAVY), + ("TEXTCOLOR", (0, 0), (-1, 0), WHITE), + ("FONTNAME", (0, 0), (-1, 0), "Montserrat-SemiBold"), + ("FONTNAME", (0, 1), (-1, -1), "Montserrat"), + ("FONTSIZE", (0, 0), (-1, -1), 9), + ("GRID", (0, 0), (-1, -1), 0.5, colors.HexColor("#dddddd")), + ("ROWBACKGROUNDS", (0, 1), (-1, -1), [WHITE, LIGHT_GRAY]), + ("ALIGN", (0, 0), (-1, -1), "CENTER"), + ("TOPPADDING", (0, 0), (-1, -1), 5), + ("BOTTOMPADDING", (0, 0), (-1, -1), 5), + ])) + elements.append(t) + + # ─── Hotspots Page ─────────────────────────────────────── + if analysis.hotspots: + elements.append(PageBreak()) + elements.append(Paragraph("Attention Hotspots", styles["heading"])) + elements.append( + Paragraph( + "The top regions ranked by predicted attention intensity. Higher rank " + "means more predicted visual attention.", + styles["body"], + ) + ) + elements.append(Spacer(1, 8)) + + hs_data = [["Rank", "Position (x, y)", "Intensity"]] + for hs in analysis.hotspots: + cx = hs.get("center_x", hs["x"]) + cy = hs.get("center_y", hs["y"]) + hs_data.append([ + f"#{hs['rank']}", + f"({cx}, {cy})", + f"{hs['intensity']:.2%}", + ]) + t = Table(hs_data, colWidths=[50, 120, 80]) + t.setStyle(TableStyle([ + ("BACKGROUND", (0, 0), (-1, 0), NAVY), + ("TEXTCOLOR", (0, 0), (-1, 0), WHITE), + ("FONTNAME", (0, 0), (-1, 0), "Montserrat-SemiBold"), + ("FONTNAME", (0, 1), (-1, -1), "Montserrat"), + ("FONTSIZE", (0, 0), (-1, -1), 9), + ("GRID", (0, 0), (-1, -1), 0.5, colors.HexColor("#dddddd")), + ("ROWBACKGROUNDS", (0, 1), (-1, -1), [WHITE, LIGHT_GRAY]), + ("ALIGN", (0, 0), (-1, -1), "CENTER"), + ("TOPPADDING", (0, 0), (-1, -1), 5), + ("BOTTOMPADDING", (0, 0), (-1, -1), 5), + ])) + elements.append(t) + + # ─── Insights Page ─────────────────────────────────────── + has_rule = rule_insights and len(rule_insights) > 0 + has_ai = ai_insights and len(ai_insights) > 0 + + if has_rule or has_ai: + elements.append(PageBreak()) + elements.append(Paragraph("Analysis Insights", styles["heading"])) + + if has_rule: + elements.append(Paragraph("Rule-Based Insights", styles["subheading"])) + elements.append( + Paragraph( + "Automatically generated observations based on the attention metrics.", + styles["body_small"], + ) + ) + elements.append(Spacer(1, 6)) + elements.extend(_build_insight_table(rule_insights, styles, is_ai=False)) + elements.append(Spacer(1, 12)) + + if has_ai: + elements.append(Paragraph("AI Design Analysis", styles["subheading"])) + ai_note = "Generated by Claude Sonnet 4.6 — context-aware design recommendations." + if ai_cost_usd is not None: + ai_note += f" (Cost: ${ai_cost_usd:.4f})" + elements.append(Paragraph(ai_note, styles["body_small"])) + elements.append(Spacer(1, 6)) + elements.extend(_build_insight_table(ai_insights, styles, is_ai=True)) + + # ─── AOI Page (if any) ─────────────────────────────────── + if aois: + elements.append(PageBreak()) + elements.append(Paragraph("Areas of Interest", styles["heading"])) + elements.append( + Paragraph( + "User-defined regions analyzed for predicted attention capture. " + "Density > 1.0 means the region captures more attention than its " + "size would suggest.", + styles["body"], + ) + ) + elements.append(Spacer(1, 8)) + + aoi_data = [["Region", "Attention %", "Area %", "Density"]] + for aoi in aois: + aoi_data.append([ + aoi.label, + f"{aoi.attention_pct:.1f}%", + f"{aoi.area_pct:.1f}%", + f"{aoi.attention_density:.2f}x", + ]) + t = Table(aoi_data, colWidths=[100, 70, 70, 70]) + t.setStyle(TableStyle([ + ("BACKGROUND", (0, 0), (-1, 0), NAVY), + ("TEXTCOLOR", (0, 0), (-1, 0), WHITE), + ("FONTNAME", (0, 0), (-1, 0), "Montserrat-SemiBold"), + ("FONTNAME", (0, 1), (-1, -1), "Montserrat"), + ("FONTSIZE", (0, 0), (-1, -1), 9), + ("GRID", (0, 0), (-1, -1), 0.5, colors.HexColor("#dddddd")), + ("ROWBACKGROUNDS", (0, 1), (-1, -1), [WHITE, LIGHT_GRAY]), + ("ALIGN", (1, 0), (-1, -1), "CENTER"), + ("TOPPADDING", (0, 0), (-1, -1), 5), + ("BOTTOMPADDING", (0, 0), (-1, -1), 5), + ])) + elements.append(t) + + # ─── Footer ────────────────────────────────────────────── + elements.append(Spacer(1, 30)) + elements.append( + Paragraph( + "Generated by OliVAS — Open-Source Visual Attention Software by OLIVER", + styles["footer"], + ) + ) + + doc.build(elements) + return buffer.getvalue() diff --git a/backend/app/services/saliency/__init__.py b/backend/app/services/saliency/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/backend/app/services/saliency/base.py b/backend/app/services/saliency/base.py new file mode 100644 index 0000000..238e23b --- /dev/null +++ b/backend/app/services/saliency/base.py @@ -0,0 +1,19 @@ +from abc import ABC, abstractmethod + +import numpy as np +from PIL import Image + + +class BaseSaliencyModel(ABC): + @abstractmethod + def load(self) -> None: + ... + + @abstractmethod + def predict(self, image: Image.Image) -> np.ndarray: + """Returns 2D array (H, W) with values in [0, 1].""" + ... + + @abstractmethod + def get_name(self) -> str: + ... diff --git a/backend/app/services/saliency/deepgaze.py b/backend/app/services/saliency/deepgaze.py new file mode 100644 index 0000000..c9c03cd --- /dev/null +++ b/backend/app/services/saliency/deepgaze.py @@ -0,0 +1,93 @@ +import logging + +import numpy as np +import torch +from PIL import Image +from scipy.ndimage import zoom as scipy_zoom +from scipy.special import logsumexp + +from app.services.saliency.base import BaseSaliencyModel + +logger = logging.getLogger("olivas.deepgaze") + +# Map variant keys to deepgaze_pytorch classes +VARIANT_MAP = { + "I": ("DeepGazeI", "DeepGaze I"), + "IIE": ("DeepGazeIIE", "DeepGaze IIE"), + "III": ("DeepGazeIII", "DeepGaze III"), +} + + +class DeepGazeModel(BaseSaliencyModel): + """Unified wrapper for all DeepGaze model variants (I, IIE, III).""" + + def __init__(self, variant: str = "IIE", device: str = "cpu"): + if variant not in VARIANT_MAP: + raise ValueError(f"Unknown DeepGaze variant: {variant}. Choose from {list(VARIANT_MAP.keys())}") + self.variant = variant + self.class_name, self.display_name = VARIANT_MAP[variant] + self.device = torch.device(device) + self.model = None + self.centerbias_template = None + + def load(self) -> None: + import deepgaze_pytorch + + logger.info(f"Loading {self.display_name} on {self.device}...") + model_cls = getattr(deepgaze_pytorch, self.class_name) + self.model = model_cls(pretrained=True).to(self.device) + self.model.eval() + + self._create_default_centerbias() + logger.info(f"{self.display_name} loaded successfully") + + def _create_default_centerbias(self): + """Create a generic center bias prior (Gaussian centered).""" + size = 1024 + x = np.linspace(-1, 1, size) + y = np.linspace(-1, 1, size) + xx, yy = np.meshgrid(x, y) + self.centerbias_template = -0.5 * (xx**2 + yy**2) / 0.5**2 + + def predict(self, image: Image.Image) -> np.ndarray: + img_np = np.array(image.convert("RGB")) + h, w = img_np.shape[:2] + + # Prepare image tensor [1, C, H, W] + image_tensor = ( + torch.tensor([img_np.transpose(2, 0, 1)]) + .float() + .to(self.device) + ) + + # Prepare centerbias + cb = scipy_zoom( + self.centerbias_template, + (h / self.centerbias_template.shape[0], w / self.centerbias_template.shape[1]), + order=0, + ) + cb -= logsumexp(cb) + centerbias_tensor = ( + torch.tensor([cb]).float().to(self.device) + ) + + with torch.no_grad(): + log_density = self.model(image_tensor, centerbias_tensor) + + saliency = torch.exp(log_density).cpu().numpy().squeeze() + + # Normalize to [0, 1] + sal_min, sal_max = saliency.min(), saliency.max() + if sal_max - sal_min > 1e-10: + saliency = (saliency - sal_min) / (sal_max - sal_min) + else: + saliency = np.zeros_like(saliency) + + return saliency + + def get_name(self) -> str: + return self.display_name + + +# Backwards-compatible alias +DeepGazeIIEModel = lambda device="cpu": DeepGazeModel(variant="IIE", device=device) diff --git a/backend/app/services/saliency/model_manager.py b/backend/app/services/saliency/model_manager.py new file mode 100644 index 0000000..3e38b10 --- /dev/null +++ b/backend/app/services/saliency/model_manager.py @@ -0,0 +1,55 @@ +import logging + +import numpy as np +from PIL import Image + +from app.services.saliency.base import BaseSaliencyModel + +logger = logging.getLogger("olivas.model_manager") + + +class ModelManager: + def __init__(self): + self.models: dict[str, BaseSaliencyModel] = {} + self.default_model = "deepgaze_iie" + + def load_models(self, device: str = "cpu") -> None: + from app.services.saliency.deepgaze import DeepGazeModel + + variants = [ + ("deepgaze_i", "I"), + ("deepgaze_iie", "IIE"), + ("deepgaze_iii", "III"), + ] + + for key, variant in variants: + try: + model = DeepGazeModel(variant=variant, device=device) + model.load() + self.models[key] = model + logger.info(f"Loaded {model.get_name()}") + except Exception as e: + logger.warning(f"Failed to load DeepGaze {variant}: {e}") + + def predict(self, image: Image.Image, model_name: str | None = None) -> np.ndarray: + name = model_name or self.default_model + if name not in self.models: + raise RuntimeError(f"Model '{name}' not loaded. Available: {list(self.models.keys())}") + return self.models[name].predict(image) + + def list_models(self) -> list[dict]: + return [ + {"id": key, "name": model.get_name()} for key, model in self.models.items() + ] + + def cleanup(self): + self.models.clear() + try: + import torch + if torch.cuda.is_available(): + torch.cuda.empty_cache() + except ImportError: + pass + + +model_manager = ModelManager() diff --git a/backend/app/services/storage.py b/backend/app/services/storage.py new file mode 100644 index 0000000..b650568 --- /dev/null +++ b/backend/app/services/storage.py @@ -0,0 +1,44 @@ +import os +from pathlib import Path + +import aiofiles + +from app.config import settings + + +class LocalStorage: + def __init__(self): + self.base_dir = Path(settings.UPLOAD_DIR) + self.base_dir.mkdir(parents=True, exist_ok=True) + + def analysis_dir(self, analysis_id: str) -> Path: + path = self.base_dir / analysis_id + path.mkdir(parents=True, exist_ok=True) + return path + + async def save_bytes(self, data: bytes, analysis_id: str, filename: str) -> str: + dir_path = self.analysis_dir(analysis_id) + file_path = dir_path / filename + async with aiofiles.open(file_path, "wb") as f: + await f.write(data) + return str(file_path) + + async def load_bytes(self, analysis_id: str, filename: str) -> bytes: + file_path = self.analysis_dir(analysis_id) / filename + async with aiofiles.open(file_path, "rb") as f: + return await f.read() + + def get_path(self, analysis_id: str, filename: str) -> Path: + return self.analysis_dir(analysis_id) / filename + + def exists(self, analysis_id: str, filename: str) -> bool: + return (self.analysis_dir(analysis_id) / filename).exists() + + async def delete_analysis(self, analysis_id: str) -> None: + import shutil + dir_path = self.base_dir / analysis_id + if dir_path.exists(): + shutil.rmtree(dir_path) + + +storage = LocalStorage() diff --git a/backend/pyproject.toml b/backend/pyproject.toml new file mode 100644 index 0000000..92ffe7c --- /dev/null +++ b/backend/pyproject.toml @@ -0,0 +1,45 @@ +[project] +name = "olivas-backend" +version = "0.1.0" +description = "OliVAS - Open-Source Visual Attention Software backend" +requires-python = ">=3.12" +dependencies = [ + "fastapi>=0.115.0", + "uvicorn[standard]>=0.30.0", + "python-multipart>=0.0.9", + "sqlalchemy[asyncio]>=2.0", + "alembic>=1.13", + "asyncpg>=0.29", + "pydantic>=2.0", + "pydantic-settings>=2.0", + "pillow>=10.0", + "numpy>=1.26", + "torch>=2.1", + "torchvision>=0.16", + "scipy>=1.11", + "matplotlib>=3.8", + "scikit-image>=0.22", + "reportlab>=4.0", + "aiofiles>=23.0", + "anthropic>=0.40", +] + +[project.optional-dependencies] +dev = [ + "pytest>=8.0", + "pytest-asyncio>=0.23", + "httpx>=0.27", + "ruff>=0.4", +] + +[build-system] +requires = ["setuptools>=68.0"] +build-backend = "setuptools.build_meta" + +[tool.ruff] +line-length = 100 +target-version = "py312" + +[tool.pytest.ini_options] +asyncio_mode = "auto" +testpaths = ["tests"] diff --git a/backend/tests/__init__.py b/backend/tests/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/backend/tests/conftest.py b/backend/tests/conftest.py new file mode 100644 index 0000000..57f7ece --- /dev/null +++ b/backend/tests/conftest.py @@ -0,0 +1,51 @@ +import asyncio + +import pytest +import pytest_asyncio +from httpx import ASGITransport, AsyncClient +from sqlalchemy.ext.asyncio import AsyncSession, async_sessionmaker, create_async_engine + +from app.main import app +from app.models.base import Base +from app.db.session import get_db + + +# Use SQLite for tests +TEST_DATABASE_URL = "sqlite+aiosqlite:///./test.db" + + +@pytest.fixture(scope="session") +def event_loop(): + loop = asyncio.new_event_loop() + yield loop + loop.close() + + +@pytest_asyncio.fixture +async def db_engine(): + engine = create_async_engine(TEST_DATABASE_URL, echo=False) + async with engine.begin() as conn: + await conn.run_sync(Base.metadata.create_all) + yield engine + async with engine.begin() as conn: + await conn.run_sync(Base.metadata.drop_all) + await engine.dispose() + + +@pytest_asyncio.fixture +async def db_session(db_engine): + session_factory = async_sessionmaker(db_engine, class_=AsyncSession, expire_on_commit=False) + async with session_factory() as session: + yield session + + +@pytest_asyncio.fixture +async def client(db_session): + async def override_get_db(): + yield db_session + + app.dependency_overrides[get_db] = override_get_db + transport = ASGITransport(app=app) + async with AsyncClient(transport=transport, base_url="http://test") as ac: + yield ac + app.dependency_overrides.clear() diff --git a/backend/tests/test_analysis.py b/backend/tests/test_analysis.py new file mode 100644 index 0000000..305c4c2 --- /dev/null +++ b/backend/tests/test_analysis.py @@ -0,0 +1,94 @@ +import numpy as np +import pytest + +from app.services.gaze_sequence import extract_gaze_sequence +from app.services.aoi_analysis import compute_aoi_attention +from app.services.heatmap import generate_heatmap_overlay, generate_standalone_heatmap +from app.services.image_processing import prepare_for_inference, upscale_saliency +from PIL import Image + + +class TestGazeSequence: + def test_extracts_correct_number_of_fixations(self): + saliency = np.random.rand(100, 100) + result = extract_gaze_sequence(saliency, num_fixations=5) + assert len(result) == 5 + + def test_fixations_are_ranked(self): + saliency = np.random.rand(100, 100) + result = extract_gaze_sequence(saliency, num_fixations=3) + ranks = [p["rank"] for p in result] + assert ranks == [1, 2, 3] + + def test_first_fixation_is_at_peak(self): + saliency = np.zeros((100, 100)) + saliency[50, 75] = 1.0 # Set a clear peak + result = extract_gaze_sequence(saliency, num_fixations=1) + assert result[0]["x"] == 75 + assert result[0]["y"] == 50 + + def test_coordinates_have_percentages(self): + saliency = np.random.rand(200, 300) + result = extract_gaze_sequence(saliency, num_fixations=1) + assert 0 <= result[0]["x_pct"] <= 100 + assert 0 <= result[0]["y_pct"] <= 100 + + +class TestAOIAnalysis: + def test_full_image_aoi_gets_100_percent(self): + saliency = np.ones((100, 100)) + regions = [{"x": 0, "y": 0, "width": 100, "height": 100}] + result = compute_aoi_attention(saliency, regions) + assert abs(result[0]["attention_pct"] - 100.0) < 0.1 + + def test_half_image_aoi(self): + saliency = np.ones((100, 100)) + regions = [{"x": 0, "y": 0, "width": 50, "height": 100}] + result = compute_aoi_attention(saliency, regions) + assert abs(result[0]["attention_pct"] - 50.0) < 1.0 + + def test_density_calculation(self): + saliency = np.zeros((100, 100)) + saliency[0:10, 0:10] = 1.0 # High saliency in small region + regions = [{"x": 0, "y": 0, "width": 10, "height": 10}] + result = compute_aoi_attention(saliency, regions) + assert result[0]["attention_density"] > 1.0 + + def test_zero_saliency(self): + saliency = np.zeros((100, 100)) + regions = [{"x": 0, "y": 0, "width": 50, "height": 50}] + result = compute_aoi_attention(saliency, regions) + assert result[0]["attention_pct"] == 0.0 + + +class TestHeatmap: + def test_generates_overlay(self): + img = Image.new("RGB", (100, 100), color="white") + saliency = np.random.rand(100, 100) + result = generate_heatmap_overlay(img, saliency) + assert result.size == (100, 100) + assert result.mode == "RGB" + + def test_generates_standalone(self): + saliency = np.random.rand(100, 100) + result = generate_standalone_heatmap(saliency) + assert result.size == (100, 100) + + +class TestImageProcessing: + def test_resize_large_image(self): + img = Image.new("RGB", (2000, 1000)) + resized, scale = prepare_for_inference(img) + assert max(resized.size) <= 1024 + assert scale < 1.0 + + def test_no_resize_small_image(self): + img = Image.new("RGB", (500, 300)) + resized, scale = prepare_for_inference(img) + assert resized.size == (500, 300) + assert scale == 1.0 + + def test_upscale_saliency(self): + saliency = np.random.rand(50, 50) + result = upscale_saliency(saliency, 200, 300) + assert result.shape == (200, 300) diff --git a/docker-compose.dev.yml b/docker-compose.dev.yml new file mode 100644 index 0000000..963cf3b --- /dev/null +++ b/docker-compose.dev.yml @@ -0,0 +1,16 @@ +services: + backend: + build: + context: ./backend + command: uvicorn app.main:app --host 0.0.0.0 --port 8000 --reload + volumes: + - ./backend:/app + - uploads:/app/data/uploads + + frontend: + build: + context: ./frontend + command: npm run dev -- --host 0.0.0.0 + volumes: + - ./frontend:/app + - /app/node_modules diff --git a/docker-compose.yml b/docker-compose.yml new file mode 100644 index 0000000..4e0954c --- /dev/null +++ b/docker-compose.yml @@ -0,0 +1,42 @@ +services: + postgres: + image: postgres:16-alpine + ports: + - "5453:5432" + environment: + POSTGRES_USER: olivas + POSTGRES_PASSWORD: olivas + POSTGRES_DB: olivas + volumes: + - pgdata:/var/lib/postgresql/data + healthcheck: + test: ["CMD-SHELL", "pg_isready -U olivas"] + interval: 5s + timeout: 5s + retries: 5 + + backend: + build: ./backend + ports: + - "8000:8000" + environment: + DATABASE_URL: postgresql+asyncpg://olivas:olivas@postgres:5432/olivas + UPLOAD_DIR: /app/data/uploads + DEVICE: auto + CORS_ORIGINS: http://localhost:1577 + volumes: + - uploads:/app/data/uploads + depends_on: + postgres: + condition: service_healthy + + frontend: + build: ./frontend + ports: + - "1577:1577" + depends_on: + - backend + +volumes: + pgdata: + uploads: diff --git a/frontend/.gitignore b/frontend/.gitignore new file mode 100644 index 0000000..a547bf3 --- /dev/null +++ b/frontend/.gitignore @@ -0,0 +1,24 @@ +# Logs +logs +*.log +npm-debug.log* +yarn-debug.log* +yarn-error.log* +pnpm-debug.log* +lerna-debug.log* + +node_modules +dist +dist-ssr +*.local + +# Editor directories and files +.vscode/* +!.vscode/extensions.json +.idea +.DS_Store +*.suo +*.ntvs* +*.njsproj +*.sln +*.sw? diff --git a/frontend/Dockerfile b/frontend/Dockerfile new file mode 100644 index 0000000..b6252c7 --- /dev/null +++ b/frontend/Dockerfile @@ -0,0 +1,13 @@ +FROM node:20-alpine AS build + +WORKDIR /app +COPY package.json package-lock.json ./ +RUN npm ci +COPY . . +RUN npm run build + +FROM nginx:alpine +COPY --from=build /app/dist /usr/share/nginx/html +COPY nginx.conf /etc/nginx/conf.d/default.conf +EXPOSE 1577 +CMD ["nginx", "-g", "daemon off;"] diff --git a/frontend/README.md b/frontend/README.md new file mode 100644 index 0000000..d2e7761 --- /dev/null +++ b/frontend/README.md @@ -0,0 +1,73 @@ +# React + TypeScript + Vite + +This template provides a minimal setup to get React working in Vite with HMR and some ESLint rules. + +Currently, two official plugins are available: + +- [@vitejs/plugin-react](https://github.com/vitejs/vite-plugin-react/blob/main/packages/plugin-react) uses [Babel](https://babeljs.io/) (or [oxc](https://oxc.rs) when used in [rolldown-vite](https://vite.dev/guide/rolldown)) for Fast Refresh +- [@vitejs/plugin-react-swc](https://github.com/vitejs/vite-plugin-react/blob/main/packages/plugin-react-swc) uses [SWC](https://swc.rs/) for Fast Refresh + +## React Compiler + +The React Compiler is not enabled on this template because of its impact on dev & build performances. To add it, see [this documentation](https://react.dev/learn/react-compiler/installation). + +## Expanding the ESLint configuration + +If you are developing a production application, we recommend updating the configuration to enable type-aware lint rules: + +```js +export default defineConfig([ + globalIgnores(['dist']), + { + files: ['**/*.{ts,tsx}'], + extends: [ + // Other configs... + + // Remove tseslint.configs.recommended and replace with this + tseslint.configs.recommendedTypeChecked, + // Alternatively, use this for stricter rules + tseslint.configs.strictTypeChecked, + // Optionally, add this for stylistic rules + tseslint.configs.stylisticTypeChecked, + + // Other configs... + ], + languageOptions: { + parserOptions: { + project: ['./tsconfig.node.json', './tsconfig.app.json'], + tsconfigRootDir: import.meta.dirname, + }, + // other options... + }, + }, +]) +``` + +You can also install [eslint-plugin-react-x](https://github.com/Rel1cx/eslint-react/tree/main/packages/plugins/eslint-plugin-react-x) and [eslint-plugin-react-dom](https://github.com/Rel1cx/eslint-react/tree/main/packages/plugins/eslint-plugin-react-dom) for React-specific lint rules: + +```js +// eslint.config.js +import reactX from 'eslint-plugin-react-x' +import reactDom from 'eslint-plugin-react-dom' + +export default defineConfig([ + globalIgnores(['dist']), + { + files: ['**/*.{ts,tsx}'], + extends: [ + // Other configs... + // Enable lint rules for React + reactX.configs['recommended-typescript'], + // Enable lint rules for React DOM + reactDom.configs.recommended, + ], + languageOptions: { + parserOptions: { + project: ['./tsconfig.node.json', './tsconfig.app.json'], + tsconfigRootDir: import.meta.dirname, + }, + // other options... + }, + }, +]) +``` diff --git a/frontend/eslint.config.js b/frontend/eslint.config.js new file mode 100644 index 0000000..5e6b472 --- /dev/null +++ b/frontend/eslint.config.js @@ -0,0 +1,23 @@ +import js from '@eslint/js' +import globals from 'globals' +import reactHooks from 'eslint-plugin-react-hooks' +import reactRefresh from 'eslint-plugin-react-refresh' +import tseslint from 'typescript-eslint' +import { defineConfig, globalIgnores } from 'eslint/config' + +export default defineConfig([ + globalIgnores(['dist']), + { + files: ['**/*.{ts,tsx}'], + extends: [ + js.configs.recommended, + tseslint.configs.recommended, + reactHooks.configs.flat.recommended, + reactRefresh.configs.vite, + ], + languageOptions: { + ecmaVersion: 2020, + globals: globals.browser, + }, + }, +]) diff --git a/frontend/index.html b/frontend/index.html new file mode 100644 index 0000000..0772292 --- /dev/null +++ b/frontend/index.html @@ -0,0 +1,16 @@ + + + + + + + + + + OliVAS + + +

+ + + diff --git a/frontend/nginx.conf b/frontend/nginx.conf new file mode 100644 index 0000000..670a2ef --- /dev/null +++ b/frontend/nginx.conf @@ -0,0 +1,18 @@ +server { + listen 1577; + server_name localhost; + root /usr/share/nginx/html; + index index.html; + + location /api { + proxy_pass http://backend:8000; + proxy_set_header Host $host; + proxy_set_header X-Real-IP $remote_addr; + proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for; + client_max_body_size 50M; + } + + location / { + try_files $uri $uri/ /index.html; + } +} diff --git a/frontend/package-lock.json b/frontend/package-lock.json new file mode 100644 index 0000000..2502453 --- /dev/null +++ b/frontend/package-lock.json @@ -0,0 +1,4364 @@ +{ + "name": "frontend", + "version": "0.0.0", + "lockfileVersion": 3, + "requires": true, + "packages": { + "": { + "name": "frontend", + "version": "0.0.0", + "dependencies": { + "@tailwindcss/vite": "^4.2.1", + "@tanstack/react-query": "^5.90.21", + "axios": "^1.13.5", + "konva": "^10.2.0", + "react": "^19.2.0", + "react-dom": "^19.2.0", + "react-dropzone": "^15.0.0", + "react-konva": "^19.2.2", + "react-router-dom": "^7.13.1", + "tailwindcss": "^4.2.1", + "zustand": "^5.0.11" + }, + "devDependencies": { + "@eslint/js": "^9.39.1", + "@types/node": "^24.10.1", + "@types/react": "^19.2.7", + "@types/react-dom": "^19.2.3", + "@vitejs/plugin-react": "^5.1.1", + "eslint": "^9.39.1", + "eslint-plugin-react-hooks": "^7.0.1", + "eslint-plugin-react-refresh": "^0.4.24", + "globals": "^16.5.0", + "typescript": "~5.9.3", + "typescript-eslint": "^8.48.0", + "vite": "^7.3.1" + } + }, + "node_modules/@babel/code-frame": { + "version": "7.29.0", + "resolved": "https://registry.npmjs.org/@babel/code-frame/-/code-frame-7.29.0.tgz", + "integrity": "sha512-9NhCeYjq9+3uxgdtp20LSiJXJvN0FeCtNGpJxuMFZ1Kv3cWUNb6DOhJwUvcVCzKGR66cw4njwM6hrJLqgOwbcw==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/helper-validator-identifier": "^7.28.5", + "js-tokens": "^4.0.0", + "picocolors": "^1.1.1" + }, + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/compat-data": { + "version": "7.29.0", + "resolved": "https://registry.npmjs.org/@babel/compat-data/-/compat-data-7.29.0.tgz", + "integrity": "sha512-T1NCJqT/j9+cn8fvkt7jtwbLBfLC/1y1c7NtCeXFRgzGTsafi68MRv8yzkYSapBnFA6L3U2VSc02ciDzoAJhJg==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/core": { + "version": "7.29.0", + "resolved": "https://registry.npmjs.org/@babel/core/-/core-7.29.0.tgz", + "integrity": "sha512-CGOfOJqWjg2qW/Mb6zNsDm+u5vFQ8DxXfbM09z69p5Z6+mE1ikP2jUXw+j42Pf1XTYED2Rni5f95npYeuwMDQA==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/code-frame": "^7.29.0", + "@babel/generator": "^7.29.0", + "@babel/helper-compilation-targets": "^7.28.6", + "@babel/helper-module-transforms": "^7.28.6", + "@babel/helpers": "^7.28.6", + "@babel/parser": "^7.29.0", + "@babel/template": "^7.28.6", + "@babel/traverse": "^7.29.0", + "@babel/types": "^7.29.0", + "@jridgewell/remapping": "^2.3.5", + "convert-source-map": "^2.0.0", + "debug": "^4.1.0", + "gensync": "^1.0.0-beta.2", + "json5": "^2.2.3", + "semver": "^6.3.1" + }, + "engines": { + "node": ">=6.9.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/babel" + } + }, + "node_modules/@babel/generator": { + "version": "7.29.1", + "resolved": "https://registry.npmjs.org/@babel/generator/-/generator-7.29.1.tgz", + "integrity": "sha512-qsaF+9Qcm2Qv8SRIMMscAvG4O3lJ0F1GuMo5HR/Bp02LopNgnZBC/EkbevHFeGs4ls/oPz9v+Bsmzbkbe+0dUw==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/parser": "^7.29.0", + "@babel/types": "^7.29.0", + "@jridgewell/gen-mapping": "^0.3.12", + "@jridgewell/trace-mapping": "^0.3.28", + "jsesc": "^3.0.2" + }, + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/helper-compilation-targets": { + "version": "7.28.6", + "resolved": "https://registry.npmjs.org/@babel/helper-compilation-targets/-/helper-compilation-targets-7.28.6.tgz", + "integrity": "sha512-JYtls3hqi15fcx5GaSNL7SCTJ2MNmjrkHXg4FSpOA/grxK8KwyZ5bubHsCq8FXCkua6xhuaaBit+3b7+VZRfcA==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/compat-data": "^7.28.6", + "@babel/helper-validator-option": "^7.27.1", + "browserslist": "^4.24.0", + "lru-cache": "^5.1.1", + "semver": "^6.3.1" + }, + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/helper-globals": { + "version": "7.28.0", + "resolved": "https://registry.npmjs.org/@babel/helper-globals/-/helper-globals-7.28.0.tgz", + "integrity": "sha512-+W6cISkXFa1jXsDEdYA8HeevQT/FULhxzR99pxphltZcVaugps53THCeiWA8SguxxpSp3gKPiuYfSWopkLQ4hw==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/helper-module-imports": { + "version": "7.28.6", + "resolved": "https://registry.npmjs.org/@babel/helper-module-imports/-/helper-module-imports-7.28.6.tgz", + "integrity": "sha512-l5XkZK7r7wa9LucGw9LwZyyCUscb4x37JWTPz7swwFE/0FMQAGpiWUZn8u9DzkSBWEcK25jmvubfpw2dnAMdbw==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/traverse": "^7.28.6", + "@babel/types": "^7.28.6" + }, + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/helper-module-transforms": { + "version": "7.28.6", + "resolved": "https://registry.npmjs.org/@babel/helper-module-transforms/-/helper-module-transforms-7.28.6.tgz", + "integrity": "sha512-67oXFAYr2cDLDVGLXTEABjdBJZ6drElUSI7WKp70NrpyISso3plG9SAGEF6y7zbha/wOzUByWWTJvEDVNIUGcA==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/helper-module-imports": "^7.28.6", + "@babel/helper-validator-identifier": "^7.28.5", + "@babel/traverse": "^7.28.6" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0" + } + }, + "node_modules/@babel/helper-plugin-utils": { + "version": "7.28.6", + "resolved": "https://registry.npmjs.org/@babel/helper-plugin-utils/-/helper-plugin-utils-7.28.6.tgz", + "integrity": "sha512-S9gzZ/bz83GRysI7gAD4wPT/AI3uCnY+9xn+Mx/KPs2JwHJIz1W8PZkg2cqyt3RNOBM8ejcXhV6y8Og7ly/Dug==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/helper-string-parser": { + "version": "7.27.1", + "resolved": "https://registry.npmjs.org/@babel/helper-string-parser/-/helper-string-parser-7.27.1.tgz", + "integrity": "sha512-qMlSxKbpRlAridDExk92nSobyDdpPijUq2DW6oDnUqd0iOGxmQjyqhMIihI9+zv4LPyZdRje2cavWPbCbWm3eA==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/helper-validator-identifier": { + "version": "7.28.5", + "resolved": "https://registry.npmjs.org/@babel/helper-validator-identifier/-/helper-validator-identifier-7.28.5.tgz", + "integrity": "sha512-qSs4ifwzKJSV39ucNjsvc6WVHs6b7S03sOh2OcHF9UHfVPqWWALUsNUVzhSBiItjRZoLHx7nIarVjqKVusUZ1Q==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/helper-validator-option": { + "version": "7.27.1", + "resolved": "https://registry.npmjs.org/@babel/helper-validator-option/-/helper-validator-option-7.27.1.tgz", + "integrity": "sha512-YvjJow9FxbhFFKDSuFnVCe2WxXk1zWc22fFePVNEaWJEu8IrZVlda6N0uHwzZrUM1il7NC9Mlp4MaJYbYd9JSg==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/helpers": { + "version": "7.28.6", + "resolved": "https://registry.npmjs.org/@babel/helpers/-/helpers-7.28.6.tgz", + "integrity": "sha512-xOBvwq86HHdB7WUDTfKfT/Vuxh7gElQ+Sfti2Cy6yIWNW05P8iUslOVcZ4/sKbE+/jQaukQAdz/gf3724kYdqw==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/template": "^7.28.6", + "@babel/types": "^7.28.6" + }, + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/parser": { + "version": "7.29.0", + "resolved": "https://registry.npmjs.org/@babel/parser/-/parser-7.29.0.tgz", + "integrity": "sha512-IyDgFV5GeDUVX4YdF/3CPULtVGSXXMLh1xVIgdCgxApktqnQV0r7/8Nqthg+8YLGaAtdyIlo2qIdZrbCv4+7ww==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/types": "^7.29.0" + }, + "bin": { + "parser": "bin/babel-parser.js" + }, + "engines": { + "node": ">=6.0.0" + } + }, + "node_modules/@babel/plugin-transform-react-jsx-self": { + "version": "7.27.1", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-react-jsx-self/-/plugin-transform-react-jsx-self-7.27.1.tgz", + "integrity": "sha512-6UzkCs+ejGdZ5mFFC/OCUrv028ab2fp1znZmCZjAOBKiBK2jXD1O+BPSfX8X2qjJ75fZBMSnQn3Rq2mrBJK2mw==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/helper-plugin-utils": "^7.27.1" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-transform-react-jsx-source": { + "version": "7.27.1", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-react-jsx-source/-/plugin-transform-react-jsx-source-7.27.1.tgz", + "integrity": "sha512-zbwoTsBruTeKB9hSq73ha66iFeJHuaFkUbwvqElnygoNbj/jHRsSeokowZFN3CZ64IvEqcmmkVe89OPXc7ldAw==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/helper-plugin-utils": "^7.27.1" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/template": { + "version": "7.28.6", + "resolved": "https://registry.npmjs.org/@babel/template/-/template-7.28.6.tgz", + "integrity": "sha512-YA6Ma2KsCdGb+WC6UpBVFJGXL58MDA6oyONbjyF/+5sBgxY/dwkhLogbMT2GXXyU84/IhRw/2D1Os1B/giz+BQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/code-frame": "^7.28.6", + "@babel/parser": "^7.28.6", + "@babel/types": "^7.28.6" + }, + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/traverse": { + "version": "7.29.0", + "resolved": "https://registry.npmjs.org/@babel/traverse/-/traverse-7.29.0.tgz", + "integrity": "sha512-4HPiQr0X7+waHfyXPZpWPfWL/J7dcN1mx9gL6WdQVMbPnF3+ZhSMs8tCxN7oHddJE9fhNE7+lxdnlyemKfJRuA==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/code-frame": "^7.29.0", + "@babel/generator": "^7.29.0", + "@babel/helper-globals": "^7.28.0", + "@babel/parser": "^7.29.0", + "@babel/template": "^7.28.6", + "@babel/types": "^7.29.0", + "debug": "^4.3.1" + }, + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/types": { + "version": "7.29.0", + "resolved": "https://registry.npmjs.org/@babel/types/-/types-7.29.0.tgz", + "integrity": "sha512-LwdZHpScM4Qz8Xw2iKSzS+cfglZzJGvofQICy7W7v4caru4EaAmyUuO6BGrbyQ2mYV11W0U8j5mBhd14dd3B0A==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/helper-string-parser": "^7.27.1", + "@babel/helper-validator-identifier": "^7.28.5" + }, + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@esbuild/aix-ppc64": { + "version": "0.27.3", + "resolved": "https://registry.npmjs.org/@esbuild/aix-ppc64/-/aix-ppc64-0.27.3.tgz", + "integrity": "sha512-9fJMTNFTWZMh5qwrBItuziu834eOCUcEqymSH7pY+zoMVEZg3gcPuBNxH1EvfVYe9h0x/Ptw8KBzv7qxb7l8dg==", + "cpu": [ + "ppc64" + ], + "license": "MIT", + "optional": true, + "os": [ + "aix" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/android-arm": { + "version": "0.27.3", + "resolved": "https://registry.npmjs.org/@esbuild/android-arm/-/android-arm-0.27.3.tgz", + "integrity": "sha512-i5D1hPY7GIQmXlXhs2w8AWHhenb00+GxjxRncS2ZM7YNVGNfaMxgzSGuO8o8SJzRc/oZwU2bcScvVERk03QhzA==", + "cpu": [ + "arm" + ], + "license": "MIT", + "optional": true, + "os": [ + "android" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/android-arm64": { + "version": "0.27.3", + "resolved": "https://registry.npmjs.org/@esbuild/android-arm64/-/android-arm64-0.27.3.tgz", + "integrity": "sha512-YdghPYUmj/FX2SYKJ0OZxf+iaKgMsKHVPF1MAq/P8WirnSpCStzKJFjOjzsW0QQ7oIAiccHdcqjbHmJxRb/dmg==", + "cpu": [ + "arm64" + ], + "license": "MIT", + "optional": true, + "os": [ + "android" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/android-x64": { + "version": "0.27.3", + "resolved": "https://registry.npmjs.org/@esbuild/android-x64/-/android-x64-0.27.3.tgz", + "integrity": "sha512-IN/0BNTkHtk8lkOM8JWAYFg4ORxBkZQf9zXiEOfERX/CzxW3Vg1ewAhU7QSWQpVIzTW+b8Xy+lGzdYXV6UZObQ==", + "cpu": [ + "x64" + ], + "license": "MIT", + "optional": true, + "os": [ + "android" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/darwin-arm64": { + "version": "0.27.3", + "resolved": "https://registry.npmjs.org/@esbuild/darwin-arm64/-/darwin-arm64-0.27.3.tgz", + "integrity": "sha512-Re491k7ByTVRy0t3EKWajdLIr0gz2kKKfzafkth4Q8A5n1xTHrkqZgLLjFEHVD+AXdUGgQMq+Godfq45mGpCKg==", + "cpu": [ + "arm64" + ], + "license": "MIT", + "optional": true, + "os": [ + "darwin" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/darwin-x64": { + "version": "0.27.3", + "resolved": "https://registry.npmjs.org/@esbuild/darwin-x64/-/darwin-x64-0.27.3.tgz", + "integrity": "sha512-vHk/hA7/1AckjGzRqi6wbo+jaShzRowYip6rt6q7VYEDX4LEy1pZfDpdxCBnGtl+A5zq8iXDcyuxwtv3hNtHFg==", + "cpu": [ + "x64" + ], + "license": "MIT", + "optional": true, + "os": [ + "darwin" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/freebsd-arm64": { + "version": "0.27.3", + "resolved": "https://registry.npmjs.org/@esbuild/freebsd-arm64/-/freebsd-arm64-0.27.3.tgz", + "integrity": "sha512-ipTYM2fjt3kQAYOvo6vcxJx3nBYAzPjgTCk7QEgZG8AUO3ydUhvelmhrbOheMnGOlaSFUoHXB6un+A7q4ygY9w==", + "cpu": [ + "arm64" + ], + "license": "MIT", + "optional": true, + "os": [ + "freebsd" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/freebsd-x64": { + "version": "0.27.3", + "resolved": "https://registry.npmjs.org/@esbuild/freebsd-x64/-/freebsd-x64-0.27.3.tgz", + "integrity": "sha512-dDk0X87T7mI6U3K9VjWtHOXqwAMJBNN2r7bejDsc+j03SEjtD9HrOl8gVFByeM0aJksoUuUVU9TBaZa2rgj0oA==", + "cpu": [ + "x64" + ], + "license": "MIT", + "optional": true, + "os": [ + "freebsd" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/linux-arm": { + "version": "0.27.3", + "resolved": "https://registry.npmjs.org/@esbuild/linux-arm/-/linux-arm-0.27.3.tgz", + "integrity": "sha512-s6nPv2QkSupJwLYyfS+gwdirm0ukyTFNl3KTgZEAiJDd+iHZcbTPPcWCcRYH+WlNbwChgH2QkE9NSlNrMT8Gfw==", + "cpu": [ + "arm" + ], + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/linux-arm64": { + "version": "0.27.3", + "resolved": "https://registry.npmjs.org/@esbuild/linux-arm64/-/linux-arm64-0.27.3.tgz", + "integrity": "sha512-sZOuFz/xWnZ4KH3YfFrKCf1WyPZHakVzTiqji3WDc0BCl2kBwiJLCXpzLzUBLgmp4veFZdvN5ChW4Eq/8Fc2Fg==", + "cpu": [ + "arm64" + ], + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/linux-ia32": { + "version": "0.27.3", + "resolved": "https://registry.npmjs.org/@esbuild/linux-ia32/-/linux-ia32-0.27.3.tgz", + "integrity": "sha512-yGlQYjdxtLdh0a3jHjuwOrxQjOZYD/C9PfdbgJJF3TIZWnm/tMd/RcNiLngiu4iwcBAOezdnSLAwQDPqTmtTYg==", + "cpu": [ + "ia32" + ], + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/linux-loong64": { + "version": "0.27.3", + "resolved": "https://registry.npmjs.org/@esbuild/linux-loong64/-/linux-loong64-0.27.3.tgz", + "integrity": "sha512-WO60Sn8ly3gtzhyjATDgieJNet/KqsDlX5nRC5Y3oTFcS1l0KWba+SEa9Ja1GfDqSF1z6hif/SkpQJbL63cgOA==", + "cpu": [ + "loong64" + ], + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/linux-mips64el": { + "version": "0.27.3", + "resolved": "https://registry.npmjs.org/@esbuild/linux-mips64el/-/linux-mips64el-0.27.3.tgz", + "integrity": "sha512-APsymYA6sGcZ4pD6k+UxbDjOFSvPWyZhjaiPyl/f79xKxwTnrn5QUnXR5prvetuaSMsb4jgeHewIDCIWljrSxw==", + "cpu": [ + "mips64el" + ], + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/linux-ppc64": { + "version": "0.27.3", + "resolved": "https://registry.npmjs.org/@esbuild/linux-ppc64/-/linux-ppc64-0.27.3.tgz", + "integrity": "sha512-eizBnTeBefojtDb9nSh4vvVQ3V9Qf9Df01PfawPcRzJH4gFSgrObw+LveUyDoKU3kxi5+9RJTCWlj4FjYXVPEA==", + "cpu": [ + "ppc64" + ], + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/linux-riscv64": { + "version": "0.27.3", + "resolved": "https://registry.npmjs.org/@esbuild/linux-riscv64/-/linux-riscv64-0.27.3.tgz", + "integrity": "sha512-3Emwh0r5wmfm3ssTWRQSyVhbOHvqegUDRd0WhmXKX2mkHJe1SFCMJhagUleMq+Uci34wLSipf8Lagt4LlpRFWQ==", + "cpu": [ + "riscv64" + ], + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/linux-s390x": { + "version": "0.27.3", + "resolved": "https://registry.npmjs.org/@esbuild/linux-s390x/-/linux-s390x-0.27.3.tgz", + "integrity": "sha512-pBHUx9LzXWBc7MFIEEL0yD/ZVtNgLytvx60gES28GcWMqil8ElCYR4kvbV2BDqsHOvVDRrOxGySBM9Fcv744hw==", + "cpu": [ + "s390x" + ], + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/linux-x64": { + "version": "0.27.3", + "resolved": "https://registry.npmjs.org/@esbuild/linux-x64/-/linux-x64-0.27.3.tgz", + "integrity": "sha512-Czi8yzXUWIQYAtL/2y6vogER8pvcsOsk5cpwL4Gk5nJqH5UZiVByIY8Eorm5R13gq+DQKYg0+JyQoytLQas4dA==", + "cpu": [ + "x64" + ], + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/netbsd-arm64": { + "version": "0.27.3", + "resolved": "https://registry.npmjs.org/@esbuild/netbsd-arm64/-/netbsd-arm64-0.27.3.tgz", + "integrity": "sha512-sDpk0RgmTCR/5HguIZa9n9u+HVKf40fbEUt+iTzSnCaGvY9kFP0YKBWZtJaraonFnqef5SlJ8/TiPAxzyS+UoA==", + "cpu": [ + "arm64" + ], + "license": "MIT", + "optional": true, + "os": [ + "netbsd" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/netbsd-x64": { + "version": "0.27.3", + "resolved": "https://registry.npmjs.org/@esbuild/netbsd-x64/-/netbsd-x64-0.27.3.tgz", + "integrity": "sha512-P14lFKJl/DdaE00LItAukUdZO5iqNH7+PjoBm+fLQjtxfcfFE20Xf5CrLsmZdq5LFFZzb5JMZ9grUwvtVYzjiA==", + "cpu": [ + "x64" + ], + "license": "MIT", + "optional": true, + "os": [ + "netbsd" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/openbsd-arm64": { + "version": "0.27.3", + "resolved": "https://registry.npmjs.org/@esbuild/openbsd-arm64/-/openbsd-arm64-0.27.3.tgz", + "integrity": "sha512-AIcMP77AvirGbRl/UZFTq5hjXK+2wC7qFRGoHSDrZ5v5b8DK/GYpXW3CPRL53NkvDqb9D+alBiC/dV0Fb7eJcw==", + "cpu": [ + "arm64" + ], + "license": "MIT", + "optional": true, + "os": [ + "openbsd" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/openbsd-x64": { + "version": "0.27.3", + "resolved": "https://registry.npmjs.org/@esbuild/openbsd-x64/-/openbsd-x64-0.27.3.tgz", + "integrity": "sha512-DnW2sRrBzA+YnE70LKqnM3P+z8vehfJWHXECbwBmH/CU51z6FiqTQTHFenPlHmo3a8UgpLyH3PT+87OViOh1AQ==", + "cpu": [ + "x64" + ], + "license": "MIT", + "optional": true, + "os": [ + "openbsd" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/openharmony-arm64": { + "version": "0.27.3", + "resolved": "https://registry.npmjs.org/@esbuild/openharmony-arm64/-/openharmony-arm64-0.27.3.tgz", + "integrity": "sha512-NinAEgr/etERPTsZJ7aEZQvvg/A6IsZG/LgZy+81wON2huV7SrK3e63dU0XhyZP4RKGyTm7aOgmQk0bGp0fy2g==", + "cpu": [ + "arm64" + ], + "license": "MIT", + "optional": true, + "os": [ + "openharmony" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/sunos-x64": { + "version": "0.27.3", + "resolved": "https://registry.npmjs.org/@esbuild/sunos-x64/-/sunos-x64-0.27.3.tgz", + "integrity": "sha512-PanZ+nEz+eWoBJ8/f8HKxTTD172SKwdXebZ0ndd953gt1HRBbhMsaNqjTyYLGLPdoWHy4zLU7bDVJztF5f3BHA==", + "cpu": [ + "x64" + ], + "license": "MIT", + "optional": true, + "os": [ + "sunos" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/win32-arm64": { + "version": "0.27.3", + "resolved": "https://registry.npmjs.org/@esbuild/win32-arm64/-/win32-arm64-0.27.3.tgz", + "integrity": "sha512-B2t59lWWYrbRDw/tjiWOuzSsFh1Y/E95ofKz7rIVYSQkUYBjfSgf6oeYPNWHToFRr2zx52JKApIcAS/D5TUBnA==", + "cpu": [ + "arm64" + ], + "license": "MIT", + "optional": true, + "os": [ + "win32" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/win32-ia32": { + "version": "0.27.3", + "resolved": "https://registry.npmjs.org/@esbuild/win32-ia32/-/win32-ia32-0.27.3.tgz", + "integrity": "sha512-QLKSFeXNS8+tHW7tZpMtjlNb7HKau0QDpwm49u0vUp9y1WOF+PEzkU84y9GqYaAVW8aH8f3GcBck26jh54cX4Q==", + "cpu": [ + "ia32" + ], + "license": "MIT", + "optional": true, + "os": [ + "win32" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/win32-x64": { + "version": "0.27.3", + "resolved": "https://registry.npmjs.org/@esbuild/win32-x64/-/win32-x64-0.27.3.tgz", + "integrity": "sha512-4uJGhsxuptu3OcpVAzli+/gWusVGwZZHTlS63hh++ehExkVT8SgiEf7/uC/PclrPPkLhZqGgCTjd0VWLo6xMqA==", + "cpu": [ + "x64" + ], + "license": "MIT", + "optional": true, + "os": [ + "win32" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@eslint-community/eslint-utils": { + "version": "4.9.1", + "resolved": "https://registry.npmjs.org/@eslint-community/eslint-utils/-/eslint-utils-4.9.1.tgz", + "integrity": "sha512-phrYmNiYppR7znFEdqgfWHXR6NCkZEK7hwWDHZUjit/2/U0r6XvkDl0SYnoM51Hq7FhCGdLDT6zxCCOY1hexsQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "eslint-visitor-keys": "^3.4.3" + }, + "engines": { + "node": "^12.22.0 || ^14.17.0 || >=16.0.0" + }, + "funding": { + "url": "https://opencollective.com/eslint" + }, + "peerDependencies": { + "eslint": "^6.0.0 || ^7.0.0 || >=8.0.0" + } + }, + "node_modules/@eslint-community/eslint-utils/node_modules/eslint-visitor-keys": { + "version": "3.4.3", + "resolved": "https://registry.npmjs.org/eslint-visitor-keys/-/eslint-visitor-keys-3.4.3.tgz", + "integrity": "sha512-wpc+LXeiyiisxPlEkUzU6svyS1frIO3Mgxj1fdy7Pm8Ygzguax2N3Fa/D/ag1WqbOprdI+uY6wMUl8/a2G+iag==", + "dev": true, + "license": "Apache-2.0", + "engines": { + "node": "^12.22.0 || ^14.17.0 || >=16.0.0" + }, + "funding": { + "url": "https://opencollective.com/eslint" + } + }, + "node_modules/@eslint-community/regexpp": { + "version": "4.12.2", + "resolved": "https://registry.npmjs.org/@eslint-community/regexpp/-/regexpp-4.12.2.tgz", + "integrity": "sha512-EriSTlt5OC9/7SXkRSCAhfSxxoSUgBm33OH+IkwbdpgoqsSsUg7y3uh+IICI/Qg4BBWr3U2i39RpmycbxMq4ew==", + "dev": true, + "license": "MIT", + "engines": { + "node": "^12.0.0 || ^14.0.0 || >=16.0.0" + } + }, + "node_modules/@eslint/config-array": { + "version": "0.21.1", + "resolved": "https://registry.npmjs.org/@eslint/config-array/-/config-array-0.21.1.tgz", + "integrity": "sha512-aw1gNayWpdI/jSYVgzN5pL0cfzU02GT3NBpeT/DXbx1/1x7ZKxFPd9bwrzygx/qiwIQiJ1sw/zD8qY/kRvlGHA==", + "dev": true, + "license": "Apache-2.0", + "dependencies": { + "@eslint/object-schema": "^2.1.7", + "debug": "^4.3.1", + "minimatch": "^3.1.2" + }, + "engines": { + "node": "^18.18.0 || ^20.9.0 || >=21.1.0" + } + }, + "node_modules/@eslint/config-helpers": { + "version": "0.4.2", + "resolved": "https://registry.npmjs.org/@eslint/config-helpers/-/config-helpers-0.4.2.tgz", + "integrity": "sha512-gBrxN88gOIf3R7ja5K9slwNayVcZgK6SOUORm2uBzTeIEfeVaIhOpCtTox3P6R7o2jLFwLFTLnC7kU/RGcYEgw==", + "dev": true, + "license": "Apache-2.0", + "dependencies": { + "@eslint/core": "^0.17.0" + }, + "engines": { + "node": "^18.18.0 || ^20.9.0 || >=21.1.0" + } + }, + "node_modules/@eslint/core": { + "version": "0.17.0", + "resolved": "https://registry.npmjs.org/@eslint/core/-/core-0.17.0.tgz", + "integrity": "sha512-yL/sLrpmtDaFEiUj1osRP4TI2MDz1AddJL+jZ7KSqvBuliN4xqYY54IfdN8qD8Toa6g1iloph1fxQNkjOxrrpQ==", + "dev": true, + "license": "Apache-2.0", + "dependencies": { + "@types/json-schema": "^7.0.15" + }, + "engines": { + "node": "^18.18.0 || ^20.9.0 || >=21.1.0" + } + }, + "node_modules/@eslint/eslintrc": { + "version": "3.3.3", + "resolved": "https://registry.npmjs.org/@eslint/eslintrc/-/eslintrc-3.3.3.tgz", + "integrity": "sha512-Kr+LPIUVKz2qkx1HAMH8q1q6azbqBAsXJUxBl/ODDuVPX45Z9DfwB8tPjTi6nNZ8BuM3nbJxC5zCAg5elnBUTQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "ajv": "^6.12.4", + "debug": "^4.3.2", + "espree": "^10.0.1", + "globals": "^14.0.0", + "ignore": "^5.2.0", + "import-fresh": "^3.2.1", + "js-yaml": "^4.1.1", + "minimatch": "^3.1.2", + "strip-json-comments": "^3.1.1" + }, + "engines": { + "node": "^18.18.0 || ^20.9.0 || >=21.1.0" + }, + "funding": { + "url": "https://opencollective.com/eslint" + } + }, + "node_modules/@eslint/eslintrc/node_modules/globals": { + "version": "14.0.0", + "resolved": "https://registry.npmjs.org/globals/-/globals-14.0.0.tgz", + "integrity": "sha512-oahGvuMGQlPw/ivIYBjVSrWAfWLBeku5tpPE2fOPLi+WHffIWbuh2tCjhyQhTBPMf5E9jDEH4FOmTYgYwbKwtQ==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=18" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/@eslint/js": { + "version": "9.39.3", + "resolved": "https://registry.npmjs.org/@eslint/js/-/js-9.39.3.tgz", + "integrity": "sha512-1B1VkCq6FuUNlQvlBYb+1jDu/gV297TIs/OeiaSR9l1H27SVW55ONE1e1Vp16NqP683+xEGzxYtv4XCiDPaQiw==", + "dev": true, + "license": "MIT", + "engines": { + "node": "^18.18.0 || ^20.9.0 || >=21.1.0" + }, + "funding": { + "url": "https://eslint.org/donate" + } + }, + "node_modules/@eslint/object-schema": { + "version": "2.1.7", + "resolved": "https://registry.npmjs.org/@eslint/object-schema/-/object-schema-2.1.7.tgz", + "integrity": "sha512-VtAOaymWVfZcmZbp6E2mympDIHvyjXs/12LqWYjVw6qjrfF+VK+fyG33kChz3nnK+SU5/NeHOqrTEHS8sXO3OA==", + "dev": true, + "license": "Apache-2.0", + "engines": { + "node": "^18.18.0 || ^20.9.0 || >=21.1.0" + } + }, + "node_modules/@eslint/plugin-kit": { + "version": "0.4.1", + "resolved": "https://registry.npmjs.org/@eslint/plugin-kit/-/plugin-kit-0.4.1.tgz", + "integrity": "sha512-43/qtrDUokr7LJqoF2c3+RInu/t4zfrpYdoSDfYyhg52rwLV6TnOvdG4fXm7IkSB3wErkcmJS9iEhjVtOSEjjA==", + "dev": true, + "license": "Apache-2.0", + "dependencies": { + "@eslint/core": "^0.17.0", + "levn": "^0.4.1" + }, + "engines": { + "node": "^18.18.0 || ^20.9.0 || >=21.1.0" + } + }, + "node_modules/@humanfs/core": { + "version": "0.19.1", + "resolved": "https://registry.npmjs.org/@humanfs/core/-/core-0.19.1.tgz", + "integrity": "sha512-5DyQ4+1JEUzejeK1JGICcideyfUbGixgS9jNgex5nqkW+cY7WZhxBigmieN5Qnw9ZosSNVC9KQKyb+GUaGyKUA==", + "dev": true, + "license": "Apache-2.0", + "engines": { + "node": ">=18.18.0" + } + }, + "node_modules/@humanfs/node": { + "version": "0.16.7", + "resolved": "https://registry.npmjs.org/@humanfs/node/-/node-0.16.7.tgz", + "integrity": "sha512-/zUx+yOsIrG4Y43Eh2peDeKCxlRt/gET6aHfaKpuq267qXdYDFViVHfMaLyygZOnl0kGWxFIgsBy8QFuTLUXEQ==", + "dev": true, + "license": "Apache-2.0", + "dependencies": { + "@humanfs/core": "^0.19.1", + "@humanwhocodes/retry": "^0.4.0" + }, + "engines": { + "node": ">=18.18.0" + } + }, + "node_modules/@humanwhocodes/module-importer": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/@humanwhocodes/module-importer/-/module-importer-1.0.1.tgz", + "integrity": "sha512-bxveV4V8v5Yb4ncFTT3rPSgZBOpCkjfK0y4oVVVJwIuDVBRMDXrPyXRL988i5ap9m9bnyEEjWfm5WkBmtffLfA==", + "dev": true, + "license": "Apache-2.0", + "engines": { + "node": ">=12.22" + }, + "funding": { + "type": "github", + "url": "https://github.com/sponsors/nzakas" + } + }, + "node_modules/@humanwhocodes/retry": { + "version": "0.4.3", + "resolved": "https://registry.npmjs.org/@humanwhocodes/retry/-/retry-0.4.3.tgz", + "integrity": "sha512-bV0Tgo9K4hfPCek+aMAn81RppFKv2ySDQeMoSZuvTASywNTnVJCArCZE2FWqpvIatKu7VMRLWlR1EazvVhDyhQ==", + "dev": true, + "license": "Apache-2.0", + "engines": { + "node": ">=18.18" + }, + "funding": { + "type": "github", + "url": "https://github.com/sponsors/nzakas" + } + }, + "node_modules/@jridgewell/gen-mapping": { + "version": "0.3.13", + "resolved": "https://registry.npmjs.org/@jridgewell/gen-mapping/-/gen-mapping-0.3.13.tgz", + "integrity": "sha512-2kkt/7niJ6MgEPxF0bYdQ6etZaA+fQvDcLKckhy1yIQOzaoKjBBjSj63/aLVjYE3qhRt5dvM+uUyfCg6UKCBbA==", + "license": "MIT", + "dependencies": { + "@jridgewell/sourcemap-codec": "^1.5.0", + "@jridgewell/trace-mapping": "^0.3.24" + } + }, + "node_modules/@jridgewell/remapping": { + "version": "2.3.5", + "resolved": "https://registry.npmjs.org/@jridgewell/remapping/-/remapping-2.3.5.tgz", + "integrity": "sha512-LI9u/+laYG4Ds1TDKSJW2YPrIlcVYOwi2fUC6xB43lueCjgxV4lffOCZCtYFiH6TNOX+tQKXx97T4IKHbhyHEQ==", + "license": "MIT", + "dependencies": { + "@jridgewell/gen-mapping": "^0.3.5", + "@jridgewell/trace-mapping": "^0.3.24" + } + }, + "node_modules/@jridgewell/resolve-uri": { + "version": "3.1.2", + "resolved": "https://registry.npmjs.org/@jridgewell/resolve-uri/-/resolve-uri-3.1.2.tgz", + "integrity": "sha512-bRISgCIjP20/tbWSPWMEi54QVPRZExkuD9lJL+UIxUKtwVJA8wW1Trb1jMs1RFXo1CBTNZ/5hpC9QvmKWdopKw==", + "license": "MIT", + "engines": { + "node": ">=6.0.0" + } + }, + "node_modules/@jridgewell/sourcemap-codec": { + "version": "1.5.5", + "resolved": "https://registry.npmjs.org/@jridgewell/sourcemap-codec/-/sourcemap-codec-1.5.5.tgz", + "integrity": "sha512-cYQ9310grqxueWbl+WuIUIaiUaDcj7WOq5fVhEljNVgRfOUhY9fy2zTvfoqWsnebh8Sl70VScFbICvJnLKB0Og==", + "license": "MIT" + }, + "node_modules/@jridgewell/trace-mapping": { + "version": "0.3.31", + "resolved": "https://registry.npmjs.org/@jridgewell/trace-mapping/-/trace-mapping-0.3.31.tgz", + "integrity": "sha512-zzNR+SdQSDJzc8joaeP8QQoCQr8NuYx2dIIytl1QeBEZHJ9uW6hebsrYgbz8hJwUQao3TWCMtmfV8Nu1twOLAw==", + "license": "MIT", + "dependencies": { + "@jridgewell/resolve-uri": "^3.1.0", + "@jridgewell/sourcemap-codec": "^1.4.14" + } + }, + "node_modules/@rolldown/pluginutils": { + "version": "1.0.0-rc.3", + "resolved": "https://registry.npmjs.org/@rolldown/pluginutils/-/pluginutils-1.0.0-rc.3.tgz", + "integrity": "sha512-eybk3TjzzzV97Dlj5c+XrBFW57eTNhzod66y9HrBlzJ6NsCrWCp/2kaPS3K9wJmurBC0Tdw4yPjXKZqlznim3Q==", + "dev": true, + "license": "MIT" + }, + "node_modules/@rollup/rollup-android-arm-eabi": { + "version": "4.59.0", + "resolved": "https://registry.npmjs.org/@rollup/rollup-android-arm-eabi/-/rollup-android-arm-eabi-4.59.0.tgz", + "integrity": "sha512-upnNBkA6ZH2VKGcBj9Fyl9IGNPULcjXRlg0LLeaioQWueH30p6IXtJEbKAgvyv+mJaMxSm1l6xwDXYjpEMiLMg==", + "cpu": [ + "arm" + ], + "license": "MIT", + "optional": true, + "os": [ + "android" + ] + }, + "node_modules/@rollup/rollup-android-arm64": { + "version": "4.59.0", + "resolved": "https://registry.npmjs.org/@rollup/rollup-android-arm64/-/rollup-android-arm64-4.59.0.tgz", + "integrity": "sha512-hZ+Zxj3SySm4A/DylsDKZAeVg0mvi++0PYVceVyX7hemkw7OreKdCvW2oQ3T1FMZvCaQXqOTHb8qmBShoqk69Q==", + "cpu": [ + "arm64" + ], + "license": "MIT", + "optional": true, + "os": [ + "android" + ] + }, + "node_modules/@rollup/rollup-darwin-arm64": { + "version": "4.59.0", + "resolved": "https://registry.npmjs.org/@rollup/rollup-darwin-arm64/-/rollup-darwin-arm64-4.59.0.tgz", + "integrity": "sha512-W2Psnbh1J8ZJw0xKAd8zdNgF9HRLkdWwwdWqubSVk0pUuQkoHnv7rx4GiF9rT4t5DIZGAsConRE3AxCdJ4m8rg==", + "cpu": [ + "arm64" + ], + "license": "MIT", + "optional": true, + "os": [ + "darwin" + ] + }, + "node_modules/@rollup/rollup-darwin-x64": { + "version": "4.59.0", + "resolved": "https://registry.npmjs.org/@rollup/rollup-darwin-x64/-/rollup-darwin-x64-4.59.0.tgz", + "integrity": "sha512-ZW2KkwlS4lwTv7ZVsYDiARfFCnSGhzYPdiOU4IM2fDbL+QGlyAbjgSFuqNRbSthybLbIJ915UtZBtmuLrQAT/w==", + "cpu": [ + "x64" + ], + "license": "MIT", + "optional": true, + "os": [ + "darwin" + ] + }, + "node_modules/@rollup/rollup-freebsd-arm64": { + "version": "4.59.0", + "resolved": "https://registry.npmjs.org/@rollup/rollup-freebsd-arm64/-/rollup-freebsd-arm64-4.59.0.tgz", + "integrity": "sha512-EsKaJ5ytAu9jI3lonzn3BgG8iRBjV4LxZexygcQbpiU0wU0ATxhNVEpXKfUa0pS05gTcSDMKpn3Sx+QB9RlTTA==", + "cpu": [ + "arm64" + ], + "license": "MIT", + "optional": true, + "os": [ + "freebsd" + ] + }, + "node_modules/@rollup/rollup-freebsd-x64": { + "version": "4.59.0", + "resolved": "https://registry.npmjs.org/@rollup/rollup-freebsd-x64/-/rollup-freebsd-x64-4.59.0.tgz", + "integrity": "sha512-d3DuZi2KzTMjImrxoHIAODUZYoUUMsuUiY4SRRcJy6NJoZ6iIqWnJu9IScV9jXysyGMVuW+KNzZvBLOcpdl3Vg==", + "cpu": [ + "x64" + ], + "license": "MIT", + "optional": true, + "os": [ + "freebsd" + ] + }, + "node_modules/@rollup/rollup-linux-arm-gnueabihf": { + "version": "4.59.0", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm-gnueabihf/-/rollup-linux-arm-gnueabihf-4.59.0.tgz", + "integrity": "sha512-t4ONHboXi/3E0rT6OZl1pKbl2Vgxf9vJfWgmUoCEVQVxhW6Cw/c8I6hbbu7DAvgp82RKiH7TpLwxnJeKv2pbsw==", + "cpu": [ + "arm" + ], + "license": "MIT", + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@rollup/rollup-linux-arm-musleabihf": { + "version": "4.59.0", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm-musleabihf/-/rollup-linux-arm-musleabihf-4.59.0.tgz", + "integrity": "sha512-CikFT7aYPA2ufMD086cVORBYGHffBo4K8MQ4uPS/ZnY54GKj36i196u8U+aDVT2LX4eSMbyHtyOh7D7Zvk2VvA==", + "cpu": [ + "arm" + ], + "license": "MIT", + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@rollup/rollup-linux-arm64-gnu": { + "version": "4.59.0", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm64-gnu/-/rollup-linux-arm64-gnu-4.59.0.tgz", + "integrity": "sha512-jYgUGk5aLd1nUb1CtQ8E+t5JhLc9x5WdBKew9ZgAXg7DBk0ZHErLHdXM24rfX+bKrFe+Xp5YuJo54I5HFjGDAA==", + "cpu": [ + "arm64" + ], + "license": "MIT", + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@rollup/rollup-linux-arm64-musl": { + "version": "4.59.0", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm64-musl/-/rollup-linux-arm64-musl-4.59.0.tgz", + "integrity": "sha512-peZRVEdnFWZ5Bh2KeumKG9ty7aCXzzEsHShOZEFiCQlDEepP1dpUl/SrUNXNg13UmZl+gzVDPsiCwnV1uI0RUA==", + "cpu": [ + "arm64" + ], + "license": "MIT", + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@rollup/rollup-linux-loong64-gnu": { + "version": "4.59.0", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-loong64-gnu/-/rollup-linux-loong64-gnu-4.59.0.tgz", + "integrity": "sha512-gbUSW/97f7+r4gHy3Jlup8zDG190AuodsWnNiXErp9mT90iCy9NKKU0Xwx5k8VlRAIV2uU9CsMnEFg/xXaOfXg==", + "cpu": [ + "loong64" + ], + "license": "MIT", + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@rollup/rollup-linux-loong64-musl": { + "version": "4.59.0", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-loong64-musl/-/rollup-linux-loong64-musl-4.59.0.tgz", + "integrity": "sha512-yTRONe79E+o0FWFijasoTjtzG9EBedFXJMl888NBEDCDV9I2wGbFFfJQQe63OijbFCUZqxpHz1GzpbtSFikJ4Q==", + "cpu": [ + "loong64" + ], + "license": "MIT", + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@rollup/rollup-linux-ppc64-gnu": { + "version": "4.59.0", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-ppc64-gnu/-/rollup-linux-ppc64-gnu-4.59.0.tgz", + "integrity": "sha512-sw1o3tfyk12k3OEpRddF68a1unZ5VCN7zoTNtSn2KndUE+ea3m3ROOKRCZxEpmT9nsGnogpFP9x6mnLTCaoLkA==", + "cpu": [ + "ppc64" + ], + "license": "MIT", + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@rollup/rollup-linux-ppc64-musl": { + "version": "4.59.0", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-ppc64-musl/-/rollup-linux-ppc64-musl-4.59.0.tgz", + "integrity": "sha512-+2kLtQ4xT3AiIxkzFVFXfsmlZiG5FXYW7ZyIIvGA7Bdeuh9Z0aN4hVyXS/G1E9bTP/vqszNIN/pUKCk/BTHsKA==", + "cpu": [ + "ppc64" + ], + "license": "MIT", + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@rollup/rollup-linux-riscv64-gnu": { + "version": "4.59.0", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-riscv64-gnu/-/rollup-linux-riscv64-gnu-4.59.0.tgz", + "integrity": "sha512-NDYMpsXYJJaj+I7UdwIuHHNxXZ/b/N2hR15NyH3m2qAtb/hHPA4g4SuuvrdxetTdndfj9b1WOmy73kcPRoERUg==", + "cpu": [ + "riscv64" + ], + "license": "MIT", + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@rollup/rollup-linux-riscv64-musl": { + "version": "4.59.0", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-riscv64-musl/-/rollup-linux-riscv64-musl-4.59.0.tgz", + "integrity": "sha512-nLckB8WOqHIf1bhymk+oHxvM9D3tyPndZH8i8+35p/1YiVoVswPid2yLzgX7ZJP0KQvnkhM4H6QZ5m0LzbyIAg==", + "cpu": [ + "riscv64" + ], + "license": "MIT", + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@rollup/rollup-linux-s390x-gnu": { + "version": "4.59.0", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-s390x-gnu/-/rollup-linux-s390x-gnu-4.59.0.tgz", + "integrity": "sha512-oF87Ie3uAIvORFBpwnCvUzdeYUqi2wY6jRFWJAy1qus/udHFYIkplYRW+wo+GRUP4sKzYdmE1Y3+rY5Gc4ZO+w==", + "cpu": [ + "s390x" + ], + "license": "MIT", + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@rollup/rollup-linux-x64-gnu": { + "version": "4.59.0", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-x64-gnu/-/rollup-linux-x64-gnu-4.59.0.tgz", + "integrity": "sha512-3AHmtQq/ppNuUspKAlvA8HtLybkDflkMuLK4DPo77DfthRb71V84/c4MlWJXixZz4uruIH4uaa07IqoAkG64fg==", + "cpu": [ + "x64" + ], + "license": "MIT", + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@rollup/rollup-linux-x64-musl": { + "version": "4.59.0", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-x64-musl/-/rollup-linux-x64-musl-4.59.0.tgz", + "integrity": "sha512-2UdiwS/9cTAx7qIUZB/fWtToJwvt0Vbo0zmnYt7ED35KPg13Q0ym1g442THLC7VyI6JfYTP4PiSOWyoMdV2/xg==", + "cpu": [ + "x64" + ], + "license": "MIT", + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@rollup/rollup-openbsd-x64": { + "version": "4.59.0", + "resolved": "https://registry.npmjs.org/@rollup/rollup-openbsd-x64/-/rollup-openbsd-x64-4.59.0.tgz", + "integrity": "sha512-M3bLRAVk6GOwFlPTIxVBSYKUaqfLrn8l0psKinkCFxl4lQvOSz8ZrKDz2gxcBwHFpci0B6rttydI4IpS4IS/jQ==", + "cpu": [ + "x64" + ], + "license": "MIT", + "optional": true, + "os": [ + "openbsd" + ] + }, + "node_modules/@rollup/rollup-openharmony-arm64": { + "version": "4.59.0", + "resolved": "https://registry.npmjs.org/@rollup/rollup-openharmony-arm64/-/rollup-openharmony-arm64-4.59.0.tgz", + "integrity": "sha512-tt9KBJqaqp5i5HUZzoafHZX8b5Q2Fe7UjYERADll83O4fGqJ49O1FsL6LpdzVFQcpwvnyd0i+K/VSwu/o/nWlA==", + "cpu": [ + "arm64" + ], + "license": "MIT", + "optional": true, + "os": [ + "openharmony" + ] + }, + "node_modules/@rollup/rollup-win32-arm64-msvc": { + "version": "4.59.0", + "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-arm64-msvc/-/rollup-win32-arm64-msvc-4.59.0.tgz", + "integrity": "sha512-V5B6mG7OrGTwnxaNUzZTDTjDS7F75PO1ae6MJYdiMu60sq0CqN5CVeVsbhPxalupvTX8gXVSU9gq+Rx1/hvu6A==", + "cpu": [ + "arm64" + ], + "license": "MIT", + "optional": true, + "os": [ + "win32" + ] + }, + "node_modules/@rollup/rollup-win32-ia32-msvc": { + "version": "4.59.0", + "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-ia32-msvc/-/rollup-win32-ia32-msvc-4.59.0.tgz", + "integrity": "sha512-UKFMHPuM9R0iBegwzKF4y0C4J9u8C6MEJgFuXTBerMk7EJ92GFVFYBfOZaSGLu6COf7FxpQNqhNS4c4icUPqxA==", + "cpu": [ + "ia32" + ], + "license": "MIT", + "optional": true, + "os": [ + "win32" + ] + }, + "node_modules/@rollup/rollup-win32-x64-gnu": { + "version": "4.59.0", + "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-x64-gnu/-/rollup-win32-x64-gnu-4.59.0.tgz", + "integrity": "sha512-laBkYlSS1n2L8fSo1thDNGrCTQMmxjYY5G0WFWjFFYZkKPjsMBsgJfGf4TLxXrF6RyhI60L8TMOjBMvXiTcxeA==", + "cpu": [ + "x64" + ], + "license": "MIT", + "optional": true, + "os": [ + "win32" + ] + }, + "node_modules/@rollup/rollup-win32-x64-msvc": { + "version": "4.59.0", + "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-x64-msvc/-/rollup-win32-x64-msvc-4.59.0.tgz", + "integrity": "sha512-2HRCml6OztYXyJXAvdDXPKcawukWY2GpR5/nxKp4iBgiO3wcoEGkAaqctIbZcNB6KlUQBIqt8VYkNSj2397EfA==", + "cpu": [ + "x64" + ], + "license": "MIT", + "optional": true, + "os": [ + "win32" + ] + }, + "node_modules/@tailwindcss/node": { + "version": "4.2.1", + "resolved": "https://registry.npmjs.org/@tailwindcss/node/-/node-4.2.1.tgz", + "integrity": "sha512-jlx6sLk4EOwO6hHe1oCGm1Q4AN/s0rSrTTPBGPM0/RQ6Uylwq17FuU8IeJJKEjtc6K6O07zsvP+gDO6MMWo7pg==", + "license": "MIT", + "dependencies": { + "@jridgewell/remapping": "^2.3.5", + "enhanced-resolve": "^5.19.0", + "jiti": "^2.6.1", + "lightningcss": "1.31.1", + "magic-string": "^0.30.21", + "source-map-js": "^1.2.1", + "tailwindcss": "4.2.1" + } + }, + "node_modules/@tailwindcss/oxide": { + "version": "4.2.1", + "resolved": "https://registry.npmjs.org/@tailwindcss/oxide/-/oxide-4.2.1.tgz", + "integrity": "sha512-yv9jeEFWnjKCI6/T3Oq50yQEOqmpmpfzG1hcZsAOaXFQPfzWprWrlHSdGPEF3WQTi8zu8ohC9Mh9J470nT5pUw==", + "license": "MIT", + "engines": { + "node": ">= 20" + }, + "optionalDependencies": { + "@tailwindcss/oxide-android-arm64": "4.2.1", + "@tailwindcss/oxide-darwin-arm64": "4.2.1", + "@tailwindcss/oxide-darwin-x64": "4.2.1", + "@tailwindcss/oxide-freebsd-x64": "4.2.1", + "@tailwindcss/oxide-linux-arm-gnueabihf": "4.2.1", + "@tailwindcss/oxide-linux-arm64-gnu": "4.2.1", + "@tailwindcss/oxide-linux-arm64-musl": "4.2.1", + "@tailwindcss/oxide-linux-x64-gnu": "4.2.1", + "@tailwindcss/oxide-linux-x64-musl": "4.2.1", + "@tailwindcss/oxide-wasm32-wasi": "4.2.1", + "@tailwindcss/oxide-win32-arm64-msvc": "4.2.1", + "@tailwindcss/oxide-win32-x64-msvc": "4.2.1" + } + }, + "node_modules/@tailwindcss/oxide-android-arm64": { + "version": "4.2.1", + "resolved": "https://registry.npmjs.org/@tailwindcss/oxide-android-arm64/-/oxide-android-arm64-4.2.1.tgz", + "integrity": "sha512-eZ7G1Zm5EC8OOKaesIKuw77jw++QJ2lL9N+dDpdQiAB/c/B2wDh0QPFHbkBVrXnwNugvrbJFk1gK2SsVjwWReg==", + "cpu": [ + "arm64" + ], + "license": "MIT", + "optional": true, + "os": [ + "android" + ], + "engines": { + "node": ">= 20" + } + }, + "node_modules/@tailwindcss/oxide-darwin-arm64": { + "version": "4.2.1", + "resolved": "https://registry.npmjs.org/@tailwindcss/oxide-darwin-arm64/-/oxide-darwin-arm64-4.2.1.tgz", + "integrity": "sha512-q/LHkOstoJ7pI1J0q6djesLzRvQSIfEto148ppAd+BVQK0JYjQIFSK3JgYZJa+Yzi0DDa52ZsQx2rqytBnf8Hw==", + "cpu": [ + "arm64" + ], + "license": "MIT", + "optional": true, + "os": [ + "darwin" + ], + "engines": { + "node": ">= 20" + } + }, + "node_modules/@tailwindcss/oxide-darwin-x64": { + "version": "4.2.1", + "resolved": "https://registry.npmjs.org/@tailwindcss/oxide-darwin-x64/-/oxide-darwin-x64-4.2.1.tgz", + "integrity": "sha512-/f/ozlaXGY6QLbpvd/kFTro2l18f7dHKpB+ieXz+Cijl4Mt9AI2rTrpq7V+t04nK+j9XBQHnSMdeQRhbGyt6fw==", + "cpu": [ + "x64" + ], + "license": "MIT", + "optional": true, + "os": [ + "darwin" + ], + "engines": { + "node": ">= 20" + } + }, + "node_modules/@tailwindcss/oxide-freebsd-x64": { + "version": "4.2.1", + "resolved": "https://registry.npmjs.org/@tailwindcss/oxide-freebsd-x64/-/oxide-freebsd-x64-4.2.1.tgz", + "integrity": "sha512-5e/AkgYJT/cpbkys/OU2Ei2jdETCLlifwm7ogMC7/hksI2fC3iiq6OcXwjibcIjPung0kRtR3TxEITkqgn0TcA==", + "cpu": [ + "x64" + ], + "license": "MIT", + "optional": true, + "os": [ + "freebsd" + ], + "engines": { + "node": ">= 20" + } + }, + "node_modules/@tailwindcss/oxide-linux-arm-gnueabihf": { + "version": "4.2.1", + "resolved": "https://registry.npmjs.org/@tailwindcss/oxide-linux-arm-gnueabihf/-/oxide-linux-arm-gnueabihf-4.2.1.tgz", + "integrity": "sha512-Uny1EcVTTmerCKt/1ZuKTkb0x8ZaiuYucg2/kImO5A5Y/kBz41/+j0gxUZl+hTF3xkWpDmHX+TaWhOtba2Fyuw==", + "cpu": [ + "arm" + ], + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">= 20" + } + }, + "node_modules/@tailwindcss/oxide-linux-arm64-gnu": { + "version": "4.2.1", + "resolved": "https://registry.npmjs.org/@tailwindcss/oxide-linux-arm64-gnu/-/oxide-linux-arm64-gnu-4.2.1.tgz", + "integrity": "sha512-CTrwomI+c7n6aSSQlsPL0roRiNMDQ/YzMD9EjcR+H4f0I1SQ8QqIuPnsVp7QgMkC1Qi8rtkekLkOFjo7OlEFRQ==", + "cpu": [ + "arm64" + ], + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">= 20" + } + }, + "node_modules/@tailwindcss/oxide-linux-arm64-musl": { + "version": "4.2.1", + "resolved": "https://registry.npmjs.org/@tailwindcss/oxide-linux-arm64-musl/-/oxide-linux-arm64-musl-4.2.1.tgz", + "integrity": "sha512-WZA0CHRL/SP1TRbA5mp9htsppSEkWuQ4KsSUumYQnyl8ZdT39ntwqmz4IUHGN6p4XdSlYfJwM4rRzZLShHsGAQ==", + "cpu": [ + "arm64" + ], + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">= 20" + } + }, + "node_modules/@tailwindcss/oxide-linux-x64-gnu": { + "version": "4.2.1", + "resolved": "https://registry.npmjs.org/@tailwindcss/oxide-linux-x64-gnu/-/oxide-linux-x64-gnu-4.2.1.tgz", + "integrity": "sha512-qMFzxI2YlBOLW5PhblzuSWlWfwLHaneBE0xHzLrBgNtqN6mWfs+qYbhryGSXQjFYB1Dzf5w+LN5qbUTPhW7Y5g==", + "cpu": [ + "x64" + ], + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">= 20" + } + }, + "node_modules/@tailwindcss/oxide-linux-x64-musl": { + "version": "4.2.1", + "resolved": "https://registry.npmjs.org/@tailwindcss/oxide-linux-x64-musl/-/oxide-linux-x64-musl-4.2.1.tgz", + "integrity": "sha512-5r1X2FKnCMUPlXTWRYpHdPYUY6a1Ar/t7P24OuiEdEOmms5lyqjDRvVY1yy9Rmioh+AunQ0rWiOTPE8F9A3v5g==", + "cpu": [ + "x64" + ], + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">= 20" + } + }, + "node_modules/@tailwindcss/oxide-wasm32-wasi": { + "version": "4.2.1", + "resolved": "https://registry.npmjs.org/@tailwindcss/oxide-wasm32-wasi/-/oxide-wasm32-wasi-4.2.1.tgz", + "integrity": "sha512-MGFB5cVPvshR85MTJkEvqDUnuNoysrsRxd6vnk1Lf2tbiqNlXpHYZqkqOQalydienEWOHHFyyuTSYRsLfxFJ2Q==", + "bundleDependencies": [ + "@napi-rs/wasm-runtime", + "@emnapi/core", + "@emnapi/runtime", + "@tybys/wasm-util", + "@emnapi/wasi-threads", + "tslib" + ], + "cpu": [ + "wasm32" + ], + "license": "MIT", + "optional": true, + "dependencies": { + "@emnapi/core": "^1.8.1", + "@emnapi/runtime": "^1.8.1", + "@emnapi/wasi-threads": "^1.1.0", + "@napi-rs/wasm-runtime": "^1.1.1", + "@tybys/wasm-util": "^0.10.1", + "tslib": "^2.8.1" + }, + "engines": { + "node": ">=14.0.0" + } + }, + "node_modules/@tailwindcss/oxide-win32-arm64-msvc": { + "version": "4.2.1", + "resolved": "https://registry.npmjs.org/@tailwindcss/oxide-win32-arm64-msvc/-/oxide-win32-arm64-msvc-4.2.1.tgz", + "integrity": "sha512-YlUEHRHBGnCMh4Nj4GnqQyBtsshUPdiNroZj8VPkvTZSoHsilRCwXcVKnG9kyi0ZFAS/3u+qKHBdDc81SADTRA==", + "cpu": [ + "arm64" + ], + "license": "MIT", + "optional": true, + "os": [ + "win32" + ], + "engines": { + "node": ">= 20" + } + }, + "node_modules/@tailwindcss/oxide-win32-x64-msvc": { + "version": "4.2.1", + "resolved": "https://registry.npmjs.org/@tailwindcss/oxide-win32-x64-msvc/-/oxide-win32-x64-msvc-4.2.1.tgz", + "integrity": "sha512-rbO34G5sMWWyrN/idLeVxAZgAKWrn5LiR3/I90Q9MkA67s6T1oB0xtTe+0heoBvHSpbU9Mk7i6uwJnpo4u21XQ==", + "cpu": [ + "x64" + ], + "license": "MIT", + "optional": true, + "os": [ + "win32" + ], + "engines": { + "node": ">= 20" + } + }, + "node_modules/@tailwindcss/vite": { + "version": "4.2.1", + "resolved": "https://registry.npmjs.org/@tailwindcss/vite/-/vite-4.2.1.tgz", + "integrity": "sha512-TBf2sJjYeb28jD2U/OhwdW0bbOsxkWPwQ7SrqGf9sVcoYwZj7rkXljroBO9wKBut9XnmQLXanuDUeqQK0lGg/w==", + "license": "MIT", + "dependencies": { + "@tailwindcss/node": "4.2.1", + "@tailwindcss/oxide": "4.2.1", + "tailwindcss": "4.2.1" + }, + "peerDependencies": { + "vite": "^5.2.0 || ^6 || ^7" + } + }, + "node_modules/@tanstack/query-core": { + "version": "5.90.20", + "resolved": "https://registry.npmjs.org/@tanstack/query-core/-/query-core-5.90.20.tgz", + "integrity": "sha512-OMD2HLpNouXEfZJWcKeVKUgQ5n+n3A2JFmBaScpNDUqSrQSjiveC7dKMe53uJUg1nDG16ttFPz2xfilz6i2uVg==", + "license": "MIT", + "funding": { + "type": "github", + "url": "https://github.com/sponsors/tannerlinsley" + } + }, + "node_modules/@tanstack/react-query": { + "version": "5.90.21", + "resolved": "https://registry.npmjs.org/@tanstack/react-query/-/react-query-5.90.21.tgz", + "integrity": "sha512-0Lu6y5t+tvlTJMTO7oh5NSpJfpg/5D41LlThfepTixPYkJ0sE2Jj0m0f6yYqujBwIXlId87e234+MxG3D3g7kg==", + "license": "MIT", + "dependencies": { + "@tanstack/query-core": "5.90.20" + }, + "funding": { + "type": "github", + "url": "https://github.com/sponsors/tannerlinsley" + }, + "peerDependencies": { + "react": "^18 || ^19" + } + }, + "node_modules/@types/babel__core": { + "version": "7.20.5", + "resolved": "https://registry.npmjs.org/@types/babel__core/-/babel__core-7.20.5.tgz", + "integrity": "sha512-qoQprZvz5wQFJwMDqeseRXWv3rqMvhgpbXFfVyWhbx9X47POIA6i/+dXefEmZKoAgOaTdaIgNSMqMIU61yRyzA==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/parser": "^7.20.7", + "@babel/types": "^7.20.7", + "@types/babel__generator": "*", + "@types/babel__template": "*", + "@types/babel__traverse": "*" + } + }, + "node_modules/@types/babel__generator": { + "version": "7.27.0", + "resolved": "https://registry.npmjs.org/@types/babel__generator/-/babel__generator-7.27.0.tgz", + "integrity": "sha512-ufFd2Xi92OAVPYsy+P4n7/U7e68fex0+Ee8gSG9KX7eo084CWiQ4sdxktvdl0bOPupXtVJPY19zk6EwWqUQ8lg==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/types": "^7.0.0" + } + }, + "node_modules/@types/babel__template": { + "version": "7.4.4", + "resolved": "https://registry.npmjs.org/@types/babel__template/-/babel__template-7.4.4.tgz", + "integrity": "sha512-h/NUaSyG5EyxBIp8YRxo4RMe2/qQgvyowRwVMzhYhBCONbW8PUsg4lkFMrhgZhUe5z3L3MiLDuvyJ/CaPa2A8A==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/parser": "^7.1.0", + "@babel/types": "^7.0.0" + } + }, + "node_modules/@types/babel__traverse": { + "version": "7.28.0", + "resolved": "https://registry.npmjs.org/@types/babel__traverse/-/babel__traverse-7.28.0.tgz", + "integrity": "sha512-8PvcXf70gTDZBgt9ptxJ8elBeBjcLOAcOtoO/mPJjtji1+CdGbHgm77om1GrsPxsiE+uXIpNSK64UYaIwQXd4Q==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/types": "^7.28.2" + } + }, + "node_modules/@types/estree": { + "version": "1.0.8", + "resolved": "https://registry.npmjs.org/@types/estree/-/estree-1.0.8.tgz", + "integrity": "sha512-dWHzHa2WqEXI/O1E9OjrocMTKJl2mSrEolh1Iomrv6U+JuNwaHXsXx9bLu5gG7BUWFIN0skIQJQ/L1rIex4X6w==", + "license": "MIT" + }, + "node_modules/@types/json-schema": { + "version": "7.0.15", + "resolved": "https://registry.npmjs.org/@types/json-schema/-/json-schema-7.0.15.tgz", + "integrity": "sha512-5+fP8P8MFNC+AyZCDxrB2pkZFPGzqQWUzpSeuuVLvm8VMcorNYavBqoFcxK8bQz4Qsbn4oUEEem4wDLfcysGHA==", + "dev": true, + "license": "MIT" + }, + "node_modules/@types/node": { + "version": "24.10.13", + "resolved": "https://registry.npmjs.org/@types/node/-/node-24.10.13.tgz", + "integrity": "sha512-oH72nZRfDv9lADUBSo104Aq7gPHpQZc4BTx38r9xf9pg5LfP6EzSyH2n7qFmmxRQXh7YlUXODcYsg6PuTDSxGg==", + "devOptional": true, + "license": "MIT", + "dependencies": { + "undici-types": "~7.16.0" + } + }, + "node_modules/@types/react": { + "version": "19.2.14", + "resolved": "https://registry.npmjs.org/@types/react/-/react-19.2.14.tgz", + "integrity": "sha512-ilcTH/UniCkMdtexkoCN0bI7pMcJDvmQFPvuPvmEaYA/NSfFTAgdUSLAoVjaRJm7+6PvcM+q1zYOwS4wTYMF9w==", + "license": "MIT", + "dependencies": { + "csstype": "^3.2.2" + } + }, + "node_modules/@types/react-dom": { + "version": "19.2.3", + "resolved": "https://registry.npmjs.org/@types/react-dom/-/react-dom-19.2.3.tgz", + "integrity": "sha512-jp2L/eY6fn+KgVVQAOqYItbF0VY/YApe5Mz2F0aykSO8gx31bYCZyvSeYxCHKvzHG5eZjc+zyaS5BrBWya2+kQ==", + "dev": true, + "license": "MIT", + "peerDependencies": { + "@types/react": "^19.2.0" + } + }, + "node_modules/@types/react-reconciler": { + "version": "0.32.3", + "resolved": "https://registry.npmjs.org/@types/react-reconciler/-/react-reconciler-0.32.3.tgz", + "integrity": "sha512-cMi5ZrLG7UtbL7LTK6hq9w/EZIRk4Mf1Z5qHoI+qBh7/WkYkFXQ7gOto2yfUvPzF5ERMAhaXS5eTQ2SAnHjLzA==", + "license": "MIT", + "peerDependencies": { + "@types/react": "*" + } + }, + "node_modules/@typescript-eslint/eslint-plugin": { + "version": "8.56.1", + "resolved": "https://registry.npmjs.org/@typescript-eslint/eslint-plugin/-/eslint-plugin-8.56.1.tgz", + "integrity": "sha512-Jz9ZztpB37dNC+HU2HI28Bs9QXpzCz+y/twHOwhyrIRdbuVDxSytJNDl6z/aAKlaRIwC7y8wJdkBv7FxYGgi0A==", + "dev": true, + "license": "MIT", + "dependencies": { + "@eslint-community/regexpp": "^4.12.2", + "@typescript-eslint/scope-manager": "8.56.1", + "@typescript-eslint/type-utils": "8.56.1", + "@typescript-eslint/utils": "8.56.1", + "@typescript-eslint/visitor-keys": "8.56.1", + "ignore": "^7.0.5", + "natural-compare": "^1.4.0", + "ts-api-utils": "^2.4.0" + }, + "engines": { + "node": "^18.18.0 || ^20.9.0 || >=21.1.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/typescript-eslint" + }, + "peerDependencies": { + "@typescript-eslint/parser": "^8.56.1", + "eslint": "^8.57.0 || ^9.0.0 || ^10.0.0", + "typescript": ">=4.8.4 <6.0.0" + } + }, + "node_modules/@typescript-eslint/eslint-plugin/node_modules/ignore": { + "version": "7.0.5", + "resolved": "https://registry.npmjs.org/ignore/-/ignore-7.0.5.tgz", + "integrity": "sha512-Hs59xBNfUIunMFgWAbGX5cq6893IbWg4KnrjbYwX3tx0ztorVgTDA6B2sxf8ejHJ4wz8BqGUMYlnzNBer5NvGg==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">= 4" + } + }, + "node_modules/@typescript-eslint/parser": { + "version": "8.56.1", + "resolved": "https://registry.npmjs.org/@typescript-eslint/parser/-/parser-8.56.1.tgz", + "integrity": "sha512-klQbnPAAiGYFyI02+znpBRLyjL4/BrBd0nyWkdC0s/6xFLkXYQ8OoRrSkqacS1ddVxf/LDyODIKbQ5TgKAf/Fg==", + "dev": true, + "license": "MIT", + "dependencies": { + "@typescript-eslint/scope-manager": "8.56.1", + "@typescript-eslint/types": "8.56.1", + "@typescript-eslint/typescript-estree": "8.56.1", + "@typescript-eslint/visitor-keys": "8.56.1", + "debug": "^4.4.3" + }, + "engines": { + "node": "^18.18.0 || ^20.9.0 || >=21.1.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/typescript-eslint" + }, + "peerDependencies": { + "eslint": "^8.57.0 || ^9.0.0 || ^10.0.0", + "typescript": ">=4.8.4 <6.0.0" + } + }, + "node_modules/@typescript-eslint/project-service": { + "version": "8.56.1", + "resolved": "https://registry.npmjs.org/@typescript-eslint/project-service/-/project-service-8.56.1.tgz", + "integrity": "sha512-TAdqQTzHNNvlVFfR+hu2PDJrURiwKsUvxFn1M0h95BB8ah5jejas08jUWG4dBA68jDMI988IvtfdAI53JzEHOQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "@typescript-eslint/tsconfig-utils": "^8.56.1", + "@typescript-eslint/types": "^8.56.1", + "debug": "^4.4.3" + }, + "engines": { + "node": "^18.18.0 || ^20.9.0 || >=21.1.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/typescript-eslint" + }, + "peerDependencies": { + "typescript": ">=4.8.4 <6.0.0" + } + }, + "node_modules/@typescript-eslint/scope-manager": { + "version": "8.56.1", + "resolved": "https://registry.npmjs.org/@typescript-eslint/scope-manager/-/scope-manager-8.56.1.tgz", + "integrity": "sha512-YAi4VDKcIZp0O4tz/haYKhmIDZFEUPOreKbfdAN3SzUDMcPhJ8QI99xQXqX+HoUVq8cs85eRKnD+rne2UAnj2w==", + "dev": true, + "license": "MIT", + "dependencies": { + "@typescript-eslint/types": "8.56.1", + "@typescript-eslint/visitor-keys": "8.56.1" + }, + "engines": { + "node": "^18.18.0 || ^20.9.0 || >=21.1.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/typescript-eslint" + } + }, + "node_modules/@typescript-eslint/tsconfig-utils": { + "version": "8.56.1", + "resolved": "https://registry.npmjs.org/@typescript-eslint/tsconfig-utils/-/tsconfig-utils-8.56.1.tgz", + "integrity": "sha512-qOtCYzKEeyr3aR9f28mPJqBty7+DBqsdd63eO0yyDwc6vgThj2UjWfJIcsFeSucYydqcuudMOprZ+x1SpF3ZuQ==", + "dev": true, + "license": "MIT", + "engines": { + "node": "^18.18.0 || ^20.9.0 || >=21.1.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/typescript-eslint" + }, + "peerDependencies": { + "typescript": ">=4.8.4 <6.0.0" + } + }, + "node_modules/@typescript-eslint/type-utils": { + "version": "8.56.1", + "resolved": "https://registry.npmjs.org/@typescript-eslint/type-utils/-/type-utils-8.56.1.tgz", + "integrity": "sha512-yB/7dxi7MgTtGhZdaHCemf7PuwrHMenHjmzgUW1aJpO+bBU43OycnM3Wn+DdvDO/8zzA9HlhaJ0AUGuvri4oGg==", + "dev": true, + "license": "MIT", + "dependencies": { + "@typescript-eslint/types": "8.56.1", + "@typescript-eslint/typescript-estree": "8.56.1", + "@typescript-eslint/utils": "8.56.1", + "debug": "^4.4.3", + "ts-api-utils": "^2.4.0" + }, + "engines": { + "node": "^18.18.0 || ^20.9.0 || >=21.1.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/typescript-eslint" + }, + "peerDependencies": { + "eslint": "^8.57.0 || ^9.0.0 || ^10.0.0", + "typescript": ">=4.8.4 <6.0.0" + } + }, + "node_modules/@typescript-eslint/types": { + "version": "8.56.1", + "resolved": "https://registry.npmjs.org/@typescript-eslint/types/-/types-8.56.1.tgz", + "integrity": "sha512-dbMkdIUkIkchgGDIv7KLUpa0Mda4IYjo4IAMJUZ+3xNoUXxMsk9YtKpTHSChRS85o+H9ftm51gsK1dZReY9CVw==", + "dev": true, + "license": "MIT", + "engines": { + "node": "^18.18.0 || ^20.9.0 || >=21.1.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/typescript-eslint" + } + }, + "node_modules/@typescript-eslint/typescript-estree": { + "version": "8.56.1", + "resolved": "https://registry.npmjs.org/@typescript-eslint/typescript-estree/-/typescript-estree-8.56.1.tgz", + "integrity": "sha512-qzUL1qgalIvKWAf9C1HpvBjif+Vm6rcT5wZd4VoMb9+Km3iS3Cv9DY6dMRMDtPnwRAFyAi7YXJpTIEXLvdfPxg==", + "dev": true, + "license": "MIT", + "dependencies": { + "@typescript-eslint/project-service": "8.56.1", + "@typescript-eslint/tsconfig-utils": "8.56.1", + "@typescript-eslint/types": "8.56.1", + "@typescript-eslint/visitor-keys": "8.56.1", + "debug": "^4.4.3", + "minimatch": "^10.2.2", + "semver": "^7.7.3", + "tinyglobby": "^0.2.15", + "ts-api-utils": "^2.4.0" + }, + "engines": { + "node": "^18.18.0 || ^20.9.0 || >=21.1.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/typescript-eslint" + }, + "peerDependencies": { + "typescript": ">=4.8.4 <6.0.0" + } + }, + "node_modules/@typescript-eslint/typescript-estree/node_modules/balanced-match": { + "version": "4.0.4", + "resolved": "https://registry.npmjs.org/balanced-match/-/balanced-match-4.0.4.tgz", + "integrity": "sha512-BLrgEcRTwX2o6gGxGOCNyMvGSp35YofuYzw9h1IMTRmKqttAZZVU67bdb9Pr2vUHA8+j3i2tJfjO6C6+4myGTA==", + "dev": true, + "license": "MIT", + "engines": { + "node": "18 || 20 || >=22" + } + }, + "node_modules/@typescript-eslint/typescript-estree/node_modules/brace-expansion": { + "version": "5.0.3", + "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-5.0.3.tgz", + "integrity": "sha512-fy6KJm2RawA5RcHkLa1z/ScpBeA762UF9KmZQxwIbDtRJrgLzM10depAiEQ+CXYcoiqW1/m96OAAoke2nE9EeA==", + "dev": true, + "license": "MIT", + "dependencies": { + "balanced-match": "^4.0.2" + }, + "engines": { + "node": "18 || 20 || >=22" + } + }, + "node_modules/@typescript-eslint/typescript-estree/node_modules/minimatch": { + "version": "10.2.2", + "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-10.2.2.tgz", + "integrity": "sha512-+G4CpNBxa5MprY+04MbgOw1v7So6n5JY166pFi9KfYwT78fxScCeSNQSNzp6dpPSW2rONOps6Ocam1wFhCgoVw==", + "dev": true, + "license": "BlueOak-1.0.0", + "dependencies": { + "brace-expansion": "^5.0.2" + }, + "engines": { + "node": "18 || 20 || >=22" + }, + "funding": { + "url": "https://github.com/sponsors/isaacs" + } + }, + "node_modules/@typescript-eslint/typescript-estree/node_modules/semver": { + "version": "7.7.4", + "resolved": "https://registry.npmjs.org/semver/-/semver-7.7.4.tgz", + "integrity": "sha512-vFKC2IEtQnVhpT78h1Yp8wzwrf8CM+MzKMHGJZfBtzhZNycRFnXsHk6E5TxIkkMsgNS7mdX3AGB7x2QM2di4lA==", + "dev": true, + "license": "ISC", + "bin": { + "semver": "bin/semver.js" + }, + "engines": { + "node": ">=10" + } + }, + "node_modules/@typescript-eslint/utils": { + "version": "8.56.1", + "resolved": "https://registry.npmjs.org/@typescript-eslint/utils/-/utils-8.56.1.tgz", + "integrity": "sha512-HPAVNIME3tABJ61siYlHzSWCGtOoeP2RTIaHXFMPqjrQKCGB9OgUVdiNgH7TJS2JNIQ5qQ4RsAUDuGaGme/KOA==", + "dev": true, + "license": "MIT", + "dependencies": { + "@eslint-community/eslint-utils": "^4.9.1", + "@typescript-eslint/scope-manager": "8.56.1", + "@typescript-eslint/types": "8.56.1", + "@typescript-eslint/typescript-estree": "8.56.1" + }, + "engines": { + "node": "^18.18.0 || ^20.9.0 || >=21.1.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/typescript-eslint" + }, + "peerDependencies": { + "eslint": "^8.57.0 || ^9.0.0 || ^10.0.0", + "typescript": ">=4.8.4 <6.0.0" + } + }, + "node_modules/@typescript-eslint/visitor-keys": { + "version": "8.56.1", + "resolved": "https://registry.npmjs.org/@typescript-eslint/visitor-keys/-/visitor-keys-8.56.1.tgz", + "integrity": "sha512-KiROIzYdEV85YygXw6BI/Dx4fnBlFQu6Mq4QE4MOH9fFnhohw6wX/OAvDY2/C+ut0I3RSPKenvZJIVYqJNkhEw==", + "dev": true, + "license": "MIT", + "dependencies": { + "@typescript-eslint/types": "8.56.1", + "eslint-visitor-keys": "^5.0.0" + }, + "engines": { + "node": "^18.18.0 || ^20.9.0 || >=21.1.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/typescript-eslint" + } + }, + "node_modules/@typescript-eslint/visitor-keys/node_modules/eslint-visitor-keys": { + "version": "5.0.1", + "resolved": "https://registry.npmjs.org/eslint-visitor-keys/-/eslint-visitor-keys-5.0.1.tgz", + "integrity": "sha512-tD40eHxA35h0PEIZNeIjkHoDR4YjjJp34biM0mDvplBe//mB+IHCqHDGV7pxF+7MklTvighcCPPZC7ynWyjdTA==", + "dev": true, + "license": "Apache-2.0", + "engines": { + "node": "^20.19.0 || ^22.13.0 || >=24" + }, + "funding": { + "url": "https://opencollective.com/eslint" + } + }, + "node_modules/@vitejs/plugin-react": { + "version": "5.1.4", + "resolved": "https://registry.npmjs.org/@vitejs/plugin-react/-/plugin-react-5.1.4.tgz", + "integrity": "sha512-VIcFLdRi/VYRU8OL/puL7QXMYafHmqOnwTZY50U1JPlCNj30PxCMx65c494b1K9be9hX83KVt0+gTEwTWLqToA==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/core": "^7.29.0", + "@babel/plugin-transform-react-jsx-self": "^7.27.1", + "@babel/plugin-transform-react-jsx-source": "^7.27.1", + "@rolldown/pluginutils": "1.0.0-rc.3", + "@types/babel__core": "^7.20.5", + "react-refresh": "^0.18.0" + }, + "engines": { + "node": "^20.19.0 || >=22.12.0" + }, + "peerDependencies": { + "vite": "^4.2.0 || ^5.0.0 || ^6.0.0 || ^7.0.0" + } + }, + "node_modules/acorn": { + "version": "8.16.0", + "resolved": "https://registry.npmjs.org/acorn/-/acorn-8.16.0.tgz", + "integrity": "sha512-UVJyE9MttOsBQIDKw1skb9nAwQuR5wuGD3+82K6JgJlm/Y+KI92oNsMNGZCYdDsVtRHSak0pcV5Dno5+4jh9sw==", + "dev": true, + "license": "MIT", + "bin": { + "acorn": "bin/acorn" + }, + "engines": { + "node": ">=0.4.0" + } + }, + "node_modules/acorn-jsx": { + "version": "5.3.2", + "resolved": "https://registry.npmjs.org/acorn-jsx/-/acorn-jsx-5.3.2.tgz", + "integrity": "sha512-rq9s+JNhf0IChjtDXxllJ7g41oZk5SlXtp0LHwyA5cejwn7vKmKp4pPri6YEePv2PU65sAsegbXtIinmDFDXgQ==", + "dev": true, + "license": "MIT", + "peerDependencies": { + "acorn": "^6.0.0 || ^7.0.0 || ^8.0.0" + } + }, + "node_modules/ajv": { + "version": "6.14.0", + "resolved": "https://registry.npmjs.org/ajv/-/ajv-6.14.0.tgz", + "integrity": "sha512-IWrosm/yrn43eiKqkfkHis7QioDleaXQHdDVPKg0FSwwd/DuvyX79TZnFOnYpB7dcsFAMmtFztZuXPDvSePkFw==", + "dev": true, + "license": "MIT", + "dependencies": { + "fast-deep-equal": "^3.1.1", + "fast-json-stable-stringify": "^2.0.0", + "json-schema-traverse": "^0.4.1", + "uri-js": "^4.2.2" + }, + "funding": { + "type": "github", + "url": "https://github.com/sponsors/epoberezkin" + } + }, + "node_modules/ansi-styles": { + "version": "4.3.0", + "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-4.3.0.tgz", + "integrity": "sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg==", + "dev": true, + "license": "MIT", + "dependencies": { + "color-convert": "^2.0.1" + }, + "engines": { + "node": ">=8" + }, + "funding": { + "url": "https://github.com/chalk/ansi-styles?sponsor=1" + } + }, + "node_modules/argparse": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/argparse/-/argparse-2.0.1.tgz", + "integrity": "sha512-8+9WqebbFzpX9OR+Wa6O29asIogeRMzcGtAINdpMHHyAg10f05aSFVBbcEqGf/PXw1EjAZ+q2/bEBg3DvurK3Q==", + "dev": true, + "license": "Python-2.0" + }, + "node_modules/asynckit": { + "version": "0.4.0", + "resolved": "https://registry.npmjs.org/asynckit/-/asynckit-0.4.0.tgz", + "integrity": "sha512-Oei9OH4tRh0YqU3GxhX79dM/mwVgvbZJaSNaRk+bshkj0S5cfHcgYakreBjrHwatXKbz+IoIdYLxrKim2MjW0Q==", + "license": "MIT" + }, + "node_modules/attr-accept": { + "version": "2.2.5", + "resolved": "https://registry.npmjs.org/attr-accept/-/attr-accept-2.2.5.tgz", + "integrity": "sha512-0bDNnY/u6pPwHDMoF0FieU354oBi0a8rD9FcsLwzcGWbc8KS8KPIi7y+s13OlVY+gMWc/9xEMUgNE6Qm8ZllYQ==", + "license": "MIT", + "engines": { + "node": ">=4" + } + }, + "node_modules/axios": { + "version": "1.13.5", + "resolved": "https://registry.npmjs.org/axios/-/axios-1.13.5.tgz", + "integrity": "sha512-cz4ur7Vb0xS4/KUN0tPWe44eqxrIu31me+fbang3ijiNscE129POzipJJA6zniq2C/Z6sJCjMimjS8Lc/GAs8Q==", + "license": "MIT", + "dependencies": { + "follow-redirects": "^1.15.11", + "form-data": "^4.0.5", + "proxy-from-env": "^1.1.0" + } + }, + "node_modules/balanced-match": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/balanced-match/-/balanced-match-1.0.2.tgz", + "integrity": "sha512-3oSeUO0TMV67hN1AmbXsK4yaqU7tjiHlbxRDZOpH0KW9+CeX4bRAaX0Anxt0tx2MrpRpWwQaPwIlISEJhYU5Pw==", + "dev": true, + "license": "MIT" + }, + "node_modules/baseline-browser-mapping": { + "version": "2.10.0", + "resolved": "https://registry.npmjs.org/baseline-browser-mapping/-/baseline-browser-mapping-2.10.0.tgz", + "integrity": "sha512-lIyg0szRfYbiy67j9KN8IyeD7q7hcmqnJ1ddWmNt19ItGpNN64mnllmxUNFIOdOm6by97jlL6wfpTTJrmnjWAA==", + "dev": true, + "license": "Apache-2.0", + "bin": { + "baseline-browser-mapping": "dist/cli.cjs" + }, + "engines": { + "node": ">=6.0.0" + } + }, + "node_modules/brace-expansion": { + "version": "1.1.12", + "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-1.1.12.tgz", + "integrity": "sha512-9T9UjW3r0UW5c1Q7GTwllptXwhvYmEzFhzMfZ9H7FQWt+uZePjZPjBP/W1ZEyZ1twGWom5/56TF4lPcqjnDHcg==", + "dev": true, + "license": "MIT", + "dependencies": { + "balanced-match": "^1.0.0", + "concat-map": "0.0.1" + } + }, + "node_modules/browserslist": { + "version": "4.28.1", + "resolved": "https://registry.npmjs.org/browserslist/-/browserslist-4.28.1.tgz", + "integrity": "sha512-ZC5Bd0LgJXgwGqUknZY/vkUQ04r8NXnJZ3yYi4vDmSiZmC/pdSN0NbNRPxZpbtO4uAfDUAFffO8IZoM3Gj8IkA==", + "dev": true, + "funding": [ + { + "type": "opencollective", + "url": "https://opencollective.com/browserslist" + }, + { + "type": "tidelift", + "url": "https://tidelift.com/funding/github/npm/browserslist" + }, + { + "type": "github", + "url": "https://github.com/sponsors/ai" + } + ], + "license": "MIT", + "dependencies": { + "baseline-browser-mapping": "^2.9.0", + "caniuse-lite": "^1.0.30001759", + "electron-to-chromium": "^1.5.263", + "node-releases": "^2.0.27", + "update-browserslist-db": "^1.2.0" + }, + "bin": { + "browserslist": "cli.js" + }, + "engines": { + "node": "^6 || ^7 || ^8 || ^9 || ^10 || ^11 || ^12 || >=13.7" + } + }, + "node_modules/call-bind-apply-helpers": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/call-bind-apply-helpers/-/call-bind-apply-helpers-1.0.2.tgz", + "integrity": "sha512-Sp1ablJ0ivDkSzjcaJdxEunN5/XvksFJ2sMBFfq6x0ryhQV/2b/KwFe21cMpmHtPOSij8K99/wSfoEuTObmuMQ==", + "license": "MIT", + "dependencies": { + "es-errors": "^1.3.0", + "function-bind": "^1.1.2" + }, + "engines": { + "node": ">= 0.4" + } + }, + "node_modules/callsites": { + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/callsites/-/callsites-3.1.0.tgz", + "integrity": "sha512-P8BjAsXvZS+VIDUI11hHCQEv74YT67YUi5JJFNWIqL235sBmjX4+qx9Muvls5ivyNENctx46xQLQ3aTuE7ssaQ==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=6" + } + }, + "node_modules/caniuse-lite": { + "version": "1.0.30001774", + "resolved": "https://registry.npmjs.org/caniuse-lite/-/caniuse-lite-1.0.30001774.tgz", + "integrity": "sha512-DDdwPGz99nmIEv216hKSgLD+D4ikHQHjBC/seF98N9CPqRX4M5mSxT9eTV6oyisnJcuzxtZy4n17yKKQYmYQOA==", + "dev": true, + "funding": [ + { + "type": "opencollective", + "url": "https://opencollective.com/browserslist" + }, + { + "type": "tidelift", + "url": "https://tidelift.com/funding/github/npm/caniuse-lite" + }, + { + "type": "github", + "url": "https://github.com/sponsors/ai" + } + ], + "license": "CC-BY-4.0" + }, + "node_modules/chalk": { + "version": "4.1.2", + "resolved": "https://registry.npmjs.org/chalk/-/chalk-4.1.2.tgz", + "integrity": "sha512-oKnbhFyRIXpUuez8iBMmyEa4nbj4IOQyuhc/wy9kY7/WVPcwIO9VA668Pu8RkO7+0G76SLROeyw9CpQ061i4mA==", + "dev": true, + "license": "MIT", + "dependencies": { + "ansi-styles": "^4.1.0", + "supports-color": "^7.1.0" + }, + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/chalk/chalk?sponsor=1" + } + }, + "node_modules/color-convert": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/color-convert/-/color-convert-2.0.1.tgz", + "integrity": "sha512-RRECPsj7iu/xb5oKYcsFHSppFNnsj/52OVTRKb4zP5onXwVF3zVmmToNcOfGC+CRDpfK/U584fMg38ZHCaElKQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "color-name": "~1.1.4" + }, + "engines": { + "node": ">=7.0.0" + } + }, + "node_modules/color-name": { + "version": "1.1.4", + "resolved": "https://registry.npmjs.org/color-name/-/color-name-1.1.4.tgz", + "integrity": "sha512-dOy+3AuW3a2wNbZHIuMZpTcgjGuLU/uBL/ubcZF9OXbDo8ff4O8yVp5Bf0efS8uEoYo5q4Fx7dY9OgQGXgAsQA==", + "dev": true, + "license": "MIT" + }, + "node_modules/combined-stream": { + "version": "1.0.8", + "resolved": "https://registry.npmjs.org/combined-stream/-/combined-stream-1.0.8.tgz", + "integrity": "sha512-FQN4MRfuJeHf7cBbBMJFXhKSDq+2kAArBlmRBvcvFE5BB1HZKXtSFASDhdlz9zOYwxh8lDdnvmMOe/+5cdoEdg==", + "license": "MIT", + "dependencies": { + "delayed-stream": "~1.0.0" + }, + "engines": { + "node": ">= 0.8" + } + }, + "node_modules/concat-map": { + "version": "0.0.1", + "resolved": "https://registry.npmjs.org/concat-map/-/concat-map-0.0.1.tgz", + "integrity": "sha512-/Srv4dswyQNBfohGpz9o6Yb3Gz3SrUDqBH5rTuhGR7ahtlbYKnVxw2bCFMRljaA7EXHaXZ8wsHdodFvbkhKmqg==", + "dev": true, + "license": "MIT" + }, + "node_modules/convert-source-map": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/convert-source-map/-/convert-source-map-2.0.0.tgz", + "integrity": "sha512-Kvp459HrV2FEJ1CAsi1Ku+MY3kasH19TFykTz2xWmMeq6bk2NU3XXvfJ+Q61m0xktWwt+1HSYf3JZsTms3aRJg==", + "dev": true, + "license": "MIT" + }, + "node_modules/cookie": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/cookie/-/cookie-1.1.1.tgz", + "integrity": "sha512-ei8Aos7ja0weRpFzJnEA9UHJ/7XQmqglbRwnf2ATjcB9Wq874VKH9kfjjirM6UhU2/E5fFYadylyhFldcqSidQ==", + "license": "MIT", + "engines": { + "node": ">=18" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/express" + } + }, + "node_modules/cross-spawn": { + "version": "7.0.6", + "resolved": "https://registry.npmjs.org/cross-spawn/-/cross-spawn-7.0.6.tgz", + "integrity": "sha512-uV2QOWP2nWzsy2aMp8aRibhi9dlzF5Hgh5SHaB9OiTGEyDTiJJyx0uy51QXdyWbtAHNua4XJzUKca3OzKUd3vA==", + "dev": true, + "license": "MIT", + "dependencies": { + "path-key": "^3.1.0", + "shebang-command": "^2.0.0", + "which": "^2.0.1" + }, + "engines": { + "node": ">= 8" + } + }, + "node_modules/csstype": { + "version": "3.2.3", + "resolved": "https://registry.npmjs.org/csstype/-/csstype-3.2.3.tgz", + "integrity": "sha512-z1HGKcYy2xA8AGQfwrn0PAy+PB7X/GSj3UVJW9qKyn43xWa+gl5nXmU4qqLMRzWVLFC8KusUX8T/0kCiOYpAIQ==", + "license": "MIT" + }, + "node_modules/debug": { + "version": "4.4.3", + "resolved": "https://registry.npmjs.org/debug/-/debug-4.4.3.tgz", + "integrity": "sha512-RGwwWnwQvkVfavKVt22FGLw+xYSdzARwm0ru6DhTVA3umU5hZc28V3kO4stgYryrTlLpuvgI9GiijltAjNbcqA==", + "dev": true, + "license": "MIT", + "dependencies": { + "ms": "^2.1.3" + }, + "engines": { + "node": ">=6.0" + }, + "peerDependenciesMeta": { + "supports-color": { + "optional": true + } + } + }, + "node_modules/deep-is": { + "version": "0.1.4", + "resolved": "https://registry.npmjs.org/deep-is/-/deep-is-0.1.4.tgz", + "integrity": "sha512-oIPzksmTg4/MriiaYGO+okXDT7ztn/w3Eptv/+gSIdMdKsJo0u4CfYNFJPy+4SKMuCqGw2wxnA+URMg3t8a/bQ==", + "dev": true, + "license": "MIT" + }, + "node_modules/delayed-stream": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/delayed-stream/-/delayed-stream-1.0.0.tgz", + "integrity": "sha512-ZySD7Nf91aLB0RxL4KGrKHBXl7Eds1DAmEdcoVawXnLD7SDhpNgtuII2aAkg7a7QS41jxPSZ17p4VdGnMHk3MQ==", + "license": "MIT", + "engines": { + "node": ">=0.4.0" + } + }, + "node_modules/detect-libc": { + "version": "2.1.2", + "resolved": "https://registry.npmjs.org/detect-libc/-/detect-libc-2.1.2.tgz", + "integrity": "sha512-Btj2BOOO83o3WyH59e8MgXsxEQVcarkUOpEYrubB0urwnN10yQ364rsiByU11nZlqWYZm05i/of7io4mzihBtQ==", + "license": "Apache-2.0", + "engines": { + "node": ">=8" + } + }, + "node_modules/dunder-proto": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/dunder-proto/-/dunder-proto-1.0.1.tgz", + "integrity": "sha512-KIN/nDJBQRcXw0MLVhZE9iQHmG68qAVIBg9CqmUYjmQIhgij9U5MFvrqkUL5FbtyyzZuOeOt0zdeRe4UY7ct+A==", + "license": "MIT", + "dependencies": { + "call-bind-apply-helpers": "^1.0.1", + "es-errors": "^1.3.0", + "gopd": "^1.2.0" + }, + "engines": { + "node": ">= 0.4" + } + }, + "node_modules/electron-to-chromium": { + "version": "1.5.302", + "resolved": "https://registry.npmjs.org/electron-to-chromium/-/electron-to-chromium-1.5.302.tgz", + "integrity": "sha512-sM6HAN2LyK82IyPBpznDRqlTQAtuSaO+ShzFiWTvoMJLHyZ+Y39r8VMfHzwbU8MVBzQ4Wdn85+wlZl2TLGIlwg==", + "dev": true, + "license": "ISC" + }, + "node_modules/enhanced-resolve": { + "version": "5.19.0", + "resolved": "https://registry.npmjs.org/enhanced-resolve/-/enhanced-resolve-5.19.0.tgz", + "integrity": "sha512-phv3E1Xl4tQOShqSte26C7Fl84EwUdZsyOuSSk9qtAGyyQs2s3jJzComh+Abf4g187lUUAvH+H26omrqia2aGg==", + "license": "MIT", + "dependencies": { + "graceful-fs": "^4.2.4", + "tapable": "^2.3.0" + }, + "engines": { + "node": ">=10.13.0" + } + }, + "node_modules/es-define-property": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/es-define-property/-/es-define-property-1.0.1.tgz", + "integrity": "sha512-e3nRfgfUZ4rNGL232gUgX06QNyyez04KdjFrF+LTRoOXmrOgFKDg4BCdsjW8EnT69eqdYGmRpJwiPVYNrCaW3g==", + "license": "MIT", + "engines": { + "node": ">= 0.4" + } + }, + "node_modules/es-errors": { + "version": "1.3.0", + "resolved": "https://registry.npmjs.org/es-errors/-/es-errors-1.3.0.tgz", + "integrity": "sha512-Zf5H2Kxt2xjTvbJvP2ZWLEICxA6j+hAmMzIlypy4xcBg1vKVnx89Wy0GbS+kf5cwCVFFzdCFh2XSCFNULS6csw==", + "license": "MIT", + "engines": { + "node": ">= 0.4" + } + }, + "node_modules/es-object-atoms": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/es-object-atoms/-/es-object-atoms-1.1.1.tgz", + "integrity": "sha512-FGgH2h8zKNim9ljj7dankFPcICIK9Cp5bm+c2gQSYePhpaG5+esrLODihIorn+Pe6FGJzWhXQotPv73jTaldXA==", + "license": "MIT", + "dependencies": { + "es-errors": "^1.3.0" + }, + "engines": { + "node": ">= 0.4" + } + }, + "node_modules/es-set-tostringtag": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/es-set-tostringtag/-/es-set-tostringtag-2.1.0.tgz", + "integrity": "sha512-j6vWzfrGVfyXxge+O0x5sh6cvxAog0a/4Rdd2K36zCMV5eJ+/+tOAngRO8cODMNWbVRdVlmGZQL2YS3yR8bIUA==", + "license": "MIT", + "dependencies": { + "es-errors": "^1.3.0", + "get-intrinsic": "^1.2.6", + "has-tostringtag": "^1.0.2", + "hasown": "^2.0.2" + }, + "engines": { + "node": ">= 0.4" + } + }, + "node_modules/esbuild": { + "version": "0.27.3", + "resolved": "https://registry.npmjs.org/esbuild/-/esbuild-0.27.3.tgz", + "integrity": "sha512-8VwMnyGCONIs6cWue2IdpHxHnAjzxnw2Zr7MkVxB2vjmQ2ivqGFb4LEG3SMnv0Gb2F/G/2yA8zUaiL1gywDCCg==", + "hasInstallScript": true, + "license": "MIT", + "bin": { + "esbuild": "bin/esbuild" + }, + "engines": { + "node": ">=18" + }, + "optionalDependencies": { + "@esbuild/aix-ppc64": "0.27.3", + "@esbuild/android-arm": "0.27.3", + "@esbuild/android-arm64": "0.27.3", + "@esbuild/android-x64": "0.27.3", + "@esbuild/darwin-arm64": "0.27.3", + "@esbuild/darwin-x64": "0.27.3", + "@esbuild/freebsd-arm64": "0.27.3", + "@esbuild/freebsd-x64": "0.27.3", + "@esbuild/linux-arm": "0.27.3", + "@esbuild/linux-arm64": "0.27.3", + "@esbuild/linux-ia32": "0.27.3", + "@esbuild/linux-loong64": "0.27.3", + "@esbuild/linux-mips64el": "0.27.3", + "@esbuild/linux-ppc64": "0.27.3", + "@esbuild/linux-riscv64": "0.27.3", + "@esbuild/linux-s390x": "0.27.3", + "@esbuild/linux-x64": "0.27.3", + "@esbuild/netbsd-arm64": "0.27.3", + "@esbuild/netbsd-x64": "0.27.3", + "@esbuild/openbsd-arm64": "0.27.3", + "@esbuild/openbsd-x64": "0.27.3", + "@esbuild/openharmony-arm64": "0.27.3", + "@esbuild/sunos-x64": "0.27.3", + "@esbuild/win32-arm64": "0.27.3", + "@esbuild/win32-ia32": "0.27.3", + "@esbuild/win32-x64": "0.27.3" + } + }, + "node_modules/escalade": { + "version": "3.2.0", + "resolved": "https://registry.npmjs.org/escalade/-/escalade-3.2.0.tgz", + "integrity": "sha512-WUj2qlxaQtO4g6Pq5c29GTcWGDyd8itL8zTlipgECz3JesAiiOKotd8JU6otB3PACgG6xkJUyVhboMS+bje/jA==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=6" + } + }, + "node_modules/escape-string-regexp": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/escape-string-regexp/-/escape-string-regexp-4.0.0.tgz", + "integrity": "sha512-TtpcNJ3XAzx3Gq8sWRzJaVajRs0uVxA2YAkdb1jm2YkPz4G6egUFAyA3n5vtEIZefPk5Wa4UXbKuS5fKkJWdgA==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/eslint": { + "version": "9.39.3", + "resolved": "https://registry.npmjs.org/eslint/-/eslint-9.39.3.tgz", + "integrity": "sha512-VmQ+sifHUbI/IcSopBCF/HO3YiHQx/AVd3UVyYL6weuwW+HvON9VYn5l6Zl1WZzPWXPNZrSQpxwkkZ/VuvJZzg==", + "dev": true, + "license": "MIT", + "dependencies": { + "@eslint-community/eslint-utils": "^4.8.0", + "@eslint-community/regexpp": "^4.12.1", + "@eslint/config-array": "^0.21.1", + "@eslint/config-helpers": "^0.4.2", + "@eslint/core": "^0.17.0", + "@eslint/eslintrc": "^3.3.1", + "@eslint/js": "9.39.3", + "@eslint/plugin-kit": "^0.4.1", + "@humanfs/node": "^0.16.6", + "@humanwhocodes/module-importer": "^1.0.1", + "@humanwhocodes/retry": "^0.4.2", + "@types/estree": "^1.0.6", + "ajv": "^6.12.4", + "chalk": "^4.0.0", + "cross-spawn": "^7.0.6", + "debug": "^4.3.2", + "escape-string-regexp": "^4.0.0", + "eslint-scope": "^8.4.0", + "eslint-visitor-keys": "^4.2.1", + "espree": "^10.4.0", + "esquery": "^1.5.0", + "esutils": "^2.0.2", + "fast-deep-equal": "^3.1.3", + "file-entry-cache": "^8.0.0", + "find-up": "^5.0.0", + "glob-parent": "^6.0.2", + "ignore": "^5.2.0", + "imurmurhash": "^0.1.4", + "is-glob": "^4.0.0", + "json-stable-stringify-without-jsonify": "^1.0.1", + "lodash.merge": "^4.6.2", + "minimatch": "^3.1.2", + "natural-compare": "^1.4.0", + "optionator": "^0.9.3" + }, + "bin": { + "eslint": "bin/eslint.js" + }, + "engines": { + "node": "^18.18.0 || ^20.9.0 || >=21.1.0" + }, + "funding": { + "url": "https://eslint.org/donate" + }, + "peerDependencies": { + "jiti": "*" + }, + "peerDependenciesMeta": { + "jiti": { + "optional": true + } + } + }, + "node_modules/eslint-plugin-react-hooks": { + "version": "7.0.1", + "resolved": "https://registry.npmjs.org/eslint-plugin-react-hooks/-/eslint-plugin-react-hooks-7.0.1.tgz", + "integrity": "sha512-O0d0m04evaNzEPoSW+59Mezf8Qt0InfgGIBJnpC0h3NH/WjUAR7BIKUfysC6todmtiZ/A0oUVS8Gce0WhBrHsA==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/core": "^7.24.4", + "@babel/parser": "^7.24.4", + "hermes-parser": "^0.25.1", + "zod": "^3.25.0 || ^4.0.0", + "zod-validation-error": "^3.5.0 || ^4.0.0" + }, + "engines": { + "node": ">=18" + }, + "peerDependencies": { + "eslint": "^3.0.0 || ^4.0.0 || ^5.0.0 || ^6.0.0 || ^7.0.0 || ^8.0.0-0 || ^9.0.0" + } + }, + "node_modules/eslint-plugin-react-refresh": { + "version": "0.4.26", + "resolved": "https://registry.npmjs.org/eslint-plugin-react-refresh/-/eslint-plugin-react-refresh-0.4.26.tgz", + "integrity": "sha512-1RETEylht2O6FM/MvgnyvT+8K21wLqDNg4qD51Zj3guhjt433XbnnkVttHMyaVyAFD03QSV4LPS5iE3VQmO7XQ==", + "dev": true, + "license": "MIT", + "peerDependencies": { + "eslint": ">=8.40" + } + }, + "node_modules/eslint-scope": { + "version": "8.4.0", + "resolved": "https://registry.npmjs.org/eslint-scope/-/eslint-scope-8.4.0.tgz", + "integrity": "sha512-sNXOfKCn74rt8RICKMvJS7XKV/Xk9kA7DyJr8mJik3S7Cwgy3qlkkmyS2uQB3jiJg6VNdZd/pDBJu0nvG2NlTg==", + "dev": true, + "license": "BSD-2-Clause", + "dependencies": { + "esrecurse": "^4.3.0", + "estraverse": "^5.2.0" + }, + "engines": { + "node": "^18.18.0 || ^20.9.0 || >=21.1.0" + }, + "funding": { + "url": "https://opencollective.com/eslint" + } + }, + "node_modules/eslint-visitor-keys": { + "version": "4.2.1", + "resolved": "https://registry.npmjs.org/eslint-visitor-keys/-/eslint-visitor-keys-4.2.1.tgz", + "integrity": "sha512-Uhdk5sfqcee/9H/rCOJikYz67o0a2Tw2hGRPOG2Y1R2dg7brRe1uG0yaNQDHu+TO/uQPF/5eCapvYSmHUjt7JQ==", + "dev": true, + "license": "Apache-2.0", + "engines": { + "node": "^18.18.0 || ^20.9.0 || >=21.1.0" + }, + "funding": { + "url": "https://opencollective.com/eslint" + } + }, + "node_modules/espree": { + "version": "10.4.0", + "resolved": "https://registry.npmjs.org/espree/-/espree-10.4.0.tgz", + "integrity": "sha512-j6PAQ2uUr79PZhBjP5C5fhl8e39FmRnOjsD5lGnWrFU8i2G776tBK7+nP8KuQUTTyAZUwfQqXAgrVH5MbH9CYQ==", + "dev": true, + "license": "BSD-2-Clause", + "dependencies": { + "acorn": "^8.15.0", + "acorn-jsx": "^5.3.2", + "eslint-visitor-keys": "^4.2.1" + }, + "engines": { + "node": "^18.18.0 || ^20.9.0 || >=21.1.0" + }, + "funding": { + "url": "https://opencollective.com/eslint" + } + }, + "node_modules/esquery": { + "version": "1.7.0", + "resolved": "https://registry.npmjs.org/esquery/-/esquery-1.7.0.tgz", + "integrity": "sha512-Ap6G0WQwcU/LHsvLwON1fAQX9Zp0A2Y6Y/cJBl9r/JbW90Zyg4/zbG6zzKa2OTALELarYHmKu0GhpM5EO+7T0g==", + "dev": true, + "license": "BSD-3-Clause", + "dependencies": { + "estraverse": "^5.1.0" + }, + "engines": { + "node": ">=0.10" + } + }, + "node_modules/esrecurse": { + "version": "4.3.0", + "resolved": "https://registry.npmjs.org/esrecurse/-/esrecurse-4.3.0.tgz", + "integrity": "sha512-KmfKL3b6G+RXvP8N1vr3Tq1kL/oCFgn2NYXEtqP8/L3pKapUA4G8cFVaoF3SU323CD4XypR/ffioHmkti6/Tag==", + "dev": true, + "license": "BSD-2-Clause", + "dependencies": { + "estraverse": "^5.2.0" + }, + "engines": { + "node": ">=4.0" + } + }, + "node_modules/estraverse": { + "version": "5.3.0", + "resolved": "https://registry.npmjs.org/estraverse/-/estraverse-5.3.0.tgz", + "integrity": "sha512-MMdARuVEQziNTeJD8DgMqmhwR11BRQ/cBP+pLtYdSTnf3MIO8fFeiINEbX36ZdNlfU/7A9f3gUw49B3oQsvwBA==", + "dev": true, + "license": "BSD-2-Clause", + "engines": { + "node": ">=4.0" + } + }, + "node_modules/esutils": { + "version": "2.0.3", + "resolved": "https://registry.npmjs.org/esutils/-/esutils-2.0.3.tgz", + "integrity": "sha512-kVscqXk4OCp68SZ0dkgEKVi6/8ij300KBWTJq32P/dYeWTSwK41WyTxalN1eRmA5Z9UU/LX9D7FWSmV9SAYx6g==", + "dev": true, + "license": "BSD-2-Clause", + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/fast-deep-equal": { + "version": "3.1.3", + "resolved": "https://registry.npmjs.org/fast-deep-equal/-/fast-deep-equal-3.1.3.tgz", + "integrity": "sha512-f3qQ9oQy9j2AhBe/H9VC91wLmKBCCU/gDOnKNAYG5hswO7BLKj09Hc5HYNz9cGI++xlpDCIgDaitVs03ATR84Q==", + "dev": true, + "license": "MIT" + }, + "node_modules/fast-json-stable-stringify": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/fast-json-stable-stringify/-/fast-json-stable-stringify-2.1.0.tgz", + "integrity": "sha512-lhd/wF+Lk98HZoTCtlVraHtfh5XYijIjalXck7saUtuanSDyLMxnHhSXEDJqHxD7msR8D0uCmqlkwjCV8xvwHw==", + "dev": true, + "license": "MIT" + }, + "node_modules/fast-levenshtein": { + "version": "2.0.6", + "resolved": "https://registry.npmjs.org/fast-levenshtein/-/fast-levenshtein-2.0.6.tgz", + "integrity": "sha512-DCXu6Ifhqcks7TZKY3Hxp3y6qphY5SJZmrWMDrKcERSOXWQdMhU9Ig/PYrzyw/ul9jOIyh0N4M0tbC5hodg8dw==", + "dev": true, + "license": "MIT" + }, + "node_modules/fdir": { + "version": "6.5.0", + "resolved": "https://registry.npmjs.org/fdir/-/fdir-6.5.0.tgz", + "integrity": "sha512-tIbYtZbucOs0BRGqPJkshJUYdL+SDH7dVM8gjy+ERp3WAUjLEFJE+02kanyHtwjWOnwrKYBiwAmM0p4kLJAnXg==", + "license": "MIT", + "engines": { + "node": ">=12.0.0" + }, + "peerDependencies": { + "picomatch": "^3 || ^4" + }, + "peerDependenciesMeta": { + "picomatch": { + "optional": true + } + } + }, + "node_modules/file-entry-cache": { + "version": "8.0.0", + "resolved": "https://registry.npmjs.org/file-entry-cache/-/file-entry-cache-8.0.0.tgz", + "integrity": "sha512-XXTUwCvisa5oacNGRP9SfNtYBNAMi+RPwBFmblZEF7N7swHYQS6/Zfk7SRwx4D5j3CH211YNRco1DEMNVfZCnQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "flat-cache": "^4.0.0" + }, + "engines": { + "node": ">=16.0.0" + } + }, + "node_modules/file-selector": { + "version": "2.1.2", + "resolved": "https://registry.npmjs.org/file-selector/-/file-selector-2.1.2.tgz", + "integrity": "sha512-QgXo+mXTe8ljeqUFaX3QVHc5osSItJ/Km+xpocx0aSqWGMSCf6qYs/VnzZgS864Pjn5iceMRFigeAV7AfTlaig==", + "license": "MIT", + "dependencies": { + "tslib": "^2.7.0" + }, + "engines": { + "node": ">= 12" + } + }, + "node_modules/find-up": { + "version": "5.0.0", + "resolved": "https://registry.npmjs.org/find-up/-/find-up-5.0.0.tgz", + "integrity": "sha512-78/PXT1wlLLDgTzDs7sjq9hzz0vXD+zn+7wypEe4fXQxCmdmqfGsEPQxmiCSQI3ajFV91bVSsvNtrJRiW6nGng==", + "dev": true, + "license": "MIT", + "dependencies": { + "locate-path": "^6.0.0", + "path-exists": "^4.0.0" + }, + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/flat-cache": { + "version": "4.0.1", + "resolved": "https://registry.npmjs.org/flat-cache/-/flat-cache-4.0.1.tgz", + "integrity": "sha512-f7ccFPK3SXFHpx15UIGyRJ/FJQctuKZ0zVuN3frBo4HnK3cay9VEW0R6yPYFHC0AgqhukPzKjq22t5DmAyqGyw==", + "dev": true, + "license": "MIT", + "dependencies": { + "flatted": "^3.2.9", + "keyv": "^4.5.4" + }, + "engines": { + "node": ">=16" + } + }, + "node_modules/flatted": { + "version": "3.3.3", + "resolved": "https://registry.npmjs.org/flatted/-/flatted-3.3.3.tgz", + "integrity": "sha512-GX+ysw4PBCz0PzosHDepZGANEuFCMLrnRTiEy9McGjmkCQYwRq4A/X786G/fjM/+OjsWSU1ZrY5qyARZmO/uwg==", + "dev": true, + "license": "ISC" + }, + "node_modules/follow-redirects": { + "version": "1.15.11", + "resolved": "https://registry.npmjs.org/follow-redirects/-/follow-redirects-1.15.11.tgz", + "integrity": "sha512-deG2P0JfjrTxl50XGCDyfI97ZGVCxIpfKYmfyrQ54n5FO/0gfIES8C/Psl6kWVDolizcaaxZJnTS0QSMxvnsBQ==", + "funding": [ + { + "type": "individual", + "url": "https://github.com/sponsors/RubenVerborgh" + } + ], + "license": "MIT", + "engines": { + "node": ">=4.0" + }, + "peerDependenciesMeta": { + "debug": { + "optional": true + } + } + }, + "node_modules/form-data": { + "version": "4.0.5", + "resolved": "https://registry.npmjs.org/form-data/-/form-data-4.0.5.tgz", + "integrity": "sha512-8RipRLol37bNs2bhoV67fiTEvdTrbMUYcFTiy3+wuuOnUog2QBHCZWXDRijWQfAkhBj2Uf5UnVaiWwA5vdd82w==", + "license": "MIT", + "dependencies": { + "asynckit": "^0.4.0", + "combined-stream": "^1.0.8", + "es-set-tostringtag": "^2.1.0", + "hasown": "^2.0.2", + "mime-types": "^2.1.12" + }, + "engines": { + "node": ">= 6" + } + }, + "node_modules/fsevents": { + "version": "2.3.3", + "resolved": "https://registry.npmjs.org/fsevents/-/fsevents-2.3.3.tgz", + "integrity": "sha512-5xoDfX+fL7faATnagmWPpbFtwh/R77WmMMqqHGS65C3vvB0YHrgF+B1YmZ3441tMj5n63k0212XNoJwzlhffQw==", + "hasInstallScript": true, + "license": "MIT", + "optional": true, + "os": [ + "darwin" + ], + "engines": { + "node": "^8.16.0 || ^10.6.0 || >=11.0.0" + } + }, + "node_modules/function-bind": { + "version": "1.1.2", + "resolved": "https://registry.npmjs.org/function-bind/-/function-bind-1.1.2.tgz", + "integrity": "sha512-7XHNxH7qX9xG5mIwxkhumTox/MIRNcOgDrxWsMt2pAr23WHp6MrRlN7FBSFpCpr+oVO0F744iUgR82nJMfG2SA==", + "license": "MIT", + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/gensync": { + "version": "1.0.0-beta.2", + "resolved": "https://registry.npmjs.org/gensync/-/gensync-1.0.0-beta.2.tgz", + "integrity": "sha512-3hN7NaskYvMDLQY55gnW3NQ+mesEAepTqlg+VEbj7zzqEMBVNhzcGYYeqFo/TlYz6eQiFcp1HcsCZO+nGgS8zg==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/get-intrinsic": { + "version": "1.3.0", + "resolved": "https://registry.npmjs.org/get-intrinsic/-/get-intrinsic-1.3.0.tgz", + "integrity": "sha512-9fSjSaos/fRIVIp+xSJlE6lfwhES7LNtKaCBIamHsjr2na1BiABJPo0mOjjz8GJDURarmCPGqaiVg5mfjb98CQ==", + "license": "MIT", + "dependencies": { + "call-bind-apply-helpers": "^1.0.2", + "es-define-property": "^1.0.1", + "es-errors": "^1.3.0", + "es-object-atoms": "^1.1.1", + "function-bind": "^1.1.2", + "get-proto": "^1.0.1", + "gopd": "^1.2.0", + "has-symbols": "^1.1.0", + "hasown": "^2.0.2", + "math-intrinsics": "^1.1.0" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/get-proto": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/get-proto/-/get-proto-1.0.1.tgz", + "integrity": "sha512-sTSfBjoXBp89JvIKIefqw7U2CCebsc74kiY6awiGogKtoSGbgjYE/G/+l9sF3MWFPNc9IcoOC4ODfKHfxFmp0g==", + "license": "MIT", + "dependencies": { + "dunder-proto": "^1.0.1", + "es-object-atoms": "^1.0.0" + }, + "engines": { + "node": ">= 0.4" + } + }, + "node_modules/glob-parent": { + "version": "6.0.2", + "resolved": "https://registry.npmjs.org/glob-parent/-/glob-parent-6.0.2.tgz", + "integrity": "sha512-XxwI8EOhVQgWp6iDL+3b0r86f4d6AX6zSU55HfB4ydCEuXLXc5FcYeOu+nnGftS4TEju/11rt4KJPTMgbfmv4A==", + "dev": true, + "license": "ISC", + "dependencies": { + "is-glob": "^4.0.3" + }, + "engines": { + "node": ">=10.13.0" + } + }, + "node_modules/globals": { + "version": "16.5.0", + "resolved": "https://registry.npmjs.org/globals/-/globals-16.5.0.tgz", + "integrity": "sha512-c/c15i26VrJ4IRt5Z89DnIzCGDn9EcebibhAOjw5ibqEHsE1wLUgkPn9RDmNcUKyU87GeaL633nyJ+pplFR2ZQ==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=18" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/gopd": { + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/gopd/-/gopd-1.2.0.tgz", + "integrity": "sha512-ZUKRh6/kUFoAiTAtTYPZJ3hw9wNxx+BIBOijnlG9PnrJsCcSjs1wyyD6vJpaYtgnzDrKYRSqf3OO6Rfa93xsRg==", + "license": "MIT", + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/graceful-fs": { + "version": "4.2.11", + "resolved": "https://registry.npmjs.org/graceful-fs/-/graceful-fs-4.2.11.tgz", + "integrity": "sha512-RbJ5/jmFcNNCcDV5o9eTnBLJ/HszWV0P73bc+Ff4nS/rJj+YaS6IGyiOL0VoBYX+l1Wrl3k63h/KrH+nhJ0XvQ==", + "license": "ISC" + }, + "node_modules/has-flag": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/has-flag/-/has-flag-4.0.0.tgz", + "integrity": "sha512-EykJT/Q1KjTWctppgIAgfSO0tKVuZUjhgMr17kqTumMl6Afv3EISleU7qZUzoXDFTAHTDC4NOoG/ZxU3EvlMPQ==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=8" + } + }, + "node_modules/has-symbols": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/has-symbols/-/has-symbols-1.1.0.tgz", + "integrity": "sha512-1cDNdwJ2Jaohmb3sg4OmKaMBwuC48sYni5HUw2DvsC8LjGTLK9h+eb1X6RyuOHe4hT0ULCW68iomhjUoKUqlPQ==", + "license": "MIT", + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/has-tostringtag": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/has-tostringtag/-/has-tostringtag-1.0.2.tgz", + "integrity": "sha512-NqADB8VjPFLM2V0VvHUewwwsw0ZWBaIdgo+ieHtK3hasLz4qeCRjYcqfB6AQrBggRKppKF8L52/VqdVsO47Dlw==", + "license": "MIT", + "dependencies": { + "has-symbols": "^1.0.3" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/hasown": { + "version": "2.0.2", + "resolved": "https://registry.npmjs.org/hasown/-/hasown-2.0.2.tgz", + "integrity": "sha512-0hJU9SCPvmMzIBdZFqNPXWa6dqh7WdH0cII9y+CyS8rG3nL48Bclra9HmKhVVUHyPWNH5Y7xDwAB7bfgSjkUMQ==", + "license": "MIT", + "dependencies": { + "function-bind": "^1.1.2" + }, + "engines": { + "node": ">= 0.4" + } + }, + "node_modules/hermes-estree": { + "version": "0.25.1", + "resolved": "https://registry.npmjs.org/hermes-estree/-/hermes-estree-0.25.1.tgz", + "integrity": "sha512-0wUoCcLp+5Ev5pDW2OriHC2MJCbwLwuRx+gAqMTOkGKJJiBCLjtrvy4PWUGn6MIVefecRpzoOZ/UV6iGdOr+Cw==", + "dev": true, + "license": "MIT" + }, + "node_modules/hermes-parser": { + "version": "0.25.1", + "resolved": "https://registry.npmjs.org/hermes-parser/-/hermes-parser-0.25.1.tgz", + "integrity": "sha512-6pEjquH3rqaI6cYAXYPcz9MS4rY6R4ngRgrgfDshRptUZIc3lw0MCIJIGDj9++mfySOuPTHB4nrSW99BCvOPIA==", + "dev": true, + "license": "MIT", + "dependencies": { + "hermes-estree": "0.25.1" + } + }, + "node_modules/ignore": { + "version": "5.3.2", + "resolved": "https://registry.npmjs.org/ignore/-/ignore-5.3.2.tgz", + "integrity": "sha512-hsBTNUqQTDwkWtcdYI2i06Y/nUBEsNEDJKjWdigLvegy8kDuJAS8uRlpkkcQpyEXL0Z/pjDy5HBmMjRCJ2gq+g==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">= 4" + } + }, + "node_modules/import-fresh": { + "version": "3.3.1", + "resolved": "https://registry.npmjs.org/import-fresh/-/import-fresh-3.3.1.tgz", + "integrity": "sha512-TR3KfrTZTYLPB6jUjfx6MF9WcWrHL9su5TObK4ZkYgBdWKPOFoSoQIdEuTuR82pmtxH2spWG9h6etwfr1pLBqQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "parent-module": "^1.0.0", + "resolve-from": "^4.0.0" + }, + "engines": { + "node": ">=6" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/imurmurhash": { + "version": "0.1.4", + "resolved": "https://registry.npmjs.org/imurmurhash/-/imurmurhash-0.1.4.tgz", + "integrity": "sha512-JmXMZ6wuvDmLiHEml9ykzqO6lwFbof0GG4IkcGaENdCRDDmMVnny7s5HsIgHCbaq0w2MyPhDqkhTUgS2LU2PHA==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=0.8.19" + } + }, + "node_modules/is-extglob": { + "version": "2.1.1", + "resolved": "https://registry.npmjs.org/is-extglob/-/is-extglob-2.1.1.tgz", + "integrity": "sha512-SbKbANkN603Vi4jEZv49LeVJMn4yGwsbzZworEoyEiutsN3nJYdbO36zfhGJ6QEDpOZIFkDtnq5JRxmvl3jsoQ==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/is-glob": { + "version": "4.0.3", + "resolved": "https://registry.npmjs.org/is-glob/-/is-glob-4.0.3.tgz", + "integrity": "sha512-xelSayHH36ZgE7ZWhli7pW34hNbNl8Ojv5KVmkJD4hBdD3th8Tfk9vYasLM+mXWOZhFkgZfxhLSnrwRr4elSSg==", + "dev": true, + "license": "MIT", + "dependencies": { + "is-extglob": "^2.1.1" + }, + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/isexe": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/isexe/-/isexe-2.0.0.tgz", + "integrity": "sha512-RHxMLp9lnKHGHRng9QFhRCMbYAcVpn69smSGcq3f36xjgVVWThj4qqLbTLlq7Ssj8B+fIQ1EuCEGI2lKsyQeIw==", + "dev": true, + "license": "ISC" + }, + "node_modules/its-fine": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/its-fine/-/its-fine-2.0.0.tgz", + "integrity": "sha512-KLViCmWx94zOvpLwSlsx6yOCeMhZYaxrJV87Po5k/FoZzcPSahvK5qJ7fYhS61sZi5ikmh2S3Hz55A2l3U69ng==", + "license": "MIT", + "dependencies": { + "@types/react-reconciler": "^0.28.9" + }, + "peerDependencies": { + "react": "^19.0.0" + } + }, + "node_modules/its-fine/node_modules/@types/react-reconciler": { + "version": "0.28.9", + "resolved": "https://registry.npmjs.org/@types/react-reconciler/-/react-reconciler-0.28.9.tgz", + "integrity": "sha512-HHM3nxyUZ3zAylX8ZEyrDNd2XZOnQ0D5XfunJF5FLQnZbHHYq4UWvW1QfelQNXv1ICNkwYhfxjwfnqivYB6bFg==", + "license": "MIT", + "peerDependencies": { + "@types/react": "*" + } + }, + "node_modules/jiti": { + "version": "2.6.1", + "resolved": "https://registry.npmjs.org/jiti/-/jiti-2.6.1.tgz", + "integrity": "sha512-ekilCSN1jwRvIbgeg/57YFh8qQDNbwDb9xT/qu2DAHbFFZUicIl4ygVaAvzveMhMVr3LnpSKTNnwt8PoOfmKhQ==", + "license": "MIT", + "bin": { + "jiti": "lib/jiti-cli.mjs" + } + }, + "node_modules/js-tokens": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/js-tokens/-/js-tokens-4.0.0.tgz", + "integrity": "sha512-RdJUflcE3cUzKiMqQgsCu06FPu9UdIJO0beYbPhHN4k6apgJtifcoCtT9bcxOpYBtpD2kCM6Sbzg4CausW/PKQ==", + "license": "MIT" + }, + "node_modules/js-yaml": { + "version": "4.1.1", + "resolved": "https://registry.npmjs.org/js-yaml/-/js-yaml-4.1.1.tgz", + "integrity": "sha512-qQKT4zQxXl8lLwBtHMWwaTcGfFOZviOJet3Oy/xmGk2gZH677CJM9EvtfdSkgWcATZhj/55JZ0rmy3myCT5lsA==", + "dev": true, + "license": "MIT", + "dependencies": { + "argparse": "^2.0.1" + }, + "bin": { + "js-yaml": "bin/js-yaml.js" + } + }, + "node_modules/jsesc": { + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/jsesc/-/jsesc-3.1.0.tgz", + "integrity": "sha512-/sM3dO2FOzXjKQhJuo0Q173wf2KOo8t4I8vHy6lF9poUp7bKT0/NHE8fPX23PwfhnykfqnC2xRxOnVw5XuGIaA==", + "dev": true, + "license": "MIT", + "bin": { + "jsesc": "bin/jsesc" + }, + "engines": { + "node": ">=6" + } + }, + "node_modules/json-buffer": { + "version": "3.0.1", + "resolved": "https://registry.npmjs.org/json-buffer/-/json-buffer-3.0.1.tgz", + "integrity": "sha512-4bV5BfR2mqfQTJm+V5tPPdf+ZpuhiIvTuAB5g8kcrXOZpTT/QwwVRWBywX1ozr6lEuPdbHxwaJlm9G6mI2sfSQ==", + "dev": true, + "license": "MIT" + }, + "node_modules/json-schema-traverse": { + "version": "0.4.1", + "resolved": "https://registry.npmjs.org/json-schema-traverse/-/json-schema-traverse-0.4.1.tgz", + "integrity": "sha512-xbbCH5dCYU5T8LcEhhuh7HJ88HXuW3qsI3Y0zOZFKfZEHcpWiHU/Jxzk629Brsab/mMiHQti9wMP+845RPe3Vg==", + "dev": true, + "license": "MIT" + }, + "node_modules/json-stable-stringify-without-jsonify": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/json-stable-stringify-without-jsonify/-/json-stable-stringify-without-jsonify-1.0.1.tgz", + "integrity": "sha512-Bdboy+l7tA3OGW6FjyFHWkP5LuByj1Tk33Ljyq0axyzdk9//JSi2u3fP1QSmd1KNwq6VOKYGlAu87CisVir6Pw==", + "dev": true, + "license": "MIT" + }, + "node_modules/json5": { + "version": "2.2.3", + "resolved": "https://registry.npmjs.org/json5/-/json5-2.2.3.tgz", + "integrity": "sha512-XmOWe7eyHYH14cLdVPoyg+GOH3rYX++KpzrylJwSW98t3Nk+U8XOl8FWKOgwtzdb8lXGf6zYwDUzeHMWfxasyg==", + "dev": true, + "license": "MIT", + "bin": { + "json5": "lib/cli.js" + }, + "engines": { + "node": ">=6" + } + }, + "node_modules/keyv": { + "version": "4.5.4", + "resolved": "https://registry.npmjs.org/keyv/-/keyv-4.5.4.tgz", + "integrity": "sha512-oxVHkHR/EJf2CNXnWxRLW6mg7JyCCUcG0DtEGmL2ctUo1PNTin1PUil+r/+4r5MpVgC/fn1kjsx7mjSujKqIpw==", + "dev": true, + "license": "MIT", + "dependencies": { + "json-buffer": "3.0.1" + } + }, + "node_modules/konva": { + "version": "10.2.0", + "resolved": "https://registry.npmjs.org/konva/-/konva-10.2.0.tgz", + "integrity": "sha512-JBoz0Xjbf49UPxCZegZ4WseqOzJ+C4AUDOtJ9eBve5RS5Fcq/u8TdBD5fDl/uPFInpC3a9uycm0sRyZpF4hheg==", + "funding": [ + { + "type": "patreon", + "url": "https://www.patreon.com/lavrton" + }, + { + "type": "opencollective", + "url": "https://opencollective.com/konva" + }, + { + "type": "github", + "url": "https://github.com/sponsors/lavrton" + } + ], + "license": "MIT" + }, + "node_modules/levn": { + "version": "0.4.1", + "resolved": "https://registry.npmjs.org/levn/-/levn-0.4.1.tgz", + "integrity": "sha512-+bT2uH4E5LGE7h/n3evcS/sQlJXCpIp6ym8OWJ5eV6+67Dsql/LaaT7qJBAt2rzfoa/5QBGBhxDix1dMt2kQKQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "prelude-ls": "^1.2.1", + "type-check": "~0.4.0" + }, + "engines": { + "node": ">= 0.8.0" + } + }, + "node_modules/lightningcss": { + "version": "1.31.1", + "resolved": "https://registry.npmjs.org/lightningcss/-/lightningcss-1.31.1.tgz", + "integrity": "sha512-l51N2r93WmGUye3WuFoN5k10zyvrVs0qfKBhyC5ogUQ6Ew6JUSswh78mbSO+IU3nTWsyOArqPCcShdQSadghBQ==", + "license": "MPL-2.0", + "dependencies": { + "detect-libc": "^2.0.3" + }, + "engines": { + "node": ">= 12.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/parcel" + }, + "optionalDependencies": { + "lightningcss-android-arm64": "1.31.1", + "lightningcss-darwin-arm64": "1.31.1", + "lightningcss-darwin-x64": "1.31.1", + "lightningcss-freebsd-x64": "1.31.1", + "lightningcss-linux-arm-gnueabihf": "1.31.1", + "lightningcss-linux-arm64-gnu": "1.31.1", + "lightningcss-linux-arm64-musl": "1.31.1", + "lightningcss-linux-x64-gnu": "1.31.1", + "lightningcss-linux-x64-musl": "1.31.1", + "lightningcss-win32-arm64-msvc": "1.31.1", + "lightningcss-win32-x64-msvc": "1.31.1" + } + }, + "node_modules/lightningcss-android-arm64": { + "version": "1.31.1", + "resolved": "https://registry.npmjs.org/lightningcss-android-arm64/-/lightningcss-android-arm64-1.31.1.tgz", + "integrity": "sha512-HXJF3x8w9nQ4jbXRiNppBCqeZPIAfUo8zE/kOEGbW5NZvGc/K7nMxbhIr+YlFlHW5mpbg/YFPdbnCh1wAXCKFg==", + "cpu": [ + "arm64" + ], + "license": "MPL-2.0", + "optional": true, + "os": [ + "android" + ], + "engines": { + "node": ">= 12.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/parcel" + } + }, + "node_modules/lightningcss-darwin-arm64": { + "version": "1.31.1", + "resolved": "https://registry.npmjs.org/lightningcss-darwin-arm64/-/lightningcss-darwin-arm64-1.31.1.tgz", + "integrity": "sha512-02uTEqf3vIfNMq3h/z2cJfcOXnQ0GRwQrkmPafhueLb2h7mqEidiCzkE4gBMEH65abHRiQvhdcQ+aP0D0g67sg==", + "cpu": [ + "arm64" + ], + "license": "MPL-2.0", + "optional": true, + "os": [ + "darwin" + ], + "engines": { + "node": ">= 12.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/parcel" + } + }, + "node_modules/lightningcss-darwin-x64": { + "version": "1.31.1", + "resolved": "https://registry.npmjs.org/lightningcss-darwin-x64/-/lightningcss-darwin-x64-1.31.1.tgz", + "integrity": "sha512-1ObhyoCY+tGxtsz1lSx5NXCj3nirk0Y0kB/g8B8DT+sSx4G9djitg9ejFnjb3gJNWo7qXH4DIy2SUHvpoFwfTA==", + "cpu": [ + "x64" + ], + "license": "MPL-2.0", + "optional": true, + "os": [ + "darwin" + ], + "engines": { + "node": ">= 12.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/parcel" + } + }, + "node_modules/lightningcss-freebsd-x64": { + "version": "1.31.1", + "resolved": "https://registry.npmjs.org/lightningcss-freebsd-x64/-/lightningcss-freebsd-x64-1.31.1.tgz", + "integrity": "sha512-1RINmQKAItO6ISxYgPwszQE1BrsVU5aB45ho6O42mu96UiZBxEXsuQ7cJW4zs4CEodPUioj/QrXW1r9pLUM74A==", + "cpu": [ + "x64" + ], + "license": "MPL-2.0", + "optional": true, + "os": [ + "freebsd" + ], + "engines": { + "node": ">= 12.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/parcel" + } + }, + "node_modules/lightningcss-linux-arm-gnueabihf": { + "version": "1.31.1", + "resolved": "https://registry.npmjs.org/lightningcss-linux-arm-gnueabihf/-/lightningcss-linux-arm-gnueabihf-1.31.1.tgz", + "integrity": "sha512-OOCm2//MZJ87CdDK62rZIu+aw9gBv4azMJuA8/KB74wmfS3lnC4yoPHm0uXZ/dvNNHmnZnB8XLAZzObeG0nS1g==", + "cpu": [ + "arm" + ], + "license": "MPL-2.0", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">= 12.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/parcel" + } + }, + "node_modules/lightningcss-linux-arm64-gnu": { + "version": "1.31.1", + "resolved": "https://registry.npmjs.org/lightningcss-linux-arm64-gnu/-/lightningcss-linux-arm64-gnu-1.31.1.tgz", + "integrity": "sha512-WKyLWztD71rTnou4xAD5kQT+982wvca7E6QoLpoawZ1gP9JM0GJj4Tp5jMUh9B3AitHbRZ2/H3W5xQmdEOUlLg==", + "cpu": [ + "arm64" + ], + "license": "MPL-2.0", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">= 12.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/parcel" + } + }, + "node_modules/lightningcss-linux-arm64-musl": { + "version": "1.31.1", + "resolved": "https://registry.npmjs.org/lightningcss-linux-arm64-musl/-/lightningcss-linux-arm64-musl-1.31.1.tgz", + "integrity": "sha512-mVZ7Pg2zIbe3XlNbZJdjs86YViQFoJSpc41CbVmKBPiGmC4YrfeOyz65ms2qpAobVd7WQsbW4PdsSJEMymyIMg==", + "cpu": [ + "arm64" + ], + "license": "MPL-2.0", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">= 12.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/parcel" + } + }, + "node_modules/lightningcss-linux-x64-gnu": { + "version": "1.31.1", + "resolved": "https://registry.npmjs.org/lightningcss-linux-x64-gnu/-/lightningcss-linux-x64-gnu-1.31.1.tgz", + "integrity": "sha512-xGlFWRMl+0KvUhgySdIaReQdB4FNudfUTARn7q0hh/V67PVGCs3ADFjw+6++kG1RNd0zdGRlEKa+T13/tQjPMA==", + "cpu": [ + "x64" + ], + "license": "MPL-2.0", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">= 12.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/parcel" + } + }, + "node_modules/lightningcss-linux-x64-musl": { + "version": "1.31.1", + "resolved": "https://registry.npmjs.org/lightningcss-linux-x64-musl/-/lightningcss-linux-x64-musl-1.31.1.tgz", + "integrity": "sha512-eowF8PrKHw9LpoZii5tdZwnBcYDxRw2rRCyvAXLi34iyeYfqCQNA9rmUM0ce62NlPhCvof1+9ivRaTY6pSKDaA==", + "cpu": [ + "x64" + ], + "license": "MPL-2.0", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">= 12.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/parcel" + } + }, + "node_modules/lightningcss-win32-arm64-msvc": { + "version": "1.31.1", + "resolved": "https://registry.npmjs.org/lightningcss-win32-arm64-msvc/-/lightningcss-win32-arm64-msvc-1.31.1.tgz", + "integrity": "sha512-aJReEbSEQzx1uBlQizAOBSjcmr9dCdL3XuC/6HLXAxmtErsj2ICo5yYggg1qOODQMtnjNQv2UHb9NpOuFtYe4w==", + "cpu": [ + "arm64" + ], + "license": "MPL-2.0", + "optional": true, + "os": [ + "win32" + ], + "engines": { + "node": ">= 12.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/parcel" + } + }, + "node_modules/lightningcss-win32-x64-msvc": { + "version": "1.31.1", + "resolved": "https://registry.npmjs.org/lightningcss-win32-x64-msvc/-/lightningcss-win32-x64-msvc-1.31.1.tgz", + "integrity": "sha512-I9aiFrbd7oYHwlnQDqr1Roz+fTz61oDDJX7n9tYF9FJymH1cIN1DtKw3iYt6b8WZgEjoNwVSncwF4wx/ZedMhw==", + "cpu": [ + "x64" + ], + "license": "MPL-2.0", + "optional": true, + "os": [ + "win32" + ], + "engines": { + "node": ">= 12.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/parcel" + } + }, + "node_modules/locate-path": { + "version": "6.0.0", + "resolved": "https://registry.npmjs.org/locate-path/-/locate-path-6.0.0.tgz", + "integrity": "sha512-iPZK6eYjbxRu3uB4/WZ3EsEIMJFMqAoopl3R+zuq0UjcAm/MO6KCweDgPfP3elTztoKP3KtnVHxTn2NHBSDVUw==", + "dev": true, + "license": "MIT", + "dependencies": { + "p-locate": "^5.0.0" + }, + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/lodash.merge": { + "version": "4.6.2", + "resolved": "https://registry.npmjs.org/lodash.merge/-/lodash.merge-4.6.2.tgz", + "integrity": "sha512-0KpjqXRVvrYyCsX1swR/XTK0va6VQkQM6MNo7PqW77ByjAhoARA8EfrP1N4+KlKj8YS0ZUCtRT/YUuhyYDujIQ==", + "dev": true, + "license": "MIT" + }, + "node_modules/loose-envify": { + "version": "1.4.0", + "resolved": "https://registry.npmjs.org/loose-envify/-/loose-envify-1.4.0.tgz", + "integrity": "sha512-lyuxPGr/Wfhrlem2CL/UcnUc1zcqKAImBDzukY7Y5F/yQiNdko6+fRLevlw1HgMySw7f611UIY408EtxRSoK3Q==", + "license": "MIT", + "dependencies": { + "js-tokens": "^3.0.0 || ^4.0.0" + }, + "bin": { + "loose-envify": "cli.js" + } + }, + "node_modules/lru-cache": { + "version": "5.1.1", + "resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-5.1.1.tgz", + "integrity": "sha512-KpNARQA3Iwv+jTA0utUVVbrh+Jlrr1Fv0e56GGzAFOXN7dk/FviaDW8LHmK52DlcH4WP2n6gI8vN1aesBFgo9w==", + "dev": true, + "license": "ISC", + "dependencies": { + "yallist": "^3.0.2" + } + }, + "node_modules/magic-string": { + "version": "0.30.21", + "resolved": "https://registry.npmjs.org/magic-string/-/magic-string-0.30.21.tgz", + "integrity": "sha512-vd2F4YUyEXKGcLHoq+TEyCjxueSeHnFxyyjNp80yg0XV4vUhnDer/lvvlqM/arB5bXQN5K2/3oinyCRyx8T2CQ==", + "license": "MIT", + "dependencies": { + "@jridgewell/sourcemap-codec": "^1.5.5" + } + }, + "node_modules/math-intrinsics": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/math-intrinsics/-/math-intrinsics-1.1.0.tgz", + "integrity": "sha512-/IXtbwEk5HTPyEwyKX6hGkYXxM9nbj64B+ilVJnC/R6B0pH5G4V3b0pVbL7DBj4tkhBAppbQUlf6F6Xl9LHu1g==", + "license": "MIT", + "engines": { + "node": ">= 0.4" + } + }, + "node_modules/mime-db": { + "version": "1.52.0", + "resolved": "https://registry.npmjs.org/mime-db/-/mime-db-1.52.0.tgz", + "integrity": "sha512-sPU4uV7dYlvtWJxwwxHD0PuihVNiE7TyAbQ5SWxDCB9mUYvOgroQOwYQQOKPJ8CIbE+1ETVlOoK1UC2nU3gYvg==", + "license": "MIT", + "engines": { + "node": ">= 0.6" + } + }, + "node_modules/mime-types": { + "version": "2.1.35", + "resolved": "https://registry.npmjs.org/mime-types/-/mime-types-2.1.35.tgz", + "integrity": "sha512-ZDY+bPm5zTTF+YpCrAU9nK0UgICYPT0QtT1NZWFv4s++TNkcgVaT0g6+4R2uI4MjQjzysHB1zxuWL50hzaeXiw==", + "license": "MIT", + "dependencies": { + "mime-db": "1.52.0" + }, + "engines": { + "node": ">= 0.6" + } + }, + "node_modules/minimatch": { + "version": "3.1.3", + "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-3.1.3.tgz", + "integrity": "sha512-M2GCs7Vk83NxkUyQV1bkABc4yxgz9kILhHImZiBPAZ9ybuvCb0/H7lEl5XvIg3g+9d4eNotkZA5IWwYl0tibaA==", + "dev": true, + "license": "ISC", + "dependencies": { + "brace-expansion": "^1.1.7" + }, + "engines": { + "node": "*" + } + }, + "node_modules/ms": { + "version": "2.1.3", + "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.3.tgz", + "integrity": "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==", + "dev": true, + "license": "MIT" + }, + "node_modules/nanoid": { + "version": "3.3.11", + "resolved": "https://registry.npmjs.org/nanoid/-/nanoid-3.3.11.tgz", + "integrity": "sha512-N8SpfPUnUp1bK+PMYW8qSWdl9U+wwNWI4QKxOYDy9JAro3WMX7p2OeVRF9v+347pnakNevPmiHhNmZ2HbFA76w==", + "funding": [ + { + "type": "github", + "url": "https://github.com/sponsors/ai" + } + ], + "license": "MIT", + "bin": { + "nanoid": "bin/nanoid.cjs" + }, + "engines": { + "node": "^10 || ^12 || ^13.7 || ^14 || >=15.0.1" + } + }, + "node_modules/natural-compare": { + "version": "1.4.0", + "resolved": "https://registry.npmjs.org/natural-compare/-/natural-compare-1.4.0.tgz", + "integrity": "sha512-OWND8ei3VtNC9h7V60qff3SVobHr996CTwgxubgyQYEpg290h9J0buyECNNJexkFm5sOajh5G116RYA1c8ZMSw==", + "dev": true, + "license": "MIT" + }, + "node_modules/node-releases": { + "version": "2.0.27", + "resolved": "https://registry.npmjs.org/node-releases/-/node-releases-2.0.27.tgz", + "integrity": "sha512-nmh3lCkYZ3grZvqcCH+fjmQ7X+H0OeZgP40OierEaAptX4XofMh5kwNbWh7lBduUzCcV/8kZ+NDLCwm2iorIlA==", + "dev": true, + "license": "MIT" + }, + "node_modules/object-assign": { + "version": "4.1.1", + "resolved": "https://registry.npmjs.org/object-assign/-/object-assign-4.1.1.tgz", + "integrity": "sha512-rJgTQnkUnH1sFw8yT6VSU3zD3sWmu6sZhIseY8VX+GRu3P6F7Fu+JNDoXfklElbLJSnc3FUQHVe4cU5hj+BcUg==", + "license": "MIT", + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/optionator": { + "version": "0.9.4", + "resolved": "https://registry.npmjs.org/optionator/-/optionator-0.9.4.tgz", + "integrity": "sha512-6IpQ7mKUxRcZNLIObR0hz7lxsapSSIYNZJwXPGeF0mTVqGKFIXj1DQcMoT22S3ROcLyY/rz0PWaWZ9ayWmad9g==", + "dev": true, + "license": "MIT", + "dependencies": { + "deep-is": "^0.1.3", + "fast-levenshtein": "^2.0.6", + "levn": "^0.4.1", + "prelude-ls": "^1.2.1", + "type-check": "^0.4.0", + "word-wrap": "^1.2.5" + }, + "engines": { + "node": ">= 0.8.0" + } + }, + "node_modules/p-limit": { + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/p-limit/-/p-limit-3.1.0.tgz", + "integrity": "sha512-TYOanM3wGwNGsZN2cVTYPArw454xnXj5qmWF1bEoAc4+cU/ol7GVh7odevjp1FNHduHc3KZMcFduxU5Xc6uJRQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "yocto-queue": "^0.1.0" + }, + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/p-locate": { + "version": "5.0.0", + "resolved": "https://registry.npmjs.org/p-locate/-/p-locate-5.0.0.tgz", + "integrity": "sha512-LaNjtRWUBY++zB5nE/NwcaoMylSPk+S+ZHNB1TzdbMJMny6dynpAGt7X/tl/QYq3TIeE6nxHppbo2LGymrG5Pw==", + "dev": true, + "license": "MIT", + "dependencies": { + "p-limit": "^3.0.2" + }, + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/parent-module": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/parent-module/-/parent-module-1.0.1.tgz", + "integrity": "sha512-GQ2EWRpQV8/o+Aw8YqtfZZPfNRWZYkbidE9k5rpl/hC3vtHHBfGm2Ifi6qWV+coDGkrUKZAxE3Lot5kcsRlh+g==", + "dev": true, + "license": "MIT", + "dependencies": { + "callsites": "^3.0.0" + }, + "engines": { + "node": ">=6" + } + }, + "node_modules/path-exists": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/path-exists/-/path-exists-4.0.0.tgz", + "integrity": "sha512-ak9Qy5Q7jYb2Wwcey5Fpvg2KoAc/ZIhLSLOSBmRmygPsGwkVVt0fZa0qrtMz+m6tJTAHfZQ8FnmB4MG4LWy7/w==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=8" + } + }, + "node_modules/path-key": { + "version": "3.1.1", + "resolved": "https://registry.npmjs.org/path-key/-/path-key-3.1.1.tgz", + "integrity": "sha512-ojmeN0qd+y0jszEtoY48r0Peq5dwMEkIlCOu6Q5f41lfkswXuKtYrhgoTpLnyIcHm24Uhqx+5Tqm2InSwLhE6Q==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=8" + } + }, + "node_modules/picocolors": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/picocolors/-/picocolors-1.1.1.tgz", + "integrity": "sha512-xceH2snhtb5M9liqDsmEw56le376mTZkEX/jEb/RxNFyegNul7eNslCXP9FDj/Lcu0X8KEyMceP2ntpaHrDEVA==", + "license": "ISC" + }, + "node_modules/picomatch": { + "version": "4.0.3", + "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-4.0.3.tgz", + "integrity": "sha512-5gTmgEY/sqK6gFXLIsQNH19lWb4ebPDLA4SdLP7dsWkIXHWlG66oPuVvXSGFPppYZz8ZDZq0dYYrbHfBCVUb1Q==", + "license": "MIT", + "engines": { + "node": ">=12" + }, + "funding": { + "url": "https://github.com/sponsors/jonschlinkert" + } + }, + "node_modules/postcss": { + "version": "8.5.6", + "resolved": "https://registry.npmjs.org/postcss/-/postcss-8.5.6.tgz", + "integrity": "sha512-3Ybi1tAuwAP9s0r1UQ2J4n5Y0G05bJkpUIO0/bI9MhwmD70S5aTWbXGBwxHrelT+XM1k6dM0pk+SwNkpTRN7Pg==", + "funding": [ + { + "type": "opencollective", + "url": "https://opencollective.com/postcss/" + }, + { + "type": "tidelift", + "url": "https://tidelift.com/funding/github/npm/postcss" + }, + { + "type": "github", + "url": "https://github.com/sponsors/ai" + } + ], + "license": "MIT", + "dependencies": { + "nanoid": "^3.3.11", + "picocolors": "^1.1.1", + "source-map-js": "^1.2.1" + }, + "engines": { + "node": "^10 || ^12 || >=14" + } + }, + "node_modules/prelude-ls": { + "version": "1.2.1", + "resolved": "https://registry.npmjs.org/prelude-ls/-/prelude-ls-1.2.1.tgz", + "integrity": "sha512-vkcDPrRZo1QZLbn5RLGPpg/WmIQ65qoWWhcGKf/b5eplkkarX0m9z8ppCat4mlOqUsWpyNuYgO3VRyrYHSzX5g==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">= 0.8.0" + } + }, + "node_modules/prop-types": { + "version": "15.8.1", + "resolved": "https://registry.npmjs.org/prop-types/-/prop-types-15.8.1.tgz", + "integrity": "sha512-oj87CgZICdulUohogVAR7AjlC0327U4el4L6eAvOqCeudMDVU0NThNaV+b9Df4dXgSP1gXMTnPdhfe/2qDH5cg==", + "license": "MIT", + "dependencies": { + "loose-envify": "^1.4.0", + "object-assign": "^4.1.1", + "react-is": "^16.13.1" + } + }, + "node_modules/proxy-from-env": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/proxy-from-env/-/proxy-from-env-1.1.0.tgz", + "integrity": "sha512-D+zkORCbA9f1tdWRK0RaCR3GPv50cMxcrz4X8k5LTSUD1Dkw47mKJEZQNunItRTkWwgtaUSo1RVFRIG9ZXiFYg==", + "license": "MIT" + }, + "node_modules/punycode": { + "version": "2.3.1", + "resolved": "https://registry.npmjs.org/punycode/-/punycode-2.3.1.tgz", + "integrity": "sha512-vYt7UD1U9Wg6138shLtLOvdAu+8DsC/ilFtEVHcH+wydcSpNE20AfSOduf6MkRFahL5FY7X1oU7nKVZFtfq8Fg==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=6" + } + }, + "node_modules/react": { + "version": "19.2.4", + "resolved": "https://registry.npmjs.org/react/-/react-19.2.4.tgz", + "integrity": "sha512-9nfp2hYpCwOjAN+8TZFGhtWEwgvWHXqESH8qT89AT/lWklpLON22Lc8pEtnpsZz7VmawabSU0gCjnj8aC0euHQ==", + "license": "MIT", + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/react-dom": { + "version": "19.2.4", + "resolved": "https://registry.npmjs.org/react-dom/-/react-dom-19.2.4.tgz", + "integrity": "sha512-AXJdLo8kgMbimY95O2aKQqsz2iWi9jMgKJhRBAxECE4IFxfcazB2LmzloIoibJI3C12IlY20+KFaLv+71bUJeQ==", + "license": "MIT", + "dependencies": { + "scheduler": "^0.27.0" + }, + "peerDependencies": { + "react": "^19.2.4" + } + }, + "node_modules/react-dropzone": { + "version": "15.0.0", + "resolved": "https://registry.npmjs.org/react-dropzone/-/react-dropzone-15.0.0.tgz", + "integrity": "sha512-lGjYV/EoqEjEWPnmiSvH4v5IoIAwQM2W4Z1C0Q/Pw2xD0eVzKPS359BQTUMum+1fa0kH2nrKjuavmTPOGhpLPg==", + "license": "MIT", + "dependencies": { + "attr-accept": "^2.2.4", + "file-selector": "^2.1.0", + "prop-types": "^15.8.1" + }, + "engines": { + "node": ">= 10.13" + }, + "peerDependencies": { + "react": ">= 16.8 || 18.0.0" + } + }, + "node_modules/react-is": { + "version": "16.13.1", + "resolved": "https://registry.npmjs.org/react-is/-/react-is-16.13.1.tgz", + "integrity": "sha512-24e6ynE2H+OKt4kqsOvNd8kBpV65zoxbA4BVsEOB3ARVWQki/DHzaUoC5KuON/BiccDaCCTZBuOcfZs70kR8bQ==", + "license": "MIT" + }, + "node_modules/react-konva": { + "version": "19.2.2", + "resolved": "https://registry.npmjs.org/react-konva/-/react-konva-19.2.2.tgz", + "integrity": "sha512-fgIevJSiZ6mYxouR0XLq7oKgQkfHHySHyNpyc1f/3in0xXq8BV7M7Y82obyoBPOAj35TBUPuZ568qZcelYm3ag==", + "funding": [ + { + "type": "patreon", + "url": "https://www.patreon.com/lavrton" + }, + { + "type": "opencollective", + "url": "https://opencollective.com/konva" + }, + { + "type": "github", + "url": "https://github.com/sponsors/lavrton" + } + ], + "license": "MIT", + "dependencies": { + "@types/react-reconciler": "^0.32.3", + "its-fine": "^2.0.0", + "react-reconciler": "0.33.0", + "scheduler": "0.27.0" + }, + "peerDependencies": { + "konva": "^8.0.1 || ^7.2.5 || ^9.0.0 || ^10.0.0", + "react": "^19.2.0", + "react-dom": "^19.2.0" + } + }, + "node_modules/react-reconciler": { + "version": "0.33.0", + "resolved": "https://registry.npmjs.org/react-reconciler/-/react-reconciler-0.33.0.tgz", + "integrity": "sha512-KetWRytFv1epdpJc3J4G75I4WrplZE5jOL7Yq0p34+OVOKF4Se7WrdIdVC45XsSSmUTlht2FM/fM1FZb1mfQeA==", + "license": "MIT", + "dependencies": { + "scheduler": "^0.27.0" + }, + "engines": { + "node": ">=0.10.0" + }, + "peerDependencies": { + "react": "^19.2.0" + } + }, + "node_modules/react-refresh": { + "version": "0.18.0", + "resolved": "https://registry.npmjs.org/react-refresh/-/react-refresh-0.18.0.tgz", + "integrity": "sha512-QgT5//D3jfjJb6Gsjxv0Slpj23ip+HtOpnNgnb2S5zU3CB26G/IDPGoy4RJB42wzFE46DRsstbW6tKHoKbhAxw==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/react-router": { + "version": "7.13.1", + "resolved": "https://registry.npmjs.org/react-router/-/react-router-7.13.1.tgz", + "integrity": "sha512-td+xP4X2/6BJvZoX6xw++A2DdEi++YypA69bJUV5oVvqf6/9/9nNlD70YO1e9d3MyamJEBQFEzk6mbfDYbqrSA==", + "license": "MIT", + "dependencies": { + "cookie": "^1.0.1", + "set-cookie-parser": "^2.6.0" + }, + "engines": { + "node": ">=20.0.0" + }, + "peerDependencies": { + "react": ">=18", + "react-dom": ">=18" + }, + "peerDependenciesMeta": { + "react-dom": { + "optional": true + } + } + }, + "node_modules/react-router-dom": { + "version": "7.13.1", + "resolved": "https://registry.npmjs.org/react-router-dom/-/react-router-dom-7.13.1.tgz", + "integrity": "sha512-UJnV3Rxc5TgUPJt2KJpo1Jpy0OKQr0AjgbZzBFjaPJcFOb2Y8jA5H3LT8HUJAiRLlWrEXWHbF1Z4SCZaQjWDHw==", + "license": "MIT", + "dependencies": { + "react-router": "7.13.1" + }, + "engines": { + "node": ">=20.0.0" + }, + "peerDependencies": { + "react": ">=18", + "react-dom": ">=18" + } + }, + "node_modules/resolve-from": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/resolve-from/-/resolve-from-4.0.0.tgz", + "integrity": "sha512-pb/MYmXstAkysRFx8piNI1tGFNQIFA3vkE3Gq4EuA1dF6gHp/+vgZqsCGJapvy8N3Q+4o7FwvquPJcnZ7RYy4g==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=4" + } + }, + "node_modules/rollup": { + "version": "4.59.0", + "resolved": "https://registry.npmjs.org/rollup/-/rollup-4.59.0.tgz", + "integrity": "sha512-2oMpl67a3zCH9H79LeMcbDhXW/UmWG/y2zuqnF2jQq5uq9TbM9TVyXvA4+t+ne2IIkBdrLpAaRQAvo7YI/Yyeg==", + "license": "MIT", + "dependencies": { + "@types/estree": "1.0.8" + }, + "bin": { + "rollup": "dist/bin/rollup" + }, + "engines": { + "node": ">=18.0.0", + "npm": ">=8.0.0" + }, + "optionalDependencies": { + "@rollup/rollup-android-arm-eabi": "4.59.0", + "@rollup/rollup-android-arm64": "4.59.0", + "@rollup/rollup-darwin-arm64": "4.59.0", + "@rollup/rollup-darwin-x64": "4.59.0", + "@rollup/rollup-freebsd-arm64": "4.59.0", + "@rollup/rollup-freebsd-x64": "4.59.0", + "@rollup/rollup-linux-arm-gnueabihf": "4.59.0", + "@rollup/rollup-linux-arm-musleabihf": "4.59.0", + "@rollup/rollup-linux-arm64-gnu": "4.59.0", + "@rollup/rollup-linux-arm64-musl": "4.59.0", + "@rollup/rollup-linux-loong64-gnu": "4.59.0", + "@rollup/rollup-linux-loong64-musl": "4.59.0", + "@rollup/rollup-linux-ppc64-gnu": "4.59.0", + "@rollup/rollup-linux-ppc64-musl": "4.59.0", + "@rollup/rollup-linux-riscv64-gnu": "4.59.0", + "@rollup/rollup-linux-riscv64-musl": "4.59.0", + "@rollup/rollup-linux-s390x-gnu": "4.59.0", + "@rollup/rollup-linux-x64-gnu": "4.59.0", + "@rollup/rollup-linux-x64-musl": "4.59.0", + "@rollup/rollup-openbsd-x64": "4.59.0", + "@rollup/rollup-openharmony-arm64": "4.59.0", + "@rollup/rollup-win32-arm64-msvc": "4.59.0", + "@rollup/rollup-win32-ia32-msvc": "4.59.0", + "@rollup/rollup-win32-x64-gnu": "4.59.0", + "@rollup/rollup-win32-x64-msvc": "4.59.0", + "fsevents": "~2.3.2" + } + }, + "node_modules/scheduler": { + "version": "0.27.0", + "resolved": "https://registry.npmjs.org/scheduler/-/scheduler-0.27.0.tgz", + "integrity": "sha512-eNv+WrVbKu1f3vbYJT/xtiF5syA5HPIMtf9IgY/nKg0sWqzAUEvqY/xm7OcZc/qafLx/iO9FgOmeSAp4v5ti/Q==", + "license": "MIT" + }, + "node_modules/semver": { + "version": "6.3.1", + "resolved": "https://registry.npmjs.org/semver/-/semver-6.3.1.tgz", + "integrity": "sha512-BR7VvDCVHO+q2xBEWskxS6DJE1qRnb7DxzUrogb71CWoSficBxYsiAGd+Kl0mmq/MprG9yArRkyrQxTO6XjMzA==", + "dev": true, + "license": "ISC", + "bin": { + "semver": "bin/semver.js" + } + }, + "node_modules/set-cookie-parser": { + "version": "2.7.2", + "resolved": "https://registry.npmjs.org/set-cookie-parser/-/set-cookie-parser-2.7.2.tgz", + "integrity": "sha512-oeM1lpU/UvhTxw+g3cIfxXHyJRc/uidd3yK1P242gzHds0udQBYzs3y8j4gCCW+ZJ7ad0yctld8RYO+bdurlvw==", + "license": "MIT" + }, + "node_modules/shebang-command": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/shebang-command/-/shebang-command-2.0.0.tgz", + "integrity": "sha512-kHxr2zZpYtdmrN1qDjrrX/Z1rR1kG8Dx+gkpK1G4eXmvXswmcE1hTWBWYUzlraYw1/yZp6YuDY77YtvbN0dmDA==", + "dev": true, + "license": "MIT", + "dependencies": { + "shebang-regex": "^3.0.0" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/shebang-regex": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/shebang-regex/-/shebang-regex-3.0.0.tgz", + "integrity": "sha512-7++dFhtcx3353uBaq8DDR4NuxBetBzC7ZQOhmTQInHEd6bSrXdiEyzCvG07Z44UYdLShWUyXt5M/yhz8ekcb1A==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=8" + } + }, + "node_modules/source-map-js": { + "version": "1.2.1", + "resolved": "https://registry.npmjs.org/source-map-js/-/source-map-js-1.2.1.tgz", + "integrity": "sha512-UXWMKhLOwVKb728IUtQPXxfYU+usdybtUrK/8uGE8CQMvrhOpwvzDBwj0QhSL7MQc7vIsISBG8VQ8+IDQxpfQA==", + "license": "BSD-3-Clause", + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/strip-json-comments": { + "version": "3.1.1", + "resolved": "https://registry.npmjs.org/strip-json-comments/-/strip-json-comments-3.1.1.tgz", + "integrity": "sha512-6fPc+R4ihwqP6N/aIv2f1gMH8lOVtWQHoqC4yK6oSDVVocumAsfCqjkXnqiYMhmMwS/mEHLp7Vehlt3ql6lEig==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=8" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/supports-color": { + "version": "7.2.0", + "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-7.2.0.tgz", + "integrity": "sha512-qpCAvRl9stuOHveKsn7HncJRvv501qIacKzQlO/+Lwxc9+0q2wLyv4Dfvt80/DPn2pqOBsJdDiogXGR9+OvwRw==", + "dev": true, + "license": "MIT", + "dependencies": { + "has-flag": "^4.0.0" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/tailwindcss": { + "version": "4.2.1", + "resolved": "https://registry.npmjs.org/tailwindcss/-/tailwindcss-4.2.1.tgz", + "integrity": "sha512-/tBrSQ36vCleJkAOsy9kbNTgaxvGbyOamC30PRePTQe/o1MFwEKHQk4Cn7BNGaPtjp+PuUrByJehM1hgxfq4sw==", + "license": "MIT" + }, + "node_modules/tapable": { + "version": "2.3.0", + "resolved": "https://registry.npmjs.org/tapable/-/tapable-2.3.0.tgz", + "integrity": "sha512-g9ljZiwki/LfxmQADO3dEY1CbpmXT5Hm2fJ+QaGKwSXUylMybePR7/67YW7jOrrvjEgL1Fmz5kzyAjWVWLlucg==", + "license": "MIT", + "engines": { + "node": ">=6" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/webpack" + } + }, + "node_modules/tinyglobby": { + "version": "0.2.15", + "resolved": "https://registry.npmjs.org/tinyglobby/-/tinyglobby-0.2.15.tgz", + "integrity": "sha512-j2Zq4NyQYG5XMST4cbs02Ak8iJUdxRM0XI5QyxXuZOzKOINmWurp3smXu3y5wDcJrptwpSjgXHzIQxR0omXljQ==", + "license": "MIT", + "dependencies": { + "fdir": "^6.5.0", + "picomatch": "^4.0.3" + }, + "engines": { + "node": ">=12.0.0" + }, + "funding": { + "url": "https://github.com/sponsors/SuperchupuDev" + } + }, + "node_modules/ts-api-utils": { + "version": "2.4.0", + "resolved": "https://registry.npmjs.org/ts-api-utils/-/ts-api-utils-2.4.0.tgz", + "integrity": "sha512-3TaVTaAv2gTiMB35i3FiGJaRfwb3Pyn/j3m/bfAvGe8FB7CF6u+LMYqYlDh7reQf7UNvoTvdfAqHGmPGOSsPmA==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=18.12" + }, + "peerDependencies": { + "typescript": ">=4.8.4" + } + }, + "node_modules/tslib": { + "version": "2.8.1", + "resolved": "https://registry.npmjs.org/tslib/-/tslib-2.8.1.tgz", + "integrity": "sha512-oJFu94HQb+KVduSUQL7wnpmqnfmLsOA/nAh6b6EH0wCEoK0/mPeXU6c3wKDV83MkOuHPRHtSXKKU99IBazS/2w==", + "license": "0BSD" + }, + "node_modules/type-check": { + "version": "0.4.0", + "resolved": "https://registry.npmjs.org/type-check/-/type-check-0.4.0.tgz", + "integrity": "sha512-XleUoc9uwGXqjWwXaUTZAmzMcFZ5858QA2vvx1Ur5xIcixXIP+8LnFDgRplU30us6teqdlskFfu+ae4K79Ooew==", + "dev": true, + "license": "MIT", + "dependencies": { + "prelude-ls": "^1.2.1" + }, + "engines": { + "node": ">= 0.8.0" + } + }, + "node_modules/typescript": { + "version": "5.9.3", + "resolved": "https://registry.npmjs.org/typescript/-/typescript-5.9.3.tgz", + "integrity": "sha512-jl1vZzPDinLr9eUt3J/t7V6FgNEw9QjvBPdysz9KfQDD41fQrC2Y4vKQdiaUpFT4bXlb1RHhLpp8wtm6M5TgSw==", + "dev": true, + "license": "Apache-2.0", + "bin": { + "tsc": "bin/tsc", + "tsserver": "bin/tsserver" + }, + "engines": { + "node": ">=14.17" + } + }, + "node_modules/typescript-eslint": { + "version": "8.56.1", + "resolved": "https://registry.npmjs.org/typescript-eslint/-/typescript-eslint-8.56.1.tgz", + "integrity": "sha512-U4lM6pjmBX7J5wk4szltF7I1cGBHXZopnAXCMXb3+fZ3B/0Z3hq3wS/CCUB2NZBNAExK92mCU2tEohWuwVMsDQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "@typescript-eslint/eslint-plugin": "8.56.1", + "@typescript-eslint/parser": "8.56.1", + "@typescript-eslint/typescript-estree": "8.56.1", + "@typescript-eslint/utils": "8.56.1" + }, + "engines": { + "node": "^18.18.0 || ^20.9.0 || >=21.1.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/typescript-eslint" + }, + "peerDependencies": { + "eslint": "^8.57.0 || ^9.0.0 || ^10.0.0", + "typescript": ">=4.8.4 <6.0.0" + } + }, + "node_modules/undici-types": { + "version": "7.16.0", + "resolved": "https://registry.npmjs.org/undici-types/-/undici-types-7.16.0.tgz", + "integrity": "sha512-Zz+aZWSj8LE6zoxD+xrjh4VfkIG8Ya6LvYkZqtUQGJPZjYl53ypCaUwWqo7eI0x66KBGeRo+mlBEkMSeSZ38Nw==", + "devOptional": true, + "license": "MIT" + }, + "node_modules/update-browserslist-db": { + "version": "1.2.3", + "resolved": "https://registry.npmjs.org/update-browserslist-db/-/update-browserslist-db-1.2.3.tgz", + "integrity": "sha512-Js0m9cx+qOgDxo0eMiFGEueWztz+d4+M3rGlmKPT+T4IS/jP4ylw3Nwpu6cpTTP8R1MAC1kF4VbdLt3ARf209w==", + "dev": true, + "funding": [ + { + "type": "opencollective", + "url": "https://opencollective.com/browserslist" + }, + { + "type": "tidelift", + "url": "https://tidelift.com/funding/github/npm/browserslist" + }, + { + "type": "github", + "url": "https://github.com/sponsors/ai" + } + ], + "license": "MIT", + "dependencies": { + "escalade": "^3.2.0", + "picocolors": "^1.1.1" + }, + "bin": { + "update-browserslist-db": "cli.js" + }, + "peerDependencies": { + "browserslist": ">= 4.21.0" + } + }, + "node_modules/uri-js": { + "version": "4.4.1", + "resolved": "https://registry.npmjs.org/uri-js/-/uri-js-4.4.1.tgz", + "integrity": "sha512-7rKUyy33Q1yc98pQ1DAmLtwX109F7TIfWlW1Ydo8Wl1ii1SeHieeh0HHfPeL2fMXK6z0s8ecKs9frCuLJvndBg==", + "dev": true, + "license": "BSD-2-Clause", + "dependencies": { + "punycode": "^2.1.0" + } + }, + "node_modules/vite": { + "version": "7.3.1", + "resolved": "https://registry.npmjs.org/vite/-/vite-7.3.1.tgz", + "integrity": "sha512-w+N7Hifpc3gRjZ63vYBXA56dvvRlNWRczTdmCBBa+CotUzAPf5b7YMdMR/8CQoeYE5LX3W4wj6RYTgonm1b9DA==", + "license": "MIT", + "dependencies": { + "esbuild": "^0.27.0", + "fdir": "^6.5.0", + "picomatch": "^4.0.3", + "postcss": "^8.5.6", + "rollup": "^4.43.0", + "tinyglobby": "^0.2.15" + }, + "bin": { + "vite": "bin/vite.js" + }, + "engines": { + "node": "^20.19.0 || >=22.12.0" + }, + "funding": { + "url": "https://github.com/vitejs/vite?sponsor=1" + }, + "optionalDependencies": { + "fsevents": "~2.3.3" + }, + "peerDependencies": { + "@types/node": "^20.19.0 || >=22.12.0", + "jiti": ">=1.21.0", + "less": "^4.0.0", + "lightningcss": "^1.21.0", + "sass": "^1.70.0", + "sass-embedded": "^1.70.0", + "stylus": ">=0.54.8", + "sugarss": "^5.0.0", + "terser": "^5.16.0", + "tsx": "^4.8.1", + "yaml": "^2.4.2" + }, + "peerDependenciesMeta": { + "@types/node": { + "optional": true + }, + "jiti": { + "optional": true + }, + "less": { + "optional": true + }, + "lightningcss": { + "optional": true + }, + "sass": { + "optional": true + }, + "sass-embedded": { + "optional": true + }, + "stylus": { + "optional": true + }, + "sugarss": { + "optional": true + }, + "terser": { + "optional": true + }, + "tsx": { + "optional": true + }, + "yaml": { + "optional": true + } + } + }, + "node_modules/which": { + "version": "2.0.2", + "resolved": "https://registry.npmjs.org/which/-/which-2.0.2.tgz", + "integrity": "sha512-BLI3Tl1TW3Pvl70l3yq3Y64i+awpwXqsGBYWkkqMtnbXgrMD+yj7rhW0kuEDxzJaYXGjEW5ogapKNMEKNMjibA==", + "dev": true, + "license": "ISC", + "dependencies": { + "isexe": "^2.0.0" + }, + "bin": { + "node-which": "bin/node-which" + }, + "engines": { + "node": ">= 8" + } + }, + "node_modules/word-wrap": { + "version": "1.2.5", + "resolved": "https://registry.npmjs.org/word-wrap/-/word-wrap-1.2.5.tgz", + "integrity": "sha512-BN22B5eaMMI9UMtjrGd5g5eCYPpCPDUy0FJXbYsaT5zYxjFOckS53SQDE3pWkVoWpHXVb3BrYcEN4Twa55B5cA==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/yallist": { + "version": "3.1.1", + "resolved": "https://registry.npmjs.org/yallist/-/yallist-3.1.1.tgz", + "integrity": "sha512-a4UGQaWPH59mOXUYnAG2ewncQS4i4F43Tv3JoAM+s2VDAmS9NsK8GpDMLrCHPksFT7h3K6TOoUNn2pb7RoXx4g==", + "dev": true, + "license": "ISC" + }, + "node_modules/yocto-queue": { + "version": "0.1.0", + "resolved": "https://registry.npmjs.org/yocto-queue/-/yocto-queue-0.1.0.tgz", + "integrity": "sha512-rVksvsnNCdJ/ohGc6xgPwyN8eheCxsiLM8mxuE/t/mOVqJewPuO1miLpTHQiRgTKCLexL4MeAFVagts7HmNZ2Q==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/zod": { + "version": "4.3.6", + "resolved": "https://registry.npmjs.org/zod/-/zod-4.3.6.tgz", + "integrity": "sha512-rftlrkhHZOcjDwkGlnUtZZkvaPHCsDATp4pGpuOOMDaTdDDXF91wuVDJoWoPsKX/3YPQ5fHuF3STjcYyKr+Qhg==", + "dev": true, + "license": "MIT", + "funding": { + "url": "https://github.com/sponsors/colinhacks" + } + }, + "node_modules/zod-validation-error": { + "version": "4.0.2", + "resolved": "https://registry.npmjs.org/zod-validation-error/-/zod-validation-error-4.0.2.tgz", + "integrity": "sha512-Q6/nZLe6jxuU80qb/4uJ4t5v2VEZ44lzQjPDhYJNztRQ4wyWc6VF3D3Kb/fAuPetZQnhS3hnajCf9CsWesghLQ==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=18.0.0" + }, + "peerDependencies": { + "zod": "^3.25.0 || ^4.0.0" + } + }, + "node_modules/zustand": { + "version": "5.0.11", + "resolved": "https://registry.npmjs.org/zustand/-/zustand-5.0.11.tgz", + "integrity": "sha512-fdZY+dk7zn/vbWNCYmzZULHRrss0jx5pPFiOuMZ/5HJN6Yv3u+1Wswy/4MpZEkEGhtNH+pwxZB8OKgUBPzYAGg==", + "license": "MIT", + "engines": { + "node": ">=12.20.0" + }, + "peerDependencies": { + "@types/react": ">=18.0.0", + "immer": ">=9.0.6", + "react": ">=18.0.0", + "use-sync-external-store": ">=1.2.0" + }, + "peerDependenciesMeta": { + "@types/react": { + "optional": true + }, + "immer": { + "optional": true + }, + "react": { + "optional": true + }, + "use-sync-external-store": { + "optional": true + } + } + } + } +} diff --git a/frontend/package.json b/frontend/package.json new file mode 100644 index 0000000..1683c85 --- /dev/null +++ b/frontend/package.json @@ -0,0 +1,39 @@ +{ + "name": "frontend", + "private": true, + "version": "0.0.0", + "type": "module", + "scripts": { + "dev": "vite", + "build": "tsc -b && vite build", + "lint": "eslint .", + "preview": "vite preview" + }, + "dependencies": { + "@tailwindcss/vite": "^4.2.1", + "@tanstack/react-query": "^5.90.21", + "axios": "^1.13.5", + "konva": "^10.2.0", + "react": "^19.2.0", + "react-dom": "^19.2.0", + "react-dropzone": "^15.0.0", + "react-konva": "^19.2.2", + "react-router-dom": "^7.13.1", + "tailwindcss": "^4.2.1", + "zustand": "^5.0.11" + }, + "devDependencies": { + "@eslint/js": "^9.39.1", + "@types/node": "^24.10.1", + "@types/react": "^19.2.7", + "@types/react-dom": "^19.2.3", + "@vitejs/plugin-react": "^5.1.1", + "eslint": "^9.39.1", + "eslint-plugin-react-hooks": "^7.0.1", + "eslint-plugin-react-refresh": "^0.4.24", + "globals": "^16.5.0", + "typescript": "~5.9.3", + "typescript-eslint": "^8.48.0", + "vite": "^7.3.1" + } +} diff --git a/frontend/public/vite.svg b/frontend/public/vite.svg new file mode 100644 index 0000000..e7b8dfb --- /dev/null +++ b/frontend/public/vite.svg @@ -0,0 +1 @@ + \ No newline at end of file diff --git a/frontend/src/App.tsx b/frontend/src/App.tsx new file mode 100644 index 0000000..e9e3108 --- /dev/null +++ b/frontend/src/App.tsx @@ -0,0 +1,27 @@ +import { Routes, Route } from "react-router-dom"; +import AppLayout from "./components/layout/AppLayout"; +import Dashboard from "./pages/Dashboard"; +import ProjectDetail from "./pages/ProjectDetail"; +import NewAnalysis from "./pages/NewAnalysis"; +import AnalysisView from "./pages/AnalysisView"; +import ComparisonView from "./pages/ComparisonView"; +import Help from "./pages/Help"; +import About from "./pages/About"; + +function App() { + return ( + + }> + } /> + } /> + } /> + } /> + } /> + } /> + } /> + + + ); +} + +export default App; diff --git a/frontend/src/api/analysis.ts b/frontend/src/api/analysis.ts new file mode 100644 index 0000000..0d13aab --- /dev/null +++ b/frontend/src/api/analysis.ts @@ -0,0 +1,83 @@ +import client from "./client"; +import type { AnalysisDetail, AnalysisStatus, AOIRegion, AOIResult, Insight } from "../types/analysis"; + +export async function createAnalysis( + projectId: string, + file: File, + name?: string, + model?: string, +): Promise { + const formData = new FormData(); + formData.append("file", file); + if (name) formData.append("name", name); + if (model) formData.append("model", model); + + const { data } = await client.post(`/projects/${projectId}/analyses`, formData, { + headers: { "Content-Type": "multipart/form-data" }, + }); + return data; +} + +export async function getAnalysis(id: string): Promise { + const { data } = await client.get(`/analyses/${id}`); + return data; +} + +export async function getAnalysisStatus(id: string): Promise { + const { data } = await client.get(`/analyses/${id}/status`); + return data; +} + +export async function deleteAnalysis(id: string): Promise { + await client.delete(`/analyses/${id}`); +} + +export function getAnalysisImageUrl( + id: string, + type: "original" | "saliency-raw" | "heatmap" | "heatmap-standalone" | "gaze-sequence" | "thumbnail", +): string { + return `/api/analyses/${id}/images/${type}`; +} + +export async function createAOIs( + analysisId: string, + regions: AOIRegion[], +): Promise { + const { data } = await client.post(`/analyses/${analysisId}/aois`, { + regions, + }); + return data; +} + +export async function getAOIs(analysisId: string): Promise { + const { data } = await client.get(`/analyses/${analysisId}/aois`); + return data; +} + +export async function checkAIInsightsAvailable(): Promise { + try { + const { data } = await client.get("/analyses/ai-insights-available"); + return data.available; + } catch { + return false; + } +} + +export interface AIInsightsResponse { + insights: Insight[]; + cost_usd: number; + input_tokens: number; + output_tokens: number; +} + +export async function generateAIInsights(analysisId: string): Promise { + const { data } = await client.post(`/analyses/${analysisId}/ai-insights`); + return data; +} + +export async function deleteAOI( + analysisId: string, + aoiId: string, +): Promise { + await client.delete(`/analyses/${analysisId}/aois/${aoiId}`); +} diff --git a/frontend/src/api/client.ts b/frontend/src/api/client.ts new file mode 100644 index 0000000..902346c --- /dev/null +++ b/frontend/src/api/client.ts @@ -0,0 +1,25 @@ +import axios from "axios"; + +const client = axios.create({ + baseURL: "/api", + headers: { + "Content-Type": "application/json", + }, +}); + +client.interceptors.request.use((config) => { + config.headers["X-User-Id"] = "default"; + return config; +}); + +client.interceptors.response.use( + (response) => response, + (error) => { + const message = + error.response?.data?.detail || error.message || "An error occurred"; + console.error("[API Error]", message); + return Promise.reject(error); + }, +); + +export default client; diff --git a/frontend/src/api/projects.ts b/frontend/src/api/projects.ts new file mode 100644 index 0000000..50fea3c --- /dev/null +++ b/frontend/src/api/projects.ts @@ -0,0 +1,37 @@ +import client from "./client"; +import type { Project, ProjectDetail, ProjectCreate } from "../types/project"; + +export async function createProject( + name: string, + description?: string, +): Promise { + const { data } = await client.post("/projects", { name, description }); + return data; +} + +export async function listProjects( + page: number = 1, + perPage: number = 20, +): Promise { + const { data } = await client.get("/projects", { + params: { page, per_page: perPage }, + }); + return data; +} + +export async function getProject(id: string): Promise { + const { data } = await client.get(`/projects/${id}`); + return data; +} + +export async function updateProject( + id: string, + updates: Partial, +): Promise { + const { data } = await client.put(`/projects/${id}`, updates); + return data; +} + +export async function deleteProject(id: string): Promise { + await client.delete(`/projects/${id}`); +} diff --git a/frontend/src/api/reports.ts b/frontend/src/api/reports.ts new file mode 100644 index 0000000..b00ee99 --- /dev/null +++ b/frontend/src/api/reports.ts @@ -0,0 +1,23 @@ +import client from "./client"; + +export async function downloadReport(analysisId: string): Promise { + const response = await client.get(`/analyses/${analysisId}/report`, { + responseType: "blob", + }); + + const blob = new Blob([response.data], { type: "application/pdf" }); + const url = window.URL.createObjectURL(blob); + const link = document.createElement("a"); + link.href = url; + + const disposition = response.headers["content-disposition"]; + const filename = disposition + ? disposition.split("filename=")[1]?.replace(/"/g, "") + : `analysis-${analysisId}-report.pdf`; + + link.download = filename; + document.body.appendChild(link); + link.click(); + document.body.removeChild(link); + window.URL.revokeObjectURL(url); +} diff --git a/frontend/src/assets/react.svg b/frontend/src/assets/react.svg new file mode 100644 index 0000000..6c87de9 --- /dev/null +++ b/frontend/src/assets/react.svg @@ -0,0 +1 @@ + \ No newline at end of file diff --git a/frontend/src/components/analysis/GazeSequence.tsx b/frontend/src/components/analysis/GazeSequence.tsx new file mode 100644 index 0000000..1e6e9eb --- /dev/null +++ b/frontend/src/components/analysis/GazeSequence.tsx @@ -0,0 +1,95 @@ +import type { GazePoint } from "../../types/analysis"; +import { useAnalysisStore } from "../../stores/analysisStore"; +import Card from "../common/Card"; + +interface GazeSequenceProps { + imageUrl: string; + gazePoints: GazePoint[]; +} + +export default function GazeSequence({ + imageUrl, + gazePoints, +}: GazeSequenceProps) { + const zoom = useAnalysisStore((s) => s.zoom); + + return ( +
+
+ Gaze sequence visualization +
+ + {gazePoints.length > 0 && ( + +

+ Predicted Gaze Sequence +

+
+ + + + + + + + + + + {gazePoints.map((point) => ( + + + + + + + ))} + +
+ Order + + X + + Y + + Intensity +
+ + {point.rank} + + + {Math.round(point.x)} + + {Math.round(point.y)} + +
+
+
+
+ + {(point.intensity * 100).toFixed(0)}% + +
+
+
+ + )} +
+ ); +} diff --git a/frontend/src/components/analysis/HeatmapControls.tsx b/frontend/src/components/analysis/HeatmapControls.tsx new file mode 100644 index 0000000..27bd560 --- /dev/null +++ b/frontend/src/components/analysis/HeatmapControls.tsx @@ -0,0 +1,68 @@ +import { useAnalysisStore } from "../../stores/analysisStore"; +import Card from "../common/Card"; + +const colormaps = ["jet", "viridis", "inferno", "magma", "plasma"]; + +export default function HeatmapControls() { + const { opacity, colormap, visible } = useAnalysisStore( + (s) => s.heatmapSettings, + ); + const setOpacity = useAnalysisStore((s) => s.setHeatmapOpacity); + const setColormap = useAnalysisStore((s) => s.setHeatmapColormap); + const setVisible = useAnalysisStore((s) => s.setHeatmapVisible); + + return ( + +

+ Heatmap Controls +

+ +
+ + +
+ +
+ + setOpacity(Number(e.target.value) / 100)} + className="w-full accent-[#ffc407]" + disabled={!visible} + /> +
+ +
+ + +
+ + ); +} diff --git a/frontend/src/components/analysis/HeatmapOverlay.tsx b/frontend/src/components/analysis/HeatmapOverlay.tsx new file mode 100644 index 0000000..1546fe6 --- /dev/null +++ b/frontend/src/components/analysis/HeatmapOverlay.tsx @@ -0,0 +1,185 @@ +import { useEffect, useRef, useState } from "react"; +import { useAnalysisStore } from "../../stores/analysisStore"; + +type ColormapName = "jet" | "viridis" | "inferno" | "magma" | "plasma"; + +function interpolateColor( + stops: [number, number, number, number][], + t: number, +): [number, number, number, number] { + const n = stops.length - 1; + const idx = Math.min(Math.floor(t * n), n - 1); + const frac = t * n - idx; + const a = stops[idx]; + const b = stops[idx + 1]; + return [ + Math.round(a[0] + (b[0] - a[0]) * frac), + Math.round(a[1] + (b[1] - a[1]) * frac), + Math.round(a[2] + (b[2] - a[2]) * frac), + Math.round(a[3] + (b[3] - a[3]) * frac), + ]; +} + +const colormapStops: Record = { + jet: [ + [0, 0, 131, 255], + [0, 60, 170, 255], + [5, 255, 255, 255], + [255, 255, 0, 255], + [250, 0, 0, 255], + [128, 0, 0, 255], + ], + viridis: [ + [68, 1, 84, 255], + [59, 82, 139, 255], + [33, 145, 140, 255], + [94, 201, 98, 255], + [253, 231, 37, 255], + ], + inferno: [ + [0, 0, 4, 255], + [40, 11, 84, 255], + [101, 21, 110, 255], + [186, 55, 42, 255], + [252, 163, 4, 255], + [252, 255, 164, 255], + ], + magma: [ + [0, 0, 4, 255], + [28, 16, 68, 255], + [79, 18, 123, 255], + [182, 54, 121, 255], + [251, 136, 97, 255], + [252, 253, 191, 255], + ], + plasma: [ + [13, 8, 135, 255], + [84, 2, 163, 255], + [139, 10, 165, 255], + [185, 50, 137, 255], + [219, 92, 104, 255], + [244, 136, 73, 255], + [240, 249, 33, 255], + ], +}; + +function buildColormapLUT(name: ColormapName): Uint8ClampedArray { + const stops = colormapStops[name]; + const lut = new Uint8ClampedArray(256 * 4); + for (let i = 0; i < 256; i++) { + const t = i / 255; + const [r, g, b, a] = interpolateColor(stops, t); + lut[i * 4] = r; + lut[i * 4 + 1] = g; + lut[i * 4 + 2] = b; + lut[i * 4 + 3] = a; + } + return lut; +} + +interface HeatmapOverlayProps { + originalUrl: string; + saliencyUrl: string; +} + +export default function HeatmapOverlay({ + originalUrl, + saliencyUrl, +}: HeatmapOverlayProps) { + const canvasRef = useRef(null); + const containerRef = useRef(null); + const { opacity, colormap, visible } = useAnalysisStore( + (s) => s.heatmapSettings, + ); + const zoom = useAnalysisStore((s) => s.zoom); + const [originalImg, setOriginalImg] = useState(null); + const [saliencyImg, setSaliencyImg] = useState(null); + const [canvasSize, setCanvasSize] = useState({ width: 800, height: 600 }); + + useEffect(() => { + const img = new Image(); + img.onload = () => setOriginalImg(img); + img.onerror = (e) => console.error("Failed to load original image:", originalUrl, e); + img.src = originalUrl; + }, [originalUrl]); + + useEffect(() => { + const img = new Image(); + img.onload = () => setSaliencyImg(img); + img.onerror = (e) => console.error("Failed to load saliency image:", saliencyUrl, e); + img.src = saliencyUrl; + }, [saliencyUrl]); + + useEffect(() => { + if (!originalImg) return; + const container = containerRef.current; + if (!container) return; + + const maxWidth = container.clientWidth; + const baseScale = Math.min(1, maxWidth / originalImg.naturalWidth); + const scale = baseScale * zoom; + setCanvasSize({ + width: Math.round(originalImg.naturalWidth * scale), + height: Math.round(originalImg.naturalHeight * scale), + }); + }, [originalImg, zoom]); + + useEffect(() => { + const canvas = canvasRef.current; + if (!canvas || !originalImg) return; + const ctx = canvas.getContext("2d"); + if (!ctx) return; + + canvas.width = canvasSize.width; + canvas.height = canvasSize.height; + + ctx.drawImage(originalImg, 0, 0, canvasSize.width, canvasSize.height); + + if (visible && saliencyImg) { + const offscreen = document.createElement("canvas"); + offscreen.width = canvasSize.width; + offscreen.height = canvasSize.height; + const offCtx = offscreen.getContext("2d")!; + offCtx.drawImage(saliencyImg, 0, 0, canvasSize.width, canvasSize.height); + const saliencyData = offCtx.getImageData( + 0, + 0, + canvasSize.width, + canvasSize.height, + ); + + // Find the max gray value to normalize the alpha range + const lut = buildColormapLUT(colormap as ColormapName); + const pixels = saliencyData.data; + let maxGray = 0; + for (let i = 0; i < pixels.length; i += 4) { + if (pixels[i] > maxGray) maxGray = pixels[i]; + } + const scale = maxGray > 0 ? 255 / maxGray : 1; + for (let i = 0; i < pixels.length; i += 4) { + const gray = pixels[i]; + // Normalize gray to full 0-255 range for better visibility + const normalized = Math.min(255, Math.round(gray * scale)); + pixels[i] = lut[normalized * 4]; + pixels[i + 1] = lut[normalized * 4 + 1]; + pixels[i + 2] = lut[normalized * 4 + 2]; + // Use sqrt for a gentler falloff so mid-range values are more visible + pixels[i + 3] = Math.round(255 * opacity * Math.sqrt(normalized / 255)); + } + + offCtx.putImageData(saliencyData, 0, 0); + ctx.drawImage(offscreen, 0, 0); + } + }, [originalImg, saliencyImg, canvasSize, opacity, colormap, visible]); + + return ( +
+ +
+ ); +} diff --git a/frontend/src/components/analysis/HotspotList.tsx b/frontend/src/components/analysis/HotspotList.tsx new file mode 100644 index 0000000..1450de4 --- /dev/null +++ b/frontend/src/components/analysis/HotspotList.tsx @@ -0,0 +1,61 @@ +import type { Hotspot } from "../../types/analysis"; +import Card from "../common/Card"; + +interface HotspotListProps { + hotspots: Hotspot[]; +} + +export default function HotspotList({ hotspots }: HotspotListProps) { + const top5 = hotspots.slice(0, 5); + const maxIntensity = top5.length > 0 ? top5[0].intensity : 1; + + return ( + +

+ Top Attention Hotspots +

+ + {top5.length === 0 ? ( +

No hotspots detected.

+ ) : ( +
+ {top5.map((hotspot) => { + const barWidth = (hotspot.intensity / maxIntensity) * 100; + return ( +
+
+
+ + {hotspot.rank} + + + {hotspot.label || `Region ${hotspot.rank}`} + +
+ + ({Math.round(hotspot.center_x ?? hotspot.x)}, {Math.round(hotspot.center_y ?? hotspot.y)}) + +
+
+
+
+

+ {(hotspot.intensity * 100).toFixed(1)}% intensity +

+
+ ); + })} +
+ )} + + ); +} diff --git a/frontend/src/components/analysis/InsightsPanel.tsx b/frontend/src/components/analysis/InsightsPanel.tsx new file mode 100644 index 0000000..5238ebe --- /dev/null +++ b/frontend/src/components/analysis/InsightsPanel.tsx @@ -0,0 +1,99 @@ +import type { Insight } from "../../types/analysis"; +import Card from "../common/Card"; + +const iconMap = { + success: ( + + + + ), + info: ( + + + + ), + warning: ( + + + + ), +}; + +const borderColorMap = { + success: "border-l-green-500", + info: "border-l-blue-500", + warning: "border-l-amber-500", +}; + +function InsightCard({ insight, isAI }: { insight: Insight; isAI?: boolean }) { + const bgClass = isAI ? "bg-purple-50/60" : "bg-gray-50"; + return ( +
+ {iconMap[insight.type]} +
+

{insight.title}

+

{insight.description}

+
+
+ ); +} + +interface InsightsPanelProps { + insights: Insight[]; + aiInsights?: Insight[]; + aiCostUsd?: number | null; +} + +export default function InsightsPanel({ insights, aiInsights, aiCostUsd }: InsightsPanelProps) { + const hasInsights = insights && insights.length > 0; + const hasAI = aiInsights && aiInsights.length > 0; + + if (!hasInsights && !hasAI) return null; + + return ( +
+ {hasInsights && ( + +

+ Analysis Insights +

+
+ {insights.map((insight, i) => ( + + ))} +
+ + )} + + {hasAI && ( + +
+

+ AI Design Analysis +

+ + AI + +
+
+ {aiInsights!.map((insight, i) => ( + + ))} +
+
+

+ Powered by Claude Sonnet 4.6. AI insights are supplementary and should be validated against your design objectives. +

+ {aiCostUsd != null && ( + + Cost: ${aiCostUsd.toFixed(4)} + + )} +
+ + )} +
+ ); +} diff --git a/frontend/src/components/aoi/AOICanvas.tsx b/frontend/src/components/aoi/AOICanvas.tsx new file mode 100644 index 0000000..bf566dc --- /dev/null +++ b/frontend/src/components/aoi/AOICanvas.tsx @@ -0,0 +1,334 @@ +import { useEffect, useRef, useState, useCallback } from "react"; +import { Stage, Layer, Image as KonvaImage, Rect, Transformer, Text, Group } from "react-konva"; +import type Konva from "konva"; +import { useAnalysisStore } from "../../stores/analysisStore"; +import type { AOIRectangle } from "../../types/aoi"; +import type { AOIRegion } from "../../types/analysis"; +import { createAOIs } from "../../api/analysis"; +import Button from "../common/Button"; +import Card from "../common/Card"; + +const AOI_COLORS = ["#ef4444", "#3b82f6", "#f59e0b", "#8b5cf6", "#ec4899", "#ffc407", "#f97316"]; + +interface AOICanvasProps { + analysisId: string; + imageUrl: string; +} + +export default function AOICanvas({ analysisId, imageUrl }: AOICanvasProps) { + const containerRef = useRef(null); + const transformerRef = useRef(null); + const [image, setImage] = useState(null); + const [stageSize, setStageSize] = useState({ width: 800, height: 600 }); + const [scale, setScale] = useState(1); + const [isDrawing, setIsDrawing] = useState(false); + const [drawMode, setDrawMode] = useState(false); + const [drawStart, setDrawStart] = useState({ x: 0, y: 0 }); + const [tempRect, setTempRect] = useState<{ x: number; y: number; width: number; height: number } | null>(null); + const [selectedId, setSelectedId] = useState(null); + const [loading, setLoading] = useState(false); + const [editingLabel, setEditingLabel] = useState(null); + + const regions = useAnalysisStore((s) => s.aoiRegions); + const setRegions = useAnalysisStore((s) => s.setAoiRegions); + const addRegion = useAnalysisStore((s) => s.addAoiRegion); + const updateRegion = useAnalysisStore((s) => s.updateAoiRegion); + const removeRegion = useAnalysisStore((s) => s.removeAoiRegion); + const setAoiResults = useAnalysisStore((s) => s.setAoiResults); + + useEffect(() => { + const img = new window.Image(); + img.crossOrigin = "anonymous"; + img.onload = () => { + setImage(img); + if (containerRef.current) { + const maxWidth = containerRef.current.clientWidth; + const s = Math.min(1, maxWidth / img.naturalWidth); + setScale(s); + setStageSize({ + width: Math.round(img.naturalWidth * s), + height: Math.round(img.naturalHeight * s), + }); + } + }; + img.src = imageUrl; + }, [imageUrl]); + + const handleMouseDown = useCallback( + (e: Konva.KonvaEventObject) => { + if (!drawMode) return; + const stage = e.target.getStage(); + if (!stage) return; + const pos = stage.getPointerPosition(); + if (!pos) return; + setIsDrawing(true); + setDrawStart({ x: pos.x, y: pos.y }); + setTempRect({ x: pos.x, y: pos.y, width: 0, height: 0 }); + }, + [drawMode], + ); + + const handleMouseMove = useCallback( + (e: Konva.KonvaEventObject) => { + if (!isDrawing) return; + const stage = e.target.getStage(); + if (!stage) return; + const pos = stage.getPointerPosition(); + if (!pos) return; + setTempRect({ + x: Math.min(drawStart.x, pos.x), + y: Math.min(drawStart.y, pos.y), + width: Math.abs(pos.x - drawStart.x), + height: Math.abs(pos.y - drawStart.y), + }); + }, + [isDrawing, drawStart], + ); + + const handleMouseUp = useCallback(() => { + if (!isDrawing || !tempRect) return; + setIsDrawing(false); + if (tempRect.width > 10 && tempRect.height > 10) { + const newRegion: AOIRectangle = { + id: `aoi-${Date.now()}`, + label: `Region ${regions.length + 1}`, + x: tempRect.x / scale, + y: tempRect.y / scale, + width: tempRect.width / scale, + height: tempRect.height / scale, + color: AOI_COLORS[regions.length % AOI_COLORS.length], + }; + addRegion(newRegion); + } + setTempRect(null); + setDrawMode(false); + }, [isDrawing, tempRect, regions.length, scale, addRegion]); + + const handleDragEnd = useCallback( + (id: string, e: Konva.KonvaEventObject) => { + updateRegion(id, { + x: e.target.x() / scale, + y: e.target.y() / scale, + }); + }, + [scale, updateRegion], + ); + + const handleTransformEnd = useCallback( + (id: string, e: Konva.KonvaEventObject) => { + const node = e.target; + const scaleX = node.scaleX(); + const scaleY = node.scaleY(); + node.scaleX(1); + node.scaleY(1); + updateRegion(id, { + x: node.x() / scale, + y: node.y() / scale, + width: (node.width() * scaleX) / scale, + height: (node.height() * scaleY) / scale, + }); + }, + [scale, updateRegion], + ); + + useEffect(() => { + if (!transformerRef.current) return; + const stage = transformerRef.current.getStage(); + if (!stage || !selectedId) { + transformerRef.current.nodes([]); + return; + } + const node = stage.findOne(`#${selectedId}`); + if (node) { + transformerRef.current.nodes([node]); + } else { + transformerRef.current.nodes([]); + } + transformerRef.current.getLayer()?.batchDraw(); + }, [selectedId]); + + const handleAnalyze = async () => { + if (regions.length === 0) return; + setLoading(true); + try { + const apiRegions: AOIRegion[] = regions.map((r) => ({ + label: r.label, + x: r.x, + y: r.y, + width: r.width, + height: r.height, + })); + const results = await createAOIs(analysisId, apiRegions); + setAoiResults(results); + } catch (err) { + console.error("AOI analysis failed:", err); + } finally { + setLoading(false); + } + }; + + const handleLabelChange = (id: string, label: string) => { + updateRegion(id, { label }); + setEditingLabel(null); + }; + + return ( +
+
+ + + {regions.length > 0 && ( + + )} + {drawMode && ( + + Click and drag on the image to draw a region + + )} +
+ +
+ {image && ( + { + if (e.target === e.target.getStage()) { + setSelectedId(null); + } + }} + > + + + {regions.map((region) => ( + + setSelectedId(region.id)} + onDragEnd={(e) => handleDragEnd(region.id, e)} + onTransformEnd={(e) => handleTransformEnd(region.id, e)} + /> + + + ))} + {tempRect && ( + + )} + { + if (newBox.width < 10 || newBox.height < 10) return oldBox; + return newBox; + }} + /> + + + )} +
+ + {regions.length > 0 && ( + +

+ Defined Regions +

+
+ {regions.map((r) => ( +
+ + {editingLabel === r.id ? ( + handleLabelChange(r.id, e.target.value)} + onKeyDown={(e) => { + if (e.key === "Enter") { + handleLabelChange(r.id, e.currentTarget.value); + } + }} + className="border border-gray-300 rounded px-2 py-0.5 text-sm flex-1" + /> + ) : ( + setEditingLabel(r.id)} + > + {r.label} + + )} + + {Math.round(r.width)}x{Math.round(r.height)} + + +
+ ))} +
+ + )} +
+ ); +} diff --git a/frontend/src/components/aoi/AOIResults.tsx b/frontend/src/components/aoi/AOIResults.tsx new file mode 100644 index 0000000..9cadb81 --- /dev/null +++ b/frontend/src/components/aoi/AOIResults.tsx @@ -0,0 +1,91 @@ +import type { AOIResult } from "../../types/analysis"; +import Card from "../common/Card"; + +interface AOIResultsProps { + results: AOIResult[]; +} + +export default function AOIResults({ results }: AOIResultsProps) { + if (results.length === 0) return null; + + return ( + +

+ AOI Analysis Results +

+
+ + + + + + + + + + + {results.map((result, idx) => { + const densityColor = + result.density >= 1 ? "#ffc407" : "#ef4444"; + return ( + + + + + + + ); + })} + +
+ Region + + Attention % + + Area % + + Density +
+ {result.label} + +
+
+
+
+ + {result.attention_percent.toFixed(1)}% + +
+
+ {result.area_percent.toFixed(1)}% + + = 1 + ? "#ffc40720" + : "#ef444420", + }} + > + {result.density.toFixed(2)}x + +
+
+

+ Density = Attention% / Area%. Values above 1.0 indicate the region + attracts more attention than its size would suggest. +

+ + ); +} diff --git a/frontend/src/components/common/Button.tsx b/frontend/src/components/common/Button.tsx new file mode 100644 index 0000000..f906e6b --- /dev/null +++ b/frontend/src/components/common/Button.tsx @@ -0,0 +1,64 @@ +import type { ButtonHTMLAttributes, ReactNode } from "react"; + +type Variant = "primary" | "secondary" | "danger"; + +interface ButtonProps extends ButtonHTMLAttributes { + variant?: Variant; + children: ReactNode; + loading?: boolean; +} + +const variantClasses: Record = { + primary: "text-gray-900", + secondary: + "bg-transparent border-2 border-gray-300 text-gray-700 hover:bg-gray-50", + danger: "bg-red-500 text-white hover:bg-red-600", +}; + +const variantStyles: Record = { + primary: { backgroundColor: "#ffc407" }, + secondary: {}, + danger: {}, +}; + +export default function Button({ + variant = "primary", + children, + loading = false, + className = "", + disabled, + style, + ...props +}: ButtonProps) { + return ( + + ); +} diff --git a/frontend/src/components/common/Card.tsx b/frontend/src/components/common/Card.tsx new file mode 100644 index 0000000..8c0edbc --- /dev/null +++ b/frontend/src/components/common/Card.tsx @@ -0,0 +1,23 @@ +import type { ReactNode } from "react"; + +interface CardProps { + children: ReactNode; + className?: string; + padding?: boolean; +} + +export default function Card({ + children, + className = "", + padding = true, +}: CardProps) { + return ( +
+ {children} +
+ ); +} diff --git a/frontend/src/components/common/LoadingSpinner.tsx b/frontend/src/components/common/LoadingSpinner.tsx new file mode 100644 index 0000000..bb6e5b5 --- /dev/null +++ b/frontend/src/components/common/LoadingSpinner.tsx @@ -0,0 +1,40 @@ +interface LoadingSpinnerProps { + size?: "sm" | "md" | "lg"; + message?: string; +} + +const sizeClasses = { + sm: "w-5 h-5", + md: "w-8 h-8", + lg: "w-12 h-12", +}; + +export default function LoadingSpinner({ + size = "md", + message, +}: LoadingSpinnerProps) { + return ( +
+ + + + + {message &&

{message}

} +
+ ); +} diff --git a/frontend/src/components/layout/AppLayout.tsx b/frontend/src/components/layout/AppLayout.tsx new file mode 100644 index 0000000..3eaf5ca --- /dev/null +++ b/frontend/src/components/layout/AppLayout.tsx @@ -0,0 +1,24 @@ +import { Outlet } from "react-router-dom"; +import Header from "./Header"; +import Sidebar from "./Sidebar"; +import { useUIStore } from "../../stores/uiStore"; + +export default function AppLayout() { + const sidebarOpen = useUIStore((s) => s.sidebarOpen); + + return ( +
+
+ +
+
+ +
+
+
+ ); +} diff --git a/frontend/src/components/layout/Header.tsx b/frontend/src/components/layout/Header.tsx new file mode 100644 index 0000000..813f3e2 --- /dev/null +++ b/frontend/src/components/layout/Header.tsx @@ -0,0 +1,77 @@ +import { Link } from "react-router-dom"; +import { useUIStore } from "../../stores/uiStore"; + +export default function Header() { + const toggleSidebar = useUIStore((s) => s.toggleSidebar); + + return ( +
+
+ + + + OliVAS + + + Visual Attention Suite + + +
+ + +
+ ); +} diff --git a/frontend/src/components/layout/Sidebar.tsx b/frontend/src/components/layout/Sidebar.tsx new file mode 100644 index 0000000..b59fb70 --- /dev/null +++ b/frontend/src/components/layout/Sidebar.tsx @@ -0,0 +1,80 @@ +import { NavLink } from "react-router-dom"; +import { useUIStore } from "../../stores/uiStore"; + +const navItems = [ + { + to: "/", + label: "Dashboard", + icon: ( + + + + ), + }, + { + to: "/analyze", + label: "New Analysis", + icon: ( + + + + ), + }, + { + to: "/help", + label: "Help", + icon: ( + + + + ), + }, + { + to: "/about", + label: "About", + icon: ( + + + + ), + }, +]; + +export default function Sidebar() { + const sidebarOpen = useUIStore((s) => s.sidebarOpen); + + return ( + + ); +} diff --git a/frontend/src/components/upload/DropZone.tsx b/frontend/src/components/upload/DropZone.tsx new file mode 100644 index 0000000..2e72b63 --- /dev/null +++ b/frontend/src/components/upload/DropZone.tsx @@ -0,0 +1,96 @@ +import { useCallback, useState } from "react"; +import { useDropzone } from "react-dropzone"; + +interface DropZoneProps { + onFileSelected: (file: File) => void; + disabled?: boolean; +} + +export default function DropZone({ onFileSelected, disabled }: DropZoneProps) { + const [preview, setPreview] = useState(null); + const [selectedFile, setSelectedFile] = useState(null); + + const onDrop = useCallback( + (acceptedFiles: File[]) => { + const file = acceptedFiles[0]; + if (!file) return; + setSelectedFile(file); + setPreview(URL.createObjectURL(file)); + onFileSelected(file); + }, + [onFileSelected], + ); + + const { getRootProps, getInputProps, isDragActive } = useDropzone({ + onDrop, + accept: { + "image/jpeg": [".jpg", ".jpeg"], + "image/png": [".png"], + "image/tiff": [".tiff", ".tif"], + "image/webp": [".webp"], + }, + maxFiles: 1, + disabled, + }); + + return ( +
+
+ + {preview ? ( +
+ Preview +
+

{selectedFile?.name}

+

+ {selectedFile + ? `${(selectedFile.size / 1024 / 1024).toFixed(2)} MB` + : ""} +

+
+

+ Drop a new image to replace +

+
+ ) : ( +
+ + + +
+

+ {isDragActive + ? "Drop your image here" + : "Drag and drop an image, or click to browse"} +

+

+ JPEG, PNG, TIFF, or WebP +

+
+
+ )} +
+
+ ); +} diff --git a/frontend/src/components/upload/UploadPreview.tsx b/frontend/src/components/upload/UploadPreview.tsx new file mode 100644 index 0000000..d4b28ba --- /dev/null +++ b/frontend/src/components/upload/UploadPreview.tsx @@ -0,0 +1,51 @@ +import { useEffect, useState } from "react"; +import Card from "../common/Card"; + +interface UploadPreviewProps { + file: File; +} + +export default function UploadPreview({ file }: UploadPreviewProps) { + const [dimensions, setDimensions] = useState<{ + width: number; + height: number; + } | null>(null); + const [previewUrl, setPreviewUrl] = useState(""); + + useEffect(() => { + const url = URL.createObjectURL(file); + setPreviewUrl(url); + + const img = new Image(); + img.onload = () => { + setDimensions({ width: img.naturalWidth, height: img.naturalHeight }); + }; + img.src = url; + + return () => URL.revokeObjectURL(url); + }, [file]); + + const sizeMB = (file.size / 1024 / 1024).toFixed(2); + + return ( + + {previewUrl && ( + Preview + )} +
+

{file.name}

+

{sizeMB} MB

+ {dimensions && ( +

+ {dimensions.width} x {dimensions.height} px +

+ )} +

{file.type}

+
+ + ); +} diff --git a/frontend/src/globals.css b/frontend/src/globals.css new file mode 100644 index 0000000..74631d8 --- /dev/null +++ b/frontend/src/globals.css @@ -0,0 +1,13 @@ +@import "tailwindcss"; + +body { + font-family: + "Montserrat", + -apple-system, + BlinkMacSystemFont, + "Segoe UI", + Roboto, + sans-serif; + -webkit-font-smoothing: antialiased; + -moz-osx-font-smoothing: grayscale; +} diff --git a/frontend/src/hooks/useAnalysis.ts b/frontend/src/hooks/useAnalysis.ts new file mode 100644 index 0000000..87425c9 --- /dev/null +++ b/frontend/src/hooks/useAnalysis.ts @@ -0,0 +1,27 @@ +import { useQuery } from "@tanstack/react-query"; +import { getAnalysis, getAnalysisStatus } from "../api/analysis"; +import type { AnalysisDetail, AnalysisStatus } from "../types/analysis"; + +export function useAnalysis(analysisId: string | undefined) { + return useQuery({ + queryKey: ["analysis", analysisId], + queryFn: () => getAnalysis(analysisId!), + enabled: !!analysisId, + }); +} + +export function useAnalysisStatus( + analysisId: string | undefined, + enabled: boolean = true, +) { + return useQuery({ + queryKey: ["analysisStatus", analysisId], + queryFn: () => getAnalysisStatus(analysisId!), + enabled: !!analysisId && enabled, + refetchInterval: (query) => { + const status = query.state.data?.status; + if (status === "completed" || status === "failed") return false; + return 2000; + }, + }); +} diff --git a/frontend/src/hooks/useProjects.ts b/frontend/src/hooks/useProjects.ts new file mode 100644 index 0000000..40940b2 --- /dev/null +++ b/frontend/src/hooks/useProjects.ts @@ -0,0 +1,63 @@ +import { useQuery, useMutation, useQueryClient } from "@tanstack/react-query"; +import { + listProjects, + getProject, + createProject, + updateProject, + deleteProject, +} from "../api/projects"; +import type { Project, ProjectDetail, ProjectCreate } from "../types/project"; + +export function useProjects(page: number = 1, perPage: number = 20) { + return useQuery({ + queryKey: ["projects", page, perPage], + queryFn: () => listProjects(page, perPage), + }); +} + +export function useProject(projectId: string | undefined) { + return useQuery({ + queryKey: ["project", projectId], + queryFn: () => getProject(projectId!), + enabled: !!projectId, + }); +} + +export function useCreateProject() { + const queryClient = useQueryClient(); + + return useMutation({ + mutationFn: ({ name, description }: ProjectCreate) => + createProject(name, description), + onSuccess: () => { + queryClient.invalidateQueries({ queryKey: ["projects"] }); + }, + }); +} + +export function useUpdateProject() { + const queryClient = useQueryClient(); + + return useMutation({ + mutationFn: ({ + id, + ...updates + }: Partial & { id: string }) => + updateProject(id, updates), + onSuccess: (_, variables) => { + queryClient.invalidateQueries({ queryKey: ["projects"] }); + queryClient.invalidateQueries({ queryKey: ["project", variables.id] }); + }, + }); +} + +export function useDeleteProject() { + const queryClient = useQueryClient(); + + return useMutation({ + mutationFn: (id: string) => deleteProject(id), + onSuccess: () => { + queryClient.invalidateQueries({ queryKey: ["projects"] }); + }, + }); +} diff --git a/frontend/src/hooks/useUpload.ts b/frontend/src/hooks/useUpload.ts new file mode 100644 index 0000000..0d2c06e --- /dev/null +++ b/frontend/src/hooks/useUpload.ts @@ -0,0 +1,48 @@ +import { useState, useCallback } from "react"; +import { useMutation } from "@tanstack/react-query"; +import { createAnalysis } from "../api/analysis"; +import type { AnalysisDetail } from "../types/analysis"; + +interface UseUploadOptions { + onSuccess?: (analysis: AnalysisDetail) => void; + onError?: (error: Error) => void; +} + +export function useUpload(options?: UseUploadOptions) { + const [progress, setProgress] = useState(0); + + const mutation = useMutation< + AnalysisDetail, + Error, + { projectId: string; file: File; name?: string; model?: string } + >({ + mutationFn: async ({ projectId, file, name, model }) => { + setProgress(10); + const result = await createAnalysis(projectId, file, name, model); + setProgress(100); + return result; + }, + onSuccess: (data) => { + options?.onSuccess?.(data); + }, + onError: (error) => { + setProgress(0); + options?.onError?.(error); + }, + }); + + const reset = useCallback(() => { + setProgress(0); + mutation.reset(); + }, [mutation]); + + return { + upload: mutation.mutate, + uploadAsync: mutation.mutateAsync, + isUploading: mutation.isPending, + progress, + error: mutation.error, + data: mutation.data, + reset, + }; +} diff --git a/frontend/src/main.tsx b/frontend/src/main.tsx new file mode 100644 index 0000000..a601f65 --- /dev/null +++ b/frontend/src/main.tsx @@ -0,0 +1,26 @@ +import { StrictMode } from "react"; +import { createRoot } from "react-dom/client"; +import { BrowserRouter } from "react-router-dom"; +import { QueryClient, QueryClientProvider } from "@tanstack/react-query"; +import App from "./App"; +import "./globals.css"; + +const queryClient = new QueryClient({ + defaultOptions: { + queries: { + retry: 1, + refetchOnWindowFocus: false, + staleTime: 30_000, + }, + }, +}); + +createRoot(document.getElementById("root")!).render( + + + + + + + , +); diff --git a/frontend/src/pages/About.tsx b/frontend/src/pages/About.tsx new file mode 100644 index 0000000..1feeda9 --- /dev/null +++ b/frontend/src/pages/About.tsx @@ -0,0 +1,468 @@ +import { useState } from "react"; +import Card from "../components/common/Card"; + +function Section({ + title, + children, +}: { + title: string; + children: React.ReactNode; +}) { + return ( + +

+ {title} +

+
+ {children} +
+ + ); +} + +function Expandable({ + label, + children, +}: { + label: string; + children: React.ReactNode; +}) { + const [open, setOpen] = useState(false); + return ( +
+ + {open && ( +
+ {children} +
+ )} +
+ ); +} + +function Citation({ + authors, + year, + title, + venue, + url, +}: { + authors: string; + year: string; + title: string; + venue: string; + url: string; +}) { + return ( +

+ {authors} ({year}).{" "} + + “{title}” + + . {venue}. +

+ ); +} + +export default function About() { + return ( +
+ {/* Hero */} +
+

+ The Science Behind Oli + VAS +

+

+ How we predict where people look — and why you can trust the results +

+
+ + {/* Layman's explanation */} +
+

+ When you look at an image — an ad, a product package, a web page — your + eyes don't scan everything equally. In the first 3–5 seconds, your gaze + is drawn to specific areas: faces, high-contrast text, bright colours, + and unusual shapes. This is called visual saliency. +

+

+ OliVAS uses deep neural networks to predict this + behaviour. These networks were trained on data from thousands of{" "} + real eye-tracking experiments, where researchers recorded + exactly where people looked when shown different images. The models + learned the patterns that drive human attention — and can now predict + them for any new image you upload. +

+

+ The result is a heatmap showing where viewers are most + likely to look, a gaze sequence predicting the order of + fixations, and attention metrics that quantify how + effectively your design captures attention. +

+
+ + {/* The Models */} +
+

+ OliVAS uses the DeepGaze family of models, developed at + the University of Tübingen by Matthias Kümmerer, Matthias Bethge, and + colleagues. These are consistently among the{" "} + top-ranked models on the{" "} + + MIT/Tübingen Saliency Benchmark + + , the standard evaluation platform for saliency prediction. +

+ + {/* DeepGaze IIE */} +
+
+

DeepGaze IIE

+ + Recommended + +
+

+ Our recommended model for most use cases. It combines features from + two powerful image recognition networks (ResNet and DenseNet) to + predict where people look. It is calibrated — meaning + its confidence scores closely match actual fixation probabilities, even + on images very different from its training data. +

+ +

+ DeepGaze IIE uses an ensemble of ResNet-50 and DenseNet-201 features + with a readout network and learned center bias prior. It was the + first model to demonstrate strong out-of-domain generalisation across + different saliency datasets. It achieves state-of-the-art performance + on the MIT/Tübingen benchmark with an Information Gain (IG) score + that significantly outperforms previous models. +

+ + +
+ + {/* DeepGaze III */} +
+

DeepGaze III

+

+ The latest model in the family, designed to predict not just{" "} + where people look but the sequence of fixations + over time. It uses a transformer-based architecture that can capture + long-range dependencies in an image — useful for complex layouts with + many elements. +

+ +

+ DeepGaze III models scanpaths (sequences of fixations) rather than + just static saliency maps. It uses a deep neural network with a + fixation selection mechanism that accounts for the temporal dynamics + of visual exploration. Published in the Journal of Vision, the + leading peer-reviewed journal for vision science. +

+ + +
+ + {/* DeepGaze I */} +
+

DeepGaze I

+

+ The original DeepGaze model that pioneered using deep learning features + for saliency prediction. It demonstrated that features learned for + object recognition (on ImageNet) naturally encode information about + where humans look. Faster than the newer variants but less accurate on + complex designs. +

+ +

+ DeepGaze I uses features from AlexNet (trained on ImageNet) with a + linear readout to predict fixation density. It was the first model to + show that deep features trained for object classification transfer + well to saliency prediction, significantly outperforming + hand-engineered feature models. +

+ + +
+
+ + {/* Validation */} +
+

+ How do we know these predictions are accurate? The models are evaluated + against real human eye-tracking data. In eye-tracking + studies, participants view images while a camera tracks their exact gaze + position at high speed (typically 250–1000 times per second). This + produces ground truth "fixation maps" showing where humans actually + looked. +

+

+ The{" "} + + MIT/Tübingen Saliency Benchmark + {" "} + is the standard platform for comparing saliency models. It uses hidden + test sets so models cannot be tuned to the evaluation data. DeepGaze + models consistently rank among the top performers. +

+

+ Key evaluation datasets include: +

+
    +
  • + MIT1003 — 1,003 natural images with eye-tracking data + from 15 viewers each ( + + Judd et al., 2009 + + ) +
    • +
  • + CAT2000 — 4,000 images across 20 categories with + fixation data from 24 observers ( + + Borji & Itti, 2015 + + ) +
    • +
+ + +

+ Models are evaluated on multiple metrics: AUC (Area Under the ROC + Curve), Information Gain (IG), Normalized Scanpath Saliency (NSS), + and KL Divergence. These measure different aspects of prediction + quality — from binary "is this a fixated location" to fine-grained + probability calibration. +

+

+ DeepGaze IIE achieves some of the highest Information Gain scores on + the MIT benchmark, meaning its predicted probability distributions + closely match actual human fixation patterns. +

+ +
+ + {/* Foundational Research */} +
+

+ The scientific study of visual attention goes back decades. In 1998, + Laurent Itti, Christof Koch, and Ernst Niebur published a landmark + computational model of visual attention based on neuroscience principles + — centre-surround contrast in colour, intensity, and orientation. This + model established the field of computational saliency prediction. +

+

+ Since then, the field has evolved from hand-crafted feature models to + deep learning approaches. DeepGaze I (2015) was a pivotal moment, + showing that neural networks trained for object recognition naturally + learn to predict human attention. Each subsequent version has improved + accuracy and generalisation. +

+ + + + +
+ + {/* Important caveats */} +
+

+ While saliency models are powerful tools, they have important + limitations to keep in mind: +

+
    +
  • + First-glance only — Predictions model the first 3–5 + seconds of free viewing. They do not predict reading behaviour, + task-driven search, or extended engagement. +
    • +
  • + Bottom-up attention — Models predict attention driven + by visual features (contrast, faces, objects). They do not account for + top-down factors like user intent, cultural context, or brand + recognition. +
    • +
  • + Aggregated viewers — Predictions represent an + average across many viewers. Individual variation can be substantial. +
    • +
  • + Static images only — Models are trained on and + predict for static images, not video or interactive content. +
    • +
+

+ For best results, use OliVAS as one input in your design review process + alongside user testing, A/B testing, and domain expertise. +

+
+ + {/* Full References */} +
+
+ + + + + + + + +
+
+

+ Open-source implementation:{" "} + + github.com/matthias-k/DeepGaze + {" "} + | Benchmark:{" "} + + saliency.tuebingen.ai + +

+
+
+ +
+ OliVAS — Open-Source Visual Attention Software by OLIVER +
+
+ ); +} diff --git a/frontend/src/pages/AnalysisView.tsx b/frontend/src/pages/AnalysisView.tsx new file mode 100644 index 0000000..be1cea2 --- /dev/null +++ b/frontend/src/pages/AnalysisView.tsx @@ -0,0 +1,274 @@ +import { useEffect, useState } from "react"; +import { useParams } from "react-router-dom"; +import { useAnalysis } from "../hooks/useAnalysis"; +import { useAnalysisStore, type AnalysisTab } from "../stores/analysisStore"; +import { getAnalysisImageUrl, checkAIInsightsAvailable, generateAIInsights } from "../api/analysis"; +import type { Insight } from "../types/analysis"; + +function ZoomableImage({ src, alt }: { src: string; alt: string }) { + const zoom = useAnalysisStore((s) => s.zoom); + return ( +
+ {alt} +
+ ); +} + +function ZoomControls() { + const zoom = useAnalysisStore((s) => s.zoom); + const setZoom = useAnalysisStore((s) => s.setZoom); + return ( +
+ + {Math.round(zoom * 100)}% + + {zoom !== 1 && ( + + )} +
+ ); +} +import { downloadReport } from "../api/reports"; +import HeatmapOverlay from "../components/analysis/HeatmapOverlay"; +import HeatmapControls from "../components/analysis/HeatmapControls"; +import GazeSequence from "../components/analysis/GazeSequence"; +import HotspotList from "../components/analysis/HotspotList"; +import InsightsPanel from "../components/analysis/InsightsPanel"; +import AOICanvas from "../components/aoi/AOICanvas"; +import AOIResults from "../components/aoi/AOIResults"; +import Card from "../components/common/Card"; +import Button from "../components/common/Button"; +import LoadingSpinner from "../components/common/LoadingSpinner"; + +const tabs: { key: AnalysisTab; label: string }[] = [ + { key: "heatmap", label: "Heatmap" }, + { key: "gaze", label: "Gaze Sequence" }, + { key: "hotspots", label: "Hotspots" }, + { key: "aoi", label: "AOI Analysis" }, +]; + +export default function AnalysisView() { + const { analysisId } = useParams<{ analysisId: string }>(); + const { data: analysis, isLoading, error } = useAnalysis(analysisId); + const activeTab = useAnalysisStore((s) => s.activeTab); + const setActiveTab = useAnalysisStore((s) => s.setActiveTab); + const setCurrentAnalysis = useAnalysisStore((s) => s.setCurrentAnalysis); + const aoiResults = useAnalysisStore((s) => s.aoiResults); + const reset = useAnalysisStore((s) => s.reset); + + const [aiAvailable, setAiAvailable] = useState(false); + const [aiInsights, setAiInsights] = useState([]); + const [aiCostUsd, setAiCostUsd] = useState(null); + const [aiLoading, setAiLoading] = useState(false); + const [aiError, setAiError] = useState(null); + + useEffect(() => { + checkAIInsightsAvailable().then(setAiAvailable); + }, []); + + // Load saved AI insights from DB when analysis loads + useEffect(() => { + if (analysis?.ai_insights && analysis.ai_insights.length > 0) { + setAiInsights(analysis.ai_insights); + setAiCostUsd(analysis.ai_cost_usd ?? null); + } + }, [analysis]); + + const handleGenerateAI = async () => { + if (!analysisId) return; + setAiLoading(true); + setAiError(null); + try { + const result = await generateAIInsights(analysisId); + setAiInsights(result.insights); + setAiCostUsd(result.cost_usd); + } catch (err: any) { + setAiError(err?.response?.data?.detail || "AI analysis failed"); + } finally { + setAiLoading(false); + } + }; + + useEffect(() => { + if (analysis) { + setCurrentAnalysis(analysis); + } + return () => { + reset(); + }; + }, [analysis, setCurrentAnalysis, reset]); + + const handleDownloadPdf = async () => { + if (!analysisId) return; + try { + await downloadReport(analysisId); + } catch (err) { + console.error("Failed to download report:", err); + } + }; + + if (isLoading) { + return ; + } + + if (error || !analysis) { + return ( +
+

+ Failed to load analysis. It may not exist or is still processing. +

+ +
+ ); + } + + const originalUrl = getAnalysisImageUrl(analysis.id, "original"); + const saliencyUrl = getAnalysisImageUrl(analysis.id, "saliency-raw"); + const gazeUrl = getAnalysisImageUrl(analysis.id, "gaze-sequence"); + + return ( +
+ {/* Header */} +
+
+

+ {analysis.name} +

+
+ Model: {analysis.model_used || analysis.model} + + {new Date(analysis.created_at).toLocaleDateString()} + + {analysis.overall_score !== undefined && ( + + Score: {analysis.overall_score.toFixed(1)} + + )} +
+
+
+ {aiAvailable && analysis.status === "completed" && aiInsights.length === 0 && ( + + )} + +
+
+ + {/* Tabs + Zoom */} +
+
+
+ {tabs.map((tab) => ( + + ))} +
+ +
+
+ + {/* Insights */} + {((analysis.insights && analysis.insights.length > 0) || aiInsights.length > 0) && ( + + )} + {aiError && ( +
+ {aiError} +
+ )} + + {/* Tab content */} + {activeTab === "heatmap" && ( +
+
+ + + +
+
+ +
+
+ )} + + {activeTab === "gaze" && ( + ({ + rank: p.rank, + x: p.x, + y: p.y, + intensity: p.probability ?? p.intensity ?? 0, + })) + } + /> + )} + + {activeTab === "hotspots" && ( +
+ + + + +
+ )} + + {activeTab === "aoi" && ( +
+ + +
+ )} +
+ ); +} diff --git a/frontend/src/pages/ComparisonView.tsx b/frontend/src/pages/ComparisonView.tsx new file mode 100644 index 0000000..e19de9e --- /dev/null +++ b/frontend/src/pages/ComparisonView.tsx @@ -0,0 +1,175 @@ +import { useEffect, useState } from "react"; +import { useParams, useNavigate } from "react-router-dom"; +import { useProject } from "../hooks/useProjects"; +import { getAnalysisImageUrl } from "../api/analysis"; +import Card from "../components/common/Card"; +import Button from "../components/common/Button"; +import LoadingSpinner from "../components/common/LoadingSpinner"; + +export default function ComparisonView() { + const { comparisonId } = useParams<{ comparisonId: string }>(); + const navigate = useNavigate(); + const { data: project, isLoading } = useProject(comparisonId); + const [selectedIds, setSelectedIds] = useState([]); + + const analyses = (project?.analyses || []).filter( + (a) => a.status === "completed", + ); + + useEffect(() => { + if (analyses.length >= 2 && selectedIds.length === 0) { + setSelectedIds(analyses.slice(0, 2).map((a) => a.id)); + } + }, [analyses, selectedIds.length]); + + const toggleSelection = (id: string) => { + setSelectedIds((prev) => + prev.includes(id) ? prev.filter((i) => i !== id) : [...prev, id], + ); + }; + + if (isLoading) { + return ; + } + + if (!project) { + return ( +
+

Project not found.

+ +
+ ); + } + + const selected = analyses.filter((a) => selectedIds.includes(a.id)); + + return ( +
+
+

+ Compare Analyses +

+

+ {project.name} -- Side-by-side heatmap comparison +

+
+ + {/* Selection */} + +

+ Select analyses to compare: +

+
+ {analyses.map((a) => ( + + ))} +
+ + + {/* Side-by-side view */} + {selected.length >= 2 ? ( +
+ {selected.map((analysis) => ( + +
+

+ {analysis.name} +

+

{analysis.model}

+
+
+ {`Heatmap: +
+ + ))} +
+ ) : ( + +

+ Select at least 2 completed analyses to compare. +

+ + )} + + {/* Comparison table */} + {selected.length >= 2 && ( + +

+ Comparison Metrics +

+
+ + + + + {selected.map((a) => ( + + ))} + + + + + + {selected.map((a) => ( + + ))} + + + + {selected.map((a) => ( + + ))} + + + + {selected.map((a) => ( + + ))} + + +
+ Metric + + {a.name} +
Model + {a.model} +
Status + + {a.status} + +
Date + {new Date(a.created_at).toLocaleDateString()} +
+
+ + )} +
+ ); +} diff --git a/frontend/src/pages/Dashboard.tsx b/frontend/src/pages/Dashboard.tsx new file mode 100644 index 0000000..65d1f9e --- /dev/null +++ b/frontend/src/pages/Dashboard.tsx @@ -0,0 +1,174 @@ +import { useState } from "react"; +import { Link } from "react-router-dom"; +import { useProjects, useCreateProject } from "../hooks/useProjects"; +import Card from "../components/common/Card"; +import Button from "../components/common/Button"; +import LoadingSpinner from "../components/common/LoadingSpinner"; + +export default function Dashboard() { + const { data, isLoading, error } = useProjects(); + const createProject = useCreateProject(); + const [showCreateModal, setShowCreateModal] = useState(false); + const [newName, setNewName] = useState(""); + const [newDescription, setNewDescription] = useState(""); + + const handleCreate = async () => { + if (!newName.trim()) return; + await createProject.mutateAsync({ + name: newName.trim(), + description: newDescription.trim() || undefined, + }); + setNewName(""); + setNewDescription(""); + setShowCreateModal(false); + }; + + if (isLoading) return ; + + if (error) { + return ( +
+

Failed to load projects. Please try again.

+
+ ); + } + + const projects = data || []; + + return ( +
+
+
+

+ Dashboard +

+

+ Manage your visual attention analysis projects +

+
+ +
+ + {projects.length === 0 ? ( + + + + +

+ No projects yet +

+

+ Create a project to start analyzing visual attention in your + creative assets. +

+ + + ) : ( +
+ {projects.map((project) => ( + + +
+

+ {project.name} +

+ + {project.analysis_count} analyses + +
+ {project.description && ( +

+ {project.description} +

+ )} +

+ Updated{" "} + {new Date(project.updated_at).toLocaleDateString()} +

+ + + ))} +
+ )} + + {showCreateModal && ( +
+ +

+ Create New Project +

+
+
+ + setNewName(e.target.value)} + placeholder="e.g., Q1 Campaign Creatives" + className="w-full border border-gray-300 rounded-lg px-3 py-2 text-sm focus:outline-none focus:ring-2 focus:ring-[#ffc407] focus:border-transparent" + autoFocus + onKeyDown={(e) => e.key === "Enter" && handleCreate()} + /> +
+
+ +