@xenknight/framework7 0.0.2

package/shared/constructor-methods.js

@@ -0,0 +1,52 @@
+import $ from './dom7.js';
+export default function ConstructorMethods(parameters) {
+  if (parameters === void 0) {
+    parameters = {};
+  }
+  const {
+    defaultSelector,
+    constructor: Constructor,
+    domProp,
+    app,
+    addMethods
+  } = parameters;
+  const methods = {
+    create() {
+      for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+        args[_key] = arguments[_key];
+      }
+      if (app) return new Constructor(app, ...args);
+      return new Constructor(...args);
+    },
+    get(el) {
+      if (el === void 0) {
+        el = defaultSelector;
+      }
+      if (el instanceof Constructor) return el;
+      const $el = $(el);
+      if ($el.length === 0) return undefined;
+      return $el[0][domProp];
+    },
+    destroy(el) {
+      const instance = methods.get(el);
+      if (instance && instance.destroy) return instance.destroy();
+      return undefined;
+    }
+  };
+  if (addMethods && Array.isArray(addMethods)) {
+    addMethods.forEach(methodName => {
+      methods[methodName] = function (el) {
+        if (el === void 0) {
+          el = defaultSelector;
+        }
+        const instance = methods.get(el);
+        for (var _len2 = arguments.length, args = new Array(_len2 > 1 ? _len2 - 1 : 0), _key2 = 1; _key2 < _len2; _key2++) {
+          args[_key2 - 1] = arguments[_key2];
+        }
+        if (instance && instance[methodName]) return instance[methodName](...args);
+        return undefined;
+      };
+    });
+  }
+  return methods;
+}

package/shared/dom7.js

@@ -0,0 +1,7 @@
+// eslint-disable-next-line
+import * as methods from 'dom7';
+Object.keys(methods).forEach(methodName => {
+  if (methodName === '$') return;
+  methods.$.fn[methodName] = methods[methodName];
+});
+export default methods.$;

package/shared/events-class.js

@@ -0,0 +1,95 @@
+class EventsClass {
+  constructor(parents) {
+    if (parents === void 0) {
+      parents = [];
+    }
+    const self = this;
+    self.eventsParents = parents;
+    self.eventsListeners = {};
+  }
+  on(events, handler, priority) {
+    const self = this;
+    if (typeof handler !== 'function') return self;
+    const method = priority ? 'unshift' : 'push';
+    events.split(' ').forEach(event => {
+      if (!self.eventsListeners[event]) self.eventsListeners[event] = [];
+      self.eventsListeners[event][method](handler);
+    });
+    return self;
+  }
+  once(events, handler, priority) {
+    const self = this;
+    if (typeof handler !== 'function') return self;
+    function onceHandler() {
+      self.off(events, onceHandler);
+      if (onceHandler.f7proxy) {
+        delete onceHandler.f7proxy;
+      }
+      for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+        args[_key] = arguments[_key];
+      }
+      handler.apply(self, args);
+    }
+    onceHandler.f7proxy = handler;
+    return self.on(events, onceHandler, priority);
+  }
+  off(events, handler) {
+    const self = this;
+    if (!self.eventsListeners) return self;
+    events.split(' ').forEach(event => {
+      if (typeof handler === 'undefined') {
+        self.eventsListeners[event] = [];
+      } else if (self.eventsListeners[event]) {
+        self.eventsListeners[event].forEach((eventHandler, index) => {
+          if (eventHandler === handler || eventHandler.f7proxy && eventHandler.f7proxy === handler) {
+            self.eventsListeners[event].splice(index, 1);
+          }
+        });
+      }
+    });
+    return self;
+  }
+  emit() {
+    const self = this;
+    if (!self.eventsListeners) return self;
+    let events;
+    let data;
+    let context;
+    let eventsParents;
+    for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
+      args[_key2] = arguments[_key2];
+    }
+    if (typeof args[0] === 'string' || Array.isArray(args[0])) {
+      events = args[0];
+      data = args.slice(1, args.length);
+      context = self;
+      eventsParents = self.eventsParents;
+    } else {
+      events = args[0].events;
+      data = args[0].data;
+      context = args[0].context || self;
+      eventsParents = args[0].local ? [] : args[0].parents || self.eventsParents;
+    }
+    const eventsArray = Array.isArray(events) ? events : events.split(' ');
+    const localEvents = eventsArray.map(eventName => eventName.replace('local::', ''));
+    const parentEvents = eventsArray.filter(eventName => eventName.indexOf('local::') < 0);
+    localEvents.forEach(event => {
+      if (self.eventsListeners && self.eventsListeners[event]) {
+        const handlers = [];
+        self.eventsListeners[event].forEach(eventHandler => {
+          handlers.push(eventHandler);
+        });
+        handlers.forEach(eventHandler => {
+          eventHandler.apply(context, data);
+        });
+      }
+    });
+    if (eventsParents && eventsParents.length > 0) {
+      eventsParents.forEach(eventsParent => {
+        eventsParent.emit(parentEvents, ...data);
+      });
+    }
+    return self;
+  }
+}
+export default EventsClass;

