kasy-cli 1.2.1

package/lib/scaffold/catalog.js

@@ -0,0 +1,177 @@
+const path = require('node:path');
+
+// Source template — bundled inside the package at cli/templates/firebase/
+const CORE_SOURCE_DIR = path.resolve(__dirname, '../../templates/firebase');
+
+// Patches por backend: cli/lib/scaffold/backends/{backend}/patch/
+const BACKENDS_PATCH_DIR = path.resolve(__dirname, 'backends');
+
+// Patches por feature: cli/lib/scaffold/features/{feature}/
+const FEATURES_PATCH_DIR = path.resolve(__dirname, 'features');
+
+const AVAILABLE_BACKENDS = [
+  { id: 'firebase', aliases: ['firebase'] },
+  { id: 'supabase', aliases: ['supabase'] },
+  { id: 'api', aliases: ['api', 'restapi', 'rest_api', 'restApi'] }
+];
+
+/**
+ * Feature catalog — single source of truth for all selectable modules.
+ *
+ * status:
+ *   public   — visible to all users in the CLI wizard and presets
+ *   internal — visible only when KASY_INTERNAL=1; shown with [beta] badge
+ *   hidden   — never shown in the CLI (can still be passed via --with)
+ *
+ * availableIn: backends that support this feature
+ * defaultInPresets: which named presets include this feature by default
+ */
+const FEATURE_CATALOG = [
+  // integrations
+  { id: 'sentry',              status: 'public',   availableIn: ['firebase', 'supabase', 'api'], defaultInPresets: ['starter', 'saas', 'content', 'full'] },
+  { id: 'analytics',           status: 'public',   availableIn: ['firebase', 'supabase', 'api'], defaultInPresets: ['starter', 'saas', 'content', 'full'] },
+  { id: 'facebook',            status: 'public',   availableIn: ['firebase', 'supabase', 'api'], defaultInPresets: ['full'] },
+  // monetization
+  { id: 'revenuecat',          status: 'public',   availableIn: ['firebase', 'supabase', 'api'], defaultInPresets: ['saas', 'full'] },
+  // features
+  { id: 'onboarding',          status: 'public',   availableIn: ['firebase', 'supabase', 'api'], defaultInPresets: ['starter', 'saas', 'content', 'full'] },
+  { id: 'web',                 status: 'public',   availableIn: ['firebase'],                    defaultInPresets: [] },
+  { id: 'widget',              status: 'public',   availableIn: ['firebase', 'supabase', 'api'], defaultInPresets: ['full'] },
+  { id: 'llm_chat',            status: 'public',   availableIn: ['firebase', 'supabase', 'api'], defaultInPresets: ['content', 'full'] },
+  { id: 'local_notifications', status: 'public',   availableIn: ['firebase', 'supabase', 'api'], defaultInPresets: [] },
+  // feedback (Firebase/Supabase only)
+  { id: 'feedback',            status: 'public',   availableIn: ['firebase', 'supabase'],        defaultInPresets: ['saas', 'full'] },
+  // ci/cd
+  { id: 'ci',                  status: 'public',   availableIn: ['firebase', 'supabase', 'api'], defaultInPresets: ['full'] },
+];
+
+/**
+ * Returns features visible to the given audience, optionally filtered by backend.
+ *
+ * @param {object} opts
+ * @param {'public'|'internal'} opts.audience - 'internal' reveals beta features
+ * @param {string|null} opts.backend - filter by backend id, or null for all
+ */
+function getVisibleFeatures({ audience = 'public', backend = null } = {}) {
+  return FEATURE_CATALOG.filter((f) => {
+    if (f.status === 'hidden') return false;
+    if (f.status === 'internal' && audience !== 'internal') return false;
+    if (backend && !f.availableIn.includes(backend)) return false;
+    return true;
+  });
+}
+
+// Flat list kept for backward-compatibility with code that uses feature ids as strings.
+const AVAILABLE_FEATURES = FEATURE_CATALOG.map((f) => f.id);
+
+const DEFAULT_FEATURES = [...AVAILABLE_FEATURES];
+
+/**
+ * Base component files that can be updated independently from optional features.
+ * Paths are relative to CORE_SOURCE_DIR.
+ *
+ * Includes `lib/core/...` only when kit components depend on those APIs (tokens,
+ * shared widgets); keep this list in sync with `Firebase/lib/components/` and
+ * the home component catalog.
+ */
+const BASE_COMPONENT_FILES = [
+  'lib/core/theme/colors.dart',
+  'lib/core/theme/shadows.dart',
+  'lib/core/widgets/kasy_pressable_depth.dart',
+  'lib/components/components.dart',
+  'lib/components/kasy_accordion.dart',
+  'lib/components/kasy_alert.dart',
+  'lib/components/kasy_app_bar.dart',
+  'lib/components/kasy_avatar.dart',
+  'lib/components/kasy_button.dart',
+  'lib/components/kasy_card.dart',
+  'lib/components/kasy_chip.dart',
+  'lib/components/kasy_input.dart',
+  'lib/components/kasy_text_field.dart',
+  'lib/features/home/home_components_page.dart',
+  'lib/features/home/home_components_preview_page.dart',
+  'lib/features/home/home_components_preview_registry.dart',
+];
+
+function normalizeBackend(value) {
+  if (!value) {
+    return null;
+  }
+
+  const raw = String(value).trim();
+  if (!raw) {
+    return null;
+  }
+
+  const lowered = raw.toLowerCase().replace(/[-\s]/g, '');
+
+  const found = AVAILABLE_BACKENDS.find((backend) =>
+    backend.aliases.some((alias) => alias.toLowerCase().replace(/[-\s]/g, '') === lowered)
+  );
+
+  return found ? found.id : null;
+}
+
+function normalizeFeature(value) {
+  if (!value) {
+    return null;
+  }
+
+  const lowered = String(value).trim().toLowerCase().replace(/[-\s]/g, '_');
+  if (!lowered) {
+    return null;
+  }
+
+  const aliases = {
+    llm: 'llm_chat',
+    llmchat: 'llm_chat',
+    llm_chat: 'llm_chat',
+    rc: 'revenuecat',
+    revenue: 'revenuecat',
+    onboard: 'onboarding',
+    fb: 'facebook',
+  };
+
+  if (aliases[lowered]) {
+    return aliases[lowered];
+  }
+
+  return AVAILABLE_FEATURES.includes(lowered) ? lowered : null;
+}
+
+function parseFeatureList(value) {
+  if (!value) {
+    return [];
+  }
+
+  const rawItems = Array.isArray(value) ? value : [value];
+  const tokens = rawItems
+    .flatMap((item) => String(item).split(','))
+    .map((item) => item.trim())
+    .filter(Boolean);
+
+  const normalized = [];
+  for (const token of tokens) {
+    const feature = normalizeFeature(token);
+    if (feature && !normalized.includes(feature)) {
+      normalized.push(feature);
+    }
+  }
+
+  return normalized;
+}
+
+module.exports = {
+  CORE_SOURCE_DIR,
+  BACKENDS_PATCH_DIR,
+  FEATURES_PATCH_DIR,
+  AVAILABLE_BACKENDS,
+  FEATURE_CATALOG,
+  AVAILABLE_FEATURES,
+  DEFAULT_FEATURES,
+  BASE_COMPONENT_FILES,
+  normalizeBackend,
+  normalizeFeature,
+  parseFeatureList,
+  getVisibleFeatures,
+};

