quasar 2.1.0

package/src/utils/open-url.js

@@ -0,0 +1,62 @@
+import Platform from '../plugins/Platform.js'
+
+import { noop } from '../utils/event.js'
+
+function parseFeatures (winFeatures) {
+  const cfg = Object.assign({ noopener: true }, winFeatures)
+  const feat = []
+  Object.keys(cfg).forEach(key => {
+    if (cfg[ key ] === true) {
+      feat.push(key)
+    }
+  })
+  return feat.join(',')
+}
+
+function openWindow (url, reject, windowFeatures) {
+  let open = window.open
+
+  if (Platform.is.cordova === true) {
+    if (cordova !== void 0 && cordova.InAppBrowser !== void 0 && cordova.InAppBrowser.open !== void 0) {
+      open = cordova.InAppBrowser.open
+    }
+    else if (navigator !== void 0 && navigator.app !== void 0) {
+      return navigator.app.loadUrl(url, {
+        openExternal: true
+      })
+    }
+  }
+
+  const win = open(url, '_blank', parseFeatures(windowFeatures))
+
+  if (win) {
+    Platform.is.desktop && win.focus()
+    return win
+  }
+  else {
+    reject && reject()
+  }
+}
+
+export default (url, reject, windowFeatures) => {
+  if (
+    Platform.is.ios === true
+    && window.SafariViewController !== void 0
+  ) {
+    window.SafariViewController.isAvailable(available => {
+      if (available) {
+        window.SafariViewController.show(
+          { url },
+          noop,
+          reject
+        )
+      }
+      else {
+        openWindow(url, reject, windowFeatures)
+      }
+    })
+    return
+  }
+
+  return openWindow(url, reject, windowFeatures)
+}

package/src/utils/patterns.js

@@ -0,0 +1,31 @@
+// file referenced from docs
+
+const
+  hex = /^#[0-9a-fA-F]{3}([0-9a-fA-F]{3})?$/,
+  hexa = /^#[0-9a-fA-F]{4}([0-9a-fA-F]{4})?$/,
+  hexOrHexa = /^#([0-9a-fA-F]{3}|[0-9a-fA-F]{4}|[0-9a-fA-F]{6}|[0-9a-fA-F]{8})$/,
+  rgb = /^rgb\(((0|[1-9][\d]?|1[\d]{0,2}|2[\d]?|2[0-4][\d]|25[0-5]),){2}(0|[1-9][\d]?|1[\d]{0,2}|2[\d]?|2[0-4][\d]|25[0-5])\)$/,
+  rgba = /^rgba\(((0|[1-9][\d]?|1[\d]{0,2}|2[\d]?|2[0-4][\d]|25[0-5]),){2}(0|[1-9][\d]?|1[\d]{0,2}|2[\d]?|2[0-4][\d]|25[0-5]),(0|0\.[0-9]+[1-9]|0\.[1-9]+|1)\)$/
+
+export const testPattern = {
+  date: v => /^-?[\d]+\/[0-1]\d\/[0-3]\d$/.test(v),
+  time: v => /^([0-1]?\d|2[0-3]):[0-5]\d$/.test(v),
+  fulltime: v => /^([0-1]?\d|2[0-3]):[0-5]\d:[0-5]\d$/.test(v),
+  timeOrFulltime: v => /^([0-1]?\d|2[0-3]):[0-5]\d(:[0-5]\d)?$/.test(v),
+
+  hexColor: v => hex.test(v),
+  hexaColor: v => hexa.test(v),
+  hexOrHexaColor: v => hexOrHexa.test(v),
+
+  rgbColor: v => rgb.test(v),
+  rgbaColor: v => rgba.test(v),
+  rgbOrRgbaColor: v => rgb.test(v) || rgba.test(v),
+
+  hexOrRgbColor: v => hex.test(v) || rgb.test(v),
+  hexaOrRgbaColor: v => hexa.test(v) || rgba.test(v),
+  anyColor: v => hexOrHexa.test(v) || rgb.test(v) || rgba.test(v)
+}
+
+export default {
+  testPattern
+}

package/src/utils/prevent-scroll.js

