init<E extends Enum> static method

Future<EnvManager<E>> init<E extends Enum>({ required E defaultEnv, required Map<E, String> configs, Set<E>? lockedEnvironments, bool persistSelection = true, EnvLoader? loader, EnvStore? store, })

Initialises the singleton with defaultEnv and the configs map.

Loads all .env asset files in parallel. If a previously persisted selection exists and persistSelection is true, it is restored; otherwise defaultEnv is used.

lockedEnvironments is an optional set of environments from which switching is forbidden. When the active environment is in this set, switchTo throws EnvSwitchLockedException. Defaults to no lock.

persistSelection controls whether the active environment is saved to and restored from SharedPreferences across sessions. When false, the store is cleared on init and switches are not written to the store. Defaults to true.

Throws EnvLoadException when any asset fails to load. Safe to call multiple times (subsequent calls replace the instance).

Implementation

static Future<EnvManager<E>> init<E extends Enum>({
  required E defaultEnv,
  required Map<E, String> configs,
  Set<E>? lockedEnvironments,
  bool persistSelection = true,
  EnvLoader? loader,
  EnvStore? store,
}) async {
  final resolvedLoader = loader ?? EnvLoader();
  final resolvedStore = store ?? EnvStore();

  // Load all env files concurrently.
  final entries = configs.entries.toList();
  final results = await Future.wait(
    entries.map((e) => resolvedLoader.load(e.value)),
  );

  final envs = <E, Map<String, String>>{};
  for (var i = 0; i < entries.length; i++) {
    envs[entries[i].key] = results[i];
  }

  final allEnumValues = configs.keys.toList();
  E startEnv = defaultEnv;

  if (persistSelection) {
    // Attempt to restore a previously persisted selection.
    final savedName = await resolvedStore.load();
    final restoredEnv = savedName != null
        ? allEnumValues.cast<E?>().firstWhere(
              (e) => e?.name == savedName,
              orElse: () => null,
            )
        : null;
    startEnv = restoredEnv ?? defaultEnv;
  } else {
    // Clear any leftover state so the store is always clean in session mode.
    await resolvedStore.clear();
  }

  final manager = EnvManager<E>._(
    defaultEnv: startEnv,
    store: resolvedStore,
    envs: envs,
    allEnumValues: allEnumValues,
    lockedEnvironments: lockedEnvironments ?? const {},
    persistSelection: persistSelection,
  );

  _instance = manager;
  return manager;
}