package/lib/scaffold/engine.js

@@ -0,0 +1,230 @@
+/**
+ * Generic copy + token-replacement engine.
+ * Backend-agnostic: receives sourceDir, targetDir, and a tokens map.
+ */
+
+const path = require('node:path');
+const fs = require('fs-extra');
+
+// Directories / files that should NEVER be copied from any source template
+const ALWAYS_EXCLUDE = new Set([
+  // Flutter / Dart build artifacts
+  'build',
+  '.dart_tool',
+  '.flutter-plugins',
+  '.flutter-plugins-dependencies',
+  'pubspec.lock',
+  // Credentials — must NEVER end up in the client's project
+  'firebase_key.json',
+  '.env',
+  'kit_setup.json',
+  // VCS / OS
+  '.git',
+  '.DS_Store',
+  // IDE & development tooling (developer-specific, not for the client)
+  'node_modules',
+  '.vscode',       // launch.json may contain developer credentials
+  '.cursor',
+  '.idea',
+  '.claude',       // AI assistant instructions — not for the client
+  // CI/CD configs — delivered only when the user selects the 'ci' module
+  // (these files live in features/ci/ and are applied as a feature patch)
+  '.github',
+  '.gitlab',
+  '.gitlab-ci.yml',
+  'codemagic.yaml',
+]);
+
+// File basenames that should NEVER be copied, regardless of directory depth
+const ALWAYS_EXCLUDE_BASENAMES = new Set([
+  'Podfile.lock',           // iOS CocoaPods lock — regenerated by pod install
+  'google-services.json',   // Firebase Android config — client must generate their own
+  'GoogleService-Info.plist', // Firebase iOS config — client must generate their own
+  'firebase_options_dev.dart', // Dev Firebase options — internal only
+]);
+
+// File extensions that may contain generated Dart code — skip these
+const GENERATED_DART_EXTENSIONS = ['.g.dart', '.freezed.dart'];
+
+// File extensions we try to replace text tokens in
+const TEXT_EXTENSIONS = new Set([
+  '.dart', '.yaml', '.json', '.xml', '.kt', '.kts', '.swift', '.m',
+  '.gradle', '.plist', '.md', '.txt', '.html', '.js', '.ts',
+  '.pbxproj', '.entitlements', '.xcscheme', '.strings', '.sh', '.sql',
+]);
+
+function isExcluded(relPath) {
+  // relPath is always normalized to forward slashes before being passed here
+  const top = relPath.split('/')[0];
+  if (ALWAYS_EXCLUDE.has(top)) return true;
+  if (ALWAYS_EXCLUDE_BASENAMES.has(path.basename(relPath))) return true;
+  if (GENERATED_DART_EXTENSIONS.some((ext) => relPath.endsWith(ext))) return true;
+  return false;
+}
+
+function isTextFile(filePath) {
+  return TEXT_EXTENSIONS.has(path.extname(filePath).toLowerCase());
+}
+
+/**
+ * Replace all occurrences of each token in content.
+ * @param {string} content
+ * @param {Record<string, string>} tokens - { 'OLD_VALUE': 'new_value', ... }
+ */
+function applyTokens(content, tokens) {
+  let result = content;
+  for (const [from, to] of Object.entries(tokens)) {
+    result = result.replaceAll(from, to);
+  }
+  return result;
+}
+
+/**
+ * Apply path replacements to a relative path.
+ * Used to rewrite Android Kotlin package paths (e.g. com/appfirebase/app → com/example/myapp).
+ * @param {string} relPath - Path with forward slashes
+ * @param {Record<string, string>} pathReplacements - { 'old/segment': 'new/segment', ... }
+ */
+function applyPathReplacements(relPath, pathReplacements) {
+  if (!pathReplacements || Object.keys(pathReplacements).length === 0) {
+    return relPath;
+  }
+  let result = relPath.replace(/\\/g, '/');
+  for (const [from, to] of Object.entries(pathReplacements)) {
+    result = result.replaceAll(from.replace(/\\/g, '/'), to.replace(/\\/g, '/'));
+  }
+  return result;
+}
+
+/**
+ * Copy a source directory to a target directory, skipping excluded paths
+ * and applying token replacement in text files.
+ *
+ * @param {string} sourceDir - Absolute path to source
+ * @param {string} targetDir - Absolute path to destination (will be created)
+ * @param {Record<string,string>} tokens - Token replacement map
+ * @param {string[]} [extraExcludes] - Additional top-level names to skip
+ * @param {Record<string,string>} [pathReplacements] - Path segment replacements (e.g. {'com/appfirebase/app':'com/example/myapp'})
+ * @returns {Promise<{filesCopied: number, filesSkipped: number}>}
+ */
+async function copyWithTokens(sourceDir, targetDir, tokens = {}, extraExcludes = [], pathReplacements = {}) {
+  const extraSet = new Set(extraExcludes);
+  let filesCopied = 0;
+  let filesSkipped = 0;
+
+  async function walk(src) {
+    const entries = await fs.readdir(src, { withFileTypes: true });
+
+    for (const entry of entries) {
+      const srcPath = path.join(src, entry.name);
+      const rel = path.relative(sourceDir, srcPath).replace(/\\/g, '/');
+      const top = rel.split('/')[0];
+
+      if (isExcluded(rel) || extraSet.has(top) || entry.name.startsWith('.DS_Store')) {
+        filesSkipped++;
+        continue;
+      }
+
+      if (entry.isDirectory()) {
+        await walk(srcPath);
+      } else if (entry.isFile()) {
+        const adjustedRel = applyPathReplacements(rel, pathReplacements);
+        const destPath = path.join(targetDir, adjustedRel);
+
+        if (isTextFile(srcPath) && Object.keys(tokens).length > 0) {
+          try {
+            const raw = await fs.readFile(srcPath, 'utf8');
+            const replaced = applyTokens(raw, tokens);
+            await fs.outputFile(destPath, replaced, 'utf8');
+          } catch {
+            await fs.copy(srcPath, destPath);
+          }
+        } else {
+          await fs.ensureDir(path.dirname(destPath));
+          await fs.copy(srcPath, destPath);
+        }
+        filesCopied++;
+      }
+    }
+  }
+
+  await walk(sourceDir);
+  return { filesCopied, filesSkipped };
+}
+
+/**
+ * Apply a patch directory over an existing target.
+ * Copies files from patchDir to targetDir, overwriting existing files.
+ * Applies token replacement to text files.
+ *
+ * @param {string} patchDir - Absolute path to patch directory (e.g. backends/supabase/patch)
+ * @param {string} targetDir - Absolute path to project (e.g. generated project root)
+ * @param {Record<string,string>} tokens - Token replacement map
+ * @param {Record<string,string>} [pathReplacements] - Path segment replacements
+ * @returns {Promise<{filesApplied: number}>}
+ */
+async function applyPatch(patchDir, targetDir, tokens = {}, pathReplacements = {}) {
+  if (!(await fs.pathExists(patchDir))) {
+    return { filesApplied: 0 };
+  }
+
+  let filesApplied = 0;
+
+  async function walk(src) {
+    const entries = await fs.readdir(src, { withFileTypes: true });
+
+    for (const entry of entries) {
+      const srcPath = path.join(src, entry.name);
+      const rel = path.relative(patchDir, srcPath).replace(/\\/g, '/');
+
+      // Skip OS junk files only — do NOT skip .github, .gitlab, etc.
+      if (entry.name === '.DS_Store' || entry.name.startsWith('._')) continue;
+      if (GENERATED_DART_EXTENSIONS.some((ext) => rel.endsWith(ext))) continue;
+
+      if (entry.isDirectory()) {
+        await walk(srcPath);
+      } else if (entry.isFile()) {
+        const adjustedRel = applyPathReplacements(rel, pathReplacements);
+        const destPath = path.join(targetDir, adjustedRel);
+        await fs.ensureDir(path.dirname(destPath));
+
+        if (isTextFile(srcPath) && Object.keys(tokens).length > 0) {
+          const raw = await fs.readFile(srcPath, 'utf8');
+          const replaced = applyTokens(raw, tokens);
+          await fs.outputFile(destPath, replaced, 'utf8');
+        } else {
+          await fs.copy(srcPath, destPath);
+        }
+        filesApplied++;
+      }
+    }
+  }
+
+  await walk(patchDir);
+  return { filesApplied };
+}
+
+/**
+ * Remove files from target that are no longer needed (e.g. Firebase-specific when using Supabase).
+ * @param {string} targetDir - Project root
+ * @param {string[]} relativePaths - Paths relative to targetDir (e.g. ['lib/core/data/api/firestore_retry.dart'])
+ */
+async function removeFiles(targetDir, relativePaths) {
+  for (const rel of relativePaths) {
+    const p = path.join(targetDir, rel);
+    if (await fs.pathExists(p)) {
+      await fs.remove(p).catch((err) => {
+        throw new Error(`Failed to remove ${rel}: ${err.message}`);
+      });
+    }
+  }
+}
+
+module.exports = {
+  copyWithTokens,
+  applyTokens,
+  applyPatch,
+  removeFiles,
+  isExcluded,
+  isTextFile,
+};