@@ -0,0 +1,195 @@
+import { getEventPath, listenOpts, stopAndPrevent } from '../utils/event.js'
+import { hasScrollbar, getVerticalScrollPosition, getHorizontalScrollPosition } from '../utils/scroll.js'
+import { client } from '../plugins/Platform.js'
+
+let
+  registered = 0,
+  scrollPositionX,
+  scrollPositionY,
+  maxScrollTop,
+  vpPendingUpdate = false,
+  bodyLeft,
+  bodyTop,
+  closeTimer
+
+function onWheel (e) {
+  if (shouldPreventScroll(e)) {
+    stopAndPrevent(e)
+  }
+}
+
+function shouldPreventScroll (e) {
+  if (e.target === document.body || e.target.classList.contains('q-layout__backdrop')) {
+    return true
+  }
+
+  const
+    path = getEventPath(e),
+    shift = e.shiftKey && !e.deltaX,
+    scrollY = !shift && Math.abs(e.deltaX) <= Math.abs(e.deltaY),
+    delta = shift || scrollY ? e.deltaY : e.deltaX
+
+  for (let index = 0; index < path.length; index++) {
+    const el = path[ index ]
+
+    if (hasScrollbar(el, scrollY)) {
+      return scrollY
+        ? (
+            delta < 0 && el.scrollTop === 0
+              ? true
+              : delta > 0 && el.scrollTop + el.clientHeight === el.scrollHeight
+          )
+        : (
+            delta < 0 && el.scrollLeft === 0
+              ? true
+              : delta > 0 && el.scrollLeft + el.clientWidth === el.scrollWidth
+          )
+    }
+  }
+
+  return true
+}
+
+function onAppleScroll (e) {
+  if (e.target === document) {
+    // required, otherwise iOS blocks further scrolling
+    // until the mobile scrollbar dissappears
+    document.scrollingElement.scrollTop = document.scrollingElement.scrollTop // eslint-disable-line
+  }
+}
+
+function onAppleResize (evt) {
+  if (vpPendingUpdate === true) {
+    return
+  }
+
+  vpPendingUpdate = true
+
+  requestAnimationFrame(() => {
+    vpPendingUpdate = false
+
+    const
+      { height } = evt.target,
+      { clientHeight, scrollTop } = document.scrollingElement
+
+    if (maxScrollTop === void 0 || height !== window.innerHeight) {
+      maxScrollTop = clientHeight - height
+      document.scrollingElement.scrollTop = scrollTop
+    }
+
+    if (scrollTop > maxScrollTop) {
+      document.scrollingElement.scrollTop -= Math.ceil((scrollTop - maxScrollTop) / 8)
+    }
+  })
+}
+
+function apply (action) {
+  const
+    body = document.body,
+    hasViewport = window.visualViewport !== void 0
+
+  if (action === 'add') {
+    const { overflowY, overflowX } = window.getComputedStyle(body)
+
+    scrollPositionX = getHorizontalScrollPosition(window)
+    scrollPositionY = getVerticalScrollPosition(window)
+    bodyLeft = body.style.left
+    bodyTop = body.style.top
+
+    body.style.left = `-${ scrollPositionX }px`
+    body.style.top = `-${ scrollPositionY }px`
+
+    if (overflowX !== 'hidden' && (overflowX === 'scroll' || body.scrollWidth > window.innerWidth)) {
+      body.classList.add('q-body--force-scrollbar-x')
+    }
+    if (overflowY !== 'hidden' && (overflowY === 'scroll' || body.scrollHeight > window.innerHeight)) {
+      body.classList.add('q-body--force-scrollbar-y')
+    }
+
+    body.classList.add('q-body--prevent-scroll')
+    document.qScrollPrevented = true
+    if (client.is.ios === true) {
+      if (hasViewport === true) {
+        window.scrollTo(0, 0)
+        window.visualViewport.addEventListener('resize', onAppleResize, listenOpts.passiveCapture)
+        window.visualViewport.addEventListener('scroll', onAppleResize, listenOpts.passiveCapture)
+        window.scrollTo(0, 0)
+      }
+      else {
+        window.addEventListener('scroll', onAppleScroll, listenOpts.passiveCapture)
+      }
+    }
+  }
+
+  if (client.is.desktop === true && client.is.mac === true) {
+    // ref. https://developers.google.com/web/updates/2017/01/scrolling-intervention
+    window[ `${ action }EventListener` ]('wheel', onWheel, listenOpts.notPassive)
+  }
+
+  if (action === 'remove') {
+    if (client.is.ios === true) {
+      if (hasViewport === true) {
+        window.visualViewport.removeEventListener('resize', onAppleResize, listenOpts.passiveCapture)
+        window.visualViewport.removeEventListener('scroll', onAppleResize, listenOpts.passiveCapture)
+      }
+      else {
+        window.removeEventListener('scroll', onAppleScroll, listenOpts.passiveCapture)
+      }
+    }
+
+    body.classList.remove('q-body--prevent-scroll')
+    body.classList.remove('q-body--force-scrollbar-x')
+    body.classList.remove('q-body--force-scrollbar-y')
+
+    document.qScrollPrevented = false
+
+    body.style.left = bodyLeft
+    body.style.top = bodyTop
+
+    window.scrollTo(scrollPositionX, scrollPositionY)
+    maxScrollTop = void 0
+  }
+}
+
+export default function (state) {
+  let action = 'add'
+
+  if (state === true) {
+    registered++
+
+    if (closeTimer !== void 0) {
+      clearTimeout(closeTimer)
+      closeTimer = void 0
+      return
+    }
+
+    if (registered > 1) {
+      return
+    }
+  }
+  else {
+    if (registered === 0) {
+      return
+    }
+
+    registered--
+
+    if (registered > 0) {
+      return
+    }
+
+    action = 'remove'
+
+    if (client.is.ios === true && client.is.nativeMobile === true) {
+      clearTimeout(closeTimer)
+
+      closeTimer = setTimeout(() => {
+        apply(action)
+        closeTimer = void 0
+      }, 100)
+      return
+    }
+  }
+
+  apply(action)
+}

