quasar 2.1.0

package/src/utils/scroll.js

@@ -0,0 +1,198 @@
+import { css, getElement } from './dom.js'
+
+const scrollTargets = __QUASAR_SSR_SERVER__
+  ? []
+  : [ null, document, document.body, document.scrollingElement, document.documentElement ]
+
+export function getScrollTarget (el, targetEl) {
+  let target = getElement(targetEl)
+
+  if (target === void 0) {
+    if (el === void 0 || el === null) {
+      return window
+    }
+
+    target = el.closest('.scroll,.scroll-y,.overflow-auto')
+  }
+
+  return scrollTargets.includes(target)
+    ? window
+    : target
+}
+
+export function getScrollHeight (el) {
+  return (el === window ? document.body : el).scrollHeight
+}
+
+export function getScrollWidth (el) {
+  return (el === window ? document.body : el).scrollWidth
+}
+
+export function getVerticalScrollPosition (scrollTarget) {
+  return scrollTarget === window
+    ? window.pageYOffset || window.scrollY || document.body.scrollTop || 0
+    : scrollTarget.scrollTop
+}
+
+export function getHorizontalScrollPosition (scrollTarget) {
+  return scrollTarget === window
+    ? window.pageXOffset || window.scrollX || document.body.scrollLeft || 0
+    : scrollTarget.scrollLeft
+}
+
+export function animVerticalScrollTo (el, to, duration = 0 /* , prevTime */) {
+  const prevTime = arguments[ 3 ] === void 0 ? performance.now() : arguments[ 3 ]
+  const pos = getVerticalScrollPosition(el)
+
+  if (duration <= 0) {
+    if (pos !== to) {
+      setScroll(el, to)
+    }
+    return
+  }
+
+  requestAnimationFrame(nowTime => {
+    const frameTime = nowTime - prevTime
+    const newPos = pos + (to - pos) / Math.max(frameTime, duration) * frameTime
+    setScroll(el, newPos)
+    if (newPos !== to) {
+      animVerticalScrollTo(el, to, duration - frameTime, nowTime)
+    }
+  })
+}
+
+export function animHorizontalScrollTo (el, to, duration = 0 /* , prevTime */) {
+  const prevTime = arguments[ 3 ] === void 0 ? performance.now() : arguments[ 3 ]
+  const pos = getHorizontalScrollPosition(el)
+
+  if (duration <= 0) {
+    if (pos !== to) {
+      setHorizontalScroll(el, to)
+    }
+    return
+  }
+
+  requestAnimationFrame(nowTime => {
+    const frameTime = nowTime - prevTime
+    const newPos = pos + (to - pos) / Math.max(frameTime, duration) * frameTime
+    setHorizontalScroll(el, newPos)
+    if (newPos !== to) {
+      animHorizontalScrollTo(el, to, duration - frameTime, nowTime)
+    }
+  })
+}
+
+function setScroll (scrollTarget, offset) {
+  if (scrollTarget === window) {
+    window.scrollTo(window.pageXOffset || window.scrollX || document.body.scrollLeft || 0, offset)
+    return
+  }
+  scrollTarget.scrollTop = offset
+}
+
+function setHorizontalScroll (scrollTarget, offset) {
+  if (scrollTarget === window) {
+    window.scrollTo(offset, window.pageYOffset || window.scrollY || document.body.scrollTop || 0)
+    return
+  }
+  scrollTarget.scrollLeft = offset
+}
+
+export function setVerticalScrollPosition (scrollTarget, offset, duration) {
+  if (duration) {
+    animVerticalScrollTo(scrollTarget, offset, duration)
+    return
+  }
+  setScroll(scrollTarget, offset)
+}
+
+export function setHorizontalScrollPosition (scrollTarget, offset, duration) {
+  if (duration) {
+    animHorizontalScrollTo(scrollTarget, offset, duration)
+    return
+  }
+  setHorizontalScroll(scrollTarget, offset)
+}
+
+let size
+export function getScrollbarWidth () {
+  if (size !== undefined) {
+    return size
+  }
+
+  const
+    inner = document.createElement('p'),
+    outer = document.createElement('div')
+
+  css(inner, {
+    width: '100%',
+    height: '200px'
+  })
+  css(outer, {
+    position: 'absolute',
+    top: '0px',
+    left: '0px',
+    visibility: 'hidden',
+    width: '200px',
+    height: '150px',
+    overflow: 'hidden'
+  })
+
+  outer.appendChild(inner)
+
+  document.body.appendChild(outer)
+
+  const w1 = inner.offsetWidth
+  outer.style.overflow = 'scroll'
+  let w2 = inner.offsetWidth
+
+  if (w1 === w2) {
+    w2 = outer.clientWidth
+  }
+
+  outer.remove()
+  size = w1 - w2
+
+  return size
+}
+
+export function hasScrollbar (el, onY = true) {
+  if (!el || el.nodeType !== Node.ELEMENT_NODE) {
+    return false
+  }
+
+  return onY
+    ? (
+        el.scrollHeight > el.clientHeight && (
+          el.classList.contains('scroll')
+          || el.classList.contains('overflow-auto')
+          || [ 'auto', 'scroll' ].includes(window.getComputedStyle(el)[ 'overflow-y' ])
+        )
+      )
+    : (
+        el.scrollWidth > el.clientWidth && (
+          el.classList.contains('scroll')
+          || el.classList.contains('overflow-auto')
+          || [ 'auto', 'scroll' ].includes(window.getComputedStyle(el)[ 'overflow-x' ])
+        )
+      )
+}
+
+export default {
+  getScrollTarget,
+
+  getScrollHeight,
+  getScrollWidth,
+
+  getVerticalScrollPosition,
+  getHorizontalScrollPosition,
+
+  animVerticalScrollTo,
+  animHorizontalScrollTo,
+
+  setVerticalScrollPosition,
+  setHorizontalScrollPosition,
+
+  getScrollbarWidth,
+  hasScrollbar
+}

