quasar 2.1.0

package/src/plugins/AppFullscreen.js

@@ -0,0 +1,110 @@
+import defineReactivePlugin from '../utils/private/define-reactive-plugin.js'
+import { changeGlobalNodesTarget } from '../utils/private/global-nodes.js'
+
+const prefixes = {}
+
+function getFullscreenElement () {
+  return (
+    document.fullscreenElement
+    || document.mozFullScreenElement
+    || document.webkitFullscreenElement
+    || document.msFullscreenElement
+  )
+}
+
+// needed for consistency across browsers
+function promisify (target, fn) {
+  try {
+    const res = target[ fn ]()
+    return res === void 0
+      ? Promise.resolve()
+      : res
+  }
+  catch (err) {
+    return Promise.reject(err)
+  }
+}
+
+const Plugin = defineReactivePlugin({
+  isActive: false,
+  activeEl: null
+}, {
+  isCapable: false,
+
+  request (target) {
+    if (Plugin.isCapable === true && Plugin.isActive === false) {
+      const el = target || document.documentElement
+      return promisify(el, prefixes.request)
+    }
+
+    return Plugin.__getErr()
+  },
+
+  exit () {
+    return Plugin.isCapable === true && Plugin.isActive === true
+      ? promisify(document, prefixes.exit)
+      : Plugin.__getErr()
+  },
+
+  toggle (target) {
+    return Plugin.isActive === true
+      ? Plugin.exit()
+      : Plugin.request(target)
+  },
+
+  install ({ $q }) {
+    $q.fullscreen = this
+  }
+})
+
+if (__QUASAR_SSR_SERVER__ !== true) {
+  function init () {
+    prefixes.request = [
+      'requestFullscreen',
+      'msRequestFullscreen', 'mozRequestFullScreen', 'webkitRequestFullscreen'
+    ].find(request => document.documentElement[ request ] !== void 0)
+
+    Plugin.isCapable = prefixes.request !== void 0
+
+    if (Plugin.isCapable === false) {
+      // it means the browser does NOT support it
+      Plugin.__getErr = () => Promise.reject('Not capable')
+      return
+    }
+
+    Plugin.__getErr = () => Promise.resolve()
+
+    prefixes.exit = [
+      'exitFullscreen',
+      'msExitFullscreen', 'mozCancelFullScreen', 'webkitExitFullscreen'
+    ].find(exit => document[ exit ])
+
+    Plugin.isActive = !!getFullscreenElement()
+
+    ;[
+      'onfullscreenchange',
+      'onmsfullscreenchange', 'onwebkitfullscreenchange'
+    ].forEach(evt => {
+      document[ evt ] = () => {
+        Plugin.isActive = Plugin.isActive === false
+
+        if (Plugin.isActive === false) {
+          Plugin.activeEl = null
+          changeGlobalNodesTarget(document.body)
+        }
+        else {
+          Plugin.activeEl = getFullscreenElement()
+          changeGlobalNodesTarget(
+            Plugin.activeEl === document.documentElement
+              ? document.body
+              : Plugin.activeEl
+          )
+        }
+      }
+    })
+  }
+
+  init()
+}
+
+export default Plugin

package/src/plugins/AppFullscreen.json

