diff --git a/.editorconfig b/.editorconfig
index 6e87a00..59d9a3a 100644
--- a/.editorconfig
+++ b/.editorconfig
@@ -1,4 +1,4 @@
-# Editor configuration, see http://editorconfig.org
+# Editor configuration, see https://editorconfig.org
root = true
[*]
@@ -8,6 +8,9 @@ indent_size = 2
insert_final_newline = true
trim_trailing_whitespace = true
+[*.ts]
+quote_type = single
+
[*.md]
max_line_length = off
trim_trailing_whitespace = false
diff --git a/.env.example b/.env.example
new file mode 100644
index 0000000..74ee2a5
--- /dev/null
+++ b/.env.example
@@ -0,0 +1,19 @@
+FIREBASE_DEPLOY_KEY=
+FIREBASE_API_KEY=
+FIREBASE_APP_ID=
+FIREBASE_AUTH_DOMAIN=
+FIREBASE_DATABASE_URL=
+FIREBASE_MEASUREMENT_ID=
+FIREBASE_MESSAGING_SENDER_ID=
+FIREBASE_PROJECT_ID=
+FIREBASE_STORAGE_BUCKET=
+FIRESTORE_COLLECTION_FILES=
+FIRESTORE_COLLECTION_MESSAGES=
+GOOGLE_TAG_MANAGER_ID=
+MAIL_ACCOUNT=
+MAIL_HOST=
+MAIL_PASSWORD=
+MAIL_PORT=
+MAILCHIMP_B_FIELD=
+MAILCHIMP_SUBSCRIBE_ENDPOINT=
+RECAPTCHA_API_KEY=
diff --git a/.eslintrc.json b/.eslintrc.json
new file mode 100644
index 0000000..25caa0c
--- /dev/null
+++ b/.eslintrc.json
@@ -0,0 +1,24 @@
+{
+ "root": true,
+ "ignorePatterns": ["projects/**/*", "dist/**", "coverage/**", "node_modules/**", "**/*.min.js"],
+ "overrides": [
+ {
+ "files": ["*.ts"],
+ "parser": "@typescript-eslint/parser",
+ "parserOptions": {
+ "project": ["./tsconfig.eslint.json"],
+ "createDefaultProgram": true
+ },
+ "extends": [
+ "plugin:@angular-eslint/recommended",
+ "plugin:@angular-eslint/template/process-inline-templates"
+ ],
+ "rules": {}
+ },
+ {
+ "files": ["*.html"],
+ "extends": ["plugin:@angular-eslint/template/recommended"],
+ "rules": {}
+ }
+ ]
+}
diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
new file mode 100644
index 0000000..274ac6d
--- /dev/null
+++ b/.github/workflows/ci.yml
@@ -0,0 +1,436 @@
+# CI and deploy pipeline.
+# Node 24, pnpm, all checks; audit does not fail the pipeline; Lighthouse + axe against deployed URLs; deploy SSR to Firebase.
+# Feature branches deploy to the staging Firebase project; main/master deploy to production.
+# Lighthouse / axe / Observatory use staging URL except on main/master → https://ditectrev.com
+# After Firebase deploy: HTTP smoke (/ + /health) and Playwright smoke.spec against that environment.
+# Required GitHub Secrets: see .github/SECRETS.md (if present) or project docs.
+
+name: CI
+
+on:
+ push:
+ branches: [main, master, feature, "feature/**"]
+ pull_request:
+ branches: [main, master, feature, "feature/**"]
+
+env:
+ NODE_VERSION: "24"
+ PNPM_VERSION: "9.15.0"
+ NODE_OPTIONS: "--openssl-legacy-provider"
+
+jobs:
+ security-audit:
+ name: Dependencies audit
+ runs-on: ubuntu-latest
+ steps:
+ - uses: actions/checkout@v4
+ with:
+ fetch-depth: 0
+ - uses: pnpm/action-setup@v4
+ with:
+ version: ${{ env.PNPM_VERSION }}
+ - uses: actions/setup-node@v4
+ with:
+ node-version: ${{ env.NODE_VERSION }}
+ cache: "pnpm"
+ - run: pnpm install --frozen-lockfile
+ # Run audit but do not fail the pipeline (findings are reported only).
+ - name: Run audit
+ run: pnpm exec audit-ci --low || true
+
+ lint:
+ name: Lint (SAST)
+ runs-on: ubuntu-latest
+ steps:
+ - uses: actions/checkout@v4
+ - uses: pnpm/action-setup@v4
+ with:
+ version: ${{ env.PNPM_VERSION }}
+ - uses: actions/setup-node@v4
+ with:
+ node-version: ${{ env.NODE_VERSION }}
+ cache: "pnpm"
+ - run: pnpm install --frozen-lockfile
+ - run: pnpm run lint
+
+ format:
+ name: Code format
+ runs-on: ubuntu-latest
+ steps:
+ - uses: actions/checkout@v4
+ - uses: pnpm/action-setup@v4
+ with:
+ version: ${{ env.PNPM_VERSION }}
+ - uses: actions/setup-node@v4
+ with:
+ node-version: ${{ env.NODE_VERSION }}
+ cache: "pnpm"
+ - run: pnpm install --frozen-lockfile
+ - run: pnpm exec prettier --check "src/**/*.{ts,html,scss,json}" "*.json" || true
+
+ test:
+ name: Unit tests
+ runs-on: ubuntu-latest
+ steps:
+ - uses: actions/checkout@v4
+ - uses: pnpm/action-setup@v4
+ with:
+ version: ${{ env.PNPM_VERSION }}
+ - uses: actions/setup-node@v4
+ with:
+ node-version: ${{ env.NODE_VERSION }}
+ cache: "pnpm"
+ - run: pnpm install --frozen-lockfile
+ - run: pnpm run test
+
+ e2e:
+ name: E2E tests
+ runs-on: ubuntu-latest
+ steps:
+ - uses: actions/checkout@v4
+ - uses: pnpm/action-setup@v4
+ with:
+ version: ${{ env.PNPM_VERSION }}
+ - uses: actions/setup-node@v4
+ with:
+ node-version: ${{ env.NODE_VERSION }}
+ cache: "pnpm"
+ - run: pnpm install --frozen-lockfile
+ - run: pnpm exec playwright install --with-deps chromium
+ - run: pnpm run e2e
+
+ build-staging:
+ name: Build (staging)
+ runs-on: ubuntu-latest
+ environment: Preview
+ env:
+ FIREBASE_API_KEY: ${{ secrets.FIREBASE_API_KEY }}
+ FIREBASE_AUTH_DOMAIN: ${{ secrets.FIREBASE_AUTH_DOMAIN }}
+ FIREBASE_DATABASE_URL: ${{ secrets.FIREBASE_DATABASE_URL }}
+ FIREBASE_PROJECT_ID: ${{ secrets.FIREBASE_PROJECT_ID }}
+ FIREBASE_STORAGE_BUCKET: ${{ secrets.FIREBASE_STORAGE_BUCKET }}
+ FIREBASE_MESSAGING_SENDER_ID: ${{ secrets.FIREBASE_MESSAGING_SENDER_ID }}
+ FIREBASE_APP_ID: ${{ secrets.FIREBASE_APP_ID }}
+ FIREBASE_MEASUREMENT_ID: ${{ secrets.FIREBASE_MEASUREMENT_ID }}
+ FIRESTORE_COLLECTION_FILES: ${{ secrets.FIRESTORE_COLLECTION_FILES }}
+ FIRESTORE_COLLECTION_MESSAGES: ${{ secrets.FIRESTORE_COLLECTION_MESSAGES }}
+ GOOGLE_TAG_MANAGER_ID: ${{ secrets.GOOGLE_TAG_MANAGER_ID }}
+ MAIL_ACCOUNT: ${{ secrets.MAIL_ACCOUNT }}
+ MAIL_HOST: ${{ secrets.MAIL_HOST }}
+ MAIL_PASSWORD: ${{ secrets.MAIL_PASSWORD }}
+ MAIL_PORT: ${{ secrets.MAIL_PORT }}
+ MAILCHIMP_SUBSCRIBE_ENDPOINT: ${{ secrets.MAILCHIMP_SUBSCRIBE_ENDPOINT }}
+ MAILCHIMP_B_FIELD: ${{ secrets.MAILCHIMP_B_FIELD }}
+ RECAPTCHA_API_KEY: ${{ secrets.RECAPTCHA_API_KEY }}
+ steps:
+ - uses: actions/checkout@v4
+ - uses: pnpm/action-setup@v4
+ with:
+ version: ${{ env.PNPM_VERSION }}
+ - uses: actions/setup-node@v4
+ with:
+ node-version: ${{ env.NODE_VERSION }}
+ cache: "pnpm"
+ - run: pnpm install --frozen-lockfile
+ - run: pnpm run build:ssr
+
+ build-production:
+ name: Build (production)
+ runs-on: ubuntu-latest
+ environment: Production
+ env:
+ FIREBASE_API_KEY: ${{ secrets.FIREBASE_API_KEY }}
+ FIREBASE_AUTH_DOMAIN: ${{ secrets.FIREBASE_AUTH_DOMAIN }}
+ FIREBASE_DATABASE_URL: ${{ secrets.FIREBASE_DATABASE_URL }}
+ FIREBASE_PROJECT_ID: ${{ secrets.FIREBASE_PROJECT_ID }}
+ FIREBASE_STORAGE_BUCKET: ${{ secrets.FIREBASE_STORAGE_BUCKET }}
+ FIREBASE_MESSAGING_SENDER_ID: ${{ secrets.FIREBASE_MESSAGING_SENDER_ID }}
+ FIREBASE_APP_ID: ${{ secrets.FIREBASE_APP_ID }}
+ FIREBASE_MEASUREMENT_ID: ${{ secrets.FIREBASE_MEASUREMENT_ID }}
+ FIRESTORE_COLLECTION_FILES: ${{ secrets.FIRESTORE_COLLECTION_FILES }}
+ FIRESTORE_COLLECTION_MESSAGES: ${{ secrets.FIRESTORE_COLLECTION_MESSAGES }}
+ GOOGLE_TAG_MANAGER_ID: ${{ secrets.GOOGLE_TAG_MANAGER_ID }}
+ MAIL_ACCOUNT: ${{ secrets.MAIL_ACCOUNT }}
+ MAIL_HOST: ${{ secrets.MAIL_HOST }}
+ MAIL_PASSWORD: ${{ secrets.MAIL_PASSWORD }}
+ MAIL_PORT: ${{ secrets.MAIL_PORT }}
+ MAILCHIMP_SUBSCRIBE_ENDPOINT: ${{ secrets.MAILCHIMP_SUBSCRIBE_ENDPOINT }}
+ MAILCHIMP_B_FIELD: ${{ secrets.MAILCHIMP_B_FIELD }}
+ RECAPTCHA_API_KEY: ${{ secrets.RECAPTCHA_API_KEY }}
+ steps:
+ - uses: actions/checkout@v4
+ - uses: pnpm/action-setup@v4
+ with:
+ version: ${{ env.PNPM_VERSION }}
+ - uses: actions/setup-node@v4
+ with:
+ node-version: ${{ env.NODE_VERSION }}
+ cache: "pnpm"
+ - run: pnpm install --frozen-lockfile
+ - run: pnpm run build:ssr:production
+
+ deploy-firebase-preview:
+ name: Deploy to Firebase Hosting (preview)
+ runs-on: ubuntu-latest
+ needs: [lint, test, build-staging]
+ environment: Preview
+ permissions:
+ contents: read
+ id-token: write
+ # Deploy full SSR previews for any feature/* branch pushes to the staging Firebase project.
+ if: github.event_name == 'push' && startsWith(github.ref, 'refs/heads/feature/')
+ steps:
+ - uses: actions/checkout@v4
+ - uses: pnpm/action-setup@v4
+ with:
+ version: ${{ env.PNPM_VERSION }}
+ - uses: actions/setup-node@v4
+ with:
+ node-version: ${{ env.NODE_VERSION }}
+ cache: "pnpm"
+ - run: pnpm install --frozen-lockfile
+ - name: Install Firebase CLI
+ run: npm install -g firebase-tools
+ - name: Build and deploy SSR app to Firebase staging project
+ env:
+ FIREBASE_API_KEY: ${{ secrets.FIREBASE_API_KEY }}
+ FIREBASE_AUTH_DOMAIN: ${{ secrets.FIREBASE_AUTH_DOMAIN }}
+ FIREBASE_DATABASE_URL: ${{ secrets.FIREBASE_DATABASE_URL }}
+ FIREBASE_PROJECT_ID: ${{ secrets.FIREBASE_PROJECT_ID }}
+ FIREBASE_STORAGE_BUCKET: ${{ secrets.FIREBASE_STORAGE_BUCKET }}
+ FIREBASE_MESSAGING_SENDER_ID: ${{ secrets.FIREBASE_MESSAGING_SENDER_ID }}
+ FIREBASE_APP_ID: ${{ secrets.FIREBASE_APP_ID }}
+ FIREBASE_MEASUREMENT_ID: ${{ secrets.FIREBASE_MEASUREMENT_ID }}
+ FIRESTORE_COLLECTION_FILES: ${{ secrets.FIRESTORE_COLLECTION_FILES }}
+ FIRESTORE_COLLECTION_MESSAGES: ${{ secrets.FIRESTORE_COLLECTION_MESSAGES }}
+ GOOGLE_TAG_MANAGER_ID: ${{ secrets.GOOGLE_TAG_MANAGER_ID }}
+ MAIL_ACCOUNT: ${{ secrets.MAIL_ACCOUNT }}
+ MAIL_HOST: ${{ secrets.MAIL_HOST }}
+ MAIL_PASSWORD: ${{ secrets.MAIL_PASSWORD }}
+ MAIL_PORT: ${{ secrets.MAIL_PORT }}
+ MAILCHIMP_SUBSCRIBE_ENDPOINT: ${{ secrets.MAILCHIMP_SUBSCRIBE_ENDPOINT }}
+ MAILCHIMP_B_FIELD: ${{ secrets.MAILCHIMP_B_FIELD }}
+ RECAPTCHA_API_KEY: ${{ secrets.RECAPTCHA_API_KEY }}
+ FIREBASE_DEPLOY_KEY: ${{ secrets.FIREBASE_DEPLOY_KEY }}
+ CI_ENVIRONMENT_SLUG: development
+ run: pnpm run build-and-deploy:ssr:staging:firebase
+
+ deploy-firebase-production:
+ name: Deploy to Firebase Hosting (production SSR)
+ runs-on: ubuntu-latest
+ needs: [lint, test, build-production]
+ environment: Production
+ permissions:
+ contents: read
+ id-token: write
+ # Deploy production only from main/master pushes.
+ if: github.event_name == 'push' && (github.ref == 'refs/heads/main' || github.ref == 'refs/heads/master')
+ steps:
+ - uses: actions/checkout@v4
+ - uses: pnpm/action-setup@v4
+ with:
+ version: ${{ env.PNPM_VERSION }}
+ - uses: actions/setup-node@v4
+ with:
+ node-version: ${{ env.NODE_VERSION }}
+ cache: "pnpm"
+ - run: pnpm install --frozen-lockfile
+ - name: Install Firebase CLI
+ run: npm install -g firebase-tools
+ - name: Build and deploy SSR app to Firebase
+ env:
+ FIREBASE_API_KEY: ${{ secrets.FIREBASE_API_KEY }}
+ FIREBASE_AUTH_DOMAIN: ${{ secrets.FIREBASE_AUTH_DOMAIN }}
+ FIREBASE_DATABASE_URL: ${{ secrets.FIREBASE_DATABASE_URL }}
+ FIREBASE_PROJECT_ID: ${{ secrets.FIREBASE_PROJECT_ID }}
+ FIREBASE_STORAGE_BUCKET: ${{ secrets.FIREBASE_STORAGE_BUCKET }}
+ FIREBASE_MESSAGING_SENDER_ID: ${{ secrets.FIREBASE_MESSAGING_SENDER_ID }}
+ FIREBASE_APP_ID: ${{ secrets.FIREBASE_APP_ID }}
+ FIREBASE_MEASUREMENT_ID: ${{ secrets.FIREBASE_MEASUREMENT_ID }}
+ FIRESTORE_COLLECTION_FILES: ${{ secrets.FIRESTORE_COLLECTION_FILES }}
+ FIRESTORE_COLLECTION_MESSAGES: ${{ secrets.FIRESTORE_COLLECTION_MESSAGES }}
+ GOOGLE_TAG_MANAGER_ID: ${{ secrets.GOOGLE_TAG_MANAGER_ID }}
+ MAIL_ACCOUNT: ${{ secrets.MAIL_ACCOUNT }}
+ MAIL_HOST: ${{ secrets.MAIL_HOST }}
+ MAIL_PASSWORD: ${{ secrets.MAIL_PASSWORD }}
+ MAIL_PORT: ${{ secrets.MAIL_PORT }}
+ MAILCHIMP_SUBSCRIBE_ENDPOINT: ${{ secrets.MAILCHIMP_SUBSCRIBE_ENDPOINT }}
+ MAILCHIMP_B_FIELD: ${{ secrets.MAILCHIMP_B_FIELD }}
+ RECAPTCHA_API_KEY: ${{ secrets.RECAPTCHA_API_KEY }}
+ FIREBASE_DEPLOY_KEY: ${{ secrets.FIREBASE_DEPLOY_KEY }}
+ CI_ENVIRONMENT_SLUG: production
+ run: pnpm run build-and-deploy:ssr:production:firebase
+
+ lighthouse:
+ name: Lighthouse CI (deployed URL)
+ runs-on: ubuntu-latest
+ needs: [lint, test]
+ env:
+ LHCI_BASE_URL: ${{ (github.ref == 'refs/heads/main' || github.ref == 'refs/heads/master') && 'https://ditectrev.com' || 'https://ditectrev-v3-staging-5ad41.web.app' }}
+ steps:
+ - uses: actions/checkout@v4
+ - uses: pnpm/action-setup@v4
+ with:
+ version: ${{ env.PNPM_VERSION }}
+ - uses: actions/setup-node@v4
+ with:
+ node-version: ${{ env.NODE_VERSION }}
+ cache: "pnpm"
+ - run: pnpm install --frozen-lockfile
+ - name: Run Lighthouse CI
+ run: |
+ echo "LHCI_BASE_URL=$LHCI_BASE_URL"
+ pnpm exec lhci autorun
+
+ accessibility-axe:
+ name: Accessibility (axe)
+ runs-on: ubuntu-latest
+ needs: [lint, test]
+ env:
+ AXE_BASE_URL: ${{ (github.ref == 'refs/heads/main' || github.ref == 'refs/heads/master') && 'https://ditectrev.com' || 'https://ditectrev-v3-staging-5ad41.web.app' }}
+ # Do not fail the job on violations; log them and track in issues (local runs still fail unless AXE_NON_BLOCKING is set).
+ AXE_NON_BLOCKING: "true"
+ steps:
+ - uses: actions/checkout@v4
+ - uses: pnpm/action-setup@v4
+ with:
+ version: ${{ env.PNPM_VERSION }}
+ - uses: actions/setup-node@v4
+ with:
+ node-version: ${{ env.NODE_VERSION }}
+ cache: "pnpm"
+ - run: pnpm install --frozen-lockfile
+ - run: pnpm exec playwright install --with-deps chromium
+ - name: Run axe on deployed site
+ run: |
+ echo "AXE_BASE_URL=$AXE_BASE_URL"
+ pnpm run a11y:axe
+
+ observatory:
+ name: MDN HTTP Observatory (deployed host)
+ runs-on: ubuntu-latest
+ needs: [lint, test]
+ env:
+ OBSERVATORY_HOST: ${{ (github.ref == 'refs/heads/main' || github.ref == 'refs/heads/master') && 'ditectrev.com' || 'ditectrev-v3-staging-5ad41.web.app' }}
+ # Uses MDN HTTP Observatory API v2 (replaces deprecated mozilla.org v1 / observatory-cli — see https://github.com/mdn/mdn-http-observatory ).
+ # Third-party API may return 502; we retry then skip with a warning so PRs are not blocked.
+ steps:
+ - name: Run Observatory scan
+ id: observatory
+ run: |
+ set -euo pipefail
+ HOST="${OBSERVATORY_HOST}"
+ API="https://observatory-api.mdn.mozilla.net/api/v2"
+
+ json_ok() {
+ jq -e . >/dev/null 2>&1
+ }
+
+ echo "Starting MDN HTTP Observatory scan for $HOST..."
+
+ # POST /scan?host= — single response with grade/score (algorithm v4); rate-limited per host (~1/min cached)
+ for attempt in $(seq 1 15); do
+ HTTP=$(curl -sS --retry 2 --retry-delay 8 -o /tmp/scan_result.json -w "%{http_code}" \
+ -X POST "$API/scan?host=$HOST" || true)
+ if [ "$HTTP" = "200" ] && json_ok < /tmp/scan_result.json; then
+ echo "Scan result (HTTP $HTTP)"
+ cat /tmp/scan_result.json
+ break
+ fi
+ echo "Observatory POST returned HTTP $HTTP or non-JSON (attempt $attempt/15); retry in 45s..."
+ head -c 400 /tmp/scan_result.json 2>/dev/null || true
+ echo
+ if [ "$attempt" -eq 15 ]; then
+ echo "::warning::MDN Observatory API unavailable after 15 attempts (often HTTP 502). Skipping scan — verify manually at https://developer.mozilla.org/en-US/observatory/analyze?host=$HOST"
+ exit 0
+ fi
+ sleep 45
+ done
+
+ ERR=$(jq -r '.error // empty' /tmp/scan_result.json)
+ if [ -n "$ERR" ]; then
+ echo "Observatory API error: $ERR"
+ jq -r '.message // empty' /tmp/scan_result.json
+ exit 1
+ fi
+
+ GRADE=$(jq -r '.grade // .scan.grade // empty' /tmp/scan_result.json)
+ SCORE=$(jq -r '.score // .scan.score // empty' /tmp/scan_result.json)
+ DETAILS_URL=$(jq -r '.details_url // empty' /tmp/scan_result.json)
+ echo "Observatory grade: $GRADE (score: $SCORE)"
+ echo "grade=$GRADE" >> "$GITHUB_OUTPUT"
+ echo "score=$SCORE" >> "$GITHUB_OUTPUT"
+
+ # Informative only — do not fail the job on grade; track improvements in issues.
+ if [[ ! "$GRADE" == A* ]]; then
+ echo "::warning::MDN HTTP Observatory: grade $GRADE (score $SCORE) for $HOST — target A; details: $DETAILS_URL"
+ else
+ echo "Observatory grade OK: $GRADE (score $SCORE) for $HOST"
+ fi
+
+ http-smoke-staging:
+ name: HTTP smoke (staging after deploy)
+ runs-on: ubuntu-latest
+ needs: [deploy-firebase-preview]
+ if: success() && github.event_name == 'push' && startsWith(github.ref, 'refs/heads/feature/')
+ steps:
+ - name: curl / and /health
+ run: |
+ BASE="https://ditectrev-v3-staging-5ad41.web.app"
+ curl -fsS "$BASE/" -o /dev/null
+ curl -fsS "$BASE/health" -o /dev/null
+ echo "Staging HTTP OK"
+
+ http-smoke-production:
+ name: HTTP smoke (production after deploy)
+ runs-on: ubuntu-latest
+ needs: [deploy-firebase-production]
+ if: success() && github.event_name == 'push' && (github.ref == 'refs/heads/main' || github.ref == 'refs/heads/master')
+ steps:
+ - name: curl / and /health
+ run: |
+ curl -fsS "https://ditectrev.com/" -o /dev/null
+ curl -fsS "https://ditectrev.com/health" -o /dev/null
+ echo "Production HTTP OK"
+
+ e2e-deployed-staging:
+ name: E2E smoke — Playwright (staging after deploy)
+ runs-on: ubuntu-latest
+ needs: [deploy-firebase-preview]
+ if: success() && github.event_name == 'push' && startsWith(github.ref, 'refs/heads/feature/')
+ env:
+ E2E_BASE_URL: https://ditectrev-v3-staging-5ad41.web.app
+ steps:
+ - uses: actions/checkout@v4
+ - uses: pnpm/action-setup@v4
+ with:
+ version: ${{ env.PNPM_VERSION }}
+ - uses: actions/setup-node@v4
+ with:
+ node-version: ${{ env.NODE_VERSION }}
+ cache: "pnpm"
+ - run: pnpm install --frozen-lockfile
+ - run: pnpm exec playwright install --with-deps chromium
+ - name: Run smoke tests against deployed staging
+ run: pnpm exec playwright test e2e/smoke.spec.ts
+
+ e2e-deployed-production:
+ name: E2E smoke — Playwright (production after deploy)
+ runs-on: ubuntu-latest
+ needs: [deploy-firebase-production]
+ if: success() && github.event_name == 'push' && (github.ref == 'refs/heads/main' || github.ref == 'refs/heads/master')
+ env:
+ E2E_BASE_URL: https://ditectrev.com
+ steps:
+ - uses: actions/checkout@v4
+ - uses: pnpm/action-setup@v4
+ with:
+ version: ${{ env.PNPM_VERSION }}
+ - uses: actions/setup-node@v4
+ with:
+ node-version: ${{ env.NODE_VERSION }}
+ cache: "pnpm"
+ - run: pnpm install --frozen-lockfile
+ - run: pnpm exec playwright install --with-deps chromium
+ - name: Run smoke tests against deployed production
+ run: pnpm exec playwright test e2e/smoke.spec.ts
diff --git a/.github/workflows/scheduled-smoke.yml b/.github/workflows/scheduled-smoke.yml
new file mode 100644
index 0000000..7698d1a
--- /dev/null
+++ b/.github/workflows/scheduled-smoke.yml
@@ -0,0 +1,56 @@
+# Nightly / manual checks against live URLs (no PR noise).
+# - HTTP: / and /health on staging + production
+# - Broken links: shallow crawl of production (skips mailto/tel and common third-party CDNs)
+
+name: Scheduled smoke & link check
+
+on:
+ schedule:
+ - cron: "0 6 * * *"
+ workflow_dispatch:
+
+permissions:
+ contents: read
+
+concurrency:
+ group: scheduled-smoke
+ cancel-in-progress: false
+
+jobs:
+ http-smoke-urls:
+ name: HTTP smoke (staging + production)
+ runs-on: ubuntu-latest
+ steps:
+ - name: Staging
+ run: |
+ curl -fsS "https://ditectrev-v3-staging-5ad41.web.app/" -o /dev/null
+ curl -fsS "https://ditectrev-v3-staging-5ad41.web.app/health" -o /dev/null
+ - name: Production
+ run: |
+ curl -fsS "https://ditectrev.com/" -o /dev/null
+ curl -fsS "https://ditectrev.com/health" -o /dev/null
+
+ broken-links-production:
+ name: Broken link crawl (production, shallow)
+ runs-on: ubuntu-latest
+ steps:
+ - uses: actions/setup-node@v4
+ with:
+ node-version: "24"
+ - name: linkinator (same-origin emphasis via skips for off-site CDNs/analytics)
+ run: |
+ npx --yes linkinator@6 https://ditectrev.com \
+ --recurse \
+ --max-depth 2 \
+ --timeout 30000 \
+ --verbosity error \
+ --skip "^mailto:" \
+ --skip "^tel:" \
+ --skip "^javascript:" \
+ --skip "^https?://www\\.googletagmanager\\.com" \
+ --skip "^https?://www\\.google-analytics\\.com" \
+ --skip "^https?://region[0-9]+\\.google-analytics\\.com" \
+ --skip "^https?://fonts\\.googleapis\\.com" \
+ --skip "^https?://fonts\\.gstatic\\.com" \
+ --skip "^https?://www\\.google\\.com/recaptcha/" \
+ --skip "^https?://www\\.gstatic\\.com/recaptcha/"
diff --git a/.gitignore b/.gitignore
index b229095..46a1da8 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,15 +1,18 @@
-# See http://help.github.com/ignore-files/ for more about ignoring files.
+# See https://docs.github.com/get-started/getting-started-with-git/ignoring-files for more about ignoring files.
-# compiled output
+# Compiled output
/dist
/tmp
/out-tsc
+/bazel-out
-# dependencies
+# Node
/node_modules
+npm-debug.log
+yarn-error.log
# IDEs and editors
-/.idea
+.idea/
.project
.classpath
.c9/
@@ -17,38 +20,27 @@
.settings/
*.sublime-workspace
-# IDE - VSCode
+# Visual Studio Code
.vscode/*
!.vscode/settings.json
!.vscode/tasks.json
!.vscode/launch.json
!.vscode/extensions.json
+.history/*
-# misc
-/.sass-cache
+# Miscellaneous
+/.angular/cache
+.sass-cache/
/connect.lock
/coverage
+/playwright-report
+/test-results
/libpeerconnection.log
-npm-debug.log
-yarn-error.log
testem.log
/typings
-# System Files
+# System files
.DS_Store
Thumbs.db
-
-# Others.
-.config
.env
-.npm
-.npm-global
-.vscode
-.ash_history
-.firebase
-firebase-debug.log
-database-debug.log
-firestore-debug.log
-ui-debug.log
-/functions/dist
-/functions/index.js
+src/assets/env.js
diff --git a/.gitlab-ci.yml b/.gitlab-ci.yml
deleted file mode 100644
index a51576e..0000000
--- a/.gitlab-ci.yml
+++ /dev/null
@@ -1,140 +0,0 @@
-# TODO: Add Lighthouse CI
-# TODO: Justify the pipeline after introducing "npm run root:starting:index:firebase", "build-and-deploy:ditectrev:ssr:staging:firebase", and "build-and-deploy:ditectrev:ssr:production:firebase".
-# TODO: Remove the benchmarks to pass the pipeline.
-# GitLab uses Docker in the background, so it's required to get the image.
-image: node:10.15.3-alpine
-
-# Cache npm modules and Cypress binary. To point at the folders the paths can be lsited in the "cache" job settings.
-variables:
- npm_config_cache: '$CI_PROJECT_DIR/.npm'
- CYPRESS_CACHE_FOLDER: '$CI_PROJECT_DIR/cache/Cypress'
-
-# Cache using branch name.
-cache:
- key: $CI_COMMIT_REF_SLUG
- paths:
- - .npm
- - cache/Cypress
- - node_modules/
-
-# Make sure to install all packages before running anything.
-before_script:
- - apk update && apk add git # Install Git in the container.
- - npm ci # For CI it's better to have this instead of npm install.
-
-# Define stages which GitLab will go through, order matters.
-stages:
- - security
- - quality
- - test
- - build
- - staging
- - security staging
- - production
- - security production
-
-# Define and run known vulnerabilities security job.
-Dependencies Scanning:
- stage: security
- script:
- - npx audit-ci --low # Prevent integration with low or higher vulnerabilities, i.e. prevent all vulnerabilities.
-
-# Define and run lint (SAST) security job.
-Static Application Security Testing (SAST):
- script:
- - npm run lint
- stage: security
-
-# Define and run formatting code quality job.
-Code Quality:
- stage: quality
- script:
- - npm run format:check
-
-# Define and run unit tests job.
-Unit Tests:
- #image: juristr/angular-ci-build:1.0.0 # Install Angular CLI.
- script:
- - npm run test --coverage
- stage: test
-
-# Define and run E2E tests job.
-E2E Tests:
- artifacts:
- expire_in: 1 day
- paths:
- - dist/out-tsc/apps/ditectrev-e2e/**/*.mp4
- - dist/out-tsc/apps/ditectrev-e2e/**/*.png
- when: always
- image: cypress/base:10
- script:
- - npm run e2e
- stage: test
-
-# Define staging build job. It installs all required modules which are described in package.json and build the arficats which are supposed to be deployed.
-Build Staging:
- # Keep the functions folder as an artifact after the app build job will be done.
- artifacts:
- expire_in: 1 day
- paths:
- - functions
- when: always
- script:
- - npm run build:ditectrev:ssr:staging
- stage: build
-
-# Define production build job. It installs all required modules which are described in package.json and build the arficats which are supposed to be deployed.
-Build Production:
- # Keep the functions folder as an artifact after the app build job will be done.
- artifacts:
- expire_in: 1 day
- paths:
- - functions
- when: always
- script:
- - npm run build:ditectrev:ssr:production
- stage: build
-
-# Deployment settings for development environment.
-Deploy to Staging:
- dependencies:
- - Build Staging
- environment:
- name: development # Deployment stage for development environment.
- only:
- - master # Corresponding only to the master branch (note: should be develop, but the project started in master, so just keep it...).
- script:
- - npm run predeploy
- - npm run deploy:cloud_functions
- stage: staging
-
-# Mozilla Observatory staging security test.
-Security Headers Staging:
- script:
- - npm install -g observatory-cli
- - observatory ditectrev-v3-staging-5ad41.firebaseapp.com --format report --zero
- - observatory ditectrev-v3-staging-5ad41.firebaseapp.com --min-score 100
- stage: security staging
-
-# Deployment settings for production environment.
-Deploy to Production:
- dependencies:
- - Build Production
- environment:
- name: production # Deployment stage for production environment.
- only:
- - master # Corresponding only to the master branch.
- script:
- - npm run predeploy
- - npm run deploy:cloud_functions
- stage: production
- when: manual # Deployment to production has to be explicitly started by a user, thus this job is not exectued automatically.
-
-# Mozilla Observatory production security test.
-Security Headers Production:
- script:
- - npm install -g observatory-cli
- - observatory ditectrev-v3-prod.firebaseapp.com --format report --zero
- - observatory ditectrev-v3-prod.firebaseapp.com --min-score 100
- stage: security production
- when: manual # Security Headers can be check once again manually once deployment to production will be done.
diff --git a/.lighthouseci/assertion-results.json b/.lighthouseci/assertion-results.json
new file mode 100644
index 0000000..557bea4
--- /dev/null
+++ b/.lighthouseci/assertion-results.json
@@ -0,0 +1,16 @@
+[
+ {
+ "name": "minScore",
+ "expected": 0.55,
+ "actual": 0.47,
+ "values": [
+ 0.47
+ ],
+ "operator": ">=",
+ "passed": false,
+ "auditProperty": "performance",
+ "auditId": "categories",
+ "level": "warn",
+ "url": "http://localhost:3000/"
+ }
+]
\ No newline at end of file
diff --git a/.lighthouseci/lhr-1774694928082.html b/.lighthouseci/lhr-1774694928082.html
new file mode 100644
index 0000000..12b8429
--- /dev/null
+++ b/.lighthouseci/lhr-1774694928082.html
@@ -0,0 +1,2727 @@
+
+
+
+
+
+
+
+ Lighthouse Report
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/.lighthouseci/lhr-1774694928082.json b/.lighthouseci/lhr-1774694928082.json
new file mode 100644
index 0000000..2580b28
--- /dev/null
+++ b/.lighthouseci/lhr-1774694928082.json
@@ -0,0 +1,11745 @@
+{
+ "lighthouseVersion": "11.4.0",
+ "requestedUrl": "http://localhost:3000/",
+ "mainDocumentUrl": "http://localhost:3000/",
+ "finalDisplayedUrl": "http://localhost:3000/",
+ "finalUrl": "http://localhost:3000/",
+ "fetchTime": "2026-03-28T10:48:37.510Z",
+ "gatherMode": "navigation",
+ "runWarnings": [],
+ "userAgent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) HeadlessChrome/146.0.0.0 Safari/537.36",
+ "environment": {
+ "networkUserAgent": "Mozilla/5.0 (Linux; Android 11; moto g power (2022)) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/119.0.0.0 Mobile Safari/537.36",
+ "hostUserAgent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) HeadlessChrome/146.0.0.0 Safari/537.36",
+ "benchmarkIndex": 2977,
+ "credits": {
+ "axe-core": "4.11.1"
+ }
+ },
+ "audits": {
+ "is-on-https": {
+ "id": "is-on-https",
+ "title": "Uses HTTPS",
+ "description": "All sites should be protected with HTTPS, even ones that don't handle sensitive data. This includes avoiding [mixed content](https://developers.google.com/web/fundamentals/security/prevent-mixed-content/what-is-mixed-content), where some resources are loaded over HTTP despite the initial request being served over HTTPS. HTTPS prevents intruders from tampering with or passively listening in on the communications between your app and your users, and is a prerequisite for HTTP/2 and many new web platform APIs. [Learn more about HTTPS](https://developer.chrome.com/docs/lighthouse/pwa/is-on-https/).",
+ "score": 1,
+ "scoreDisplayMode": "binary",
+ "details": {
+ "type": "table",
+ "headings": [],
+ "items": []
+ }
+ },
+ "viewport": {
+ "id": "viewport",
+ "title": "Has a `` tag with `width` or `initial-scale`",
+ "description": "A `` not only optimizes your app for mobile screen sizes, but also prevents [a 300 millisecond delay to user input](https://developer.chrome.com/blog/300ms-tap-delay-gone-away/). [Learn more about using the viewport meta tag](https://developer.chrome.com/docs/lighthouse/pwa/viewport/).",
+ "score": 1,
+ "scoreDisplayMode": "metricSavings",
+ "warnings": [],
+ "metricSavings": {
+ "INP": 0
+ },
+ "guidanceLevel": 3
+ },
+ "first-contentful-paint": {
+ "id": "first-contentful-paint",
+ "title": "First Contentful Paint",
+ "description": "First Contentful Paint marks the time at which the first text or image is painted. [Learn more about the First Contentful Paint metric](https://developer.chrome.com/docs/lighthouse/performance/first-contentful-paint/).",
+ "score": 0.27,
+ "scoreDisplayMode": "numeric",
+ "numericValue": 3789.1294,
+ "numericUnit": "millisecond",
+ "displayValue": "3.8 s",
+ "scoringOptions": {
+ "p10": 1800,
+ "median": 3000
+ }
+ },
+ "largest-contentful-paint": {
+ "id": "largest-contentful-paint",
+ "title": "Largest Contentful Paint",
+ "description": "Largest Contentful Paint marks the time at which the largest text or image is painted. [Learn more about the Largest Contentful Paint metric](https://developer.chrome.com/docs/lighthouse/performance/lighthouse-largest-contentful-paint/)",
+ "score": 0.04,
+ "scoreDisplayMode": "numeric",
+ "numericValue": 7484.3330499999975,
+ "numericUnit": "millisecond",
+ "displayValue": "7.5 s",
+ "scoringOptions": {
+ "p10": 2500,
+ "median": 4000
+ }
+ },
+ "first-meaningful-paint": {
+ "id": "first-meaningful-paint",
+ "title": "First Meaningful Paint",
+ "description": "First Meaningful Paint measures when the primary content of a page is visible. [Learn more about the First Meaningful Paint metric](https://developer.chrome.com/docs/lighthouse/performance/first-meaningful-paint/).",
+ "score": 0.55,
+ "scoreDisplayMode": "numeric",
+ "numericValue": 3789.1294,
+ "numericUnit": "millisecond",
+ "displayValue": "3.8 s"
+ },
+ "speed-index": {
+ "id": "speed-index",
+ "title": "Speed Index",
+ "description": "Speed Index shows how quickly the contents of a page are visibly populated. [Learn more about the Speed Index metric](https://developer.chrome.com/docs/lighthouse/performance/speed-index/).",
+ "score": 0.6,
+ "scoreDisplayMode": "numeric",
+ "numericValue": 5171.238697268976,
+ "numericUnit": "millisecond",
+ "displayValue": "5.2 s",
+ "scoringOptions": {
+ "p10": 3387,
+ "median": 5800
+ }
+ },
+ "screenshot-thumbnails": {
+ "id": "screenshot-thumbnails",
+ "title": "Screenshot Thumbnails",
+ "description": "This is what the load of your site looked like.",
+ "score": null,
+ "scoreDisplayMode": "informative",
+ "details": {
+ "type": "filmstrip",
+ "scale": 3476,
+ "items": [
+ {
+ "timing": 435,
+ "timestamp": 7583698189,
+ "data": "data:image/jpeg;base64,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"
+ },
+ {
+ "timing": 869,
+ "timestamp": 7584132689,
+ "data": "data:image/jpeg;base64,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"
+ },
+ {
+ "timing": 1304,
+ "timestamp": 7584567189,
+ "data": "data:image/jpeg;base64,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"
+ },
+ {
+ "timing": 1738,
+ "timestamp": 7585001689,
+ "data": "data:image/jpeg;base64,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"
+ },
+ {
+ "timing": 2173,
+ "timestamp": 7585436189,
+ "data": "data:image/jpeg;base64,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"
+ },
+ {
+ "timing": 2607,
+ "timestamp": 7585870689,
+ "data": "data:image/jpeg;base64,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"
+ },
+ {
+ "timing": 3042,
+ "timestamp": 7586305189,
+ "data": "data:image/jpeg;base64,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"
+ },
+ {
+ "timing": 3476,
+ "timestamp": 7586739689,
+ "data": "data:image/jpeg;base64,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"
+ }
+ ]
+ }
+ },
+ "final-screenshot": {
+ "id": "final-screenshot",
+ "title": "Final Screenshot",
+ "description": "The last screenshot captured of the pageload.",
+ "score": null,
+ "scoreDisplayMode": "informative",
+ "details": {
+ "type": "screenshot",
+ "timing": 3476,
+ "timestamp": 7586740132,
+ "data": "data:image/jpeg;base64,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"
+ }
+ },
+ "total-blocking-time": {
+ "id": "total-blocking-time",
+ "title": "Total Blocking Time",
+ "description": "Sum of all time periods between FCP and Time to Interactive, when task length exceeded 50ms, expressed in milliseconds. [Learn more about the Total Blocking Time metric](https://developer.chrome.com/docs/lighthouse/performance/lighthouse-total-blocking-time/).",
+ "score": 0.4,
+ "scoreDisplayMode": "numeric",
+ "numericValue": 742.9817500000004,
+ "numericUnit": "millisecond",
+ "displayValue": "740 ms",
+ "scoringOptions": {
+ "p10": 200,
+ "median": 600
+ }
+ },
+ "max-potential-fid": {
+ "id": "max-potential-fid",
+ "title": "Max Potential First Input Delay",
+ "description": "The maximum potential First Input Delay that your users could experience is the duration of the longest task. [Learn more about the Maximum Potential First Input Delay metric](https://developer.chrome.com/docs/lighthouse/performance/lighthouse-max-potential-fid/).",
+ "score": 0.01,
+ "scoreDisplayMode": "numeric",
+ "numericValue": 787.0000000000005,
+ "numericUnit": "millisecond",
+ "displayValue": "790 ms"
+ },
+ "cumulative-layout-shift": {
+ "id": "cumulative-layout-shift",
+ "title": "Cumulative Layout Shift",
+ "description": "Cumulative Layout Shift measures the movement of visible elements within the viewport. [Learn more about the Cumulative Layout Shift metric](https://web.dev/articles/cls).",
+ "score": 1,
+ "scoreDisplayMode": "numeric",
+ "numericValue": 0.033939,
+ "numericUnit": "unitless",
+ "displayValue": "0.034",
+ "scoringOptions": {
+ "p10": 0.1,
+ "median": 0.25
+ },
+ "details": {
+ "type": "debugdata",
+ "items": [
+ {
+ "cumulativeLayoutShiftMainFrame": 0.033939
+ }
+ ]
+ }
+ },
+ "errors-in-console": {
+ "id": "errors-in-console",
+ "title": "No browser errors logged to the console",
+ "description": "Errors logged to the console indicate unresolved problems. They can come from network request failures and other browser concerns. [Learn more about this errors in console diagnostic audit](https://developer.chrome.com/docs/lighthouse/best-practices/errors-in-console/)",
+ "score": 1,
+ "scoreDisplayMode": "binary",
+ "details": {
+ "type": "table",
+ "headings": [],
+ "items": []
+ }
+ },
+ "server-response-time": {
+ "id": "server-response-time",
+ "title": "Initial server response time was short",
+ "description": "Keep the server response time for the main document short because all other requests depend on it. [Learn more about the Time to First Byte metric](https://developer.chrome.com/docs/lighthouse/performance/time-to-first-byte/).",
+ "score": null,
+ "scoreDisplayMode": "informative",
+ "numericValue": 14.199,
+ "numericUnit": "millisecond",
+ "displayValue": "Root document took 10 ms",
+ "metricSavings": {
+ "FCP": 0,
+ "LCP": 0
+ },
+ "details": {
+ "type": "opportunity",
+ "headings": [
+ {
+ "key": "url",
+ "valueType": "url",
+ "label": "URL"
+ },
+ {
+ "key": "responseTime",
+ "valueType": "timespanMs",
+ "label": "Time Spent"
+ }
+ ],
+ "items": [
+ {
+ "url": "http://localhost:3000/",
+ "responseTime": 14.199
+ }
+ ],
+ "overallSavingsMs": 0
+ },
+ "guidanceLevel": 1
+ },
+ "interactive": {
+ "id": "interactive",
+ "title": "Time to Interactive",
+ "description": "Time to Interactive is the amount of time it takes for the page to become fully interactive. [Learn more about the Time to Interactive metric](https://developer.chrome.com/docs/lighthouse/performance/interactive/).",
+ "score": 0.42,
+ "scoreDisplayMode": "numeric",
+ "numericValue": 8073.931974999999,
+ "numericUnit": "millisecond",
+ "displayValue": "8.1 s"
+ },
+ "user-timings": {
+ "id": "user-timings",
+ "title": "User Timing marks and measures",
+ "description": "Consider instrumenting your app with the User Timing API to measure your app's real-world performance during key user experiences. [Learn more about User Timing marks](https://developer.chrome.com/docs/lighthouse/performance/user-timings/).",
+ "score": null,
+ "scoreDisplayMode": "informative",
+ "displayValue": "46 user timings",
+ "details": {
+ "type": "table",
+ "headings": [
+ {
+ "key": "name",
+ "valueType": "text",
+ "label": "Name"
+ },
+ {
+ "key": "timingType",
+ "valueType": "text",
+ "label": "Type"
+ },
+ {
+ "key": "startTime",
+ "valueType": "ms",
+ "granularity": 0.01,
+ "label": "Start Time"
+ },
+ {
+ "key": "duration",
+ "valueType": "ms",
+ "granularity": 0.01,
+ "label": "Duration"
+ }
+ ],
+ "items": [
+ {
+ "name": "GTM-G-PM7746GQBC:15:17",
+ "startTime": 0,
+ "duration": 52.199,
+ "timingType": "Measure"
+ },
+ {
+ "name": "GTM-G-PM7746GQBC:3:17:14",
+ "startTime": 52.199,
+ "duration": 627.273,
+ "timingType": "Measure"
+ },
+ {
+ "name": "GTM-G-PM7746GQBC:10:17:14",
+ "startTime": 52.199,
+ "duration": 630.714,
+ "timingType": "Measure"
+ },
+ {
+ "name": "Zone",
+ "startTime": 55.28,
+ "duration": 0.141,
+ "timingType": "Measure"
+ },
+ {
+ "name": "Zone:ZoneAwarePromise",
+ "startTime": 55.469,
+ "duration": 0.232,
+ "timingType": "Measure"
+ },
+ {
+ "name": "Zone:toString",
+ "startTime": 55.708,
+ "duration": 0.034,
+ "timingType": "Measure"
+ },
+ {
+ "name": "Zone:util",
+ "startTime": 55.748,
+ "duration": 0.254,
+ "timingType": "Measure"
+ },
+ {
+ "name": "Zone:legacy",
+ "startTime": 56.015,
+ "duration": 0.014,
+ "timingType": "Measure"
+ },
+ {
+ "name": "Zone:timers",
+ "startTime": 56.034,
+ "duration": 0.106,
+ "timingType": "Measure"
+ },
+ {
+ "name": "Zone:requestAnimationFrame",
+ "startTime": 56.144,
+ "duration": 0.031,
+ "timingType": "Measure"
+ },
+ {
+ "name": "Zone:blocking",
+ "startTime": 56.179,
+ "duration": 0.035,
+ "timingType": "Measure"
+ },
+ {
+ "name": "Zone:EventTarget",
+ "startTime": 56.219,
+ "duration": 0.328,
+ "timingType": "Measure"
+ },
+ {
+ "name": "Zone:MutationObserver",
+ "startTime": 56.553,
+ "duration": 0.079,
+ "timingType": "Measure"
+ },
+ {
+ "name": "Zone:IntersectionObserver",
+ "startTime": 56.641,
+ "duration": 0.045,
+ "timingType": "Measure"
+ },
+ {
+ "name": "Zone:FileReader",
+ "startTime": 56.69,
+ "duration": 0.057,
+ "timingType": "Measure"
+ },
+ {
+ "name": "Zone:on_property",
+ "startTime": 56.753,
+ "duration": 10.679,
+ "timingType": "Measure"
+ },
+ {
+ "name": "Zone:customElements",
+ "startTime": 67.452,
+ "duration": 0.126,
+ "timingType": "Measure"
+ },
+ {
+ "name": "Zone:XHR",
+ "startTime": 67.585,
+ "duration": 0.099,
+ "timingType": "Measure"
+ },
+ {
+ "name": "Zone:geolocation",
+ "startTime": 67.689,
+ "duration": 0.068,
+ "timingType": "Measure"
+ },
+ {
+ "name": "Zone:PromiseRejectionEvent",
+ "startTime": 67.762,
+ "duration": 0.037,
+ "timingType": "Measure"
+ },
+ {
+ "name": "Zone:queueMicrotask",
+ "startTime": 67.803,
+ "duration": 0.026,
+ "timingType": "Measure"
+ },
+ {
+ "name": "GTM-G-PM7746GQBC:15",
+ "startTime": 0,
+ "timingType": "Mark"
+ },
+ {
+ "name": "GTM-G-PM7746GQBC:17",
+ "startTime": 52.199,
+ "timingType": "Mark"
+ },
+ {
+ "name": "Zone",
+ "startTime": 55.28,
+ "timingType": "Mark"
+ },
+ {
+ "name": "Zone:ZoneAwarePromise",
+ "startTime": 55.469,
+ "timingType": "Mark"
+ },
+ {
+ "name": "Zone:toString",
+ "startTime": 55.708,
+ "timingType": "Mark"
+ },
+ {
+ "name": "Zone:util",
+ "startTime": 55.748,
+ "timingType": "Mark"
+ },
+ {
+ "name": "Zone:legacy",
+ "startTime": 56.015,
+ "timingType": "Mark"
+ },
+ {
+ "name": "Zone:timers",
+ "startTime": 56.034,
+ "timingType": "Mark"
+ },
+ {
+ "name": "Zone:requestAnimationFrame",
+ "startTime": 56.144,
+ "timingType": "Mark"
+ },
+ {
+ "name": "Zone:blocking",
+ "startTime": 56.179,
+ "timingType": "Mark"
+ },
+ {
+ "name": "Zone:EventTarget",
+ "startTime": 56.219,
+ "timingType": "Mark"
+ },
+ {
+ "name": "Zone:MutationObserver",
+ "startTime": 56.553,
+ "timingType": "Mark"
+ },
+ {
+ "name": "Zone:IntersectionObserver",
+ "startTime": 56.641,
+ "timingType": "Mark"
+ },
+ {
+ "name": "Zone:FileReader",
+ "startTime": 56.69,
+ "timingType": "Mark"
+ },
+ {
+ "name": "Zone:on_property",
+ "startTime": 56.753,
+ "timingType": "Mark"
+ },
+ {
+ "name": "Zone:customElements",
+ "startTime": 67.452,
+ "timingType": "Mark"
+ },
+ {
+ "name": "Zone:XHR",
+ "startTime": 67.585,
+ "timingType": "Mark"
+ },
+ {
+ "name": "Zone:geolocation",
+ "startTime": 67.689,
+ "timingType": "Mark"
+ },
+ {
+ "name": "Zone:PromiseRejectionEvent",
+ "startTime": 67.762,
+ "timingType": "Mark"
+ },
+ {
+ "name": "Zone:queueMicrotask",
+ "startTime": 67.803,
+ "timingType": "Mark"
+ },
+ {
+ "name": "mark_feature_usage",
+ "startTime": 118.124,
+ "timingType": "Mark"
+ },
+ {
+ "name": "mark_feature_usage",
+ "startTime": 141.364,
+ "timingType": "Mark"
+ },
+ {
+ "name": "mark_feature_usage",
+ "startTime": 172.242,
+ "timingType": "Mark"
+ },
+ {
+ "name": "GTM-G-PM7746GQBC:3:14",
+ "startTime": 679.472,
+ "timingType": "Mark"
+ },
+ {
+ "name": "GTM-G-PM7746GQBC:10:14",
+ "startTime": 682.913,
+ "timingType": "Mark"
+ }
+ ]
+ },
+ "guidanceLevel": 2
+ },
+ "critical-request-chains": {
+ "id": "critical-request-chains",
+ "title": "Avoid chaining critical requests",
+ "description": "The Critical Request Chains below show you what resources are loaded with a high priority. Consider reducing the length of chains, reducing the download size of resources, or deferring the download of unnecessary resources to improve page load. [Learn how to avoid chaining critical requests](https://developer.chrome.com/docs/lighthouse/performance/critical-request-chains/).",
+ "score": null,
+ "scoreDisplayMode": "informative",
+ "displayValue": "10 chains found",
+ "details": {
+ "type": "criticalrequestchain",
+ "chains": {
+ "80171A32A3A9859F7593B457DBCB329A": {
+ "request": {
+ "url": "http://localhost:3000/",
+ "startTime": 7583.264594,
+ "endTime": 7583.279664,
+ "responseReceivedTime": 7583.279004000001,
+ "transferSize": 9792
+ },
+ "children": {
+ "19023.2": {
+ "request": {
+ "url": "http://localhost:3000/assets/env.js",
+ "startTime": 7583.284348,
+ "endTime": 7583.315232,
+ "responseReceivedTime": 7583.314967,
+ "transferSize": 1298
+ }
+ },
+ "19023.3": {
+ "request": {
+ "url": "http://localhost:3000/runtime.c167dac1b654160d.js",
+ "startTime": 7583.284707,
+ "endTime": 7583.315301,
+ "responseReceivedTime": 7583.315107999999,
+ "transferSize": 2135
+ }
+ },
+ "19023.4": {
+ "request": {
+ "url": "http://localhost:3000/polyfills.c7317d11d03309fd.js",
+ "startTime": 7583.284953,
+ "endTime": 7583.316513,
+ "responseReceivedTime": 7583.315966000001,
+ "transferSize": 14058
+ }
+ },
+ "19023.6": {
+ "request": {
+ "url": "http://localhost:3000/main.fda060d231cb9051.js",
+ "startTime": 7583.285069,
+ "endTime": 7583.342326,
+ "responseReceivedTime": 7583.338274,
+ "transferSize": 371837
+ },
+ "children": {
+ "19023.40": {
+ "request": {
+ "url": "http://localhost:3000/225.6744f601143b47ed.js",
+ "startTime": 7583.449533,
+ "endTime": 7583.47464,
+ "responseReceivedTime": 7583.473888,
+ "transferSize": 9608
+ }
+ }
+ }
+ },
+ "19023.8": {
+ "request": {
+ "url": "http://localhost:3000/manifest.webmanifest",
+ "startTime": 7583.285251,
+ "endTime": 7583.317619,
+ "responseReceivedTime": 7583.317009,
+ "transferSize": 664
+ }
+ },
+ "19023.21": {
+ "request": {
+ "url": "https://fonts.gstatic.com/s/lora/v37/0QIvMX1D_JOuMwr7Iw.woff2",
+ "startTime": 7583.3385849999995,
+ "endTime": 7583.373081,
+ "responseReceivedTime": 7583.3600750000005,
+ "transferSize": 38338
+ }
+ },
+ "19023.33": {
+ "request": {
+ "url": "https://fonts.gstatic.com/s/philosopher/v21/vEFV2_5QCwIS4_Dhez5jcWBuT00.woff2",
+ "startTime": 7583.462786,
+ "endTime": 7583.482554,
+ "responseReceivedTime": 7583.480433000001,
+ "transferSize": 22178
+ }
+ },
+ "19023.38": {
+ "request": {
+ "url": "https://fonts.gstatic.com/s/philosopher/v21/vEFI2_5QCwIS4_Dhez5jcWjValgb8tc.woff2",
+ "startTime": 7583.463298,
+ "endTime": 7583.488417,
+ "responseReceivedTime": 7583.482005,
+ "transferSize": 22390
+ }
+ },
+ "19023.39": {
+ "request": {
+ "url": "https://fonts.gstatic.com/s/materialicons/v145/flUhRq6tzZclQEJ-Vdg-IuiaDsNc.woff2",
+ "startTime": 7583.463498,
+ "endTime": 7583.508757,
+ "responseReceivedTime": 7583.488546999999,
+ "transferSize": 128533
+ }
+ },
+ "19023.20": {
+ "request": {
+ "url": "https://fonts.gstatic.com/s/lora/v37/0QIvMX1D_JOuMwT7I-NP.woff2",
+ "startTime": 7583.886457,
+ "endTime": 7583.901576,
+ "responseReceivedTime": 7583.901355999999,
+ "transferSize": 20117
+ }
+ }
+ }
+ }
+ },
+ "longestChain": {
+ "duration": 636.9819999998435,
+ "length": 2,
+ "transferSize": 20117
+ }
+ },
+ "guidanceLevel": 1
+ },
+ "redirects": {
+ "id": "redirects",
+ "title": "Avoid multiple page redirects",
+ "description": "Redirects introduce additional delays before the page can be loaded. [Learn how to avoid page redirects](https://developer.chrome.com/docs/lighthouse/performance/redirects/).",
+ "score": 1,
+ "scoreDisplayMode": "metricSavings",
+ "numericValue": 0,
+ "numericUnit": "millisecond",
+ "displayValue": "",
+ "metricSavings": {
+ "LCP": 0,
+ "FCP": 0
+ },
+ "details": {
+ "type": "opportunity",
+ "headings": [],
+ "items": [],
+ "overallSavingsMs": 0
+ },
+ "guidanceLevel": 2
+ },
+ "installable-manifest": {
+ "id": "installable-manifest",
+ "title": "Web app manifest and service worker meet the installability requirements",
+ "description": "Service worker is the technology that enables your app to use many Progressive Web App features, such as offline, add to homescreen, and push notifications. With proper service worker and manifest implementations, browsers can proactively prompt users to add your app to their homescreen, which can lead to higher engagement. [Learn more about manifest installability requirements](https://developer.chrome.com/docs/lighthouse/pwa/installable-manifest/).",
+ "score": 1,
+ "scoreDisplayMode": "binary",
+ "warnings": [],
+ "details": {
+ "type": "table",
+ "headings": [],
+ "items": [],
+ "debugData": {
+ "type": "debugdata",
+ "manifestUrl": "http://localhost:3000/manifest.webmanifest"
+ }
+ }
+ },
+ "splash-screen": {
+ "id": "splash-screen",
+ "title": "Configured for a custom splash screen",
+ "description": "A themed splash screen ensures a high-quality experience when users launch your app from their homescreens. [Learn more about splash screens](https://developer.chrome.com/docs/lighthouse/pwa/splash-screen/).",
+ "score": 1,
+ "scoreDisplayMode": "binary",
+ "details": {
+ "type": "debugdata",
+ "items": [
+ {
+ "failures": [],
+ "isParseFailure": false,
+ "hasStartUrl": true,
+ "hasIconsAtLeast144px": true,
+ "hasIconsAtLeast512px": true,
+ "fetchesIcon": true,
+ "hasPWADisplayValue": true,
+ "hasBackgroundColor": true,
+ "hasThemeColor": true,
+ "hasShortName": true,
+ "shortNameLength": true,
+ "hasName": true,
+ "hasMaskableIcon": true
+ }
+ ]
+ }
+ },
+ "themed-omnibox": {
+ "id": "themed-omnibox",
+ "title": "Sets a theme color for the address bar.",
+ "description": "The browser address bar can be themed to match your site. [Learn more about theming the address bar](https://developer.chrome.com/docs/lighthouse/pwa/themed-omnibox/).",
+ "score": 1,
+ "scoreDisplayMode": "binary",
+ "details": {
+ "type": "debugdata",
+ "items": [
+ {
+ "failures": [],
+ "themeColor": "#3f51b5",
+ "isParseFailure": false,
+ "hasStartUrl": true,
+ "hasIconsAtLeast144px": true,
+ "hasIconsAtLeast512px": true,
+ "fetchesIcon": true,
+ "hasPWADisplayValue": true,
+ "hasBackgroundColor": true,
+ "hasThemeColor": true,
+ "hasShortName": true,
+ "shortNameLength": true,
+ "hasName": true,
+ "hasMaskableIcon": true
+ }
+ ]
+ }
+ },
+ "maskable-icon": {
+ "id": "maskable-icon",
+ "title": "Manifest has a maskable icon",
+ "description": "A maskable icon ensures that the image fills the entire shape without being letterboxed when installing the app on a device. [Learn about maskable manifest icons](https://developer.chrome.com/docs/lighthouse/pwa/maskable-icon-audit/).",
+ "score": 1,
+ "scoreDisplayMode": "binary"
+ },
+ "content-width": {
+ "id": "content-width",
+ "title": "Content is sized correctly for the viewport",
+ "description": "If the width of your app's content doesn't match the width of the viewport, your app might not be optimized for mobile screens. [Learn how to size content for the viewport](https://developer.chrome.com/docs/lighthouse/pwa/content-width/).",
+ "score": 1,
+ "scoreDisplayMode": "binary"
+ },
+ "image-aspect-ratio": {
+ "id": "image-aspect-ratio",
+ "title": "Displays images with incorrect aspect ratio",
+ "description": "Image display dimensions should match natural aspect ratio. [Learn more about image aspect ratio](https://developer.chrome.com/docs/lighthouse/best-practices/image-aspect-ratio/).",
+ "score": 0,
+ "scoreDisplayMode": "binary",
+ "details": {
+ "type": "table",
+ "headings": [
+ {
+ "key": "node",
+ "valueType": "node",
+ "label": ""
+ },
+ {
+ "key": "url",
+ "valueType": "url",
+ "label": "URL"
+ },
+ {
+ "key": "displayedAspectRatio",
+ "valueType": "text",
+ "label": "Aspect Ratio (Displayed)"
+ },
+ {
+ "key": "actualAspectRatio",
+ "valueType": "text",
+ "label": "Aspect Ratio (Actual)"
+ }
+ ],
+ "items": [
+ {
+ "url": "http://localhost:3000/assets/cyber-security.avif",
+ "node": {
+ "type": "node",
+ "lhId": "1-50-IMG",
+ "path": "1,HTML,1,BODY,0,APP-ROOT,1,MAIN,1,APP-HOME,1,APP-GALLERY,1,DIV,1,DIV,0,IMG",
+ "selector": "app-gallery.ng-tns-c2633705164-21 > div.gallery-container > div.gallery-thumbnails > img.thumbnail",
+ "boundingRect": {
+ "top": 1227,
+ "bottom": 1282,
+ "left": 87,
+ "right": 159,
+ "width": 72,
+ "height": 55
+ },
+ "snippet": "![\"Cyber](\"./assets/cyber-security.avif\")
",
+ "nodeLabel": "Cyber Security"
+ },
+ "displayedAspectRatio": "60 x 45\n (1.33)",
+ "actualAspectRatio": "1024 x 576\n (1.78)",
+ "doRatiosMatch": false
+ },
+ {
+ "url": "http://localhost:3000/assets/digital-strategy.avif",
+ "node": {
+ "type": "node",
+ "lhId": "1-51-IMG",
+ "path": "1,HTML,1,BODY,0,APP-ROOT,1,MAIN,1,APP-HOME,1,APP-GALLERY,1,DIV,1,DIV,1,IMG",
+ "selector": "app-gallery.ng-tns-c2633705164-21 > div.gallery-container > div.gallery-thumbnails > img.thumbnail",
+ "boundingRect": {
+ "top": 1231,
+ "bottom": 1280,
+ "left": 184,
+ "right": 248,
+ "width": 64,
+ "height": 49
+ },
+ "snippet": "![\"Digital](\"assets/digital-strategy.avif\")
",
+ "nodeLabel": "Digital Strategy"
+ },
+ "displayedAspectRatio": "60 x 45\n (1.33)",
+ "actualAspectRatio": "1024 x 576\n (1.78)",
+ "doRatiosMatch": false
+ },
+ {
+ "url": "http://localhost:3000/assets/software-development.avif",
+ "node": {
+ "type": "node",
+ "lhId": "1-52-IMG",
+ "path": "1,HTML,1,BODY,0,APP-ROOT,1,MAIN,1,APP-HOME,1,APP-GALLERY,1,DIV,1,DIV,2,IMG",
+ "selector": "app-gallery.ng-tns-c2633705164-21 > div.gallery-container > div.gallery-thumbnails > img.thumbnail",
+ "boundingRect": {
+ "top": 1232,
+ "bottom": 1277,
+ "left": 279,
+ "right": 339,
+ "width": 60,
+ "height": 45
+ },
+ "snippet": "![\"Software](\"assets/software-development.avif\")
",
+ "nodeLabel": "Software Development"
+ },
+ "displayedAspectRatio": "60 x 45\n (1.33)",
+ "actualAspectRatio": "1024 x 576\n (1.78)",
+ "doRatiosMatch": false
+ }
+ ]
+ }
+ },
+ "image-size-responsive": {
+ "id": "image-size-responsive",
+ "title": "Serves images with appropriate resolution",
+ "description": "Image natural dimensions should be proportional to the display size and the pixel ratio to maximize image clarity. [Learn how to provide responsive images](https://web.dev/articles/serve-responsive-images).",
+ "score": 1,
+ "scoreDisplayMode": "binary",
+ "details": {
+ "type": "table",
+ "headings": [],
+ "items": []
+ }
+ },
+ "preload-fonts": {
+ "id": "preload-fonts",
+ "title": "Fonts with `font-display: optional` are preloaded",
+ "description": "Preload `optional` fonts so first-time visitors may use them. [Learn more about preloading fonts](https://web.dev/articles/preload-optional-fonts)",
+ "score": null,
+ "scoreDisplayMode": "notApplicable"
+ },
+ "deprecations": {
+ "id": "deprecations",
+ "title": "Avoids deprecated APIs",
+ "description": "Deprecated APIs will eventually be removed from the browser. [Learn more about deprecated APIs](https://developer.chrome.com/docs/lighthouse/best-practices/deprecations/).",
+ "score": 1,
+ "scoreDisplayMode": "binary",
+ "details": {
+ "type": "table",
+ "headings": [],
+ "items": []
+ }
+ },
+ "third-party-cookies": {
+ "id": "third-party-cookies",
+ "title": "Avoids third-party cookies",
+ "description": "Support for third-party cookies will be removed in a future version of Chrome. [Learn more about phasing out third-party cookies](https://developer.chrome.com/en/docs/privacy-sandbox/third-party-cookie-phase-out/).",
+ "score": 1,
+ "scoreDisplayMode": "binary",
+ "details": {
+ "type": "table",
+ "headings": [],
+ "items": []
+ }
+ },
+ "mainthread-work-breakdown": {
+ "id": "mainthread-work-breakdown",
+ "title": "Minimize main-thread work",
+ "description": "Consider reducing the time spent parsing, compiling and executing JS. You may find delivering smaller JS payloads helps with this. [Learn how to minimize main-thread work](https://developer.chrome.com/docs/lighthouse/performance/mainthread-work-breakdown/)",
+ "score": 0,
+ "scoreDisplayMode": "metricSavings",
+ "numericValue": 5580.187999999959,
+ "numericUnit": "millisecond",
+ "displayValue": "5.6 s",
+ "metricSavings": {
+ "TBT": 742.9817500000004
+ },
+ "details": {
+ "type": "table",
+ "headings": [
+ {
+ "key": "groupLabel",
+ "valueType": "text",
+ "label": "Category"
+ },
+ {
+ "key": "duration",
+ "valueType": "ms",
+ "granularity": 1,
+ "label": "Time Spent"
+ }
+ ],
+ "items": [
+ {
+ "group": "scriptEvaluation",
+ "groupLabel": "Script Evaluation",
+ "duration": 3413.9999999999004
+ },
+ {
+ "group": "other",
+ "groupLabel": "Other",
+ "duration": 1171.2080000000008
+ },
+ {
+ "group": "styleLayout",
+ "groupLabel": "Style & Layout",
+ "duration": 516.3480000000009
+ },
+ {
+ "group": "paintCompositeRender",
+ "groupLabel": "Rendering",
+ "duration": 388.66000000005596
+ },
+ {
+ "group": "scriptParseCompile",
+ "groupLabel": "Script Parsing & Compilation",
+ "duration": 42.192
+ },
+ {
+ "group": "parseHTML",
+ "groupLabel": "Parse HTML & CSS",
+ "duration": 24.480000000000018
+ },
+ {
+ "group": "garbageCollection",
+ "groupLabel": "Garbage Collection",
+ "duration": 23.300000000000008
+ }
+ ],
+ "sortedBy": [
+ "duration"
+ ]
+ },
+ "guidanceLevel": 1
+ },
+ "bootup-time": {
+ "id": "bootup-time",
+ "title": "Reduce JavaScript execution time",
+ "description": "Consider reducing the time spent parsing, compiling, and executing JS. You may find delivering smaller JS payloads helps with this. [Learn how to reduce Javascript execution time](https://developer.chrome.com/docs/lighthouse/performance/bootup-time/).",
+ "score": 0,
+ "scoreDisplayMode": "metricSavings",
+ "numericValue": 3449.9279999999626,
+ "numericUnit": "millisecond",
+ "displayValue": "3.4 s",
+ "metricSavings": {
+ "TBT": 854.1474942411713
+ },
+ "details": {
+ "type": "table",
+ "headings": [
+ {
+ "key": "url",
+ "valueType": "url",
+ "label": "URL"
+ },
+ {
+ "key": "total",
+ "granularity": 1,
+ "valueType": "ms",
+ "label": "Total CPU Time"
+ },
+ {
+ "key": "scripting",
+ "granularity": 1,
+ "valueType": "ms",
+ "label": "Script Evaluation"
+ },
+ {
+ "key": "scriptParseCompile",
+ "granularity": 1,
+ "valueType": "ms",
+ "label": "Script Parse"
+ }
+ ],
+ "items": [
+ {
+ "url": "http://localhost:3000/polyfills.c7317d11d03309fd.js",
+ "total": 2567.3239999999682,
+ "scripting": 1414.4319999999827,
+ "scriptParseCompile": 0.168
+ },
+ {
+ "url": "http://localhost:3000/scripts.b1c7266d51240602.js",
+ "total": 1643.7919999999797,
+ "scripting": 1622.6159999999797,
+ "scriptParseCompile": 2.132
+ },
+ {
+ "url": "http://localhost:3000/",
+ "total": 710.7240000000007,
+ "scripting": 4.604,
+ "scriptParseCompile": 0.628
+ },
+ {
+ "url": "Unattributable",
+ "total": 300.53200000000163,
+ "scripting": 92.0360000000002,
+ "scriptParseCompile": 0
+ },
+ {
+ "url": "http://localhost:3000/main.fda060d231cb9051.js",
+ "total": 179.9399999999996,
+ "scripting": 151.27999999999963,
+ "scriptParseCompile": 4.88
+ },
+ {
+ "url": "https://www.googletagmanager.com/gtag/js?id=G-PM7746GQBC&cx=c>m=4e63p1",
+ "total": 93.8919999999999,
+ "scripting": 73.4319999999999,
+ "scriptParseCompile": 18.976
+ },
+ {
+ "url": "https://www.googletagmanager.com/gtm.js?id=GTM-N382336",
+ "total": 65.53200000000002,
+ "scripting": 50.696000000000026,
+ "scriptParseCompile": 14.048
+ }
+ ],
+ "summary": {
+ "wastedMs": 3449.9279999999626
+ },
+ "sortedBy": [
+ "total"
+ ]
+ },
+ "guidanceLevel": 1
+ },
+ "uses-rel-preload": {
+ "id": "uses-rel-preload",
+ "title": "Preload key requests",
+ "description": "Consider using `` to prioritize fetching resources that are currently requested later in page load. [Learn how to preload key requests](https://developer.chrome.com/docs/lighthouse/performance/uses-rel-preload/).",
+ "score": null,
+ "scoreDisplayMode": "notApplicable",
+ "details": {
+ "type": "opportunity",
+ "headings": [],
+ "items": [],
+ "overallSavingsMs": 0
+ },
+ "guidanceLevel": 3
+ },
+ "uses-rel-preconnect": {
+ "id": "uses-rel-preconnect",
+ "title": "Preconnect to required origins",
+ "description": "Consider adding `preconnect` or `dns-prefetch` resource hints to establish early connections to important third-party origins. [Learn how to preconnect to required origins](https://developer.chrome.com/docs/lighthouse/performance/uses-rel-preconnect/).",
+ "score": 1,
+ "scoreDisplayMode": "metricSavings",
+ "warnings": [
+ "A `` was found for \"https://fonts.googleapis.com\" but was not used by the browser. Only use `preconnect` for important origins that the page will certainly request."
+ ],
+ "metricSavings": {
+ "LCP": 206.4499999998808,
+ "FCP": 0
+ },
+ "guidanceLevel": 3
+ },
+ "font-display": {
+ "id": "font-display",
+ "title": "Ensure text remains visible during webfont load",
+ "description": "Leverage the `font-display` CSS feature to ensure text is user-visible while webfonts are loading. [Learn more about `font-display`](https://developer.chrome.com/docs/lighthouse/performance/font-display/).",
+ "score": 0.5,
+ "scoreDisplayMode": "metricSavings",
+ "warnings": [],
+ "details": {
+ "type": "table",
+ "headings": [
+ {
+ "key": "url",
+ "valueType": "url",
+ "label": "URL"
+ },
+ {
+ "key": "wastedMs",
+ "valueType": "ms",
+ "label": "Potential Savings"
+ }
+ ],
+ "items": [
+ {
+ "url": "https://fonts.gstatic.com/s/materialicons/v145/flUhRq6tzZclQEJ-Vdg-IuiaDsNc.woff2",
+ "wastedMs": 45.25899999961257
+ }
+ ]
+ },
+ "guidanceLevel": 3
+ },
+ "diagnostics": {
+ "id": "diagnostics",
+ "title": "Diagnostics",
+ "description": "Collection of useful page vitals.",
+ "score": null,
+ "scoreDisplayMode": "informative",
+ "details": {
+ "type": "debugdata",
+ "items": [
+ {
+ "numRequests": 26,
+ "numScripts": 9,
+ "numStylesheets": 1,
+ "numFonts": 5,
+ "numTasks": 3126,
+ "numTasksOver10ms": 7,
+ "numTasksOver25ms": 2,
+ "numTasksOver50ms": 2,
+ "numTasksOver100ms": 1,
+ "numTasksOver500ms": 0,
+ "rtt": 0.00019999999999999998,
+ "throughput": 57560975.61084272,
+ "maxRtt": 23.732,
+ "maxServerLatency": 488.7588,
+ "totalByteWeight": 1078520,
+ "totalTaskTime": 1395.046999999972,
+ "mainDocumentTransferSize": 9792
+ }
+ ]
+ }
+ },
+ "network-requests": {
+ "id": "network-requests",
+ "title": "Network Requests",
+ "description": "Lists the network requests that were made during page load.",
+ "score": null,
+ "scoreDisplayMode": "informative",
+ "details": {
+ "type": "table",
+ "headings": [
+ {
+ "key": "url",
+ "valueType": "url",
+ "label": "URL"
+ },
+ {
+ "key": "protocol",
+ "valueType": "text",
+ "label": "Protocol"
+ },
+ {
+ "key": "networkRequestTime",
+ "valueType": "ms",
+ "granularity": 1,
+ "label": "Network Request Time"
+ },
+ {
+ "key": "networkEndTime",
+ "valueType": "ms",
+ "granularity": 1,
+ "label": "Network End Time"
+ },
+ {
+ "key": "transferSize",
+ "valueType": "bytes",
+ "displayUnit": "kb",
+ "granularity": 1,
+ "label": "Transfer Size"
+ },
+ {
+ "key": "resourceSize",
+ "valueType": "bytes",
+ "displayUnit": "kb",
+ "granularity": 1,
+ "label": "Resource Size"
+ },
+ {
+ "key": "statusCode",
+ "valueType": "text",
+ "label": "Status Code"
+ },
+ {
+ "key": "mimeType",
+ "valueType": "text",
+ "label": "MIME Type"
+ },
+ {
+ "key": "resourceType",
+ "valueType": "text",
+ "label": "Resource Type"
+ }
+ ],
+ "items": [
+ {
+ "url": "http://localhost:3000/",
+ "sessionTargetType": "page",
+ "protocol": "http/1.1",
+ "rendererStartTime": 0,
+ "networkRequestTime": 0.42700000014156103,
+ "networkEndTime": 15.496999999508262,
+ "finished": true,
+ "transferSize": 9792,
+ "resourceSize": 63046,
+ "statusCode": 200,
+ "mimeType": "text/html",
+ "resourceType": "Document",
+ "priority": "VeryHigh",
+ "experimentalFromMainFrame": true,
+ "entity": "localhost"
+ },
+ {
+ "url": "http://localhost:3000/assets/env.js",
+ "sessionTargetType": "page",
+ "protocol": "http/1.1",
+ "rendererStartTime": 19.438999999314547,
+ "networkRequestTime": 20.18099999986589,
+ "networkEndTime": 51.06499999947846,
+ "finished": true,
+ "transferSize": 1298,
+ "resourceSize": 978,
+ "statusCode": 200,
+ "mimeType": "application/javascript",
+ "resourceType": "Script",
+ "priority": "High",
+ "experimentalFromMainFrame": true,
+ "entity": "localhost"
+ },
+ {
+ "url": "http://localhost:3000/runtime.c167dac1b654160d.js",
+ "sessionTargetType": "page",
+ "protocol": "http/1.1",
+ "rendererStartTime": 19.580000000074506,
+ "networkRequestTime": 20.53999999910593,
+ "networkEndTime": 51.13399999961257,
+ "finished": true,
+ "transferSize": 2135,
+ "resourceSize": 3198,
+ "statusCode": 200,
+ "mimeType": "application/javascript",
+ "resourceType": "Script",
+ "priority": "High",
+ "experimentalFromMainFrame": true,
+ "entity": "localhost"
+ },
+ {
+ "url": "http://localhost:3000/polyfills.c7317d11d03309fd.js",
+ "sessionTargetType": "page",
+ "protocol": "http/1.1",
+ "rendererStartTime": 19.615000000223517,
+ "networkRequestTime": 20.786000000312924,
+ "networkEndTime": 52.34599999897182,
+ "finished": true,
+ "transferSize": 14058,
+ "resourceSize": 36654,
+ "statusCode": 200,
+ "mimeType": "application/javascript",
+ "resourceType": "Script",
+ "priority": "High",
+ "experimentalFromMainFrame": true,
+ "entity": "localhost"
+ },
+ {
+ "url": "http://localhost:3000/scripts.b1c7266d51240602.js",
+ "sessionTargetType": "page",
+ "protocol": "http/1.1",
+ "rendererStartTime": 19.657999999821186,
+ "networkRequestTime": 52.99500000011176,
+ "networkEndTime": 61.71299999952316,
+ "finished": true,
+ "transferSize": 13619,
+ "resourceSize": 45904,
+ "statusCode": 200,
+ "mimeType": "application/javascript",
+ "resourceType": "Script",
+ "priority": "Low",
+ "experimentalFromMainFrame": true,
+ "entity": "localhost"
+ },
+ {
+ "url": "http://localhost:3000/main.fda060d231cb9051.js",
+ "sessionTargetType": "page",
+ "protocol": "http/1.1",
+ "rendererStartTime": 19.691999999806285,
+ "networkRequestTime": 20.90199999883771,
+ "networkEndTime": 78.1589999999851,
+ "finished": true,
+ "transferSize": 371837,
+ "resourceSize": 1531109,
+ "statusCode": 200,
+ "mimeType": "application/javascript",
+ "resourceType": "Script",
+ "priority": "High",
+ "experimentalFromMainFrame": true,
+ "entity": "localhost"
+ },
+ {
+ "url": "http://localhost:3000/manifest.webmanifest",
+ "sessionTargetType": "page",
+ "protocol": "http/1.1",
+ "rendererStartTime": 20.924999999813735,
+ "networkRequestTime": 21.083999999798834,
+ "networkEndTime": 53.45199999958277,
+ "finished": true,
+ "transferSize": 664,
+ "resourceSize": 1144,
+ "statusCode": 200,
+ "mimeType": "application/manifest+json",
+ "resourceType": "Manifest",
+ "priority": "Medium",
+ "experimentalFromMainFrame": true,
+ "entity": "localhost"
+ },
+ {
+ "url": "https://www.googletagmanager.com/gtm.js?id=GTM-N382336",
+ "sessionTargetType": "page",
+ "protocol": "h2",
+ "rendererStartTime": 52.088999999687076,
+ "networkRequestTime": 53.11299999989569,
+ "networkEndTime": 198.42499999981374,
+ "finished": true,
+ "transferSize": 118379,
+ "resourceSize": 333586,
+ "statusCode": 200,
+ "mimeType": "application/javascript",
+ "resourceType": "Script",
+ "priority": "Low",
+ "experimentalFromMainFrame": true,
+ "entity": "Google Tag Manager"
+ },
+ {
+ "url": "http://localhost:3000/styles.f220ee24dd559218.css",
+ "sessionTargetType": "page",
+ "protocol": "http/1.1",
+ "rendererStartTime": 52.700999999418855,
+ "networkRequestTime": 53.60899999924004,
+ "networkEndTime": 63.27900000009686,
+ "finished": true,
+ "transferSize": 21209,
+ "resourceSize": 158637,
+ "statusCode": 200,
+ "mimeType": "text/css",
+ "resourceType": "Stylesheet",
+ "priority": "VeryLow",
+ "experimentalFromMainFrame": true,
+ "entity": "localhost"
+ },
+ {
+ "url": "https://fonts.gstatic.com/s/lora/v37/0QIvMX1D_JOuMwr7Iw.woff2",
+ "sessionTargetType": "page",
+ "protocol": "h2",
+ "rendererStartTime": 73.34199999924749,
+ "networkRequestTime": 74.41799999959767,
+ "networkEndTime": 108.91399999894202,
+ "finished": true,
+ "transferSize": 38338,
+ "resourceSize": 37788,
+ "statusCode": 200,
+ "mimeType": "font/woff2",
+ "resourceType": "Font",
+ "priority": "VeryHigh",
+ "experimentalFromMainFrame": true,
+ "entity": "Google Fonts"
+ },
+ {
+ "url": "http://localhost:3000/225.6744f601143b47ed.js",
+ "sessionTargetType": "page",
+ "protocol": "http/1.1",
+ "rendererStartTime": 184.64299999922514,
+ "networkRequestTime": 185.3659999994561,
+ "networkEndTime": 210.47300000023097,
+ "finished": true,
+ "transferSize": 9608,
+ "resourceSize": 39575,
+ "statusCode": 200,
+ "mimeType": "application/javascript",
+ "resourceType": "Script",
+ "priority": "High",
+ "experimentalFromMainFrame": true,
+ "entity": "localhost"
+ },
+ {
+ "url": "http://localhost:3000/assets/logo.svg",
+ "sessionTargetType": "page",
+ "protocol": "http/1.1",
+ "rendererStartTime": 186.29100000020117,
+ "networkRequestTime": 186.4779999991879,
+ "networkEndTime": 216.64299999922514,
+ "finished": true,
+ "transferSize": 1853,
+ "resourceSize": 4337,
+ "statusCode": 200,
+ "mimeType": "image/svg+xml",
+ "resourceType": "Image",
+ "priority": "High",
+ "experimentalFromMainFrame": true,
+ "entity": "localhost"
+ },
+ {
+ "url": "https://fonts.gstatic.com/s/philosopher/v21/vEFV2_5QCwIS4_Dhez5jcWBuT00.woff2",
+ "sessionTargetType": "page",
+ "protocol": "h2",
+ "rendererStartTime": 188.30499999970198,
+ "networkRequestTime": 198.61899999994785,
+ "networkEndTime": 218.3870000001043,
+ "finished": true,
+ "transferSize": 22178,
+ "resourceSize": 22052,
+ "statusCode": 200,
+ "mimeType": "font/woff2",
+ "resourceType": "Font",
+ "priority": "VeryHigh",
+ "experimentalFromMainFrame": true,
+ "entity": "Google Fonts"
+ },
+ {
+ "url": "https://fonts.gstatic.com/s/philosopher/v21/vEFI2_5QCwIS4_Dhez5jcWjValgb8tc.woff2",
+ "sessionTargetType": "page",
+ "protocol": "h2",
+ "rendererStartTime": 188.3879999993369,
+ "networkRequestTime": 199.13099999912083,
+ "networkEndTime": 224.24999999906868,
+ "finished": true,
+ "transferSize": 22390,
+ "resourceSize": 22264,
+ "statusCode": 200,
+ "mimeType": "font/woff2",
+ "resourceType": "Font",
+ "priority": "VeryHigh",
+ "experimentalFromMainFrame": true,
+ "entity": "Google Fonts"
+ },
+ {
+ "url": "https://fonts.gstatic.com/s/materialicons/v145/flUhRq6tzZclQEJ-Vdg-IuiaDsNc.woff2",
+ "sessionTargetType": "page",
+ "protocol": "h2",
+ "rendererStartTime": 188.44999999925494,
+ "networkRequestTime": 199.3309999993071,
+ "networkEndTime": 244.58999999891967,
+ "finished": true,
+ "transferSize": 128533,
+ "resourceSize": 128352,
+ "statusCode": 200,
+ "mimeType": "font/woff2",
+ "resourceType": "Font",
+ "priority": "VeryHigh",
+ "experimentalFromMainFrame": true,
+ "entity": "Google Fonts"
+ },
+ {
+ "url": "https://www.googletagmanager.com/gtag/js?id=G-PM7746GQBC&cx=c>m=4e63p1",
+ "sessionTargetType": "page",
+ "protocol": "h2",
+ "rendererStartTime": 220.3759999992326,
+ "networkRequestTime": 220.70600000023842,
+ "networkEndTime": 318.9400000004098,
+ "finished": true,
+ "transferSize": 151850,
+ "resourceSize": 436747,
+ "statusCode": 200,
+ "mimeType": "application/javascript",
+ "resourceType": "Script",
+ "priority": "Low",
+ "experimentalFromMainFrame": true,
+ "entity": "Google Tag Manager"
+ },
+ {
+ "url": "https://static.hotjar.com/c/hotjar-2343122.js?sv=7",
+ "sessionTargetType": "page",
+ "protocol": "h2",
+ "rendererStartTime": 221.59899999946356,
+ "networkRequestTime": 221.89399999938905,
+ "networkEndTime": 336.2869999995455,
+ "finished": true,
+ "transferSize": 7148,
+ "resourceSize": 17391,
+ "statusCode": 200,
+ "mimeType": "application/javascript",
+ "resourceType": "Script",
+ "priority": "Low",
+ "experimentalFromMainFrame": true,
+ "entity": "Hotjar"
+ },
+ {
+ "url": "https://fonts.gstatic.com/s/lora/v37/0QIvMX1D_JOuMwT7I-NP.woff2",
+ "sessionTargetType": "page",
+ "protocol": "h3",
+ "rendererStartTime": 615.74199999962,
+ "networkRequestTime": 622.2899999991059,
+ "networkEndTime": 637.4089999999851,
+ "finished": true,
+ "transferSize": 20117,
+ "resourceSize": 20088,
+ "statusCode": 200,
+ "mimeType": "font/woff2",
+ "resourceType": "Font",
+ "priority": "VeryHigh",
+ "experimentalFromMainFrame": true,
+ "entity": "Google Fonts"
+ },
+ {
+ "url": "http://localhost:3000/assets/cyber-security.avif",
+ "sessionTargetType": "page",
+ "protocol": "http/1.1",
+ "rendererStartTime": 618.3689999999478,
+ "networkRequestTime": 618.7000000001863,
+ "networkEndTime": 657.9419999998063,
+ "finished": true,
+ "transferSize": 37687,
+ "resourceSize": 37428,
+ "statusCode": 200,
+ "mimeType": "application/octet-stream",
+ "resourceType": "Image",
+ "priority": "Low",
+ "experimentalFromMainFrame": true,
+ "entity": "localhost"
+ },
+ {
+ "url": "http://localhost:3000/assets/digital-strategy.avif",
+ "sessionTargetType": "page",
+ "protocol": "http/1.1",
+ "rendererStartTime": 618.6039999993518,
+ "networkRequestTime": 618.8969999989495,
+ "networkEndTime": 658.0299999993294,
+ "finished": true,
+ "transferSize": 38337,
+ "resourceSize": 38076,
+ "statusCode": 200,
+ "mimeType": "application/octet-stream",
+ "resourceType": "Image",
+ "priority": "Low",
+ "experimentalFromMainFrame": true,
+ "entity": "localhost"
+ },
+ {
+ "url": "http://localhost:3000/assets/software-development.avif",
+ "sessionTargetType": "page",
+ "protocol": "http/1.1",
+ "rendererStartTime": 618.7819999996573,
+ "networkRequestTime": 619.1109999995679,
+ "networkEndTime": 658.3089999994263,
+ "finished": true,
+ "transferSize": 21547,
+ "resourceSize": 21282,
+ "statusCode": 200,
+ "mimeType": "application/octet-stream",
+ "resourceType": "Image",
+ "priority": "Low",
+ "experimentalFromMainFrame": true,
+ "entity": "localhost"
+ },
+ {
+ "url": "http://localhost:3000/assets/man.png",
+ "sessionTargetType": "page",
+ "protocol": "http/1.1",
+ "rendererStartTime": 619,
+ "networkRequestTime": 619.4109999993816,
+ "networkEndTime": 668.8779999995604,
+ "finished": true,
+ "transferSize": 12958,
+ "resourceSize": 12686,
+ "statusCode": 200,
+ "mimeType": "image/png",
+ "resourceType": "Image",
+ "priority": "Low",
+ "experimentalFromMainFrame": true,
+ "entity": "localhost"
+ },
+ {
+ "url": "http://localhost:3000/assets/woman.png",
+ "sessionTargetType": "page",
+ "protocol": "http/1.1",
+ "rendererStartTime": 619.2139999996871,
+ "networkRequestTime": 619.6639999998733,
+ "networkEndTime": 670.1569999996573,
+ "finished": true,
+ "transferSize": 12985,
+ "resourceSize": 12711,
+ "statusCode": 200,
+ "mimeType": "image/png",
+ "resourceType": "Image",
+ "priority": "Low",
+ "experimentalFromMainFrame": true,
+ "entity": "localhost"
+ },
+ {
+ "url": "https://region1.google-analytics.com/g/collect?v=2&tid=G-PM7746GQBC>m=45je63p1v877503170z8843435470za20gzb843435470zd843435470&_p=1774694917813&gcd=13l3l3l2l1l1&npa=1&dma_cps=a&dma=1&cid=342057496.1774694918&ul=en-gb&sr=412x823&uaa=&uab=64&uafvl=Chromium%3B146.0.7680.165%7CNot-A.Brand%3B24.0.0.0%7CGoogle%2520Chrome%3B146.0.7680.165&uamb=1&uam=moto%20g%20power%20(2022)&uap=Android&uapv=11.0&uaw=0&are=1&frm=0&pscdl=noapi&_s=1&tag_exp=0~115616986~115938465~115938468~116133314~117484252&sid=1774694918&sct=1&seg=0&dl=http%3A%2F%2Flocalhost%2F&dt=%F0%9F%8E%93%20Ditectrev%20%E2%80%93%20Online%20Education%20and%20Information%20Technology%20(IT)%20Consulting&en=page_view&_fv=1&_nsi=1&_ss=1&tfd=679",
+ "sessionTargetType": "page",
+ "protocol": "h2",
+ "rendererStartTime": 678.3899999996647,
+ "networkRequestTime": 678.7119999993593,
+ "networkEndTime": 1168.205999999307,
+ "finished": true,
+ "transferSize": 0,
+ "resourceSize": 0,
+ "statusCode": 204,
+ "mimeType": "text/plain",
+ "resourceType": "Fetch",
+ "priority": "High",
+ "experimentalFromMainFrame": true,
+ "entity": "Google Analytics"
+ },
+ {
+ "url": "http://localhost:3000/favicon.ico",
+ "sessionTargetType": "page",
+ "protocol": "http/1.1",
+ "rendererStartTime": 691.5499999998137,
+ "networkRequestTime": 691.714999999851,
+ "networkEndTime": 1073.7359999995679,
+ "finished": true,
+ "transferSize": 0,
+ "resourceSize": 25338,
+ "statusCode": 200,
+ "mimeType": "image/x-icon",
+ "resourceType": "Other",
+ "priority": "High",
+ "experimentalFromMainFrame": true,
+ "entity": "localhost"
+ },
+ {
+ "url": "http://localhost:3000/assets/icons/icon-144x144.png",
+ "sessionTargetType": "page",
+ "protocol": "http/1.1",
+ "rendererStartTime": 691.6720000002533,
+ "networkRequestTime": 691.7960000000894,
+ "networkEndTime": 1078.1909999996424,
+ "finished": true,
+ "transferSize": 0,
+ "resourceSize": 19242,
+ "statusCode": 200,
+ "mimeType": "image/png",
+ "resourceType": "Other",
+ "priority": "High",
+ "experimentalFromMainFrame": true,
+ "entity": "localhost"
+ }
+ ],
+ "debugData": {
+ "type": "debugdata",
+ "networkStartTimeTs": 7583264167
+ }
+ }
+ },
+ "network-rtt": {
+ "id": "network-rtt",
+ "title": "Network Round Trip Times",
+ "description": "Network round trip times (RTT) have a large impact on performance. If the RTT to an origin is high, it's an indication that servers closer to the user could improve performance. [Learn more about the Round Trip Time](https://hpbn.co/primer-on-latency-and-bandwidth/).",
+ "score": null,
+ "scoreDisplayMode": "informative",
+ "numericValue": 23.732,
+ "numericUnit": "millisecond",
+ "displayValue": "20 ms",
+ "details": {
+ "type": "table",
+ "headings": [
+ {
+ "key": "origin",
+ "valueType": "text",
+ "label": "URL"
+ },
+ {
+ "key": "rtt",
+ "valueType": "ms",
+ "granularity": 1,
+ "label": "Time Spent"
+ }
+ ],
+ "items": [
+ {
+ "origin": "https://static.hotjar.com",
+ "rtt": 23.732
+ },
+ {
+ "origin": "https://www.googletagmanager.com",
+ "rtt": 12.083
+ },
+ {
+ "origin": "https://fonts.gstatic.com",
+ "rtt": 4.841
+ },
+ {
+ "origin": "http://localhost:3000",
+ "rtt": 0.018449999999999998
+ },
+ {
+ "origin": "https://region1.google-analytics.com",
+ "rtt": 0.00019999999999999998
+ }
+ ],
+ "sortedBy": [
+ "rtt"
+ ]
+ }
+ },
+ "network-server-latency": {
+ "id": "network-server-latency",
+ "title": "Server Backend Latencies",
+ "description": "Server latencies can impact web performance. If the server latency of an origin is high, it's an indication the server is overloaded or has poor backend performance. [Learn more about server response time](https://hpbn.co/primer-on-web-performance/#analyzing-the-resource-waterfall).",
+ "score": null,
+ "scoreDisplayMode": "informative",
+ "numericValue": 488.7588,
+ "numericUnit": "millisecond",
+ "displayValue": "490 ms",
+ "details": {
+ "type": "table",
+ "headings": [
+ {
+ "key": "origin",
+ "valueType": "text",
+ "label": "URL"
+ },
+ {
+ "key": "serverResponseTime",
+ "valueType": "ms",
+ "granularity": 1,
+ "label": "Time Spent"
+ }
+ ],
+ "items": [
+ {
+ "origin": "https://region1.google-analytics.com",
+ "serverResponseTime": 488.7588
+ },
+ {
+ "origin": "https://www.googletagmanager.com",
+ "serverResponseTime": 33.791000000000004
+ },
+ {
+ "origin": "http://localhost:3000",
+ "serverResponseTime": 31.588549999999998
+ },
+ {
+ "origin": "https://static.hotjar.com",
+ "serverResponseTime": 26.79
+ },
+ {
+ "origin": "https://fonts.gstatic.com",
+ "serverResponseTime": 12.130999999999997
+ }
+ ],
+ "sortedBy": [
+ "serverResponseTime"
+ ]
+ }
+ },
+ "main-thread-tasks": {
+ "id": "main-thread-tasks",
+ "title": "Tasks",
+ "description": "Lists the toplevel main thread tasks that executed during page load.",
+ "score": null,
+ "scoreDisplayMode": "informative",
+ "details": {
+ "type": "table",
+ "headings": [
+ {
+ "key": "startTime",
+ "valueType": "ms",
+ "granularity": 1,
+ "label": "Start Time"
+ },
+ {
+ "key": "duration",
+ "valueType": "ms",
+ "granularity": 1,
+ "label": "End Time"
+ }
+ ],
+ "items": [
+ {
+ "duration": 13.729,
+ "startTime": 54.271
+ },
+ {
+ "duration": 5.494,
+ "startTime": 69.016
+ },
+ {
+ "duration": 14.511,
+ "startTime": 93.524
+ },
+ {
+ "duration": 90.242,
+ "startTime": 108.05
+ },
+ {
+ "duration": 10.077,
+ "startTime": 202.05
+ },
+ {
+ "duration": 5.835,
+ "startTime": 216.999
+ },
+ {
+ "duration": 393.57,
+ "startTime": 228.507
+ },
+ {
+ "duration": 5.96,
+ "startTime": 622.653
+ },
+ {
+ "duration": 18.906,
+ "startTime": 631.325
+ },
+ {
+ "duration": 19.805,
+ "startTime": 650.554
+ },
+ {
+ "duration": 8.535,
+ "startTime": 671.145
+ },
+ {
+ "duration": 5.148,
+ "startTime": 2786.245
+ }
+ ]
+ }
+ },
+ "metrics": {
+ "id": "metrics",
+ "title": "Metrics",
+ "description": "Collects all available metrics.",
+ "score": null,
+ "scoreDisplayMode": "informative",
+ "numericValue": 8074,
+ "numericUnit": "millisecond",
+ "details": {
+ "type": "debugdata",
+ "items": [
+ {
+ "firstContentfulPaint": 3789,
+ "firstMeaningfulPaint": 3789,
+ "largestContentfulPaint": 7484,
+ "interactive": 8074,
+ "speedIndex": 5171,
+ "totalBlockingTime": 743,
+ "maxPotentialFID": 787,
+ "cumulativeLayoutShift": 0.033939,
+ "cumulativeLayoutShiftMainFrame": 0.033939,
+ "timeToFirstByte": 482,
+ "observedTimeOrigin": 0,
+ "observedTimeOriginTs": 7583263689,
+ "observedNavigationStart": 0,
+ "observedNavigationStartTs": 7583263689,
+ "observedFirstPaint": 87,
+ "observedFirstPaintTs": 7583350522,
+ "observedFirstContentfulPaint": 228,
+ "observedFirstContentfulPaintTs": 7583492188,
+ "observedFirstContentfulPaintAllFrames": 228,
+ "observedFirstContentfulPaintAllFramesTs": 7583492188,
+ "observedFirstMeaningfulPaint": 228,
+ "observedFirstMeaningfulPaintTs": 7583492188,
+ "observedLargestContentfulPaint": 670,
+ "observedLargestContentfulPaintTs": 7583933853,
+ "observedLargestContentfulPaintAllFrames": 670,
+ "observedLargestContentfulPaintAllFramesTs": 7583933853,
+ "observedTraceEnd": 3480,
+ "observedTraceEndTs": 7586743830,
+ "observedLoad": 691,
+ "observedLoadTs": 7583954499,
+ "observedDomContentLoaded": 187,
+ "observedDomContentLoadedTs": 7583450760,
+ "observedCumulativeLayoutShift": 0.033939,
+ "observedCumulativeLayoutShiftMainFrame": 0.033939,
+ "observedFirstVisualChange": 217,
+ "observedFirstVisualChangeTs": 7583480689,
+ "observedLastVisualChange": 3476,
+ "observedLastVisualChangeTs": 7586739689,
+ "observedSpeedIndex": 901,
+ "observedSpeedIndexTs": 7584164851
+ },
+ {
+ "lcpInvalidated": false
+ }
+ ]
+ }
+ },
+ "performance-budget": {
+ "id": "performance-budget",
+ "title": "Performance budget",
+ "description": "Keep the quantity and size of network requests under the targets set by the provided performance budget. [Learn more about performance budgets](https://developers.google.com/web/tools/lighthouse/audits/budgets).",
+ "score": null,
+ "scoreDisplayMode": "notApplicable"
+ },
+ "timing-budget": {
+ "id": "timing-budget",
+ "title": "Timing budget",
+ "description": "Set a timing budget to help you keep an eye on the performance of your site. Performant sites load fast and respond to user input events quickly. [Learn more about performance budgets](https://developers.google.com/web/tools/lighthouse/audits/budgets).",
+ "score": null,
+ "scoreDisplayMode": "notApplicable"
+ },
+ "resource-summary": {
+ "id": "resource-summary",
+ "title": "Resources Summary",
+ "description": "Aggregates all network requests and groups them by type",
+ "score": null,
+ "scoreDisplayMode": "informative",
+ "details": {
+ "type": "table",
+ "headings": [
+ {
+ "key": "label",
+ "valueType": "text",
+ "label": "Resource Type"
+ },
+ {
+ "key": "requestCount",
+ "valueType": "numeric",
+ "label": "Requests"
+ },
+ {
+ "key": "transferSize",
+ "valueType": "bytes",
+ "label": "Transfer Size"
+ }
+ ],
+ "items": [
+ {
+ "resourceType": "total",
+ "label": "Total",
+ "requestCount": 25,
+ "transferSize": 1078520
+ },
+ {
+ "resourceType": "script",
+ "label": "Script",
+ "requestCount": 9,
+ "transferSize": 689932
+ },
+ {
+ "resourceType": "font",
+ "label": "Font",
+ "requestCount": 5,
+ "transferSize": 231556
+ },
+ {
+ "resourceType": "image",
+ "label": "Image",
+ "requestCount": 6,
+ "transferSize": 125367
+ },
+ {
+ "resourceType": "stylesheet",
+ "label": "Stylesheet",
+ "requestCount": 1,
+ "transferSize": 21209
+ },
+ {
+ "resourceType": "document",
+ "label": "Document",
+ "requestCount": 1,
+ "transferSize": 9792
+ },
+ {
+ "resourceType": "other",
+ "label": "Other",
+ "requestCount": 3,
+ "transferSize": 664
+ },
+ {
+ "resourceType": "media",
+ "label": "Media",
+ "requestCount": 0,
+ "transferSize": 0
+ },
+ {
+ "resourceType": "third-party",
+ "label": "Third-party",
+ "requestCount": 9,
+ "transferSize": 508933
+ }
+ ]
+ }
+ },
+ "third-party-summary": {
+ "id": "third-party-summary",
+ "title": "Minimize third-party usage",
+ "description": "Third-party code can significantly impact load performance. Limit the number of redundant third-party providers and try to load third-party code after your page has primarily finished loading. [Learn how to minimize third-party impact](https://developers.google.com/web/fundamentals/performance/optimizing-content-efficiency/loading-third-party-javascript/).",
+ "score": null,
+ "scoreDisplayMode": "informative",
+ "displayValue": "Third-party code blocked the main thread for 0 ms",
+ "metricSavings": {
+ "TBT": 26.000000000000004
+ },
+ "details": {
+ "type": "table",
+ "headings": [
+ {
+ "key": "entity",
+ "valueType": "text",
+ "label": "Third-Party",
+ "subItemsHeading": {
+ "key": "url",
+ "valueType": "url"
+ }
+ },
+ {
+ "key": "transferSize",
+ "granularity": 1,
+ "valueType": "bytes",
+ "label": "Transfer Size",
+ "subItemsHeading": {
+ "key": "transferSize"
+ }
+ },
+ {
+ "key": "blockingTime",
+ "granularity": 1,
+ "valueType": "ms",
+ "label": "Main-Thread Blocking Time",
+ "subItemsHeading": {
+ "key": "blockingTime"
+ }
+ }
+ ],
+ "items": [
+ {
+ "mainThreadTime": 159.4240000000009,
+ "blockingTime": 4.427999999999997,
+ "transferSize": 270229,
+ "tbtImpact": 26.000000000000004,
+ "entity": "Google Tag Manager",
+ "subItems": {
+ "type": "subitems",
+ "items": [
+ {
+ "url": "https://www.googletagmanager.com/gtag/js?id=G-PM7746GQBC&cx=c>m=4e63p1",
+ "mainThreadTime": 93.89200000000102,
+ "blockingTime": 4.427999999999997,
+ "transferSize": 151850,
+ "tbtImpact": 26.000000000000004
+ },
+ {
+ "url": "https://www.googletagmanager.com/gtm.js?id=GTM-N382336",
+ "mainThreadTime": 65.53199999999985,
+ "blockingTime": 0,
+ "transferSize": 118379,
+ "tbtImpact": 0
+ }
+ ]
+ }
+ },
+ {
+ "mainThreadTime": 0,
+ "blockingTime": 0,
+ "transferSize": 231556,
+ "tbtImpact": 0,
+ "entity": "Google Fonts",
+ "subItems": {
+ "type": "subitems",
+ "items": [
+ {
+ "url": "https://fonts.gstatic.com/s/materialicons/v145/flUhRq6tzZclQEJ-Vdg-IuiaDsNc.woff2",
+ "mainThreadTime": 0,
+ "blockingTime": 0,
+ "transferSize": 128533,
+ "tbtImpact": 0
+ },
+ {
+ "url": "https://fonts.gstatic.com/s/lora/v37/0QIvMX1D_JOuMwr7Iw.woff2",
+ "mainThreadTime": 0,
+ "blockingTime": 0,
+ "transferSize": 38338,
+ "tbtImpact": 0
+ },
+ {
+ "url": "https://fonts.gstatic.com/s/philosopher/v21/vEFI2_5QCwIS4_Dhez5jcWjValgb8tc.woff2",
+ "mainThreadTime": 0,
+ "blockingTime": 0,
+ "transferSize": 22390,
+ "tbtImpact": 0
+ },
+ {
+ "url": "https://fonts.gstatic.com/s/philosopher/v21/vEFV2_5QCwIS4_Dhez5jcWBuT00.woff2",
+ "mainThreadTime": 0,
+ "blockingTime": 0,
+ "transferSize": 22178,
+ "tbtImpact": 0
+ },
+ {
+ "url": "https://fonts.gstatic.com/s/lora/v37/0QIvMX1D_JOuMwT7I-NP.woff2",
+ "mainThreadTime": 0,
+ "blockingTime": 0,
+ "transferSize": 20117,
+ "tbtImpact": 0
+ }
+ ]
+ }
+ },
+ {
+ "mainThreadTime": 4.059999999999999,
+ "blockingTime": 0,
+ "transferSize": 7148,
+ "tbtImpact": 0,
+ "entity": "Hotjar",
+ "subItems": {
+ "type": "subitems",
+ "items": [
+ {
+ "url": "https://static.hotjar.com/c/hotjar-2343122.js?sv=7",
+ "mainThreadTime": 4.059999999999999,
+ "blockingTime": 0,
+ "transferSize": 7148,
+ "tbtImpact": 0
+ }
+ ]
+ }
+ },
+ {
+ "mainThreadTime": 0,
+ "blockingTime": 0,
+ "transferSize": 0,
+ "tbtImpact": 0,
+ "entity": "Google Analytics",
+ "subItems": {
+ "type": "subitems",
+ "items": [
+ {
+ "url": "https://region1.google-analytics.com/g/collect?v=2&tid=G-PM7746GQBC>m=45je63p1v877503170z8843435470za20gzb843435470zd843435470&_p=1774694917813&gcd=13l3l3l2l1l1&npa=1&dma_cps=a&dma=1&cid=342057496.1774694918&ul=en-gb&sr=412x823&uaa=&uab=64&uafvl=Chromium%3B146.0.7680.165%7CNot-A.Brand%3B24.0.0.0%7CGoogle%2520Chrome%3B146.0.7680.165&uamb=1&uam=moto%20g%20power%20(2022)&uap=Android&uapv=11.0&uaw=0&are=1&frm=0&pscdl=noapi&_s=1&tag_exp=0~115616986~115938465~115938468~116133314~117484252&sid=1774694918&sct=1&seg=0&dl=http%3A%2F%2Flocalhost%2F&dt=%F0%9F%8E%93%20Ditectrev%20%E2%80%93%20Online%20Education%20and%20Information%20Technology%20(IT)%20Consulting&en=page_view&_fv=1&_nsi=1&_ss=1&tfd=679",
+ "mainThreadTime": 0,
+ "blockingTime": 0,
+ "transferSize": 0,
+ "tbtImpact": 0
+ }
+ ]
+ }
+ }
+ ],
+ "summary": {
+ "wastedBytes": 508933,
+ "wastedMs": 4.427999999999997
+ },
+ "isEntityGrouped": true
+ },
+ "guidanceLevel": 1
+ },
+ "third-party-facades": {
+ "id": "third-party-facades",
+ "title": "Lazy load third-party resources with facades",
+ "description": "Some third-party embeds can be lazy loaded. Consider replacing them with a facade until they are required. [Learn how to defer third-parties with a facade](https://developer.chrome.com/docs/lighthouse/performance/third-party-facades/).",
+ "score": null,
+ "scoreDisplayMode": "notApplicable",
+ "metricSavings": {
+ "TBT": 0
+ },
+ "guidanceLevel": 3
+ },
+ "largest-contentful-paint-element": {
+ "id": "largest-contentful-paint-element",
+ "title": "Largest Contentful Paint element",
+ "description": "This is the largest contentful element painted within the viewport. [Learn more about the Largest Contentful Paint element](https://developer.chrome.com/docs/lighthouse/performance/lighthouse-largest-contentful-paint/)",
+ "score": 0,
+ "scoreDisplayMode": "metricSavings",
+ "displayValue": "7,480 ms",
+ "metricSavings": {
+ "LCP": 4984.3330499999975
+ },
+ "details": {
+ "type": "list",
+ "items": [
+ {
+ "type": "table",
+ "headings": [
+ {
+ "key": "node",
+ "valueType": "node",
+ "label": "Element"
+ }
+ ],
+ "items": [
+ {
+ "node": {
+ "type": "node",
+ "lhId": "page-0-P",
+ "path": "1,HTML,1,BODY,0,APP-ROOT,1,MAIN,1,APP-HOME,0,APP-HERO,0,DIV,0,DIV,3,P",
+ "selector": "app-hero > div#particles-js > div#heading > p",
+ "boundingRect": {
+ "top": 485,
+ "bottom": 840,
+ "left": 16,
+ "right": 396,
+ "width": 380,
+ "height": 355
+ },
+ "snippet": "",
+ "nodeLabel": "Online Education and Information Technology (IT) Consulting. Ditectrev was foun…"
+ }
+ }
+ ]
+ },
+ {
+ "type": "table",
+ "headings": [
+ {
+ "key": "phase",
+ "valueType": "text",
+ "label": "Phase"
+ },
+ {
+ "key": "percent",
+ "valueType": "text",
+ "label": "% of LCP"
+ },
+ {
+ "key": "timing",
+ "valueType": "ms",
+ "label": "Timing"
+ }
+ ],
+ "items": [
+ {
+ "phase": "TTFB",
+ "timing": 481.58855,
+ "percent": "6%"
+ },
+ {
+ "phase": "Load Delay",
+ "timing": 0,
+ "percent": "0%"
+ },
+ {
+ "phase": "Load Time",
+ "timing": 0,
+ "percent": "0%"
+ },
+ {
+ "phase": "Render Delay",
+ "timing": 7002.744499999997,
+ "percent": "94%"
+ }
+ ]
+ }
+ ]
+ },
+ "guidanceLevel": 1
+ },
+ "lcp-lazy-loaded": {
+ "id": "lcp-lazy-loaded",
+ "title": "Largest Contentful Paint image was not lazily loaded",
+ "description": "Above-the-fold images that are lazily loaded render later in the page lifecycle, which can delay the largest contentful paint. [Learn more about optimal lazy loading](https://web.dev/articles/lcp-lazy-loading).",
+ "score": null,
+ "scoreDisplayMode": "notApplicable",
+ "metricSavings": {
+ "LCP": 0
+ },
+ "guidanceLevel": 3
+ },
+ "layout-shift-elements": {
+ "id": "layout-shift-elements",
+ "title": "Avoid large layout shifts",
+ "description": "These DOM elements were most affected by layout shifts. Some layout shifts may not be included in the CLS metric value due to [windowing](https://web.dev/articles/cls#what_is_cls). [Learn how to improve CLS](https://web.dev/articles/optimize-cls)",
+ "score": null,
+ "scoreDisplayMode": "informative",
+ "displayValue": "6 elements found",
+ "metricSavings": {
+ "CLS": 0.033939
+ },
+ "details": {
+ "type": "table",
+ "headings": [
+ {
+ "key": "node",
+ "valueType": "node",
+ "label": "Element"
+ },
+ {
+ "key": "score",
+ "valueType": "numeric",
+ "granularity": 0.001,
+ "label": "Layout shift impact"
+ }
+ ],
+ "items": [
+ {
+ "node": {
+ "type": "node",
+ "lhId": "page-1-DIV",
+ "path": "1,HTML,1,BODY,0,APP-ROOT,2,APP-FOOTER,0,FOOTER,0,ASIDE,4,DIV",
+ "selector": "app-footer.ng-tns-c1105037843-0 > footer > aside.footer-grid > div.footer-resources",
+ "boundingRect": {
+ "top": 2575,
+ "bottom": 2786,
+ "left": 16,
+ "right": 411,
+ "width": 395,
+ "height": 210
+ },
+ "snippet": "