package/shared/get-device.d.ts

@@ -0,0 +1,52 @@
+export interface Device {
+  /** true for iOS device */
+  ios: boolean;
+  /** true for Android device */
+  android: boolean;
+  /** true for Android Chrome */
+  androidChrome: boolean;
+  /** true for desktop browser */
+  desktop: boolean;
+  /** true for iPhone */
+  iphone: boolean;
+  /** true for iPod */
+  ipod: boolean;
+  /** true for iPad */
+  ipad: boolean;
+  /** true for MS Edge browser */
+  edge: boolean;
+  /** true for Internet Explorer browser */
+  ie: boolean;
+  /** true for FireFox browser */
+  firefox: boolean;
+  /** true for desktop macOS */
+  macos: boolean;
+  /** true for desktop windows */
+  windows: boolean;
+  /** true when app running in cordova environment */
+  cordova: boolean;
+  /** true when app running in capacitor environment */
+  capacitor: boolean;
+  /** true when app is running under Electron environment */
+  electron: boolean;
+  /** true when app is running under NW.js environment */
+  nwjs: boolean;
+  /** true if app runs in web view - webapp installed to home screen */
+  webView: boolean;
+  /** true if app runs in web view - webapp installed to home screen */
+  standalone: boolean;
+  /** Contains OS can be ios, android, macos, windows */
+  os: string;
+  /** Contains OS version, e.g. 11.2.0 */
+  osVersion: string;
+  /** Device pixel ratio */
+  pixelRatio: number;
+  /** Returns 'dark' or 'light' if (prefers-color-theme) media supported, otherwise returns undefined */
+  prefersColorScheme(): string;
+}
+
+export interface DeviceParams {
+  userAgent: string;
+}
+
+export const getDevice: (overrides?: DeviceParams) => Device;

package/shared/get-device.js

