Merge branch 'main' of https://github.com/florentianayuwono/LiteUp

.last_build_id

@@ -0,0 +1 @@
+748d941958faf0597d35e4b1f30f4331

flutter.js

@@ -0,0 +1,144 @@
+// Copyright 2014 The Flutter Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+/**
+ * This script installs service_worker.js to provide PWA functionality to
+ *     application. For more information, see:
+ *     https://developers.google.com/web/fundamentals/primers/service-workers
+ */
+
+if (!_flutter) {
+  var _flutter = {};
+}
+_flutter.loader = null;
+
+(function() {
+  "use strict";
+  class FlutterLoader {
+    // TODO: Move the below methods to "#private" once supported by all the browsers
+    // we support. In the meantime, we use the "revealing module" pattern.
+
+    // Watchdog to prevent injecting the main entrypoint multiple times.
+    _scriptLoaded = null;
+
+    // Resolver for the pending promise returned by loadEntrypoint.
+    _didCreateEngineInitializerResolve = null;
+
+    /**
+     * Initializes the main.dart.js with/without serviceWorker.
+     * @param {*} options
+     * @returns a Promise that will eventually resolve with an EngineInitializer,
+     * or will be rejected with the error caused by the loader.
+     */
+    loadEntrypoint(options) {
+      const {
+        entrypointUrl = "main.dart.js",
+        serviceWorker,
+      } = (options || {});
+      return this._loadWithServiceWorker(entrypointUrl, serviceWorker);
+    }
+
+    /**
+     * Resolves the promise created by loadEntrypoint. Called by Flutter.
+     * Needs to be weirdly bound like it is, so "this" is preserved across
+     * the JS <-> Flutter jumps.
+     * @param {*} engineInitializer
+     */
+    didCreateEngineInitializer = (function(engineInitializer) {
+      if (typeof this._didCreateEngineInitializerResolve != "function") {
+        console.warn("Do not call didCreateEngineInitializer by hand. Start with loadEntrypoint instead.");
+      }
+      this._didCreateEngineInitializerResolve(engineInitializer);
+      // Remove this method after it's done, so Flutter Web can hot restart.
+      delete this.didCreateEngineInitializer;
+    }).bind(this);
+
+    _loadEntrypoint(entrypointUrl) {
+      if (!this._scriptLoaded) {
+        this._scriptLoaded = new Promise((resolve, reject) => {
+          let scriptTag = document.createElement("script");
+          scriptTag.src = entrypointUrl;
+          scriptTag.type = "application/javascript";
+          this._didCreateEngineInitializerResolve = resolve; // Cache the resolve, so it can be called from Flutter.
+          scriptTag.addEventListener("error", reject);
+          document.body.append(scriptTag);
+        });
+      }
+
+      return this._scriptLoaded;
+    }
+
+    _waitForServiceWorkerActivation(serviceWorker, entrypointUrl) {
+      if (!serviceWorker || serviceWorker.state == "activated") {
+        if (!serviceWorker) {
+          console.warn("Cannot activate a null service worker. Falling back to plain <script> tag.");
+        } else {
+          console.debug("Service worker already active.");
+        }
+        return this._loadEntrypoint(entrypointUrl);
+      }
+      return new Promise((resolve, _) => {
+        serviceWorker.addEventListener("statechange", () => {
+          if (serviceWorker.state == "activated") {
+            console.debug("Installed new service worker.");
+            resolve(this._loadEntrypoint(entrypointUrl));
+          }
+        });
+      });
+    }
+
+    _loadWithServiceWorker(entrypointUrl, serviceWorkerOptions) {
+      if (!("serviceWorker" in navigator) || serviceWorkerOptions == null) {
+        console.warn("Service worker not supported (or configured). Falling back to plain <script> tag.", serviceWorkerOptions);
+        return this._loadEntrypoint(entrypointUrl);
+      }
+
+      const {
+        serviceWorkerVersion,
+        timeoutMillis = 4000,
+      } = serviceWorkerOptions;
+
+      let serviceWorkerUrl = "flutter_service_worker.js?v=" + serviceWorkerVersion;
+      let loader = navigator.serviceWorker.register(serviceWorkerUrl)
+          .then((reg) => {
+            if (!reg.active && (reg.installing || reg.waiting)) {
+              // No active web worker and we have installed or are installing
+              // one for the first time. Simply wait for it to activate.
+              let sw = reg.installing || reg.waiting;
+              return this._waitForServiceWorkerActivation(sw, entrypointUrl);
+            } else if (!reg.active.scriptURL.endsWith(serviceWorkerVersion)) {
+              // When the app updates the serviceWorkerVersion changes, so we
+              // need to ask the service worker to update.
+              console.debug("New service worker available.");
+              return reg.update().then((reg) => {
+                console.debug("Service worker updated.");
+                let sw = reg.installing || reg.waiting || reg.active;
+                return this._waitForServiceWorkerActivation(sw, entrypointUrl);
+              });
+            } else {
+              // Existing service worker is still good.
+              console.debug("Loading app from service worker.");
+              return this._loadEntrypoint(entrypointUrl);
+            }
+          });
+
+      // Timeout race promise
+      let timeout;
+      if (timeoutMillis > 0) {
+        timeout = new Promise((resolve, _) => {
+          setTimeout(() => {
+            if (!this._scriptLoaded) {
+              console.warn("Failed to load app from service worker. Falling back to plain <script> tag.");
+              resolve(this._loadEntrypoint(entrypointUrl));
+            }
+          }, timeoutMillis);
+        });
+      }
+
+      return Promise.race([loader, timeout]);
+    }
+  }
+
+  _flutter.loader = new FlutterLoader();
+}());