@@ -0,0 +1,74 @@
+{
+  "meta": {
+    "docsUrl": "https://v2.quasar.dev/quasar-plugins/app-fullscreen"
+  },
+
+  "injection": "$q.fullscreen",
+
+  "props": {
+    "isCapable": {
+      "type": "Boolean",
+      "desc": "Does browser support it?"
+    },
+
+    "isActive": {
+      "type": "Boolean",
+      "desc": "Is Fullscreen active?"
+    },
+
+    "activeEl": {
+      "type": "Object",
+      "desc": "The DOM element used as root for fullscreen, otherwise 'null'",
+      "__exemption": [ "examples" ]
+    }
+  },
+
+  "methods": {
+    "request": {
+      "desc": "Request going into Fullscreen (with optional target)",
+      "params": {
+        "target": {
+          "type": "Element",
+          "desc": "Optional Element of target to request Fullscreen on",
+          "examples": [ "document.getElementById('example')" ]
+        }
+      },
+      "returns": {
+        "type": "Promise<any>",
+        "desc": "A Promise with the outcome (true -> validation was a success, false -> invalid models detected)",
+        "examples": [
+          "request().then(response => { ... }).catch(err => { ... })"
+        ]
+      }
+    },
+
+    "exit": {
+      "desc": "Request exiting out of Fullscreen mode",
+      "returns": {
+        "type": "Promise<any>",
+        "desc": "A Promise with the outcome (true -> validation was a success, false -> invalid models detected)",
+        "examples": [
+          "exit().then(response => { ... }).catch(err => { ... })"
+        ]
+      }
+    },
+
+    "toggle": {
+      "desc": "Request toggling Fullscreen mode (with optional target if requesting going into Fullscreen only)",
+      "params": {
+        "target": {
+          "type": "Element",
+          "desc": "Optional Element of target to request Fullscreen on",
+          "examples": [ "document.getElementById('example')" ]
+        }
+      },
+      "returns": {
+        "type": "Promise<any>",
+        "desc": "A Promise with the outcome (true -> validation was a success, false -> invalid models detected)",
+        "examples": [
+          "toggle().then(response => { ... }).catch(err => { ... })"
+        ]
+      }
+    }
+  }
+}

package/src/plugins/AppVisibility.js

@@ -0,0 +1,40 @@
+import defineReactivePlugin from '../utils/private/define-reactive-plugin.js'
+
+const Plugin = defineReactivePlugin({
+  appVisible: true
+}, {
+  install ({ $q }) {
+    if (__QUASAR_SSR_SERVER__) {
+      this.appVisible = $q.appVisible = true
+      return
+    }
+
+    Object.defineProperty($q, 'appVisible', {
+      get: () => this.appVisible
+    })
+  }
+})
+
+if (__QUASAR_SSR_SERVER__ !== true) {
+  let prop, evt
+
+  if (typeof document.hidden !== 'undefined') { // Opera 12.10 and Firefox 18 and later support
+    prop = 'hidden'
+    evt = 'visibilitychange'
+  }
+  else if (typeof document.msHidden !== 'undefined') {
+    prop = 'msHidden'
+    evt = 'msvisibilitychange'
+  }
+  else if (typeof document.webkitHidden !== 'undefined') {
+    prop = 'webkitHidden'
+    evt = 'webkitvisibilitychange'
+  }
+
+  if (evt && typeof document[ prop ] !== 'undefined') {
+    const update = () => { Plugin.appVisible = !document[ prop ] }
+    document.addEventListener(evt, update, false)
+  }
+}
+
+export default Plugin

package/src/plugins/AppVisibility.json

@@ -0,0 +1,16 @@
+{
+  "meta": {
+    "docsUrl": "https://v2.quasar.dev/quasar-plugins/app-visibility"
+  },
+
+  "injection": "$q.appVisible",
+
+  "props": {
+    "appVisible": {
+      "tsInjectionPoint": true,
+      "type": "Boolean",
+      "desc": "Does the app have user focus? Or the app runs in the background / another tab has the user's attention",
+      "reactive": true
+    }
+  }
+}

package/src/plugins/BottomSheet.js

@@ -0,0 +1,13 @@
+import BottomSheet from '../components/dialog-bottom-sheet/BottomSheet.js'
+import globalDialog from '../utils/private/global-dialog.js'
+
+export default {
+  install ({ $q, parentApp }) {
+    if (this.__installed === true) {
+      $q.bottomSheet = globalDialog(BottomSheet, false, parentApp)
+    }
+    else {
+      this.create = $q.bottomSheet = globalDialog(BottomSheet, false, parentApp)
+    }
+  }
+}

package/src/plugins/BottomSheet.json

