First Committ

public/js/fetch.js

@@ -0,0 +1,457 @@
+(function (self) {
+  if (self.fetch) {
+    return
+  }
+
+  const support = {
+    searchParams: 'URLSearchParams' in self,
+    iterable: 'Symbol' in self && 'iterator' in Symbol,
+    blob: 'FileReader' in self && 'Blob' in self && (function () {
+      try {
+        new Blob()
+        return true
+      } catch (e) {
+        return false
+      }
+    }()),
+    formData: 'FormData' in self,
+    arrayBuffer: 'ArrayBuffer' in self,
+  }
+
+  if (support.arrayBuffer) {
+    const viewClasses = [
+      '[object Int8Array]',
+      '[object Uint8Array]',
+      '[object Uint8ClampedArray]',
+      '[object Int16Array]',
+      '[object Uint16Array]',
+      '[object Int32Array]',
+      '[object Uint32Array]',
+      '[object Float32Array]',
+      '[object Float64Array]',
+    ]
+
+    var isDataView = function (obj) {
+      return obj && DataView.prototype.isPrototypeOf(obj)
+    }
+
+    var isArrayBufferView = ArrayBuffer.isView || function (obj) {
+      return obj && viewClasses.indexOf(Object.prototype.toString.call(obj)) > -1
+    }
+  }
+
+  function normalizeName(name) {
+    if (typeof name !== 'string') {
+      name = String(name)
+    }
+    if (/[^a-z0-9\-#$%&'*+.\^_`|~]/i.test(name)) {
+      throw new TypeError('Invalid character in header field nametranslate')
+    }
+    return name.toLowerCase()
+  }
+
+  function normalizeValue(value) {
+    if (typeof value !== 'string') {
+      value = String(value)
+    }
+    return value
+  }
+
+  // Build a destructive iterator for the value list
+  function iteratorFor(items) {
+    const iterator = {
+      next() {
+        const value = items.shift()
+        return { done: value === undefined, value }
+      },
+    }
+
+    if (support.iterable) {
+      iterator[Symbol.iterator] = function () {
+        return iterator
+      }
+    }
+
+    return iterator
+  }
+
+  function Headers(headers) {
+    this.map = {}
+
+    if (headers instanceof Headers) {
+      headers.forEach(function (value, name) {
+        this.append(name, value)
+      }, this)
+    } else if (Array.isArray(headers)) {
+      headers.forEach(function (header) {
+        this.append(header[0], header[1])
+      }, this)
+    } else if (headers) {
+      Object.getOwnPropertyNames(headers).forEach(function (name) {
+        this.append(name, headers[name])
+      }, this)
+    }
+  }
+
+  Headers.prototype.append = function (name, value) {
+    name = normalizeName(name)
+    value = normalizeValue(value)
+    const oldValue = this.map[name]
+    this.map[name] = oldValue ? `${oldValue},${value}` : value
+  }
+
+  Headers.prototype.delete = function (name) {
+    delete this.map[normalizeName(name)]
+  }
+
+  Headers.prototype.get = function (name) {
+    name = normalizeName(name)
+    return this.has(name) ? this.map[name] : null
+  }
+
+  Headers.prototype.has = function (name) {
+    return this.map.hasOwnProperty(normalizeName(name))
+  }
+
+  Headers.prototype.set = function (name, value) {
+    this.map[normalizeName(name)] = normalizeValue(value)
+  }
+
+  Headers.prototype.forEach = function (callback, thisArg) {
+    for (const name in this.map) {
+      if (this.map.hasOwnProperty(name)) {
+        callback.call(thisArg, this.map[name], name, this)
+      }
+    }
+  }
+
+  Headers.prototype.keys = function () {
+    const items = []
+    this.forEach((value, name) => { items.push(name) })
+    return iteratorFor(items)
+  }
+
+  Headers.prototype.values = function () {
+    const items = []
+    this.forEach((value) => { items.push(value) })
+    return iteratorFor(items)
+  }
+
+  Headers.prototype.entries = function () {
+    const items = []
+    this.forEach((value, name) => { items.push([name, value]) })
+    return iteratorFor(items)
+  }
+
+  if (support.iterable) {
+    Headers.prototype[Symbol.iterator] = Headers.prototype.entries
+  }
+
+  function consumed(body) {
+    if (body.bodyUsed) {
+      return Promise.reject(new TypeError('Already read'))
+    }
+    body.bodyUsed = true
+  }
+
+  function fileReaderReady(reader) {
+    return new Promise((resolve, reject) => {
+      reader.onload = function () {
+        resolve(reader.result)
+      }
+      reader.onerror = function () {
+        reject(reader.error)
+      }
+    })
+  }
+
+  function readBlobAsArrayBuffer(blob) {
+    const reader = new FileReader()
+    const promise = fileReaderReady(reader)
+    reader.readAsArrayBuffer(blob)
+    return promise
+  }
+
+  function readBlobAsText(blob) {
+    const reader = new FileReader()
+    const promise = fileReaderReady(reader)
+    reader.readAsText(blob)
+    return promise
+  }
+
+  function readArrayBufferAsText(buf) {
+    const view = new Uint8Array(buf)
+    const chars = new Array(view.length)
+
+    for (let i = 0; i < view.length; i++) {
+      chars[i] = String.fromCharCode(view[i])
+    }
+    return chars.join('')
+  }
+
+  function bufferClone(buf) {
+    if (buf.slice) {
+      return buf.slice(0)
+    }
+    const view = new Uint8Array(buf.byteLength)
+    view.set(new Uint8Array(buf))
+    return view.buffer
+  }
+
+  function Body() {
+    this.bodyUsed = false
+
+    this._initBody = function (body) {
+      this._bodyInit = body
+      if (!body) {
+        this._bodyText = ''
+      } else if (typeof body === 'string') {
+        this._bodyText = body
+      } else if (support.blob && Blob.prototype.isPrototypeOf(body)) {
+        this._bodyBlob = body
+      } else if (support.formData && FormData.prototype.isPrototypeOf(body)) {
+        this._bodyFormData = body
+      } else if (support.searchParams && URLSearchParams.prototype.isPrototypeOf(body)) {
+        this._bodyText = body.toString()
+      } else if (support.arrayBuffer && support.blob && isDataView(body)) {
+        this._bodyArrayBuffer = bufferClone(body.buffer)
+        // IE 10-11 can't handle a DataView body.
+        this._bodyInit = new Blob([this._bodyArrayBuffer])
+      } else if (support.arrayBuffer && (ArrayBuffer.prototype.isPrototypeOf(body) || isArrayBufferView(body))) {
+        this._bodyArrayBuffer = bufferClone(body)
+      } else {
+        throw new Error('unsupported BodyInit type')
+      }
+
+      if (!this.headers.get('content-type')) {
+        if (typeof body === 'string') {
+          this.headers.set('content-type', 'text/plain;charset=UTF-8')
+        } else if (this._bodyBlob && this._bodyBlob.type) {
+          this.headers.set('content-type', this._bodyBlob.type)
+        } else if (support.searchParams && URLSearchParams.prototype.isPrototypeOf(body)) {
+          this.headers.set('content-type', 'application/x-www-form-urlencoded;charset=UTF-8')
+        }
+      }
+    }
+
+    if (support.blob) {
+      this.blob = function () {
+        const rejected = consumed(this)
+        if (rejected) {
+          return rejected
+        }
+
+        if (this._bodyBlob) {
+          return Promise.resolve(this._bodyBlob)
+        } if (this._bodyArrayBuffer) {
+          return Promise.resolve(new Blob([this._bodyArrayBuffer]))
+        } if (this._bodyFormData) {
+          throw new Error('could not read FormData body as blob')
+        } else {
+          return Promise.resolve(new Blob([this._bodyText]))
+        }
+      }
+
+      this.arrayBuffer = function () {
+        if (this._bodyArrayBuffer) {
+          return consumed(this) || Promise.resolve(this._bodyArrayBuffer)
+        }
+        return this.blob().then(readBlobAsArrayBuffer)
+      }
+    }
+
+    this.text = function () {
+      const rejected = consumed(this)
+      if (rejected) {
+        return rejected
+      }
+
+      if (this._bodyBlob) {
+        return readBlobAsText(this._bodyBlob)
+      } if (this._bodyArrayBuffer) {
+        return Promise.resolve(readArrayBufferAsText(this._bodyArrayBuffer))
+      } if (this._bodyFormData) {
+        throw new Error('could not read FormData body as text')
+      } else {
+        return Promise.resolve(this._bodyText)
+      }
+    }
+
+    if (support.formData) {
+      this.formData = function () {
+        return this.text().then(decode)
+      }
+    }
+
+    this.json = function () {
+      return this.text().then(JSON.parse)
+    }
+
+    return this
+  }
+
+  // HTTP methods whose capitalization should be normalized
+  const methods = ['DELETE', 'GET', 'HEAD', 'OPTIONS', 'POST', 'PUT']
+
+  function normalizeMethod(method) {
+    const upcased = method.toUpperCase()
+    return (methods.indexOf(upcased) > -1) ? upcased : method
+  }
+
+  function Request(input, options) {
+    options = options || {}
+    let { body } = options
+
+    if (input instanceof Request) {
+      if (input.bodyUsed) {
+        throw new TypeError('Already read')
+      }
+      this.url = input.url
+      this.credentials = input.credentials
+      if (!options.headers) {
+        this.headers = new Headers(input.headers)
+      }
+      this.method = input.method
+      this.mode = input.mode
+      if (!body && input._bodyInit != null) {
+        body = input._bodyInit
+        input.bodyUsed = true
+      }
+    } else {
+      this.url = String(input)
+    }
+
+    this.credentials = options.credentials || this.credentials || 'omit'
+    if (options.headers || !this.headers) {
+      this.headers = new Headers(options.headers)
+    }
+    this.method = normalizeMethod(options.method || this.method || 'GET')
+    this.mode = options.mode || this.mode || null
+    this.referrer = null
+
+    if ((this.method === 'GET' || this.method === 'HEAD') && body) {
+      throw new TypeError('Body not allowed for GET or HEAD requests')
+    }
+    this._initBody(body)
+  }
+
+  Request.prototype.clone = function () {
+    return new Request(this, { body: this._bodyInit })
+  }
+
+  function decode(body) {
+    const form = new FormData()
+    body.trim().split('&').forEach((bytes) => {
+      if (bytes) {
+        const split = bytes.split('=')
+        const name = split.shift().replace(/\+/g, ' ')
+        const value = split.join('=').replace(/\+/g, ' ')
+        form.append(decodeURIComponent(name), decodeURIComponent(value))
+      }
+    })
+    return form
+  }
+
+  function parseHeaders(rawHeaders) {
+    const headers = new Headers()
+    rawHeaders.split(/\r?\n/).forEach((line) => {
+      const parts = line.split(':')
+      const key = parts.shift().trim()
+      if (key) {
+        const value = parts.join(':').trim()
+        headers.append(key, value)
+      }
+    })
+    return headers
+  }
+
+  Body.call(Request.prototype)
+
+  function Response(bodyInit, options) {
+    if (!options) {
+      options = {}
+    }
+
+    this.type = 'default'
+    this.status = 'status' in options ? options.status : 200
+    this.ok = this.status >= 200 && this.status < 300
+    this.statusText = 'statusText' in options ? options.statusText : 'OK'
+    this.headers = new Headers(options.headers)
+    this.url = options.url || ''
+    this._initBody(bodyInit)
+  }
+
+  Body.call(Response.prototype)
+
+  Response.prototype.clone = function () {
+    return new Response(this._bodyInit, {
+      status: this.status,
+      statusText: this.statusText,
+      headers: new Headers(this.headers),
+      url: this.url,
+    })
+  }
+
+  Response.error = function () {
+    const response = new Response(null, { status: 0, statusText: '' })
+    response.type = 'error'
+    return response
+  }
+
+  const redirectStatuses = [301, 302, 303, 307, 308]
+
+  Response.redirect = function (url, status) {
+    if (redirectStatuses.indexOf(status) === -1) {
+      throw new RangeError('Invalid status code')
+    }
+
+    return new Response(null, { status, headers: { location: url } })
+  }
+
+  self.Headers = Headers
+  self.Request = Request
+  self.Response = Response
+
+  self.fetch = function (input, init) {
+    return new Promise((resolve, reject) => {
+      const request = new Request(input, init)
+      const xhr = new XMLHttpRequest()
+
+      xhr.onload = function () {
+        const options = {
+          status: xhr.status,
+          statusText: xhr.statusText,
+          headers: parseHeaders(xhr.getAllResponseHeaders() || ''),
+        }
+        options.url = 'responseURL' in xhr ? xhr.responseURL : options.headers.get('X-Request-URL')
+        const body = 'response' in xhr ? xhr.response : xhr.responseText
+        resolve(new Response(body, options))
+      }
+
+      xhr.onerror = function () {
+        reject(new TypeError('Network request failed'))
+      }
+
+      xhr.ontimeout = function () {
+        reject(new TypeError('Network request failed'))
+      }
+
+      xhr.open(request.method, request.url, true)
+
+      if (request.credentials === 'include') {
+        xhr.withCredentials = true
+      }
+
+      if ('responseType' in xhr && support.blob) {
+        xhr.responseType = 'blob'
+      }
+
+      request.headers.forEach((value, name) => {
+        xhr.setRequestHeader(name, value)
+      })
+
+      xhr.send(typeof request._bodyInit === 'undefined' ? null : request._bodyInit)
+    })
+  }
+  self.fetch.polyfill = true
+}(typeof self !== 'undefined' ? self : this));

public/js/globalenv.js

@@ -0,0 +1,25 @@
+// importScripts('/public/js/immortal-db.min.js');
+
+/*
+const cfgenv = {
+  website: 'http://localhost:8081',
+  serverweb: 'http://localhost:3000',
+  dbname: 'mydb3',
+  dbversion: 10,
+}
+*/
+
+/*
+async function clearAllDataImmortal(table) {
+  console.log('clearAllDataImmortal', table)
+  const db = ImmortalDB.ImmortalDB
+  await db.remove(table)
+}
+
+async function writeDataImmortal(table, datavalue) {
+  console.log('writeDataImmortal', table, datavalue)
+  const db = ImmortalDB.ImmortalDB
+  await db.set(table, datavalue)
+}
+
+*/

public/js/idb.js

@@ -0,0 +1,306 @@
+(function () {
+  function toArray(arr) {
+    return Array.prototype.slice.call(arr);
+  }
+
+  function promisifyRequest(request) {
+    return new Promise((resolve, reject) => {
+      request.onsuccess = function () {
+        resolve(request.result);
+      };
+
+      request.onerror = function () {
+        reject(request.error);
+      };
+    });
+  }
+
+  function promisifyRequestCall(obj, method, args) {
+    let request;
+    const p = new Promise((resolve, reject) => {
+      request = obj[method].apply(obj, args);
+      promisifyRequest(request).then(resolve, reject);
+    });
+
+    p.request = request;
+    return p;
+  }
+
+  function promisifyCursorRequestCall(obj, method, args) {
+    const p = promisifyRequestCall(obj, method, args);
+    return p.then((value) => {
+      if (!value) return;
+      return new Cursor(value, p.request);
+    });
+  }
+
+  function proxyProperties(ProxyClass, targetProp, properties) {
+    properties.forEach((prop) => {
+      Object.defineProperty(ProxyClass.prototype, prop, {
+        get() {
+          return this[targetProp][prop];
+        },
+        set(val) {
+          this[targetProp][prop] = val;
+        },
+      });
+    });
+  }
+
+  function proxyRequestMethods(ProxyClass, targetProp, Constructor, properties) {
+    properties.forEach((prop) => {
+      if (!(prop in Constructor.prototype)) return;
+      ProxyClass.prototype[prop] = function () {
+        return promisifyRequestCall(this[targetProp], prop, arguments);
+      };
+    });
+  }
+
+  function proxyMethods(ProxyClass, targetProp, Constructor, properties) {
+    properties.forEach((prop) => {
+      if (!(prop in Constructor.prototype)) return;
+      ProxyClass.prototype[prop] = function () {
+        return this[targetProp][prop].apply(this[targetProp], arguments);
+      };
+    });
+  }
+
+  function proxyCursorRequestMethods(ProxyClass, targetProp, Constructor, properties) {
+    properties.forEach((prop) => {
+      if (!(prop in Constructor.prototype)) return;
+      ProxyClass.prototype[prop] = function () {
+        return promisifyCursorRequestCall(this[targetProp], prop, arguments);
+      };
+    });
+  }
+
+  function Index(index) {
+    this._index = index;
+  }
+
+  proxyProperties(Index, '_index', [
+    'name',
+    'keyPath',
+    'multiEntry',
+    'unique',
+  ]);
+
+  proxyRequestMethods(Index, '_index', IDBIndex, [
+    'get',
+    'getKey',
+    'getAll',
+    'getAllKeys',
+    'count',
+  ]);
+
+  proxyCursorRequestMethods(Index, '_index', IDBIndex, [
+    'openCursor',
+    'openKeyCursor',
+  ]);
+
+  function Cursor(cursor, request) {
+    this._cursor = cursor;
+    this._request = request;
+  }
+
+  proxyProperties(Cursor, '_cursor', [
+    'direction',
+    'key',
+    'primaryKey',
+    'value',
+  ]);
+
+  proxyRequestMethods(Cursor, '_cursor', IDBCursor, [
+    'update',
+    'delete',
+  ]);
+
+  // proxy 'next' methods
+  ['advance', 'continue', 'continuePrimaryKey'].forEach((methodName) => {
+    if (!(methodName in IDBCursor.prototype)) return;
+    Cursor.prototype[methodName] = function () {
+      const cursor = this;
+      const args = arguments;
+      return Promise.resolve().then(() => {
+        cursor._cursor[methodName].apply(cursor._cursor, args);
+        return promisifyRequest(cursor._request).then((value) => {
+          if (!value) return;
+          return new Cursor(value, cursor._request);
+        });
+      });
+    };
+  });
+
+  function ObjectStore(store) {
+    this._store = store;
+  }
+
+  ObjectStore.prototype.createIndex = function () {
+    return new Index(this._store.createIndex.apply(this._store, arguments));
+  };
+
+  ObjectStore.prototype.index = function () {
+    return new Index(this._store.index.apply(this._store, arguments));
+  };
+
+  proxyProperties(ObjectStore, '_store', [
+    'name',
+    'keyPath',
+    'indexNames',
+    'autoIncrement',
+  ]);
+
+  proxyRequestMethods(ObjectStore, '_store', IDBObjectStore, [
+    'put',
+    'add',
+    'delete',
+    'clear',
+    'get',
+    'getAll',
+    'getKey',
+    'getAllKeys',
+    'count',
+  ]);
+
+  proxyCursorRequestMethods(ObjectStore, '_store', IDBObjectStore, [
+    'openCursor',
+    'openKeyCursor',
+  ]);
+
+  proxyMethods(ObjectStore, '_store', IDBObjectStore, [
+    'deleteIndex',
+  ]);
+
+  function Transaction(idbTransaction) {
+    this._tx = idbTransaction;
+    this.complete = new Promise((resolve, reject) => {
+      idbTransaction.oncomplete = function () {
+        resolve();
+      };
+      idbTransaction.onerror = function () {
+        reject(idbTransaction.error);
+      };
+      idbTransaction.onabort = function () {
+        reject(idbTransaction.error);
+      };
+    });
+  }
+
+  Transaction.prototype.objectStore = function () {
+    return new ObjectStore(this._tx.objectStore.apply(this._tx, arguments));
+  };
+
+  proxyProperties(Transaction, '_tx', [
+    'objectStoreNames',
+    'mode',
+  ]);
+
+  proxyMethods(Transaction, '_tx', IDBTransaction, [
+    'abort',
+  ]);
+
+  function UpgradeDB(db, oldVersion, transaction) {
+    this._db = db;
+    this.oldVersion = oldVersion;
+    this.transaction = new Transaction(transaction);
+  }
+
+  UpgradeDB.prototype.createObjectStore = function () {
+    return new ObjectStore(this._db.createObjectStore.apply(this._db, arguments));
+  };
+
+  proxyProperties(UpgradeDB, '_db', [
+    'name',
+    'version',
+    'objectStoreNames',
+  ]);
+
+  proxyMethods(UpgradeDB, '_db', IDBDatabase, [
+    'deleteObjectStore',
+    'close',
+  ]);
+
+  function DB(db) {
+    this._db = db;
+  }
+
+  DB.prototype.transaction = function () {
+    return new Transaction(this._db.transaction.apply(this._db, arguments));
+  };
+
+  proxyProperties(DB, '_db', [
+    'name',
+    'version',
+    'objectStoreNames',
+  ]);
+
+  proxyMethods(DB, '_db', IDBDatabase, [
+    'close',
+  ]);
+
+  // Add cursor iterators
+  // TODO: remove this once browsers do the right thing with promises
+  ['openCursor', 'openKeyCursor'].forEach((funcName) => {
+    [ObjectStore, Index].forEach((Constructor) => {
+      Constructor.prototype[funcName.replace('open', 'iterate')] = function () {
+        const args = toArray(arguments);
+        const callback = args[args.length - 1];
+        const nativeObject = this._store || this._index;
+        const request = nativeObject[funcName].apply(nativeObject, args.slice(0, -1));
+        request.onsuccess = function () {
+          callback(request.result);
+        };
+      };
+    });
+  });
+
+  // polyfill getAll
+  [Index, ObjectStore].forEach((Constructor) => {
+    if (Constructor.prototype.getAll) return;
+    Constructor.prototype.getAll = function (query, count) {
+      const instance = this;
+      const items = [];
+
+      return new Promise((resolve) => {
+        instance.iterateCursor(query, (cursor) => {
+          if (!cursor) {
+            resolve(items);
+            return;
+          }
+          items.push(cursor.value);
+
+          if (!!count && items.length == count) {
+            resolve(items);
+            return;
+          }
+          cursor.continue();
+        });
+      });
+    };
+  });
+
+  const exp = {
+    open(name, version, upgradeCallback) {
+      const p = promisifyRequestCall(indexedDB, 'open', [name, version]);
+      const { request } = p;
+
+      request.onupgradeneeded = function (event) {
+        if (upgradeCallback) {
+          upgradeCallback(new UpgradeDB(request.result, event.oldVersion, request.transaction));
+        }
+      };
+
+      return p.then((db) => new DB(db));
+    },
+    delete(name) {
+      return promisifyRequestCall(indexedDB, 'deleteDatabase', [name]);
+    },
+  };
+
+  if (typeof module !== 'undefined') {
+    module.exports = exp;
+    module.exports.default = module.exports;
+  } else {
+    self.idb = exp;
+  }
+}());

public/js/promise.js

@@ -0,0 +1,368 @@
+/**
+ * setImmediate polyfill v1.0.1, supports IE9+
+ * © 2014–2015 Dmitry Korobkin
+ * Released under the MIT license
+ * github.com/Octane/setImmediate
+ */
+window.setImmediate || (function () {
+  let uid = 0;
+  const storage = {};
+  let firstCall = true;
+  const { slice } = Array.prototype;
+  const message = 'setImmediatePolyfillMessage';
+
+  function fastApply(args) {
+    const func = args[0];
+    switch (args.length) {
+      case 1:
+        return func();
+      case 2:
+        return func(args[1]);
+      case 3:
+        return func(args[1], args[2]);
+    }
+    return func.apply(window, slice.call(args, 1));
+  }
+
+  function callback(event) {
+    const key = event.data;
+    let data;
+    if (typeof key === 'string' && key.indexOf(message) == 0) {
+      data = storage[key];
+      if (data) {
+        delete storage[key];
+        fastApply(data);
+      }
+    }
+  }
+
+  window.setImmediate = function setImmediate() {
+    const id = uid++;
+    const key = message + id;
+    let i = arguments.length;
+    const args = new Array(i);
+    while (i--) {
+      args[i] = arguments[i];
+    }
+    storage[key] = args;
+    if (firstCall) {
+      firstCall = false;
+      window.addEventListener('message', callback);
+    }
+    window.postMessage(key, '*');
+    return id;
+  };
+
+  window.clearImmediate = function clearImmediate(id) {
+    delete storage[message + id];
+  };
+}());
+
+/**
+ * Promise polyfill v1.0.10
+ * requires setImmediate
+ *
+ * © 2014–2015 Dmitry Korobkin
+ * Released under the MIT license
+ * github.com/Octane/Promise
+ */
+(function (global) {
+  const STATUS = '[[PromiseStatus]]';
+  const VALUE = '[[PromiseValue]]';
+  const ON_FUlFILLED = '[[OnFulfilled]]';
+  const ON_REJECTED = '[[OnRejected]]';
+  const ORIGINAL_ERROR = '[[OriginalError]]';
+  const PENDING = 'pending';
+  const INTERNAL_PENDING = 'internal pending';
+  const FULFILLED = 'fulfilled';
+  const REJECTED = 'rejected';
+  const NOT_ARRAY = 'not an array.';
+  const REQUIRES_NEW = 'constructor Promise requires "new".';
+  const CHAINING_CYCLE = 'then() cannot return same Promise that it resolves.';
+
+  const setImmediate = global.setImmediate || require('timers').setImmediate;
+  const isArray = Array.isArray || function (anything) {
+    return Object.prototype.toString.call(anything) == '[object Array]';
+  };
+
+  function InternalError(originalError) {
+    this[ORIGINAL_ERROR] = originalError;
+  }
+
+  function isInternalError(anything) {
+    return anything instanceof InternalError;
+  }
+
+  function isObject(anything) {
+    // Object.create(null) instanceof Object → false
+    return Object(anything) === anything;
+  }
+
+  function isCallable(anything) {
+    return typeof anything === 'function';
+  }
+
+  function isPromise(anything) {
+    return anything instanceof Promise;
+  }
+
+  function identity(value) {
+    return value;
+  }
+
+  function thrower(reason) {
+    throw reason;
+  }
+
+  function enqueue(promise, onFulfilled, onRejected) {
+    if (!promise[ON_FUlFILLED]) {
+      promise[ON_FUlFILLED] = [];
+      promise[ON_REJECTED] = [];
+    }
+    promise[ON_FUlFILLED].push(onFulfilled);
+    promise[ON_REJECTED].push(onRejected);
+  }
+
+  function clearAllQueues(promise) {
+    delete promise[ON_FUlFILLED];
+    delete promise[ON_REJECTED];
+  }
+
+  function callEach(queue) {
+    let i;
+    const { length } = queue;
+    for (i = 0; i < length; i++) {
+      queue[i]();
+    }
+  }
+
+  function call(resolve, reject, value) {
+    const anything = toPromise(value);
+    if (isPromise(anything)) {
+      anything.then(resolve, reject);
+    } else if (isInternalError(anything)) {
+      reject(anything[ORIGINAL_ERROR]);
+    } else {
+      resolve(value);
+    }
+  }
+
+  function toPromise(anything) {
+    let then;
+    if (isPromise(anything)) {
+      return anything;
+    }
+    if (isObject(anything)) {
+      try {
+        then = anything.then;
+      } catch (error) {
+        return new InternalError(error);
+      }
+      if (isCallable(then)) {
+        return new Promise((resolve, reject) => {
+          setImmediate(() => {
+            try {
+              then.call(anything, resolve, reject);
+            } catch (error) {
+              reject(error);
+            }
+          });
+        });
+      }
+    }
+    return null;
+  }
+
+  function resolvePromise(promise, resolver) {
+    function resolve(value) {
+      if (promise[STATUS] == PENDING) {
+        fulfillPromise(promise, value);
+      }
+    }
+    function reject(reason) {
+      if (promise[STATUS] == PENDING) {
+        rejectPromise(promise, reason);
+      }
+    }
+    try {
+      resolver(resolve, reject);
+    } catch (error) {
+      reject(error);
+    }
+  }
+
+  function fulfillPromise(promise, value) {
+    let queue;
+    const anything = toPromise(value);
+    if (isPromise(anything)) {
+      promise[STATUS] = INTERNAL_PENDING;
+      anything.then(
+        (value) => {
+          fulfillPromise(promise, value);
+        },
+        (reason) => {
+          rejectPromise(promise, reason);
+        },
+      );
+    } else if (isInternalError(anything)) {
+      rejectPromise(promise, anything[ORIGINAL_ERROR]);
+    } else {
+      promise[STATUS] = FULFILLED;
+      promise[VALUE] = value;
+      queue = promise[ON_FUlFILLED];
+      if (queue && queue.length) {
+        clearAllQueues(promise);
+        callEach(queue);
+      }
+    }
+  }
+
+  function rejectPromise(promise, reason) {
+    const queue = promise[ON_REJECTED];
+    promise[STATUS] = REJECTED;
+    promise[VALUE] = reason;
+    if (queue && queue.length) {
+      clearAllQueues(promise);
+      callEach(queue);
+    }
+  }
+
+  function Promise(resolver) {
+    const promise = this;
+    if (!isPromise(promise)) {
+      throw new TypeError(REQUIRES_NEW);
+    }
+    promise[STATUS] = PENDING;
+    promise[VALUE] = undefined;
+    resolvePromise(promise, resolver);
+  }
+
+  Promise.prototype.then = function (onFulfilled, onRejected) {
+    const promise = this;
+    let nextPromise;
+    onFulfilled = isCallable(onFulfilled) ? onFulfilled : identity;
+    onRejected = isCallable(onRejected) ? onRejected : thrower;
+    nextPromise = new Promise((resolve, reject) => {
+      function tryCall(func) {
+        let value;
+        try {
+          value = func(promise[VALUE]);
+        } catch (error) {
+          reject(error);
+          return;
+        }
+        if (value === nextPromise) {
+          reject(new TypeError(CHAINING_CYCLE));
+        } else {
+          call(resolve, reject, value);
+        }
+      }
+      function asyncOnFulfilled() {
+        setImmediate(tryCall, onFulfilled);
+      }
+      function asyncOnRejected() {
+        setImmediate(tryCall, onRejected);
+      }
+      switch (promise[STATUS]) {
+        case FULFILLED:
+          asyncOnFulfilled();
+          break;
+        case REJECTED:
+          asyncOnRejected();
+          break;
+        default:
+          enqueue(promise, asyncOnFulfilled, asyncOnRejected);
+      }
+    });
+    return nextPromise;
+  };
+
+  Promise.prototype.catch = function (onRejected) {
+    return this.then(identity, onRejected);
+  };
+
+  Promise.resolve = function (value) {
+    const anything = toPromise(value);
+    if (isPromise(anything)) {
+      return anything;
+    }
+    return new Promise((resolve, reject) => {
+      if (isInternalError(anything)) {
+        reject(anything[ORIGINAL_ERROR]);
+      } else {
+        resolve(value);
+      }
+    });
+  };
+
+  Promise.reject = function (reason) {
+    return new Promise((resolve, reject) => {
+      reject(reason);
+    });
+  };
+
+  Promise.race = function (values) {
+    return new Promise((resolve, reject) => {
+      let i;
+      let length;
+      if (isArray(values)) {
+        length = values.length;
+        for (i = 0; i < length; i++) {
+          call(resolve, reject, values[i]);
+        }
+      } else {
+        reject(new TypeError(NOT_ARRAY));
+      }
+    });
+  };
+
+  Promise.all = function (values) {
+    return new Promise((resolve, reject) => {
+      let fulfilledCount = 0;
+      let promiseCount = 0;
+      let anything;
+      let length;
+      let value;
+      let i;
+      if (isArray(values)) {
+        values = values.slice(0);
+        length = values.length;
+        for (i = 0; i < length; i++) {
+          value = values[i];
+          anything = toPromise(value);
+          if (isPromise(anything)) {
+            promiseCount++;
+            anything.then(
+              (function (index) {
+                return function (value) {
+                  values[index] = value;
+                  fulfilledCount++;
+                  if (fulfilledCount == promiseCount) {
+                    resolve(values);
+                  }
+                };
+              }(i)),
+              reject,
+            );
+          } else if (isInternalError(anything)) {
+            reject(anything[ORIGINAL_ERROR]);
+          } else {
+            // [1, , 3] → [1, undefined, 3]
+            values[i] = value;
+          }
+        }
+        if (!promiseCount) {
+          resolve(values);
+        }
+      } else {
+        reject(new TypeError(NOT_ARRAY));
+      }
+    });
+  };
+
+  if (typeof module !== 'undefined' && module.exports) {
+    module.exports = global.Promise || Promise;
+  } else if (!global.Promise) {
+    global.Promise = Promise;
+  }
+}(this));

public/js/storage.js

@@ -0,0 +1,144 @@
+const OtherTables = ['categories', 'config', 'swmsg']
+const MainTables = ['todos', 'projects']
+const allMethod = ['sync_post_', 'sync_patch_', 'delete_']
+
+// -------------------------------------
+
+let idbKeyval = (() => {
+  let db;
+
+  // console.log('idbKeyval...')
+
+  function getDB() {
+    if (!db) {
+      // console.log('CREO DB STORAGE JS !')
+      db = new Promise((resolve, reject) => {
+        const openreq = indexedDB.open('mydb3', 11);
+
+        openreq.onerror = () => {
+          reject(openreq.error);
+        };
+
+        openreq.onupgradeneeded = () => {
+          // First time setup: create an empty object store
+          for (const mytab of MainTables) {
+            openreq.result.createObjectStore(mytab, { keyPath: '_id' });
+            for (const mymeth of allMethod) {
+              const tab = mymeth + mytab
+              openreq.result.createObjectStore(tab, { keyPath: '_id' });
+            }
+          }
+          for (const mytab of OtherTables) {
+            openreq.result.createObjectStore(mytab, { keyPath: '_id' });
+          }
+        };
+
+        openreq.onsuccess = () => {
+          resolve(openreq.result);
+        };
+      });
+    }
+    return db;
+  }
+
+  async function withStore(type, table, callback) {
+    const db = await getDB();
+    return new Promise((resolve, reject) => {
+      const transaction = db.transaction(table, type);
+      transaction.oncomplete = () => resolve();
+      transaction.onerror = () => reject(transaction.error);
+      callback(transaction.objectStore(table));
+    });
+  }
+
+  return {
+    getArrayByTable(nametable, data) {
+      if (nametable === 'todos') {
+        return data.todos
+      } if (nametable === 'projects') {
+        return data.projects
+      }
+    },
+
+    async get(key) {
+      let req;
+      await withStore('readonly', 'keyval', store => {
+        req = store.get(key);
+      });
+      return req.result;
+    },
+
+    // jsonCopy(src) {
+    //   return JSON.parse(JSON.stringify(src));
+    // },
+
+    // contains(a, b) {
+    //   // array matches
+    //   if (Array.isArray(b)) {
+    //     return b.some(x => a.indexOf(x) > -1);
+    //   }
+    //   // string match
+    //   return a.indexOf(b) > -1;
+    // },
+
+    async getdata(table, key) {
+      let req;
+
+      await withStore('readonly', table, store => {
+        // console.log('store', store, 'key', key)
+        req = store.get(key);
+      });
+
+      return req.result;
+    },
+    async getalldata(table) {
+      let req;
+      await withStore('readonly', table, store => {
+        req = store.getAll();
+      });
+      return req.result;
+    },
+    async set(key, value) {
+      let req;
+      await withStore('readwrite', 'keyval', store => {
+        req = store.put(value, key);
+      });
+      return req.result;
+    },
+    async setdata(table, value) {
+      let req;
+      // console.log('setdata', table, value)
+
+      await withStore('readwrite', table, store => {
+        req = store.put(value);
+      });
+      return req.result;
+    },
+    async delete(key) {
+      return withStore('readwrite', 'keyval', store => {
+        store.delete(key);
+      });
+    },
+    async deletedata(table, key) {
+      return withStore('readwrite', table, store => {
+        store.delete(key);
+      });
+    },
+    async clearalldata(table) {
+      // console.log('clearalldata', table)
+      return withStore('readwrite', table, store => {
+        store.clear();
+      });
+    },
+  };
+})();
+
+// iOS add-to-homescreen is missing IDB, or at least it used to.
+// I haven't tested this in a while.
+if (!self.indexedDB) {
+  idbKeyval = {
+    get: key => Promise.resolve(localStorage.getItem(key)),
+    set: (key, val) => Promise.resolve(localStorage.setItem(key, val)),
+    delete: key => Promise.resolve(localStorage.removeItem(key)),
+  };
+}

public/js/track.js

@@ -0,0 +1,34 @@
+function geturl() {
+  const miaurl = document.location.href
+
+  if (miaurl.includes('localhost')) {
+    return 'http://localhost:8084/'
+  }
+  return 'https://mandalasolidale.freeplanet.app/'
+}
+
+function getidtrack() {
+  const miaurl = document.location.href
+
+  if (miaurl.includes('test.') || miaurl.includes('localhost')) {
+    return '4c40a07bc88a9c50c9b70dc9c5cd8e2e'
+  }
+  return 'ccfd6c90e17b6809f9717675764c3f5d' // Associazione Shen
+}
+
+let owa_baseUrl = `${geturl()}owa/`;
+if (owa_cmds) var owa_cmds = [];
+else var owa_cmds = owa_cmds || [];
+owa_cmds.push(['setSiteId', getidtrack()]);
+owa_cmds.push(['trackPageView']);
+// owa_cmds.push(['trackClicks']);
+
+(function () {
+  const _owa = document.createElement('script');
+  _owa.type = 'text/javascript';
+  _owa.async = true;
+  owa_baseUrl = (document.location.protocol == 'https:' ? window.owa_baseSecUrl || owa_baseUrl.replace(/http:/, 'https:') : owa_baseUrl);
+  _owa.src = `${owa_baseUrl}modules/base/js/owa.tracker-combined-min.js`;
+  const _owa_s = document.getElementsByTagName('script')[0];
+  _owa_s.parentNode.insertBefore(_owa, _owa_s);
+}());

public/js/workbox-sw-3-0-0.js.off

@@ -0,0 +1,3 @@
+var workbox=function(){"use strict";try{self.workbox.v["workbox:sw:3.0.0"]=1}catch(t){}const t="https://storage.googleapis.com/workbox-cdn/releases/3.0.0",e={backgroundSync:"background-sync",core:"core",expiration:"cache-expiration",googleAnalytics:"google-analytics",strategies:"strategies",precaching:"precaching",routing:"routing",cacheableResponse:"cacheable-response",broadcastUpdate:"broadcast-cache-update",rangeRequests:"range-requests"};return new class{constructor(){return this.v={},this.t={debug:"localhost"===self.location.hostname,modulePathPrefix:null,modulePathCb:null},this.e=this.t.debug?"dev":"prod",this.s=!1,new Proxy(this,{get(t,s){if(t[s])return t[s];const o=e[s];return o&&t.loadModule(`workbox-${o}`),t[s]}})}setConfig(t={}){if(this.s)throw new Error("Config must be set before accessing workbox.* modules");Object.assign(this.t,t),this.e=this.t.debug?"dev":"prod"}skipWaiting(){self.addEventListener("install",()=>self.skipWaiting())}clientsClaim(){self.addEventListener("activate",()=>self.clients.claim())}loadModule(t){const e=this.o(t);try{importScripts(e),this.s=!0}catch(s){throw console.error(`Unable to import module '${t}' from '${e}'.`),s}}o(e){if(this.t.modulePathCb)return this.t.modulePathCb(e,this.t.debug);let s=[t];const o=`${e}.${this.e}.js`,r=this.t.modulePathPrefix;return r&&""===(s=r.split("/"))[s.length-1]&&s.splice(s.length-1,1),s.push(o),s.join("/")}}}();
+
+//# sourceMappingURL=workbox-sw.js.map

public/js/workbox-sw.js

@@ -0,0 +1,23 @@
+const workbox = (function () {
+  try { self.workbox.v['workbox:sw:3.4.1'] = 1 } catch (t) {} const t = 'https://storage.googleapis.com/workbox-cdn/releases/3.4.1',
+    e = {
+      backgroundSync: 'background-sync', broadcastUpdate: 'broadcast-cache-update', cacheableResponse: 'cacheable-response', core: 'core', expiration: 'cache-expiration', googleAnalytics: 'google-analytics', navigationPreload: 'navigation-preload', precaching: 'precaching', rangeRequests: 'range-requests', routing: 'routing', strategies: 'strategies', streams: 'streams',
+    }; return new class {
+    constructor() { return this.v = {}, this.t = { debug: self.location.hostname === 'localhost', modulePathPrefix: null, modulePathCb: null }, this.e = this.t.debug ? 'dev' : 'prod', this.s = !1, new Proxy(this, { get(t, s) { if (t[s]) return t[s]; const o = e[s]; return o && t.loadModule(`workbox-${o}`), t[s] } }) }
+
+    setConfig(t = {}) { if (this.s) throw new Error('Config must be set before accessing workbox.* modules'); Object.assign(this.t, t), this.e = this.t.debug ? 'dev' : 'prod' }
+
+    skipWaiting() { self.addEventListener('install', () => self.skipWaiting()) }
+
+    clientsClaim() { self.addEventListener('activate', () => self.clients.claim()) }
+
+    loadModule(t) { const e = this.o(t); try { importScripts(e), this.s = !0 } catch (s) { throw console.error(`Unable to import module '${t}' from '${e}'.`), s } }
+
+    o(e) {
+      if (this.t.modulePathCb) return this.t.modulePathCb(e, this.t.debug); let s = [t]; const o = `${e}.${this.e}.js`,
+        r = this.t.modulePathPrefix; return r && (s = r.split('/'))[s.length - 1] === '' && s.splice(s.length - 1, 1), s.push(o), s.join('/')
+    }
+  }()
+}());
+
+// # sourceMappingURL=workbox-sw.js.map

public/js/workbox-sw3-4-1.js.off

@@ -0,0 +1,3 @@
+var workbox=function(){"use strict";try{self.workbox.v["workbox:sw:3.4.1"]=1}catch(t){}const t="https://storage.googleapis.com/workbox-cdn/releases/3.4.1",e={backgroundSync:"background-sync",broadcastUpdate:"broadcast-cache-update",cacheableResponse:"cacheable-response",core:"core",expiration:"cache-expiration",googleAnalytics:"google-analytics",navigationPreload:"navigation-preload",precaching:"precaching",rangeRequests:"range-requests",routing:"routing",strategies:"strategies",streams:"streams"};return new class{constructor(){return this.v={},this.t={debug:"localhost"===self.location.hostname,modulePathPrefix:null,modulePathCb:null},this.e=this.t.debug?"dev":"prod",this.s=!1,new Proxy(this,{get(t,s){if(t[s])return t[s];const o=e[s];return o&&t.loadModule(`workbox-${o}`),t[s]}})}setConfig(t={}){if(this.s)throw new Error("Config must be set before accessing workbox.* modules");Object.assign(this.t,t),this.e=this.t.debug?"dev":"prod"}skipWaiting(){self.addEventListener("install",()=>self.skipWaiting())}clientsClaim(){self.addEventListener("activate",()=>self.clients.claim())}loadModule(t){const e=this.o(t);try{importScripts(e),this.s=!0}catch(s){throw console.error(`Unable to import module '${t}' from '${e}'.`),s}}o(e){if(this.t.modulePathCb)return this.t.modulePathCb(e,this.t.debug);let s=[t];const o=`${e}.${this.e}.js`,r=this.t.modulePathPrefix;return r&&""===(s=r.split("/"))[s.length-1]&&s.splice(s.length-1,1),s.push(o),s.join("/")}}}();
+
+//# sourceMappingURL=workbox-sw.js.map