package/src/utils/set-css-var.js

@@ -0,0 +1,13 @@
+export default function setCssVar (propName, value, element = document.body) {
+  if (typeof propName !== 'string') {
+    throw new TypeError('Expected a string as propName')
+  }
+  if (typeof value !== 'string') {
+    throw new TypeError('Expected a string as value')
+  }
+  if (!(element instanceof Element)) {
+    throw new TypeError('Expected a DOM element')
+  }
+
+  element.style.setProperty(`--q-${ propName }`, value)
+}

package/src/utils/throttle.js

@@ -0,0 +1,13 @@
+export default function (fn, limit = 250) {
+  let wait = false, result
+
+  return function (/* ...args */) {
+    if (wait === false) {
+      wait = true
+      setTimeout(() => { wait = false }, limit)
+      result = fn.apply(this, arguments)
+    }
+
+    return result
+  }
+}

package/src/utils/uid.js

@@ -0,0 +1,72 @@
+/**
+ * Based on the work of https://github.com/jchook/uuid-random
+ */
+
+let
+  buf,
+  bufIdx = 0
+const hexBytes = new Array(256)
+
+// Pre-calculate toString(16) for speed
+for (let i = 0; i < 256; i++) {
+  hexBytes[ i ] = (i + 0x100).toString(16).substr(1)
+}
+
+// Use best available PRNG
+const randomBytes = (() => {
+  // Node & Browser support
+  const lib = typeof crypto !== 'undefined'
+    ? crypto
+    : (
+        typeof window !== 'undefined'
+          ? window.crypto || window.msCrypto
+          : void 0
+      )
+
+  if (lib !== void 0) {
+    if (lib.randomBytes !== void 0) {
+      return lib.randomBytes
+    }
+    if (lib.getRandomValues !== void 0) {
+      return n => {
+        const bytes = new Uint8Array(n)
+        lib.getRandomValues(bytes)
+        return bytes
+      }
+    }
+  }
+
+  return n => {
+    const r = []
+    for (let i = n; i > 0; i--) {
+      r.push(Math.floor(Math.random() * 256))
+    }
+    return r
+  }
+})()
+
+// Buffer random numbers for speed
+// Reduce memory usage by decreasing this number (min 16)
+// or improve speed by increasing this number (try 16384)
+const BUFFER_SIZE = 4096
+
+export default function () {
+  // Buffer some random bytes for speed
+  if (buf === void 0 || (bufIdx + 16 > BUFFER_SIZE)) {
+    bufIdx = 0
+    buf = randomBytes(BUFFER_SIZE)
+  }
+
+  const b = Array.prototype.slice.call(buf, bufIdx, (bufIdx += 16))
+  b[ 6 ] = (b[ 6 ] & 0x0f) | 0x40
+  b[ 8 ] = (b[ 8 ] & 0x3f) | 0x80
+
+  return hexBytes[ b[ 0 ] ] + hexBytes[ b[ 1 ] ]
+    + hexBytes[ b[ 2 ] ] + hexBytes[ b[ 3 ] ] + '-'
+    + hexBytes[ b[ 4 ] ] + hexBytes[ b[ 5 ] ] + '-'
+    + hexBytes[ b[ 6 ] ] + hexBytes[ b[ 7 ] ] + '-'
+    + hexBytes[ b[ 8 ] ] + hexBytes[ b[ 9 ] ] + '-'
+    + hexBytes[ b[ 10 ] ] + hexBytes[ b[ 11 ] ]
+    + hexBytes[ b[ 12 ] ] + hexBytes[ b[ 13 ] ]
+    + hexBytes[ b[ 14 ] ] + hexBytes[ b[ 15 ] ]
+}

