import * as localforage from 'localforage';

import * as lo from 'localforage-observable';
import 'localforage-observable';
require('localforage-observable');
const lo = require('localforage-observable');

function isDate(value) {
   return toString.call(value) === '[object Date]';
}

import localForage from "localforage";
// OR based on your configuration:
// import * as localForage from "localforage";

import { extendPrototype } from "localforage-observable";

var localforage = extendPrototype(localForage);
localforage.ready().then(() => {
  // TypeScript will find `newObservable()` after the casting that `extendPrototype()` does
  var observable = localforage.newObservable();
});

Unhandled Promise rejection: Observable is not defined ; Zone: <root> ; Task: Promise.then ; Value: ReferenceError: Observable is not defined
    at newObservable.factory (localforage-observable.js:444:9)
    at LocalForage.newObservable (localforage-observable.js:431:40)

        entry: {
            'main-client': [
                "babel-polyfill",
                'react-hot-loader/patch',
                './clientApp/boot-client.tsx'
            ]
        },

import * as localforage from "localforage";
import "localforage-observable";

[...]

  componentDidMount = () => {
    localforage.ready(() => {
      const observable = localforage.newObservable({ key: "Messages" });
      this.subscription = observable.subscribe({
        next: data => {
          // handle data changes
        }
      });
    });
  };

const instanceOne = localforage.createInstance({
    name        : dbName,
    storeName   : 'tableOne',
});

const instanceTwo = localforage.createInstance({
    name        : dbName,
    storeName   : 'tableOne',
});

...

const observableOne = instanceOne.newObservable()
const subscriptionOne = observableOne.subscribe({ next: (args) => { ... } })

...

const observableTwo = instanceTwo.newObservable()
const subscriptionTwo = observableTwo.subscribe({ next: (args) => { ... } })

...
 
instanceOne.setItem("ACTION", { value: "something" }) // it should be caught by both observable
 

import localforage from 'localforage'
import 'localforage-observable'

let store = localforage.createInstance({name:'clear-test'})
store.ready(function() {
  let observable = store.newObservable({
  })
  observable.subscribe({
    next: function(args) {
      console.log('observable', args);
    }
  })
})

store.setItem('1','test')
.then(()=>{store.clear()})

public getUsers(userIds: string[], callback: NextObserver<any> | Function) {
    let cacheKeys = userIds.map((userId:any) => {
        return this.getUserCacheKey(userId);
    });

    let applyCallback = (item) => {
        this.$rootScope.$apply(() => {
            callback(item);
        });
    };

    //noinspection TypeScriptUnresolvedFunction
    let subscriber = Observable.from(cacheKeys)
        .flatMap((key) => {
            this.CacheService.getItem(key)
                .then((user: IApiUser) => {
                    return new ngLeague.User(user);
                })
                .then(applyCallback)
                .catch(x => x);

            return this.CacheService.getObservable(key);
        })
        .map((user:IApiUser) => {
            console.log(user);
            return new ngLeague.User(user);
        })
        .subscribe(applyCallback);

    this.CacheService.setItem("user:9373305", "Hi", this.CachingTimes.getUserCacheTimeout());

    this.fetchUncachedUsers(userIds).then((users) => {
        this.CacheService.setItem("user:9373305", "Hi2", this.CachingTimes.getUserCacheTimeout());

        _.forEach(users, (user: IApiUser) => {
            let cacheKey = this.getUserCacheKey(user.id);
            this.CacheService.setItem(cacheKey, user);
        });
    });

    return subscriber;
}

UserCacheProxy.getUsers(["9373305"], function(user:ngLeague.User) {
    // do nothing
});

User {apiData: "Hi"}
User {apiData: "Hi2"}
User {apiData: "{..}"} // actual user data from the server

User {apiData: "Hi"}

public getObservable(key) {
        return this.localForage.newObservable({key: key}).map((item:any) => {
            return this.getItemContent(key, item);
        });
}

return Observable.from(teamIds).flatMap((teamId:any) => {
    return this.CacheService.getObservable(this.getTeamCacheKey(teamId));
});

let observables = teamIds.map((teamId:any) => {
    return this.CacheService.getObservable(this.getTeamCacheKey(teamId));
});

//noinspection TypeScriptUnresolvedFunction
return Observable.concat(observables).flatMap((x:any) => {
    return x;
});