feat: add example templates to the local service and update stream after initialization

apps/example/lib/main.dart

@@ -47,7 +47,7 @@ class Home extends StatelessWidget {
         floatingActionButton: FloatingActionButton(
           onPressed: () async {
             debugPrint("starting availability user story");
-            await openAvailabilitiesForUser(context, "anonymous", null);
+            await openAvailabilitiesForUser(context, "", null);
             debugPrint("finishing availability user story");
           },
         ),

packages/flutter_availability/lib/src/service/initial_data.dart

@@ -0,0 +1,52 @@
+import "package:flutter/material.dart";
+import "package:flutter_availability_data_interface/flutter_availability_data_interface.dart";
+
+/// Returns the default local availabilities for a user
+List<AvailabilityModel> getDefaultLocalAvailabilitiesForUser() {
+  var currentMonth = DateTime(DateTime.now().year, DateTime.now().month);
+  return [
+    for (var availability in <(String, int, String)>[
+      ("1", 0, "1"),
+      ("2", 2, "2"),
+      ("3", 3, "2"),
+      ("4", 6, "4"),
+      ("5", 8, "5"),
+    ]) ...[
+      AvailabilityModel(
+        id: availability.$1,
+        userId: "",
+        startDate: currentMonth.add(Duration(days: availability.$2)),
+        endDate: currentMonth.add(Duration(days: availability.$2)),
+        breaks: [],
+        templateId: availability.$3,
+      ),
+    ],
+  ];
+}
+
+/// returns the default local templates for a user
+List<AvailabilityTemplateModel> getDefaultLocalTemplatesForUser() {
+  var currentMonth = DateTime(DateTime.now().year, DateTime.now().month);
+  return [
+    for (var template in <(String, String, Color)>[
+      ("1", "Morning", Colors.blue),
+      ("2", "Afternoon", Colors.green),
+      ("3", "Evening", Colors.red),
+      ("4", "Night", Colors.purple),
+      ("5", "All day", Colors.orange),
+    ]) ...[
+      AvailabilityTemplateModel(
+        id: template.$1,
+        userId: "",
+        name: template.$2,
+        color: template.$3.value,
+        templateType: AvailabilityTemplateType.day,
+        templateData: DayTemplateData(
+          startTime: currentMonth,
+          endTime: currentMonth,
+          breaks: [],
+        ),
+      ),
+    ],
+  ];
+}

packages/flutter_availability/lib/src/service/local_data_interface.dart

@@ -1,12 +1,24 @@
 import "dart:async";
 
+import "package:flutter_availability/src/service/initial_data.dart";
 import "package:flutter_availability_data_interface/flutter_availability_data_interface.dart";
 
 /// A local implementation of the [AvailabilityDataInterface] that stores data
 /// in memory.
 class LocalAvailabilityDataInterface implements AvailabilityDataInterface {
-  final Map<String, List<AvailabilityModel>> _userAvailabilities = {};
+  ///
-  final Map<String, List<AvailabilityTemplateModel>> _userTemplates = {};
+  LocalAvailabilityDataInterface() {
+    _notifyAvailabilityChanges();
+    _notifyTemplateChanges();
+  }
+
+  final Map<String, List<AvailabilityModel>> _userAvailabilities = {
+    "": getDefaultLocalAvailabilitiesForUser(),
+  };
+
+  final Map<String, List<AvailabilityTemplateModel>> _userTemplates = {
+    "": getDefaultLocalTemplatesForUser(),
+  };
 
   final StreamController<Map<String, List<AvailabilityModel>>>
       _availabilityController = StreamController.broadcast();
@@ -105,25 +117,30 @@ class LocalAvailabilityDataInterface implements AvailabilityDataInterface {
     required String userId,
     DateTime? start,
     DateTime? end,
-  }) =>
+  }) {
-      _availabilityController.stream.map((availabilitiesMap) {
+    // load the availabilities 1 second later to simulate a network request
-        var availabilities = availabilitiesMap[userId];
+    Future.delayed(const Duration(seconds: 1), _notifyAvailabilityChanges);
-        if (availabilities != null) {
+
-          if (start != null && end != null) {
+    return _availabilityController.stream
-            return availabilities
+        .map<List<AvailabilityModel>>((availabilitiesMap) {
-                .where(
+      var availabilities = availabilitiesMap[userId];
-                  (availability) =>
+      if (availabilities != null) {
-                      availability.startDate.isBefore(end) &&
+        if (start != null && end != null) {
-                      availability.endDate.isAfter(start),
+          return availabilities
-                )
+              .where(
-                .toList();
+                (availability) =>
-          } else {
+                    availability.startDate.isBefore(end) &&
-            return availabilities;
+                    availability.endDate.isAfter(start),
-          }
+              )
+              .toList();
         } else {
-          return [];
+          return availabilities;
         }
-      });
+      } else {
+        return [];
+      }
+    }).handleError((error) => []);
+  }
 
   @override
   Stream<AvailabilityModel> getAvailabilityForUserById(
@@ -158,18 +175,21 @@ class LocalAvailabilityDataInterface implements AvailabilityDataInterface {
   Stream<List<AvailabilityTemplateModel>> getTemplatesForUser({
     required String userId,
     List<String>? templateIds,
-  }) =>
+  }) {
-      _templateController.stream.map((templatesMap) {
+    // load the templates 1 second later to simulate a network request
-        var templates = templatesMap[userId];
+    Future.delayed(const Duration(seconds: 1), _notifyTemplateChanges);
-        if (templateIds != null) {
+    return _templateController.stream.map((templatesMap) {
-          return templates
+      var templates = templatesMap[userId];
-                  ?.where((template) => templateIds.contains(template.id))
+      if (templateIds != null) {
-                  .toList() ??
+        return templates
-              [];
+                ?.where((template) => templateIds.contains(template.id))
-        } else {
+                .toList() ??
-          return templates ?? [];
+            [];
-        }
+      } else {
-      });
+        return templates ?? [];
+      }
+    }).handleError((error) => []);
+  }
 
   @override
   Future<AvailabilityModel> updateAvailabilityForUser(