@@ -0,0 +1,147 @@
+import { getWindow, getDocument } from 'ssr-window';
+import { getSupport } from './get-support.js';
+let deviceCalculated;
+function calcDevice(_temp) {
+  let {
+    userAgent
+  } = _temp === void 0 ? {} : _temp;
+  const support = getSupport();
+  const window = getWindow();
+  const platform = window.navigator.platform;
+  const ua = userAgent || window.navigator.userAgent;
+  const device = {
+    ios: false,
+    android: false,
+    androidChrome: false,
+    desktop: false,
+    iphone: false,
+    ipod: false,
+    ipad: false,
+    edge: false,
+    ie: false,
+    firefox: false,
+    macos: false,
+    windows: false,
+    cordova: !!window.cordova,
+    electron: false,
+    capacitor: !!window.Capacitor,
+    nwjs: false
+  };
+  const screenWidth = window.screen.width;
+  const screenHeight = window.screen.height;
+  const android = ua.match(/(Android);?[\s\/]+([\d.]+)?/); // eslint-disable-line
+  let ipad = ua.match(/(iPad).*OS\s([\d_]+)/);
+  const ipod = ua.match(/(iPod)(.*OS\s([\d_]+))?/);
+  const iphone = !ipad && ua.match(/(iPhone\sOS|iOS|iPhone;\sCPU\sOS)\s([\d_]+)/);
+  const ie = ua.indexOf('MSIE ') >= 0 || ua.indexOf('Trident/') >= 0;
+  const edge = ua.indexOf('Edge/') >= 0;
+  const firefox = ua.indexOf('Gecko/') >= 0 && ua.indexOf('Firefox/') >= 0;
+  const windows = platform === 'Win32';
+  const electron = ua.toLowerCase().indexOf('electron') >= 0;
+  const nwjs = typeof nw !== 'undefined' && typeof process !== 'undefined' && typeof process.versions !== 'undefined' && typeof process.versions.nw !== 'undefined';
+  let macos = platform === 'MacIntel';
+
+  // iPadOs 13 fix
+  const iPadScreens = ['1024x1366', '1366x1024', '834x1194', '1194x834', '834x1112', '1112x834', '768x1024', '1024x768', '820x1180', '1180x820', '810x1080', '1080x810'];
+  if (!ipad && macos && support.touch && iPadScreens.indexOf(`${screenWidth}x${screenHeight}`) >= 0) {
+    ipad = ua.match(/(Version)\/([\d.]+)/);
+    if (!ipad) ipad = [0, 1, '13_0_0'];
+    macos = false;
+  }
+  device.ie = ie;
+  device.edge = edge;
+  device.firefox = firefox;
+
+  // Android
+  if (android) {
+    device.os = 'android';
+    device.osVersion = android[2];
+    device.android = true;
+    device.androidChrome = ua.toLowerCase().indexOf('chrome') >= 0;
+  }
+  if (ipad || iphone || ipod) {
+    device.os = 'ios';
+    device.ios = true;
+  }
+  // iOS
+  if (iphone && !ipod) {
+    device.osVersion = iphone[2].replace(/_/g, '.');
+    device.iphone = true;
+  }
+  if (ipad) {
+    device.osVersion = ipad[2].replace(/_/g, '.');
+    device.ipad = true;
+  }
+  if (ipod) {
+    device.osVersion = ipod[3] ? ipod[3].replace(/_/g, '.') : null;
+    device.ipod = true;
+  }
+  // iOS 8+ changed UA
+  if (device.ios && device.osVersion && ua.indexOf('Version/') >= 0) {
+    if (device.osVersion.split('.')[0] === '10') {
+      device.osVersion = ua.toLowerCase().split('version/')[1].split(' ')[0];
+    }
+  }
+
+  // Webview
+  device.webView = !!((iphone || ipad || ipod) && (ua.match(/.*AppleWebKit(?!.*Safari)/i) || window.navigator.standalone)) || window.matchMedia && window.matchMedia('(display-mode: standalone)').matches;
+  device.webview = device.webView;
+  device.standalone = device.webView;
+
+  // Desktop
+  device.desktop = !(device.ios || device.android) || electron || nwjs;
+  if (device.desktop) {
+    device.electron = electron;
+    device.nwjs = nwjs;
+    device.macos = macos;
+    device.windows = windows;
+    if (device.macos) {
+      device.os = 'macos';
+    }
+    if (device.windows) {
+      device.os = 'windows';
+    }
+  }
+
+  // Pixel Ratio
+  device.pixelRatio = window.devicePixelRatio || 1;
+
+  // Color Scheme
+  const DARK = '(prefers-color-scheme: dark)';
+  const LIGHT = '(prefers-color-scheme: light)';
+  device.prefersColorScheme = function prefersColorTheme() {
+    let theme;
+    if (window.matchMedia && window.matchMedia(LIGHT).matches) {
+      theme = 'light';
+    }
+    if (window.matchMedia && window.matchMedia(DARK).matches) {
+      theme = 'dark';
+    }
+    return theme;
+  };
+
+  // Export object
+  return device;
+}
+const IS_BROWSER = (() => {
+  const document = getDocument();
+  try {
+    // eslint-disable-next-line no-restricted-globals
+    return Boolean(document && document.body && document.body.getBoundingClientRect && document.body.getBoundingClientRect().width > 0);
+  } catch (e) {
+    return false;
+  }
+})();
+function getDevice(overrides, reset) {
+  if (overrides === void 0) {
+    overrides = {};
+  }
+  if (reset === void 0) {
+    reset = IS_BROWSER;
+  }
+  if (!deviceCalculated || reset) {
+    deviceCalculated = calcDevice(overrides);
+  }
+  return deviceCalculated;
+}
+export { getDevice };

package/shared/get-support.d.ts

@@ -0,0 +1,12 @@
+export interface Support {
+  /** Touch events support (touchstart, touchmove, touchend) */
+  touch: boolean;
+  /** Pointer events support */
+  pointerEvents: boolean;
+  /** Passive event listener support */
+  passiveListener: boolean;
+  /** Intersection Observer support */
+  intersectionObserver: boolean;
+}
+
+export const getSupport: () => Support;

package/shared/get-support.js

@@ -0,0 +1,35 @@
+import { getWindow, getDocument } from 'ssr-window';
+let support;
+function calcSupport() {
+  const window = getWindow();
+  const document = getDocument();
+  return {
+    touch: !!('ontouchstart' in window || window.DocumentTouch && document instanceof window.DocumentTouch),
+    pointerEvents: !!window.PointerEvent && 'maxTouchPoints' in window.navigator && window.navigator.maxTouchPoints >= 0,
+    passiveListener: function checkPassiveListener() {
+      let supportsPassive = false;
+      try {
+        const opts = Object.defineProperty({}, 'passive', {
+          // eslint-disable-next-line
+          get() {
+            supportsPassive = true;
+          }
+        });
+        window.addEventListener('testPassiveListener', null, opts);
+      } catch (e) {
+        // No support
+      }
+      return supportsPassive;
+    }(),
+    intersectionObserver: function checkObserver() {
+      return 'IntersectionObserver' in window;
+    }()
+  };
+}
+function getSupport() {
+  if (!support) {
+    support = calcSupport();
+  }
+  return support;
+}
+export { getSupport };