@@ -0,0 +1,91 @@
+{
+  "mixins": [ "utils/private/global-dialog" ],
+
+  "meta": {
+    "docsUrl": "https://v2.quasar.dev/quasar-plugins/bottom-sheet"
+  },
+
+  "injection": "$q.bottomSheet",
+
+  "methods": {
+    "create": {
+      "tsInjectionPoint": true,
+      "desc": "Creates an ad-hoc Bottom Sheet; Same as calling $q.bottomSheet(...)",
+      "params": {
+        "opts": {
+          "desc": "Bottom Sheet options",
+          "definition": {
+            "title": {
+              "type": "String",
+              "desc": "Title",
+              "examples": [ "Share" ]
+            },
+
+            "message": {
+              "type": "String",
+              "desc": "Message",
+              "examples": [ "Please select how to share" ]
+            },
+
+            "actions": {
+              "type": "Array",
+              "desc": "Array of Objects, each Object defining an action",
+              "definition": {
+                "classes": {
+                  "type": [ "String", "Array", "Object" ],
+                  "desc": "CSS classes for this action",
+                  "examples": [ "my-class" ]
+                },
+
+                "icon": {
+                  "extends": "icon"
+                },
+
+                "img": {
+                  "type": "String",
+                  "desc": "Path to an image for this action",
+                  "examples": [
+                    "(statics folder) statics/img/something.png",
+                    "(relative path format) :src=\"require('./my_img.jpg')\"",
+                    "(URL) https://some-site.net/some-img.gif"
+                  ]
+                },
+
+                "avatar": {
+                  "type": "Boolean",
+                  "desc": "Display img as avatar (round borders)"
+                },
+
+                "label": {
+                  "type": [ "String", "Number" ],
+                  "desc": "Action label",
+                  "examples": [ "Facebook" ]
+                }
+              }
+            },
+
+            "grid": {
+              "type": "Boolean",
+              "desc": "Display actions as a grid instead of as a list"
+            },
+
+            "dark": {
+              "extends": "dark",
+              "desc": "Apply dark mode"
+            },
+
+            "seamless": {
+              "type": "Boolean",
+              "desc": "Put Bottom Sheet into seamless mode; Does not use a backdrop so user is able to interact with the rest of the page too"
+            },
+
+            "persistent": {
+              "type": "Boolean",
+              "desc": "User cannot dismiss Bottom Sheet if clicking outside of it or hitting ESC key"
+            }
+          }
+        }
+      }
+    }
+  }
+}

package/src/plugins/Cookies.js

