@wavemaker/app-rn-runtime 12.0.0-next.46502 → 12.0.0-next.47810

package/core/key.extractor.js

@@ -0,0 +1,21 @@
+function _defineProperty(e, r, t) { return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, { value: t, enumerable: !0, configurable: !0, writable: !0 }) : e[r] = t, e; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == typeof i ? i : i + ""; }
+function _toPrimitive(t, r) { if ("object" != typeof t || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != typeof i) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+export class DefaultKeyExtractor {
+  constructor() {
+    _defineProperty(this, "store", new Map());
+    _defineProperty(this, "nextKey", 1);
+  }
+  getKey(o, create = false) {
+    let k = this.store.get(o);
+    if (!k && create) {
+      k = `key:${Date.now()}:${this.nextKey++}`;
+      this.store.set(o, k);
+    }
+    return k;
+  }
+  clear() {
+    this.store = new Map();
+  }
+}
+//# sourceMappingURL=key.extractor.js.map

package/core/logger.js

@@ -0,0 +1,123 @@
+function _defineProperty(e, r, t) { return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, { value: t, enumerable: !0, configurable: !0, writable: !0 }) : e[r] = t, e; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == typeof i ? i : i + ""; }
+function _toPrimitive(t, r) { if ("object" != typeof t || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != typeof i) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+import { keys, sortBy } from 'lodash-es';
+import { logger } from 'react-native-logs';
+import StorageService from './storage.service';
+class LoggerCollection {
+  constructor() {
+    _defineProperty(this, "loggerMap", new Map());
+    _defineProperty(this, "config", {});
+    _defineProperty(this, "key", 'wm.log.config');
+  }
+  init() {
+    StorageService.getItem(this.key).then(data => {
+      if (data) {
+        this.config = JSON.parse(data) || {};
+        keys(this.config).forEach(k => {
+          var _this$loggerMap$get;
+          (_this$loggerMap$get = this.loggerMap.get(k)) === null || _this$loggerMap$get === void 0 || _this$loggerMap$get.setLevel(this.config[k].level);
+        });
+      }
+    }).catch(() => {});
+  }
+  get(name) {
+    return this.loggerMap.get(name);
+  }
+  set(name, logger) {
+    this.loggerMap.set(name, logger);
+  }
+  setLogLevel(name, level) {
+    if (!level && name && levels[name] !== undefined) {
+      level = name;
+      name = undefined;
+    }
+    if (level !== undefined) {
+      [...this.loggerMap.keys()].filter(k => !name || k.startsWith(name)).forEach(k => {
+        var _this$loggerMap$get2;
+        level && ((_this$loggerMap$get2 = this.loggerMap.get(k)) === null || _this$loggerMap$get2 === void 0 ? void 0 : _this$loggerMap$get2.setLevel(level));
+        if (k) {
+          this.config[k] = this.config[k] || {};
+          this.config[k].level = level;
+        }
+      });
+      StorageService.setItem(this.key, JSON.stringify(this.config));
+    }
+  }
+  getLogLevel(name, level) {
+    var _this$config$name;
+    return name && ((_this$config$name = this.config[name]) === null || _this$config$name === void 0 ? void 0 : _this$config$name.level);
+  }
+  list() {
+    return sortBy([...this.loggerMap.keys()]);
+  }
+}
+const levels = {
+  debug: 0,
+  info: 1,
+  warn: 2,
+  error: 3
+};
+const loggerCollection = new LoggerCollection();
+const log = logger.createLogger({
+  severity: 'debug',
+  levels: levels,
+  enabledExtensions: []
+});
+export class Logger {
+  constructor(name, level) {
+    this.name = name;
+    this.level = level;
+    _defineProperty(this, "ins", null);
+    this.ins = log.extend(this.name);
+    log.enable(this.name);
+  }
+  isEnabled(level) {
+    return levels[level] >= levels[this.level];
+  }
+  log(level, msg) {
+    if (this.isEnabled(level)) {
+      if (msg instanceof Function) {
+        msg = msg();
+      }
+      this.ins[level](msg);
+    }
+  }
+  extend(name) {
+    return getLogger(this.name + '.' + name);
+  }
+  setLevel(level) {
+    this.level = level;
+  }
+  debug(msg) {
+    this.log('debug', msg);
+  }
+  info(msg) {
+    this.log('info', msg);
+  }
+  warn(msg) {
+    this.log('warn', msg);
+  }
+  error(msg) {
+    this.log('error', msg);
+  }
+}
+const getLogger = (name, level) => {
+  let logger = loggerCollection.get(name);
+  if (!logger) {
+    logger = new Logger(name, loggerCollection.getLogLevel(name) || 'error');
+    loggerCollection.set(name, logger);
+  }
+  return logger;
+};
+export const ROOT_LOGGER = getLogger('root');
+export const PERFORMANCE_LOGGER = ROOT_LOGGER.extend('performance');
+export const RENDER_LOGGER = PERFORMANCE_LOGGER.extend('render');
+export default {
+  get: getLogger,
+  setLogLevel: (name, level) => loggerCollection.setLogLevel(name, level),
+  list: () => loggerCollection.list(),
+  reset: () => loggerCollection.setLogLevel('root', 'error'),
+  init: () => loggerCollection.init()
+};
+//# sourceMappingURL=logger.js.map

package/core/navigation.service.js

@@ -0,0 +1,70 @@
+import React from 'react';
+import { createNavigationContainerRef } from '@react-navigation/native';
+const NavigationContext = /*#__PURE__*/React.createContext(null);
+export const NavigationServiceProvider = NavigationContext.Provider;
+export const NavigationServiceConsumer = NavigationContext.Consumer;
+
+// Error Boundary - Navigation handling in case of app level errors.
+
+// Creating a navigationRef for use with NavigationContainer in App.navigator.tsx
+export const navigationRef = createNavigationContainerRef();
+
+// Flag to track whether the NavigationContainer is ready
+let isNavigationReady = false;
+
+// Queue to hold navigation actions while NavigationContainer is not ready
+let pendingNavigation = [];
+
+/**
+ * Set the navigation readiness state.
+ * If NavigationContainer becomes ready, flush any pending navigation actions.
+ */
+export function setNavigationReady(ready) {
+  isNavigationReady = ready;
+  if (ready) {
+    flushPendingNavigation();
+  }
+}
+
+/**
+ * Get the current navigation readiness state.
+ */
+export function getNavigationReady() {
+  return isNavigationReady;
+}
+
+/**
+ * Execute all queued navigation actions.
+ */
+function flushPendingNavigation() {
+  while (pendingNavigation.length > 0) {
+    const action = pendingNavigation.shift();
+    if (action) action();
+  }
+}
+
+/**
+ * Navigate to a specific screen.
+ * If NavigationContainer isn't ready, queue the navigation action.
+ */
+export function navigate(name, params) {
+  if (isNavigationReady && navigationRef.isReady()) {
+    navigationRef.navigate(name, params);
+  } else {
+    pendingNavigation.push(() => navigationRef.navigate(name, params));
+  }
+}
+
+/**
+ * Navigate back to the previous screen.
+ * If NavigationContainer isn't ready, queue the goBack action.
+ */
+export function goBackRef() {
+  if (isNavigationReady && navigationRef.isReady() && navigationRef.canGoBack()) {
+    navigationRef.goBack();
+  } else {
+    pendingNavigation.push(() => navigationRef.goBack());
+  }
+}
+export { isNavigationReady };
+//# sourceMappingURL=navigation.service.js.map

package/core/navigation.service.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["React","createNavigationContainerRef","NavigationContext","createContext","NavigationServiceProvider","Provider","NavigationServiceConsumer","Consumer","navigationRef","isNavigationReady","pendingNavigation","setNavigationReady","ready","flushPendingNavigation","getNavigationReady","length","action","shift","navigate","name","params","isReady","push","goBackRef","canGoBack","goBack"],"sources":["navigation.service.ts"],"sourcesContent":["import React from 'react';\nimport { createNavigationContainerRef, ParamListBase } from '@react-navigation/native';\n\nexport default interface NavigationService {\n    goToPage: (pageName: string, params: any) => Promise<void>;\n    goBack: (pageName: string, params: any) => Promise<void>;\n    openUrl: (url: string, params?: any) => Promise<void>;\n}\n\nconst NavigationContext = React.createContext<NavigationService>(null as any);\n\nexport const NavigationServiceProvider = NavigationContext.Provider;\nexport const NavigationServiceConsumer = NavigationContext.Consumer;\n\n\n// Error Boundary - Navigation handling in case of app level errors.\n\n// Creating a navigationRef for use with NavigationContainer in App.navigator.tsx\nexport const navigationRef = createNavigationContainerRef<ParamListBase>();\n\n// Flag to track whether the NavigationContainer is ready\nlet isNavigationReady = false;\n\n// Queue to hold navigation actions while NavigationContainer is not ready\nlet pendingNavigation: (() => void)[] = [];\n\n/**\n * Set the navigation readiness state.\n * If NavigationContainer becomes ready, flush any pending navigation actions.\n */\nexport function setNavigationReady(ready: boolean) {\n  isNavigationReady = ready;\n  if (ready) {\n    flushPendingNavigation();\n  }\n}\n\n/**\n * Get the current navigation readiness state.\n */\nexport function getNavigationReady() {\n  return isNavigationReady;\n}\n\n/**\n * Execute all queued navigation actions.\n */\nfunction flushPendingNavigation() {\n  while (pendingNavigation.length > 0) {\n    const action = pendingNavigation.shift();\n    if (action) action();\n  }\n}\n\n/**\n * Navigate to a specific screen.\n * If NavigationContainer isn't ready, queue the navigation action.\n */\nexport function navigate(name: string, params: any) {\n  if (isNavigationReady && navigationRef.isReady()) {\n    navigationRef.navigate(name, params);\n  } else {\n    pendingNavigation.push(() => navigationRef.navigate(name, params));\n  }\n}\n\n/**\n * Navigate back to the previous screen.\n * If NavigationContainer isn't ready, queue the goBack action.\n */\nexport function goBackRef() {\n  if (isNavigationReady && navigationRef.isReady() && navigationRef.canGoBack()) {\n    navigationRef.goBack();\n  } else {\n    pendingNavigation.push(() => navigationRef.goBack());\n  }\n}\n\nexport { isNavigationReady };\n"],"mappings":"AAAA,OAAOA,KAAK,MAAM,OAAO;AACzB,SAASC,4BAA4B,QAAuB,0BAA0B;AAQtF,MAAMC,iBAAiB,gBAAGF,KAAK,CAACG,aAAa,CAAoB,IAAW,CAAC;AAE7E,OAAO,MAAMC,yBAAyB,GAAGF,iBAAiB,CAACG,QAAQ;AACnE,OAAO,MAAMC,yBAAyB,GAAGJ,iBAAiB,CAACK,QAAQ;;AAGnE;;AAEA;AACA,OAAO,MAAMC,aAAa,GAAGP,4BAA4B,CAAgB,CAAC;;AAE1E;AACA,IAAIQ,iBAAiB,GAAG,KAAK;;AAE7B;AACA,IAAIC,iBAAiC,GAAG,EAAE;;AAE1C;AACA;AACA;AACA;AACA,OAAO,SAASC,kBAAkBA,CAACC,KAAc,EAAE;EACjDH,iBAAiB,GAAGG,KAAK;EACzB,IAAIA,KAAK,EAAE;IACTC,sBAAsB,CAAC,CAAC;EAC1B;AACF;;AAEA;AACA;AACA;AACA,OAAO,SAASC,kBAAkBA,CAAA,EAAG;EACnC,OAAOL,iBAAiB;AAC1B;;AAEA;AACA;AACA;AACA,SAASI,sBAAsBA,CAAA,EAAG;EAChC,OAAOH,iBAAiB,CAACK,MAAM,GAAG,CAAC,EAAE;IACnC,MAAMC,MAAM,GAAGN,iBAAiB,CAACO,KAAK,CAAC,CAAC;IACxC,IAAID,MAAM,EAAEA,MAAM,CAAC,CAAC;EACtB;AACF;;AAEA;AACA;AACA;AACA;AACA,OAAO,SAASE,QAAQA,CAACC,IAAY,EAAEC,MAAW,EAAE;EAClD,IAAIX,iBAAiB,IAAID,aAAa,CAACa,OAAO,CAAC,CAAC,EAAE;IAChDb,aAAa,CAACU,QAAQ,CAACC,IAAI,EAAEC,MAAM,CAAC;EACtC,CAAC,MAAM;IACLV,iBAAiB,CAACY,IAAI,CAAC,MAAMd,aAAa,CAACU,QAAQ,CAACC,IAAI,EAAEC,MAAM,CAAC,CAAC;EACpE;AACF;;AAEA;AACA;AACA;AACA;AACA,OAAO,SAASG,SAASA,CAAA,EAAG;EAC1B,IAAId,iBAAiB,IAAID,aAAa,CAACa,OAAO,CAAC,CAAC,IAAIb,aAAa,CAACgB,SAAS,CAAC,CAAC,EAAE;IAC7EhB,aAAa,CAACiB,MAAM,CAAC,CAAC;EACxB,CAAC,MAAM;IACLf,iBAAiB,CAACY,IAAI,CAAC,MAAMd,aAAa,CAACiB,MAAM,CAAC,CAAC,CAAC;EACtD;AACF;AAEA,SAAShB,iBAAiB","ignoreList":[]}