package/shared/history.js

@@ -0,0 +1,171 @@
+import { getWindow, getDocument } from 'ssr-window';
+import $ from './dom7.js';
+import { extend } from './utils.js';
+const History = {
+  queue: [],
+  clearQueue() {
+    if (History.queue.length === 0) return;
+    const currentQueue = History.queue.shift();
+    currentQueue();
+  },
+  routerQueue: [],
+  clearRouterQueue() {
+    if (History.routerQueue.length === 0) return;
+    const currentQueue = History.routerQueue.pop();
+    const {
+      router,
+      stateUrl,
+      action
+    } = currentQueue;
+    let animate = router.params.animate;
+    if (router.params.browserHistoryAnimate === false) animate = false;
+    if (action === 'back') {
+      router.back({
+        animate,
+        browserHistory: false
+      });
+    }
+    if (action === 'load') {
+      router.navigate(stateUrl, {
+        animate,
+        browserHistory: false
+      });
+    }
+  },
+  handle(e) {
+    if (History.blockPopstate) return;
+    const app = this;
+    // const mainView = app.views.main;
+    let state = e.state;
+    History.previousState = History.state;
+    History.state = state;
+    History.allowChange = true;
+    History.clearQueue();
+    state = History.state;
+    if (!state) state = {};
+    app.views.forEach(view => {
+      const router = view.router;
+      let viewState = state[view.id];
+      if (!viewState && view.params.browserHistory) {
+        viewState = {
+          url: view.router.history[0]
+        };
+      }
+      if (!viewState) return;
+      const stateUrl = viewState.url || undefined;
+      let animate = router.params.animate;
+      if (router.params.browserHistoryAnimate === false) animate = false;
+      if (stateUrl !== router.url) {
+        if (router.history.indexOf(stateUrl) >= 0) {
+          // Go Back
+          if (router.allowPageChange) {
+            router.back({
+              animate,
+              browserHistory: false
+            });
+          } else {
+            History.routerQueue.push({
+              action: 'back',
+              router
+            });
+          }
+        } else if (router.allowPageChange) {
+          // Load page
+          router.navigate(stateUrl, {
+            animate,
+            browserHistory: false
+          });
+        } else {
+          History.routerQueue.unshift({
+            action: 'load',
+            stateUrl,
+            router
+          });
+        }
+      }
+    });
+  },
+  initViewState(viewId, viewState) {
+    const window = getWindow();
+    const newState = extend({}, History.state || {}, {
+      [viewId]: viewState
+    });
+    History.state = newState;
+    window.history.replaceState(newState, '');
+  },
+  push(viewId, viewState, url) {
+    const window = getWindow();
+    const document = getDocument();
+    /* eslint-disable no-param-reassign */
+    if (url.substr(-3) === '#!/') {
+      url = url.replace('#!/', '');
+      if (url === '') {
+        url = document.location.href;
+        if (url.includes('#!/')) {
+          url = document.location.href.split('#!/')[0];
+        }
+      }
+    }
+    /* eslint-enable no-param-reassign */
+    if (!History.allowChange) {
+      History.queue.push(() => {
+        History.push(viewId, viewState, url);
+      });
+      return;
+    }
+    History.previousState = History.state;
+    const newState = extend({}, History.previousState || {}, {
+      [viewId]: viewState
+    });
+    History.state = newState;
+    window.history.pushState(newState, '', url);
+  },
+  replace(viewId, viewState, url) {
+    const window = getWindow();
+    if (url.substr(-3) === '#!/') {
+      // eslint-disable-next-line
+      url = url.replace('#!/', '');
+    }
+    if (!History.allowChange) {
+      History.queue.push(() => {
+        History.replace(viewId, viewState, url);
+      });
+      return;
+    }
+    History.previousState = History.state;
+    const newState = extend({}, History.previousState || {}, {
+      [viewId]: viewState
+    });
+    History.state = newState;
+    window.history.replaceState(newState, '', url);
+  },
+  go(index) {
+    const window = getWindow();
+    History.allowChange = false;
+    window.history.go(index);
+  },
+  back() {
+    const window = getWindow();
+    History.allowChange = false;
+    window.history.back();
+  },
+  allowChange: true,
+  previousState: {},
+  state: {},
+  blockPopstate: true,
+  init(app) {
+    const window = getWindow();
+    const document = getDocument();
+    History.state = window.history.state;
+    $(window).on('load', () => {
+      setTimeout(() => {
+        History.blockPopstate = false;
+      }, 0);
+    });
+    if (document.readyState && document.readyState === 'complete') {
+      History.blockPopstate = false;
+    }
+    $(window).on('popstate', History.handle.bind(app));
+  }
+};
+export default History;