package/src/utils.js

@@ -0,0 +1,46 @@
+import clone from './utils/clone.js'
+import colors from './utils/colors.js'
+import copyToClipboard from './utils/copy-to-clipboard.js'
+import createMetaMixin from './utils/create-meta-mixin.js'
+import createUploaderComponent from './utils/create-uploader-component.js'
+import date from './utils/date.js'
+import debounce from './utils/debounce.js'
+import dom from './utils/dom.js'
+import event, { noop } from './utils/event.js'
+import exportFile from './utils/export-file.js'
+import extend from './utils/extend.js'
+import format from './utils/format.js'
+import frameDebounce from './utils/frame-debounce.js'
+import getCssVar from './utils/get-css-var.js'
+import morph from './utils/morph.js'
+import openURL from './utils/open-url.js'
+import patterns from './utils/patterns.js'
+import scroll from './utils/scroll.js'
+import setCssVar from './utils/set-css-var.js'
+import throttle from './utils/throttle.js'
+import uid from './utils/uid.js'
+
+export {
+  clone,
+  colors,
+  copyToClipboard,
+  createMetaMixin,
+  createUploaderComponent,
+  date,
+  debounce,
+  dom,
+  event,
+  exportFile,
+  extend,
+  format,
+  frameDebounce,
+  getCssVar,
+  noop,
+  morph,
+  openURL,
+  patterns,
+  scroll,
+  setCssVar,
+  throttle,
+  uid
+}

package/src/vue-plugin.js

@@ -0,0 +1,10 @@
+import installQuasar from './install-quasar.js'
+import lang from './lang.js'
+import iconSet from './icon-set.js'
+
+export default {
+  version: __QUASAR_VERSION__,
+  install: installQuasar,
+  lang,
+  iconSet
+}

package/wrappers/index.js

@@ -0,0 +1,31 @@
+// Functions in this file are no-op,
+//  they just take a callback function and return it
+// They're used to apply typings to the callback
+//  parameters and return value when using Quasar with TypeScript
+// We need these in `ui` folder to make `quasar/wrapper` import work,
+//  but they are useful only for Quasar CLI projects
+// They are typed via module augmentation by `@quasar/app`
+
+module.exports.boot = function (callback) {
+  return callback
+}
+
+module.exports.ssrMiddleware = function (callback) {
+  return callback
+}
+
+module.exports.configure = function (callback) {
+  return callback
+}
+
+module.exports.preFetch = function (callback) {
+  return callback
+}
+
+module.exports.route = function (callback) {
+  return callback
+}
+
+module.exports.store = function (callback) {
+  return callback
+}