package/core/network.service.js

@@ -0,0 +1,327 @@
+function _defineProperty(e, r, t) { return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, { value: t, enumerable: !0, configurable: !0, writable: !0 }) : e[r] = t, e; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == typeof i ? i : i + ""; }
+function _toPrimitive(t, r) { if ("object" != typeof t || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != typeof i) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+import axios from 'axios';
+import { clone, isEqual, noop } from 'lodash-es';
+import * as Network from 'expo-network';
+import NetInfo from '@react-native-community/netinfo';
+import StorageService from './storage.service';
+import EventNotifier from './event-notifier';
+import { getAbortableDefer, isWebPreviewMode, retryIfFails } from './utils';
+export class NetworkState {
+  constructor() {
+    _defineProperty(this, "isConnecting", false);
+    _defineProperty(this, "isConnected", true);
+    _defineProperty(this, "isNetworkAvailable", true);
+    _defineProperty(this, "isServiceAvailable", true);
+    _defineProperty(this, "noServiceRequired", false);
+  }
+}
+const AUTO_CONNECT_KEY = 'WM.NetworkService._autoConnect',
+  IS_CONNECTED_KEY = 'WM.NetworkService.isConnected',
+  excludedList = [new RegExp('/wmProperties.js')],
+  networkState = new NetworkState();
+
+/**
+ * If server is not connected and url does not match the unblock list of regular expressions,
+ * then this function return true. Otherwise, return false.
+ * @param url
+ * @returns {boolean}
+ */
+const blockUrl = url => {
+  return !networkState.isConnected && url.startsWith('http') && excludedList.findIndex(regExp => regExp.test(url)) < 0;
+};
+axios.interceptors.request.use(request => {
+  if (!networkState.noServiceRequired && request.url && blockUrl(request.url)) {
+    const url = request.url;
+    const urlSplits = url.split('://');
+    const pathIndex = urlSplits[1].indexOf('/');
+    urlSplits[1] = 'localhost' + (pathIndex > 0 ? urlSplits[1].substr(pathIndex) : '/');
+    request.url = urlSplits.join('://');
+  }
+  return request;
+});
+class NetworkService {
+  constructor() {
+    _defineProperty(this, "_autoConnect", true);
+    _defineProperty(this, "_lastKnownNetworkState", void 0);
+    _defineProperty(this, "_isCheckingServer", false);
+    _defineProperty(this, "appConfig", null);
+    _defineProperty(this, "notifier", new EventNotifier());
+    /**
+     * When the auto connect is enabled, then app is automatically connected  whenever server is available.
+     * Every time when app goes offline, auto connect is enabled. Before app coming to online, one can disable
+     * the auto connection flow using this method.
+     */
+    _defineProperty(this, "disableAutoConnect", () => this.setAutoConnect(false));
+    /**
+     * Returns true, if app is connected to server. Otherwise, returns false.
+     *
+     * @returns {boolean} Returns true, if app is connected to server. Otherwise, returns false.
+     */
+    _defineProperty(this, "isConnected", () => {
+      this.checkForNetworkStateChange();
+      return networkState.isConnected;
+    });
+    /**
+     * Returns true if app is trying to connect to server. Otherwise, returns false.
+     *
+     * @returns {boolean} Returns true if app is trying to connect to server. Otherwise, returns false.
+     */
+    _defineProperty(this, "isConnecting", () => networkState.isConnecting);
+  }
+
+  /**
+   * This method attempts to connect app to the server and returns a promise that will be resolved with
+   * a boolean value based on the operation result.
+   *
+   * @returns {object} promise
+   */
+  connect(silent = false) {
+    this.setAutoConnect(true);
+    return this.tryToConnect(silent);
+  }
+  /**
+   * This method disconnects the app from the server and returns a promise that will be resolved with
+   * a boolean value based on the operation result. Use connect method to reconnect.
+   *
+   * @returns {object} promise
+   */
+  disconnect() {
+    const p = this.tryToDisconnect();
+    this.disableAutoConnect();
+    return p;
+  }
+
+  /**
+   * If pingServer is true, then it returns a promise that will be resolved with boolean based on service availability
+   * check.If pingServer is false, returns a boolean value based on the last known service availability.
+   *
+   * @returns {boolean} if pingServer is true, then a promise is returned. Otherwise, a boolean value.
+   */
+  isAvailable(pingServer = false) {
+    if (pingServer) {
+      return this.isServiceAvailable().then(() => {
+        this.checkForNetworkStateChange();
+        return networkState.isServiceAvailable;
+      });
+    }
+    return networkState.isServiceAvailable;
+  }
+  /**
+   * This method returns a promise that is resolved when connection is established with server.
+   *
+   * @returns {object} promise a promise that is resolved with the returned object of fn
+   */
+  onConnect() {
+    let defer = getAbortableDefer(),
+      cancelSubscription;
+    if (this.isConnected()) {
+      return Promise.resolve();
+    }
+    cancelSubscription = this.notifier.subscribe('onNetworkStateChange', () => {
+      if (this.isConnected()) {
+        defer.resolve(true);
+        cancelSubscription();
+      }
+    });
+    defer.promise.catch(function () {
+      cancelSubscription();
+    });
+    return defer.promise;
+  }
+
+  /**
+   * This is a util method. If fn cannot execute successfully and network lost connection, then the fn will
+   * be invoked when network is back. The returned can also be aborted.
+   *
+   * @param {function()} fn method to invoke.
+   * @returns {object} promise a promise that is resolved with the returned object of fn
+   */
+  retryIfNetworkFails(fn) {
+    const defer = getAbortableDefer();
+    retryIfFails(fn, 0, 0, () => {
+      let onConnectPromise;
+      if (!this.isConnected()) {
+        onConnectPromise = this.onConnect();
+        defer.promise.catch(function () {
+          onConnectPromise.abort();
+        });
+        return onConnectPromise;
+      }
+      return false;
+    }).then(defer.resolve, defer.reject);
+    return defer.promise;
+  }
+  async start(appConfig) {
+    this.appConfig = appConfig;
+    networkState.noServiceRequired = !appConfig.url;
+    networkState.isConnected = (await StorageService.getItem(IS_CONNECTED_KEY)) !== 'false';
+    this._autoConnect = (await StorageService.getItem(AUTO_CONNECT_KEY)) !== 'false';
+    const state = await Network.getNetworkStateAsync();
+    networkState.isNetworkAvailable = !!state.isConnected;
+    networkState.isConnected = networkState.isNetworkAvailable && networkState.isConnected;
+    !isWebPreviewMode() && NetInfo.addEventListener(state => {
+      if (state.isConnected !== networkState.isConnected) {
+        if (state.isConnected) {
+          networkState.isNetworkAvailable = !!state.isConnected;
+          this.tryToConnect().catch(noop);
+        } else {
+          networkState.isNetworkAvailable = false;
+          networkState.isServiceAvailable = false;
+          networkState.isConnected = false;
+          this.tryToDisconnect();
+        }
+      }
+    });
+    this.notifier.subscribe('onNetworkStateChange', data => {
+      /**
+       * If network is available and server is not available,then
+       * try to connect when server is available.
+       */
+      if (data.isNetworkAvailable && !data.isServiceAvailable && !this._isCheckingServer && !data.noServiceRequired) {
+        this._isCheckingServer = true;
+        this.checkForServiceAvailiblity().then(() => {
+          this._isCheckingServer = false;
+          this.connect();
+        }, () => {
+          this._isCheckingServer = false;
+        });
+      }
+    });
+    // to set the default n/w connection values.
+    return this.tryToConnect(true).catch(noop);
+  }
+  getServiceName() {
+    return NetworkService.SERVICE_NAME;
+  }
+
+  /**
+   * This function adds the given regular expression to the unblockList. Even app is in offline mode,
+   * the urls matching with the given regular expression are not blocked by NetworkService.
+   *
+   * @param {string} urlRegex regular expression
+   */
+  unblock(urlRegex) {
+    excludedList.push(new RegExp(urlRegex));
+  }
+  getState() {
+    return clone(networkState);
+  }
+  checkForNetworkStateChange() {
+    if (!isEqual(this._lastKnownNetworkState, networkState)) {
+      this._lastKnownNetworkState = clone(networkState);
+      this.notifier.notify('onNetworkStateChange', [this._lastKnownNetworkState]);
+    }
+  }
+
+  /**
+   * Returns a promise that is resolved when server is available.
+   * @returns {*}
+   */
+  checkForServiceAvailiblity() {
+    const maxTimeout = 4500;
+    return new Promise(resolve => {
+      const intervalId = setInterval(() => {
+        if (networkState.isNetworkAvailable) {
+          this.isServiceAvailable(maxTimeout).then(available => {
+            if (available) {
+              clearInterval(intervalId);
+              resolve();
+            }
+          });
+        }
+      }, 5000);
+    });
+  }
+
+  /**
+   * Pings server to check whether server is available. Based on ping response network state is modified.
+   * @returns {*} a promise that resolved with true, if server responds with valid status.
+   * Otherwise, the promise is resolved with false.
+   */
+  isServiceAvailable(maxTimeout) {
+    if (networkState.noServiceRequired) {
+      networkState.isServiceAvailable = false;
+      networkState.noServiceRequired = true;
+      return Promise.resolve(false);
+    }
+    return this.pingServer(maxTimeout).then(response => {
+      networkState.isServiceAvailable = response;
+      if (!networkState.isServiceAvailable) {
+        networkState.isConnecting = false;
+        networkState.isConnected = false;
+      }
+      return response;
+    });
+  }
+
+  /**
+   * Pings server
+   * @returns {*} a promise that resolved with true, if server responds with valid status.
+   * Otherwise, the promise is resolved with false.
+   * default timeout value is 1min.
+   */
+  pingServer(maxTimeout = 60000) {
+    let baseURL = this.appConfig.url;
+    if (baseURL && !baseURL.endsWith('/')) {
+      baseURL += '/';
+    } else {
+      baseURL = baseURL || '';
+    }
+    return axios.get(baseURL + 'services/application/wmProperties.js?t=' + Date.now(), {
+      responseType: 'text',
+      timeout: maxTimeout
+    }).then(res => res.status === 200, () => false);
+  }
+  setAutoConnect(flag) {
+    this._autoConnect = flag;
+    StorageService.setItem(AUTO_CONNECT_KEY, '' + flag);
+  }
+
+  /**
+   * Tries to connect to remote server. Network State will be changed based on the success of connection
+   * operation and emits an event notifying the network state change.
+   *
+   * @param silentMode {boolean} if true and connection is successful, then no event is emitted. Otherwise,
+   * events are emitted for network status change.
+   * @returns {*} a promise
+   */
+  tryToConnect(silentMode = false) {
+    return new Promise((resolve, reject) => {
+      this.isServiceAvailable(5000).then(() => {
+        if (networkState.isServiceAvailable && this._autoConnect) {
+          networkState.isConnecting = true;
+          if (!silentMode) {
+            this.checkForNetworkStateChange();
+          }
+          setTimeout(() => {
+            networkState.isConnecting = false;
+            networkState.isConnected = true;
+            StorageService.setItem(IS_CONNECTED_KEY, '' + true);
+            if (!silentMode) {
+              this.checkForNetworkStateChange();
+            }
+            resolve(true);
+          }, silentMode ? 0 : 5000);
+        } else {
+          networkState.isConnecting = false;
+          networkState.isConnected = false;
+          StorageService.setItem(IS_CONNECTED_KEY, '' + false);
+          reject();
+          this.checkForNetworkStateChange();
+        }
+      });
+    });
+  }
+  tryToDisconnect() {
+    networkState.isConnected = false;
+    networkState.isConnecting = false;
+    this.checkForNetworkStateChange();
+    StorageService.setItem(IS_CONNECTED_KEY, '' + networkState.isConnected);
+    return Promise.resolve(networkState.isConnected);
+  }
+}
+_defineProperty(NetworkService, "SERVICE_NAME", 'NetworkService');
+export default new NetworkService();
+//# sourceMappingURL=network.service.js.map

package/core/partial.service.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["React","PartialContext","createContext","PartialProvider","Provider","PartialConsumer","Consumer"],"sources":["partial.service.ts"],"sourcesContent":["import React from 'react';\n\nexport default interface PartialService {\n    get: (partialName: string, params?: {isPrefab: boolean, name: string}) => any;\n}\n\nconst PartialContext = React.createContext<PartialService>(null as any);\n\nexport const PartialProvider = PartialContext.Provider;\nexport const PartialConsumer = PartialContext.Consumer;"],"mappings":"AAAA,OAAOA,KAAK,MAAM,OAAO;AAMzB,MAAMC,cAAc,gBAAGD,KAAK,CAACE,aAAa,CAAiB,IAAW,CAAC;AAEvE,OAAO,MAAMC,eAAe,GAAGF,cAAc,CAACG,QAAQ;AACtD,OAAO,MAAMC,eAAe,GAAGJ,cAAc,CAACK,QAAQ","ignoreList":[]}

