FM / pos

/var/www/qr4y.gr/www/pos

Name	Size	Mode	Actions
.git/	-	0755	rm
assets/	-	0755	rm
canvaskit/	-	0755	rm
dl/	-	0755	rm
icons/	-	0755	rm
.last_build_id	32	0644	edit dl rm
favicon.png	16691	0644	edit dl rm
flutter.js	6458	0644	edit dl rm
flutter_service_worker.js	46157	0644	edit dl rm
index.html	1476	0644	edit dl rm
main.dart.js	4560937	0644	edit dl rm
manifest.json	565	0644	edit dl rm
README.md	0	0644	edit dl rm
version.json	67	0644	edit dl rm

Edit: /var/www/qr4y.gr/www/pos/flutter.js (6458B)

// 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 {
    /**
     * Creates a FlutterLoader, and initializes its instance methods.
     */
    constructor() {
      // 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.
      this._scriptLoaded = null;

// Resolver for the pending promise returned by loadEntrypoint.
      this._didCreateEngineInitializerResolve = null;

// Called by Flutter web.
      // Bound to `this` now, so "this" is preserved across JS <-> Flutter jumps.
      this.didCreateEngineInitializer = this._didCreateEngineInitializer.bind(this);
    }

/**
     * 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 through the public `didCreateEngineInitializer` method,
     * which is bound to the correct instance of the FlutterLoader on the page.
     * @param {*} engineInitializer
     */
    _didCreateEngineInitializer(engineInitializer) {
      if (typeof this._didCreateEngineInitializerResolve != "function") {
        console.warn("Do not call didCreateEngineInitializer by hand. Start with loadEntrypoint instead.");
      }
      this._didCreateEngineInitializerResolve(engineInitializer);
      // Remove the public method after it's done, so Flutter Web can hot restart.
      delete this.didCreateEngineInitializer;
    }

_loadEntrypoint(entrypointUrl) {
      if (!this._scriptLoaded) {
        console.debug("Injecting <script> tag.");
        this._scriptLoaded = new Promise((resolve, reject) => {
          let scriptTag = document.createElement("script");
          scriptTag.src = entrypointUrl;
          scriptTag.type = "application/javascript";
          // Cache the resolve, so it can be called from Flutter.
          // Note: Flutter hot restart doesn't re-create this promise, so this
          // can only be called once. Instead, we need to model this as a stream
          // of `engineCreated` events coming from Flutter that are handled by JS.
          this._didCreateEngineInitializerResolve = resolve;
          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.");
        } 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).", serviceWorkerOptions);
        return this._loadEntrypoint(entrypointUrl);
      }

const {
        serviceWorkerVersion,
        timeoutMillis = 4000,
      } = serviceWorkerOptions;

// Timeout race promise
      let timeout;
      if (timeoutMillis > 0) {
        timeout = new Promise((resolve, _) => {
          setTimeout(() => {
            if (!this._scriptLoaded) {
              console.warn("Loading from service worker timed out after", timeoutMillis, "milliseconds.");
              resolve(this._loadEntrypoint(entrypointUrl));
            }
          }, timeoutMillis);
        });
      }

return Promise.race([loader, timeout]);
    }
  }

_flutter.loader = new FlutterLoader();
}());

// 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 { /** * Creates a FlutterLoader, and initializes its instance methods. */ constructor() { // 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. this._scriptLoaded = null; // Resolver for the pending promise returned by loadEntrypoint. this._didCreateEngineInitializerResolve = null; // Called by Flutter web. // Bound to `this` now, so "this" is preserved across JS <-> Flutter jumps. this.didCreateEngineInitializer = this._didCreateEngineInitializer.bind(this); } /** * 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 through the public `didCreateEngineInitializer` method, * which is bound to the correct instance of the FlutterLoader on the page. * @param {*} engineInitializer */ _didCreateEngineInitializer(engineInitializer) { if (typeof this._didCreateEngineInitializerResolve != "function") { console.warn("Do not call didCreateEngineInitializer by hand. Start with loadEntrypoint instead."); } this._didCreateEngineInitializerResolve(engineInitializer); // Remove the public method after it's done, so Flutter Web can hot restart. delete this.didCreateEngineInitializer; } _loadEntrypoint(entrypointUrl) { if (!this._scriptLoaded) { console.debug("Injecting