@@ -0,0 +1,204 @@
+function encode (string) {
+  return encodeURIComponent(string)
+}
+
+function decode (string) {
+  return decodeURIComponent(string)
+}
+
+function stringifyCookieValue (value) {
+  return encode(value === Object(value) ? JSON.stringify(value) : '' + value)
+}
+
+function read (string) {
+  if (string === '') {
+    return string
+  }
+
+  if (string.indexOf('"') === 0) {
+    // This is a quoted cookie as according to RFC2068, unescape...
+    string = string.slice(1, -1).replace(/\\"/g, '"').replace(/\\\\/g, '\\')
+  }
+
+  // Replace server-side written pluses with spaces.
+  // If we can't decode the cookie, ignore it, it's unusable.
+  // If we can't parse the cookie, ignore it, it's unusable.
+  string = decode(string.replace(/\+/g, ' '))
+
+  try {
+    string = JSON.parse(string)
+  }
+  catch (e) {}
+
+  return string
+}
+
+function getString (msOffset) {
+  const time = new Date()
+  time.setMilliseconds(time.getMilliseconds() + msOffset)
+  return time.toUTCString()
+}
+
+function parseExpireString (str) {
+  let timestamp = 0
+
+  const days = str.match(/(\d+)d/)
+  const hours = str.match(/(\d+)h/)
+  const minutes = str.match(/(\d+)m/)
+  const seconds = str.match(/(\d+)s/)
+
+  if (days) { timestamp += days[ 1 ] * 864e+5 }
+  if (hours) { timestamp += hours[ 1 ] * 36e+5 }
+  if (minutes) { timestamp += minutes[ 1 ] * 6e+4 }
+  if (seconds) { timestamp += seconds[ 1 ] * 1000 }
+
+  return timestamp === 0
+    ? str
+    : getString(timestamp)
+}
+
+function set (key, val, opts = {}, ssr) {
+  let expire, expireValue
+
+  if (opts.expires !== void 0) {
+    // if it's a Date Object
+    if (Object.prototype.toString.call(opts.expires) === '[object Date]') {
+      expire = opts.expires.toUTCString()
+    }
+    // if it's a String (eg. "15m", "1h", "13d", "1d 15m", "31s")
+    // possible units: d (days), h (hours), m (minutes), s (seconds)
+    else if (typeof opts.expires === 'string') {
+      expire = parseExpireString(opts.expires)
+    }
+    // otherwise it must be a Number (defined in days)
+    else {
+      expireValue = parseFloat(opts.expires)
+      expire = isNaN(expireValue) === false
+        ? getString(expireValue * 864e+5)
+        : opts.expires
+    }
+  }
+
+  const keyValue = `${ encode(key) }=${ stringifyCookieValue(val) }`
+
+  const cookie = [
+    keyValue,
+    expire !== void 0 ? '; Expires=' + expire : '', // use expires attribute, max-age is not supported by IE
+    opts.path ? '; Path=' + opts.path : '',
+    opts.domain ? '; Domain=' + opts.domain : '',
+    opts.sameSite ? '; SameSite=' + opts.sameSite : '',
+    opts.httpOnly ? '; HttpOnly' : '',
+    opts.secure ? '; Secure' : '',
+    opts.other ? '; ' + opts.other : ''
+  ].join('')
+
+  if (ssr) {
+    if (ssr.req.qCookies) {
+      ssr.req.qCookies.push(cookie)
+    }
+    else {
+      ssr.req.qCookies = [ cookie ]
+    }
+
+    ssr.res.setHeader('Set-Cookie', ssr.req.qCookies)
+
+    // make temporary update so future get()
+    // within same SSR timeframe would return the set value
+
+    let all = ssr.req.headers.cookie || ''
+
+    if (expire !== void 0 && expireValue < 0) {
+      const val = get(key, ssr)
+      if (val !== undefined) {
+        all = all
+          .replace(`${ key }=${ val }; `, '')
+          .replace(`; ${ key }=${ val }`, '')
+          .replace(`${ key }=${ val }`, '')
+      }
+    }
+    else {
+      all = all
+        ? `${ keyValue }; ${ all }`
+        : cookie
+    }
+
+    ssr.req.headers.cookie = all
+  }
+  else {
+    document.cookie = cookie
+  }
+}
+
+function get (key, ssr) {
+  const
+    cookieSource = ssr ? ssr.req.headers : document,
+    cookies = cookieSource.cookie ? cookieSource.cookie.split('; ') : [],
+    l = cookies.length
+  let
+    result = key ? null : {},
+    i = 0,
+    parts,
+    name,
+    cookie
+
+  for (; i < l; i++) {
+    parts = cookies[ i ].split('=')
+    name = decode(parts.shift())
+    cookie = parts.join('=')
+
+    if (!key) {
+      result[ name ] = cookie
+    }
+    else if (key === name) {
+      result = read(cookie)
+      break
+    }
+  }
+
+  return result
+}
+
+function remove (key, options, ssr) {
+  set(
+    key,
+    '',
+    { expires: -1, ...options },
+    ssr
+  )
+}
+
+function has (key, ssr) {
+  return get(key, ssr) !== null
+}
+
+export function getObject (ssr) {
+  return {
+    get: key => get(key, ssr),
+    set: (key, val, opts) => set(key, val, opts, ssr),
+    has: key => has(key, ssr),
+    remove: (key, options) => remove(key, options, ssr),
+    getAll: () => get(null, ssr)
+  }
+}
+
+const Plugin = {
+  install ({ $q, ssrContext }) {
+    $q.cookies = __QUASAR_SSR_SERVER__
+      ? getObject(ssrContext)
+      : this
+  }
+}
+
+if (__QUASAR_SSR__) {
+  Plugin.parseSSR = ssrContext => {
+    if (ssrContext !== void 0) {
+      return getObject(ssrContext)
+    }
+  }
+}
+
+if (__QUASAR_SSR_SERVER__ !== true) {
+  Object.assign(Plugin, getObject())
+}
+
+export default Plugin