package/core/props.provider.js

@@ -0,0 +1,88 @@
+function _defineProperty(e, r, t) { return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, { value: t, enumerable: !0, configurable: !0, writable: !0 }) : e[r] = t, e; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == typeof i ? i : i + ""; }
+function _toPrimitive(t, r) { if ("object" != typeof t || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != typeof i) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+import { assign, isNil } from "lodash-es";
+export class PropsProvider {
+  constructor(defaultProps, initprops, onChange = (name, $new, $old) => {}) {
+    this.defaultProps = defaultProps;
+    this.initprops = initprops;
+    this.onChange = onChange;
+    _defineProperty(this, "oldProps", {});
+    _defineProperty(this, "overriddenProps", {});
+    _defineProperty(this, "propsProxy", void 0);
+    _defineProperty(this, "isDirty", false);
+    _defineProperty(this, "propertyNames", {});
+    this.initprops = this.initprops || {};
+    Object.keys(defaultProps).forEach(k => this.propertyNames[k] = true);
+    Object.keys(initprops).forEach(k => this.propertyNames[k] = true);
+    //@ts-ignore
+    this.propsProxy = new Proxy({}, {
+      get: (target, prop, receiver) => {
+        const propName = prop.toString();
+        let value = this.defaultProps[propName];
+        if (this.overriddenProps.hasOwnProperty(propName)) {
+          value = this.overriddenProps[propName];
+        } else if (this.oldProps.hasOwnProperty(propName)) {
+          value = this.oldProps[propName];
+        }
+        return value;
+      },
+      set: (target, prop, value) => {
+        const propName = prop.toString();
+        if (!this.has(propName)) {
+          return true;
+        }
+        this.isDirty = this.isDirty || this.overriddenProps[propName] !== value;
+        this.overriddenProps[propName] = value;
+        if (this.oldProps[propName] !== value) {
+          const oldValue = this.oldProps[propName];
+          this.onChange(propName, value, oldValue);
+          this.oldProps[propName] = value;
+        }
+        return true;
+      }
+    });
+  }
+  setDefault(propName, value) {
+    this.defaultProps[propName] = value;
+  }
+  overrideProp(propName, value) {
+    this.overriddenProps[propName] = value;
+    this.isDirty = true;
+  }
+  check(nextProps) {
+    if (!nextProps) {
+      nextProps = assign({}, this.defaultProps, this.initprops);
+    }
+    const result = Object.keys(nextProps).reduce((b, k) => {
+      let flag = false;
+      //@ts-ignore
+      const value = nextProps[k];
+      const oldValue = this.oldProps[k];
+      if (isNil(this.overriddenProps[k]) && (!this.oldProps.hasOwnProperty(k) || this.oldProps[k] !== value)) {
+        this.oldProps[k] = value;
+        this.onChange(k, value, oldValue);
+        flag = true;
+      }
+      return b || flag;
+    }, false) || this.isDirty;
+    this.isDirty = false;
+    return result;
+  }
+
+  // sets the property. But, value gets overriden when the original prop changes.
+  set(name, value) {
+    const oldValue = this.oldProps[name];
+    if (oldValue !== value) {
+      this.oldProps[name] = value;
+      this.onChange(name, value, oldValue);
+    }
+  }
+  has(propName) {
+    return !!this.propertyNames[propName];
+  }
+  get() {
+    return this.propsProxy;
+  }
+}
+//# sourceMappingURL=props.provider.js.map