package/lib/scaffold/features/README.md

@@ -0,0 +1,152 @@
+# Feature Patches
+
+Este diretório contém os **patches por feature**: arquivos extras que são copiados para o projeto gerado quando o usuário seleciona um módulo específico no wizard do CLI.
+
+## Estrutura esperada
+
+```
+features/
+  ci/                  ← patch aplicado quando o usuário seleciona o módulo "ci"
+    .github/
+      workflows/
+        app.yml
+    .gitlab-ci.yml
+    ...
+  web/                 ← patch aplicado quando "web" é selecionado
+    web/
+      index.html
+      ...
+  widget/              ← patch aplicado quando "widget" é selecionado
+    android/
+      ...
+```
+
+Cada subdiretório tem o **mesmo nome** que o valor do módulo em `new.js` (`sentry`, `analytics`, `facebook`, `revenuecat`, `onboarding`, `web`, `widget`, `camera`, `llm_chat`, `feedback`, `ci`).
+
+Ao gerar um projeto, o engine copia recursivamente o conteúdo de `features/{modulo}/` para a raiz do projeto, sobrescrevendo ou acrescentando arquivos.
+
+## Módulos que precisam de patch físico
+
+| Módulo       | Patch necessário? | Motivo                                              |
+|-------------|------------------|-----------------------------------------------------|
+| `ci`        | ✅ Sim            | Adiciona `.github/`, `.gitlab-ci.yml`, etc.         |
+| `web`       | ✅ Sim            | Adiciona pasta `web/` e configurações de plataforma |
+| `widget`    | ✅ Sim            | Adiciona configurações Android para home widgets    |
+| `camera`    | Opcional          | Permissões extras no AndroidManifest / Info.plist   |
+| `llm_chat`  | Não               | Apenas `LLM_CHAT_ENDPOINT` via dart-define. A chave da API LLM fica no servidor (Firebase Secret / Supabase Secret) — nunca no app. |
+| `sentry`    | Não               | Apenas dart-define (`SENTRY_DSN`)                   |
+| `analytics` | Não               | Apenas dart-define                                  |
+| `facebook`  | Não               | Token já substituído via `buildTokens`              |
+| `revenuecat`| Não               | Apenas dart-define (`REVENUECAT_KEY_*`)             |
+| `onboarding`| Não               | Habilitado via dart-define / `features_config.json` |
+| `feedback`  | Não               | Habilitado via dart-define / `features_config.json` |
+| `local_notifications` | ✅ Sim  | Copia `lib/features/local_reminder/` com UI, provider e repositório |
+
+## Como criar um patch
+
+1. Crie a pasta `features/{modulo}/`.
+2. Coloque dentro dela os arquivos **exatamente como devem aparecer** no projeto gerado (caminhos relativos à raiz do projeto).
+3. O engine aplica os patches após copiar o template base e após aplicar o patch do backend.
+
+> Os patches de feature são aplicados pelo `generate.js` via `applyFeaturePatches()`.
+> Os geradores específicos por backend (`firebase/generator.js`, `supabase/generator.js`, `api/generator.js`)
+> precisam ser atualizados para chamar essa etapa quando a unificação for concluída.
+
+---
+
+## Feature: `local_notifications` — Notificações Locais Agendadas
+
+> **Plataformas:** iOS e Android apenas (sem suporte Web/Desktop).
+
+### O que esta feature faz
+
+Permite ao usuário configurar um lembrete recorrente diretamente no app, sem servidor. A notificação é agendada localmente via `flutter_local_notifications` e persiste entre sessões via `SharedPreferences`.
+
+### Tipos de lembrete suportados
+
+| Tipo            | Comportamento                                        |
+|-----------------|------------------------------------------------------|
+| `daily`         | Dispara todo dia no horário escolhido                |
+| `weekly`        | Dispara uma vez por semana no dia + horário escolhido |
+| `specificDate`  | Dispara uma única vez na data + hora escolhida        |
+
+### Entrada do usuário
+
+Acesso via **Settings → Lembretes** (`/reminder`):
+
+1. **Toggle "Ativar lembrete"** — liga/desliga (cancela notificação pendente ao desligar)
+2. **Segmented button "Repetir"** — escolhe o tipo: `Todo dia / Toda semana / Data específica`
+3. **Horário** — `TimePicker` nativo do sistema
+4. **Dia da semana** — `ChoiceChip` (seg–dom), aparece somente no modo semanal
+5. **Data e hora** — `DatePicker` + `TimePicker` em sequência, aparece somente no modo data específica
+
+### Estrutura de arquivos gerados no projeto
+
+```
+lib/features/local_reminder/
+  repositories/
+    reminder_preferences.dart    ← SharedPreferences (load/save ReminderState)
+  providers/
+    reminder_notifier.dart       ← AsyncNotifier (keepAlive) + agenda/cancela
+    reminder_notifier.g.dart     ← gerado pelo build_runner (provider: reminderProvider)
+  ui/
+    reminder_page.dart           ← ReminderPage + _ReminderForm + subwidgets
+```
+
+### Integrações automáticas pelo CLI
+
+| Arquivo                        | O que é adicionado                                      |
+|--------------------------------|---------------------------------------------------------|
+| `lib/core/config/features.dart` | `const bool withLocalNotifications = true/false;`      |
+| `lib/router.dart`              | Import + `GoRoute(path: '/reminder', ...)`              |
+| `lib/features/settings/settings_page.dart` | Tile "Lembretes" → `context.push('/reminder')` |
+
+### Model — `ReminderState`
+
+```dart
+class ReminderState {
+  final bool enabled;
+  final ReminderType type;   // daily | weekly | specificDate
+  final int hour;
+  final int minute;
+  final int dayOfWeek;       // 1=Segunda … 7=Domingo
+  final DateTime? date;      // usado somente para specificDate
+}
+```
+
+### Notificação agendada
+
+ID fixo `42`. Texto configurado via i18n (`dailyReminder.title` / `dailyReminder.body`).  
+Ao salvar qualquer mudança, o provider cancela o ID 42 e re-agenda com os novos parâmetros.
+
+### Dependências (já no core — não adicionadas pelo módulo)
+
+- `flutter_local_notifications`
+- `flutter_timezone` + `timezone`
+- `shared_preferences`
+- `riverpod_annotation`
+
+### Traduções adicionadas
+
+Chaves em `lib/i18n/{pt,en,es}.i18n.json`:
+
+```json
+"reminderPage": {
+  "title": "Lembretes",
+  "toggleLabel": "Ativar lembrete",
+  "typeLabel": "Repetir",
+  "daily": "Todo dia",
+  "weekly": "Toda semana",
+  "specificDate": "Data específica",
+  "timeLabel": "Horário",
+  "dayLabel": "Dia da semana",
+  "dateLabel": "Data e hora",
+  "selectDate": "Selecionar data e hora"
+},
+"dailyReminder": { "title": "Lembrete", "body": "Está na hora de beber água." },
+"settings": { "reminders": "Lembretes" }
+```
+
+### Bug corrigido durante a implementação
+
+`local_notifier.dart` tinha um método `scheduleFromNow()` com lógica invertida (agendava apenas quando **não** havia notificações pendentes) e usava `Future.delayed` que não sobrevive ao restart do app. O método foi **removido** completamente.