package/src/utils/private/click-outside.js

@@ -0,0 +1,81 @@
+import { listenOpts } from '../event.js'
+
+let timer
+
+const
+  { notPassiveCapture } = listenOpts,
+  registeredList = []
+
+function hasModalsAbove (node) {
+  while ((node = node.nextElementSibling) !== null) {
+    if (node.classList.contains('q-dialog--modal')) {
+      return true
+    }
+  }
+
+  return false
+}
+
+function globalHandler (evt) {
+  clearTimeout(timer)
+
+  const target = evt.target
+
+  if (
+    target === void 0
+    || target.nodeType === 8
+    || target.classList.contains('no-pointer-events') === true
+  ) {
+    return
+  }
+
+  for (let i = registeredList.length - 1; i >= 0; i--) {
+    const state = registeredList[ i ]
+    if (
+      (
+        state.anchorEl.value === null
+        || state.anchorEl.value.contains(target) === false
+      )
+      && (
+        target === document.body
+        || (state.innerRef.value  !== null && state.innerRef.value.contains(target) === false)
+      )
+      && (
+        state.getEl !== void 0
+          ? hasModalsAbove(state.getEl()) !== true
+          : true
+      )
+    ) {
+      // mark the event as being processed by clickOutside
+      // used to prevent refocus after menu close
+      evt.qClickOutside = true
+      state.onClickOutside(evt)
+    }
+    else {
+      return
+    }
+  }
+}
+
+export function addClickOutside (clickOutsideProps) {
+  registeredList.push(clickOutsideProps)
+
+  if (registeredList.length === 1) {
+    document.addEventListener('mousedown', globalHandler, notPassiveCapture)
+    document.addEventListener('touchstart', globalHandler, notPassiveCapture)
+  }
+}
+
+export function removeClickOutside (clickOutsideProps) {
+  const index = registeredList.findIndex(h => h === clickOutsideProps)
+
+  if (index > -1) {
+    registeredList.splice(index, 1)
+
+    if (registeredList.length === 0) {
+      clearTimeout(timer)
+      document.removeEventListener('mousedown', globalHandler, notPassiveCapture)
+      document.removeEventListener('touchstart', globalHandler, notPassiveCapture)
+    }
+  }
+}

package/src/utils/private/date-persian.js