flutter_service_worker.js

@@ -0,0 +1,207 @@
+'use strict';
+const MANIFEST = 'flutter-app-manifest';
+const TEMP = 'flutter-temp-cache';
+const CACHE_NAME = 'flutter-app-cache';
+const RESOURCES = {
+  "assets/AssetManifest.json": "fc0f9a7d7a77ece1ff3fdbda0a46a5bc",
+"assets/FontManifest.json": "dc3d03800ccca4601324923c0b1d6d57",
+"assets/fonts/MaterialIcons-Regular.otf": "95db9098c58fd6db106f1116bae85a0b",
+"assets/lib/assets/images/audioPlayer_icon.png": "7325e816e285933da4355e12ce3cddbd",
+"assets/lib/assets/images/currentTab_icon.png": "9f0b58076c56403fd0d17015741bbded",
+"assets/lib/assets/images/LiteUp_logo.png": "ac9999e12000d2431f916d0b58392440",
+"assets/lib/assets/images/lock_icon.png": "9ff6e7b525fb5a733628d1a83541a576",
+"assets/lib/assets/images/nextTab_icon.png": "8e65af977acb38fd3606afc776bbf0ce",
+"assets/lib/assets/images/recorder_icon.png": "0b24cbb2436c0c5eb1a5bbed72af6469",
+"assets/lib/assets/images/UserProfile.png": "9ee18ec0f0d5b483f6f770dfb318e727",
+"assets/NOTICES": "9118d1bbfd36fecdaf0c893697eb02f8",
+"assets/packages/cupertino_icons/assets/CupertinoIcons.ttf": "6d342eb68f170c97609e9da345464e5e",
+"assets/packages/flutter_sound_web/howler/howler.js": "2bba823e6b4d71ea019d81d384672823",
+"assets/packages/flutter_sound_web/src/flutter_sound.js": "aecd83c80bf4faace0bcea4cd47ab307",
+"assets/packages/flutter_sound_web/src/flutter_sound_player.js": "6bf84579813fd481ec5e24e73927500d",
+"assets/packages/flutter_sound_web/src/flutter_sound_recorder.js": "f7ac74c4e0fd5cd472d86c3fe93883fc",
+"canvaskit/canvaskit.js": "c2b4e5f3d7a3d82aed024e7249a78487",
+"canvaskit/canvaskit.wasm": "4b83d89d9fecbea8ca46f2f760c5a9ba",
+"canvaskit/profiling/canvaskit.js": "ae2949af4efc61d28a4a80fffa1db900",
+"canvaskit/profiling/canvaskit.wasm": "95e736ab31147d1b2c7b25f11d4c32cd",
+"favicon.png": "5dcef449791fa27946b3d35ad8803796",
+"flutter.js": "0816e65a103ba8ba51b174eeeeb2cb67",
+"icons/Icon-192.png": "ac9a721a12bbc803b44f645561ecb1e1",
+"icons/Icon-512.png": "96e752610906ba2a93c65f8abe1645f1",
+"icons/Icon-maskable-192.png": "c457ef57daa1d16f64b27b786ec2ea3c",
+"icons/Icon-maskable-512.png": "301a7604d45b3e739efc881eb04896ea",
+"index.html": "acab664d9d643b8dc952876603c0fa7b",
+"/": "acab664d9d643b8dc952876603c0fa7b",
+"main.dart.js": "5407c27c97c1b90758f0c819fd36de87",
+"manifest.json": "b6f879c0208ffc3c66a29dfabb6715d5",
+"version.json": "6df3ea57e197e18ec488046dc791ac83"
+};
+
+// The application shell files that are downloaded before a service worker can
+// start.
+const CORE = [
+  "main.dart.js",
+"index.html",
+"assets/NOTICES",
+"assets/AssetManifest.json",
+"assets/FontManifest.json"];
+// During install, the TEMP cache is populated with the application shell files.
+self.addEventListener("install", (event) => {
+  self.skipWaiting();
+  return event.waitUntil(
+    caches.open(TEMP).then((cache) => {
+      return cache.addAll(
+        CORE.map((value) => new Request(value, {'cache': 'reload'})));
+    })
+  );
+});
+
+// During activate, the cache is populated with the temp files downloaded in
+// install. If this service worker is upgrading from one with a saved
+// MANIFEST, then use this to retain unchanged resource files.
+self.addEventListener("activate", function(event) {
+  return event.waitUntil(async function() {
+    try {
+      var contentCache = await caches.open(CACHE_NAME);
+      var tempCache = await caches.open(TEMP);
+      var manifestCache = await caches.open(MANIFEST);
+      var manifest = await manifestCache.match('manifest');
+      // When there is no prior manifest, clear the entire cache.
+      if (!manifest) {
+        await caches.delete(CACHE_NAME);
+        contentCache = await caches.open(CACHE_NAME);
+        for (var request of await tempCache.keys()) {
+          var response = await tempCache.match(request);
+          await contentCache.put(request, response);
+        }
+        await caches.delete(TEMP);
+        // Save the manifest to make future upgrades efficient.
+        await manifestCache.put('manifest', new Response(JSON.stringify(RESOURCES)));
+        return;
+      }
+      var oldManifest = await manifest.json();
+      var origin = self.location.origin;
+      for (var request of await contentCache.keys()) {
+        var key = request.url.substring(origin.length + 1);
+        if (key == "") {
+          key = "/";
+        }
+        // If a resource from the old manifest is not in the new cache, or if
+        // the MD5 sum has changed, delete it. Otherwise the resource is left
+        // in the cache and can be reused by the new service worker.
+        if (!RESOURCES[key] || RESOURCES[key] != oldManifest[key]) {
+          await contentCache.delete(request);
+        }
+      }
+      // Populate the cache with the app shell TEMP files, potentially overwriting
+      // cache files preserved above.
+      for (var request of await tempCache.keys()) {
+        var response = await tempCache.match(request);
+        await contentCache.put(request, response);
+      }
+      await caches.delete(TEMP);
+      // Save the manifest to make future upgrades efficient.
+      await manifestCache.put('manifest', new Response(JSON.stringify(RESOURCES)));
+      return;
+    } catch (err) {
+      // On an unhandled exception the state of the cache cannot be guaranteed.
+      console.error('Failed to upgrade service worker: ' + err);
+      await caches.delete(CACHE_NAME);
+      await caches.delete(TEMP);
+      await caches.delete(MANIFEST);
+    }
+  }());
+});
+
+// The fetch handler redirects requests for RESOURCE files to the service
+// worker cache.
+self.addEventListener("fetch", (event) => {
+  if (event.request.method !== 'GET') {
+    return;
+  }
+  var origin = self.location.origin;
+  var key = event.request.url.substring(origin.length + 1);
+  // Redirect URLs to the index.html
+  if (key.indexOf('?v=') != -1) {
+    key = key.split('?v=')[0];
+  }
+  if (event.request.url == origin || event.request.url.startsWith(origin + '/#') || key == '') {
+    key = '/';
+  }
+  // If the URL is not the RESOURCE list then return to signal that the
+  // browser should take over.
+  if (!RESOURCES[key]) {
+    return;
+  }
+  // If the URL is the index.html, perform an online-first request.
+  if (key == '/') {
+    return onlineFirst(event);
+  }
+  event.respondWith(caches.open(CACHE_NAME)
+    .then((cache) =>  {
+      return cache.match(event.request).then((response) => {
+        // Either respond with the cached resource, or perform a fetch and
+        // lazily populate the cache.
+        return response || fetch(event.request).then((response) => {
+          cache.put(event.request, response.clone());
+          return response;
+        });
+      })
+    })
+  );
+});
+
+self.addEventListener('message', (event) => {
+  // SkipWaiting can be used to immediately activate a waiting service worker.
+  // This will also require a page refresh triggered by the main worker.
+  if (event.data === 'skipWaiting') {
+    self.skipWaiting();
+    return;
+  }
+  if (event.data === 'downloadOffline') {
+    downloadOffline();
+    return;
+  }
+});
+
+// Download offline will check the RESOURCES for all files not in the cache
+// and populate them.
+async function downloadOffline() {
+  var resources = [];
+  var contentCache = await caches.open(CACHE_NAME);
+  var currentContent = {};
+  for (var request of await contentCache.keys()) {
+    var key = request.url.substring(origin.length + 1);
+    if (key == "") {
+      key = "/";
+    }
+    currentContent[key] = true;
+  }
+  for (var resourceKey of Object.keys(RESOURCES)) {
+    if (!currentContent[resourceKey]) {
+      resources.push(resourceKey);
+    }
+  }
+  return contentCache.addAll(resources);
+}
+
+// Attempt to download the resource online before falling back to
+// the offline cache.
+function onlineFirst(event) {
+  return event.respondWith(
+    fetch(event.request).then((response) => {
+      return caches.open(CACHE_NAME).then((cache) => {
+        cache.put(event.request, response.clone());
+        return response;
+      });
+    }).catch((error) => {
+      return caches.open(CACHE_NAME).then((cache) => {
+        return cache.match(event.request).then((response) => {
+          if (response != null) {
+            return response;
+          }
+          throw error;
+        });
+      });
+    })
+  );
+}