package/lib/scaffold/features/analytics/lib/core/data/api/analytics_api.dart

@@ -0,0 +1,124 @@
+import 'package:flutter/material.dart';
+import 'package:flutter_riverpod/flutter_riverpod.dart';
+import 'package:mixpanel_flutter/mixpanel_flutter.dart';
+import 'package:kasy_kit/core/data/models/user.dart';
+import 'package:kasy_kit/core/initializer/onstart_service.dart';
+import 'package:kasy_kit/environnements.dart';
+
+final analyticsApiProvider = Provider<AnalyticsApi>(
+  (ref) => MixpanelAnalyticsApi.instance(),
+  
+);
+
+abstract class AnalyticsApi implements OnStartService {
+  /// Log an event to your analytics platform
+  Future<void> logEvent(String name, Map<String, dynamic> params);
+
+  /// Log a signout event to your analytics platform
+  Future<void> logSignout();
+
+  /// Identify a user to your analytics platform
+  Future<void> identify(User user);
+}
+
+
+class MixpanelAnalyticsApi implements AnalyticsApi {
+  final Environment environment;
+  Mixpanel? mixpanel;
+  MixpanelAnalyticsApi._({
+    required this.environment,
+  });
+
+  static MixpanelAnalyticsApi? _instance;
+
+  factory MixpanelAnalyticsApi.instance() {
+    return _instance ??= MixpanelAnalyticsApi._(
+      environment: Environment.fromEnv(),
+    );
+  }
+
+  @override
+  Future<void> init() async {
+    if (environment.mixpanelToken == null ||
+        environment.mixpanelToken!.isEmpty) {
+      return;
+    }
+    try {
+      mixpanel = await Mixpanel.init(
+        environment.mixpanelToken!,
+        trackAutomaticEvents: true,
+      );
+    } catch (e, s) {
+      debugPrint('Error initializing Mixpanel: $e\n$s');
+    }
+  }
+
+  @override
+  Future<void> logEvent(String name, Map<String, dynamic> params) async {
+    mixpanel?.track(name, properties: params);
+  }
+
+  @override
+  Future<void> logSignout() async {
+    mixpanel?.reset();
+    mixpanel?.track('logout');
+  }
+
+  @override
+  Future<void> identify(User user) async {
+    mixpanel?.track('login');
+    final userId = user.idOrNull;
+    if (userId != null) {
+      mixpanel?.identify(userId);
+    }
+  }
+}
+
+
+
+
+class AnalyticsObserver extends RouteObserver<ModalRoute<dynamic>> {
+  final AnalyticsApi analyticsApi;
+  final String? prefix;
+
+  AnalyticsObserver({
+    required this.analyticsApi,
+    this.prefix,
+  });
+
+  @override
+  void didPush(Route<dynamic> route, Route<dynamic>? previousRoute) {
+    // debugPrint('didPush $prefix${route.settings.name} ');
+    if (route.settings.name != null && prefix != null) {
+      analyticsApi.logEvent('$prefix${route.settings.name}', {});
+    } else if (route.settings.name != null && prefix == null) {
+      analyticsApi.logEvent('${route.settings.name}', {});
+    }
+  }
+
+  @override
+  void didReplace({Route<dynamic>? newRoute, Route<dynamic>? oldRoute}) {
+    // debugPrint('didReplace ${newRoute?.settings.name}');
+    if (newRoute?.settings.name != null && prefix != null) {
+      analyticsApi.logEvent('$prefix${newRoute!.settings.name!}', {});
+    } else if (newRoute?.settings.name != null && prefix == null) {
+      analyticsApi.logEvent(newRoute!.settings.name!, {});
+    }
+  }
+
+  @override
+  void didPop(Route<dynamic> route, Route<dynamic>? previousRoute) {}
+
+  @override
+  void didRemove(Route<dynamic> route, Route<dynamic>? previousRoute) {}
+
+  @override
+  void didStartUserGesture(
+    Route<dynamic> route,
+    Route<dynamic>? previousRoute,
+  ) {}
+
+  @override
+  void didStopUserGesture() {}
+}
+