@@ -0,0 +1,281 @@
+// taken from https://github.com/jalaali/jalaali-js
+
+/*
+  Jalaali years starting the 33-year rule.
+*/
+const breaks = [
+  -61, 9, 38, 199, 426, 686, 756, 818, 1111, 1181, 1210,
+  1635, 2060, 2097, 2192, 2262, 2324, 2394, 2456, 3178
+]
+
+/*
+  Converts a Gregorian date to Jalaali.
+*/
+export function toJalaali (gy, gm, gd) {
+  if (Object.prototype.toString.call(gy) === '[object Date]') {
+    gd = gy.getDate()
+    gm = gy.getMonth() + 1
+    gy = gy.getFullYear()
+  }
+  return d2j(g2d(gy, gm, gd))
+}
+
+/*
+  Converts a Jalaali date to Gregorian.
+*/
+export function toGregorian (jy, jm, jd) {
+  return d2g(j2d(jy, jm, jd))
+}
+
+/*
+  Checks whether a Jalaali date is valid or not.
+*/
+export function isValidJalaaliDate (jy, jm, jd) {
+  return jy >= -61 && jy <= 3177
+          && jm >= 1 && jm <= 12
+          && jd >= 1 && jd <= jalaaliMonthLength(jy, jm)
+}
+
+/*
+  Is this a leap year or not?
+*/
+function isLeapJalaaliYear (jy) {
+  return jalCalLeap(jy) === 0
+}
+
+/*
+  Number of days in a given month in a Jalaali year.
+*/
+export function jalaaliMonthLength (jy, jm) {
+  if (jm <= 6) return 31
+  if (jm <= 11) return 30
+  if (isLeapJalaaliYear(jy)) return 30
+  return 29
+}
+
+/*
+    This function determines if the Jalaali (Persian) year is
+    leap (366-day long) or is the common year (365 days)
+
+    @param jy Jalaali calendar year (-61 to 3177)
+    @returns number of years since the last leap year (0 to 4)
+ */
+function jalCalLeap (jy) {
+  const bl = breaks.length
+  let
+    jp = breaks[ 0 ],
+    jm,
+    jump,
+    leap,
+    n,
+    i
+
+  if (jy < jp || jy >= breaks[ bl - 1 ]) { throw new Error('Invalid Jalaali year ' + jy) }
+
+  for (i = 1; i < bl; i += 1) {
+    jm = breaks[ i ]
+    jump = jm - jp
+    if (jy < jm) { break }
+    jp = jm
+  }
+  n = jy - jp
+
+  if (jump - n < 6) { n = n - jump + div(jump + 4, 33) * 33 }
+  leap = mod(mod(n + 1, 33) - 1, 4)
+  if (leap === -1) {
+    leap = 4
+  }
+
+  return leap
+}
+
+/*
+  This function determines if the Jalaali (Persian) year is
+  leap (366-day long) or is the common year (365 days), and
+  finds the day in March (Gregorian calendar) of the first
+  day of the Jalaali year (jy).
+
+  @param jy Jalaali calendar year (-61 to 3177)
+  @param withoutLeap when don't need leap (true or false) default is false
+  @return
+    leap: number of years since the last leap year (0 to 4)
+    gy: Gregorian year of the beginning of Jalaali year
+    march: the March day of Farvardin the 1st (1st day of jy)
+  @see: http://www.astro.uni.torun.pl/~kb/Papers/EMP/PersianC-EMP.htm
+  @see: http://www.fourmilab.ch/documents/calendar/
+*/
+function jalCal (jy, withoutLeap) {
+  const
+    bl = breaks.length,
+    gy = jy + 621
+  let
+    leapJ = -14,
+    jp = breaks[ 0 ],
+    jm,
+    jump,
+    leap,
+    n,
+    i
+
+  if (jy < jp || jy >= breaks[ bl - 1 ]) { throw new Error('Invalid Jalaali year ' + jy) }
+
+  // Find the limiting years for the Jalaali year jy.
+  for (i = 1; i < bl; i += 1) {
+    jm = breaks[ i ]
+    jump = jm - jp
+    if (jy < jm) { break }
+    leapJ = leapJ + div(jump, 33) * 8 + div(mod(jump, 33), 4)
+    jp = jm
+  }
+  n = jy - jp
+
+  // Find the number of leap years from AD 621 to the beginning
+  // of the current Jalaali year in the Persian calendar.
+  leapJ = leapJ + div(n, 33) * 8 + div(mod(n, 33) + 3, 4)
+  if (mod(jump, 33) === 4 && jump - n === 4) { leapJ += 1 }
+
+  // And the same in the Gregorian calendar (until the year gy).
+  const leapG = div(gy, 4) - div((div(gy, 100) + 1) * 3, 4) - 150
+
+  // Determine the Gregorian date of Farvardin the 1st.
+  const march = 20 + leapJ - leapG
+
+  // Find how many years have passed since the last leap year.
+  if (!withoutLeap) {
+    if (jump - n < 6) { n = n - jump + div(jump + 4, 33) * 33 }
+    leap = mod(mod(n + 1, 33) - 1, 4)
+    if (leap === -1) {
+      leap = 4
+    }
+  }
+
+  return {
+    leap: leap,
+    gy: gy,
+    march: march
+  }
+}
+
+/*
+  Converts a date of the Jalaali calendar to the Julian Day number.
+
+  @param jy Jalaali year (1 to 3100)
+  @param jm Jalaali month (1 to 12)
+  @param jd Jalaali day (1 to 29/31)
+  @return Julian Day number
+*/
+function j2d (jy, jm, jd) {
+  const r = jalCal(jy, true)
+  return g2d(r.gy, 3, r.march) + (jm - 1) * 31 - div(jm, 7) * (jm - 7) + jd - 1
+}
+
+/*
+  Converts the Julian Day number to a date in the Jalaali calendar.
+
+  @param jdn Julian Day number
+  @return
+    jy: Jalaali year (1 to 3100)
+    jm: Jalaali month (1 to 12)
+    jd: Jalaali day (1 to 29/31)
+*/
+function d2j (jdn) {
+  const gy = d2g(jdn).gy // Calculate Gregorian year (gy).
+  let
+    jy = gy - 621,
+    jd,
+    jm,
+    k
+  const
+    r = jalCal(jy, false),
+    jdn1f = g2d(gy, 3, r.march)
+
+  // Find number of days that passed since 1 Farvardin.
+  k = jdn - jdn1f
+  if (k >= 0) {
+    if (k <= 185) {
+      // The first 6 months.
+      jm = 1 + div(k, 31)
+      jd = mod(k, 31) + 1
+      return {
+        jy: jy,
+        jm: jm,
+        jd: jd
+      }
+    }
+    else {
+      // The remaining months.
+      k -= 186
+    }
+  }
+  else {
+    // Previous Jalaali year.
+    jy -= 1
+    k += 179
+    if (r.leap === 1) { k += 1 }
+  }
+  jm = 7 + div(k, 30)
+  jd = mod(k, 30) + 1
+  return {
+    jy: jy,
+    jm: jm,
+    jd: jd
+  }
+}
+
+/*
+  Calculates the Julian Day number from Gregorian or Julian
+  calendar dates. This integer number corresponds to the noon of
+  the date (i.e. 12 hours of Universal Time).
+  The procedure was tested to be good since 1 March, -100100 (of both
+  calendars) up to a few million years into the future.
+
+  @param gy Calendar year (years BC numbered 0, -1, -2, ...)
+  @param gm Calendar month (1 to 12)
+  @param gd Calendar day of the month (1 to 28/29/30/31)
+  @return Julian Day number
+*/
+function g2d (gy, gm, gd) {
+  let d = div((gy + div(gm - 8, 6) + 100100) * 1461, 4)
+      + div(153 * mod(gm + 9, 12) + 2, 5)
+      + gd - 34840408
+  d = d - div(div(gy + 100100 + div(gm - 8, 6), 100) * 3, 4) + 752
+  return d
+}
+
+/*
+  Calculates Gregorian and Julian calendar dates from the Julian Day number
+  (jdn) for the period since jdn=-34839655 (i.e. the year -100100 of both
+  calendars) to some millions years ahead of the present.
+
+  @param jdn Julian Day number
+  @return
+    gy: Calendar year (years BC numbered 0, -1, -2, ...)
+    gm: Calendar month (1 to 12)
+    gd: Calendar day of the month M (1 to 28/29/30/31)
+*/
+function d2g (jdn) {
+  let j = 4 * jdn + 139361631
+  j = j + div(div(4 * jdn + 183187720, 146097) * 3, 4) * 4 - 3908
+  const
+    i = div(mod(j, 1461), 4) * 5 + 308,
+    gd = div(mod(i, 153), 5) + 1,
+    gm = mod(div(i, 153), 12) + 1,
+    gy = div(j, 1461) - 100100 + div(8 - gm, 6)
+  return {
+    gy: gy,
+    gm: gm,
+    gd: gd
+  }
+}
+
+/*
+  Utility helper functions.
+*/
+
+function div (a, b) {
+  return ~~(a / b)
+}
+
+function mod (a, b) {
+  return a - ~~(a / b) * b
+}