quasar 2.8.3 → 2.9.0

package/src/utils/private/inject-obj-prop.js

@@ -4,10 +4,12 @@ export function injectProp (target, propName, get, set) {
     set,
     enumerable: true
   })
+  return target
 }
 
 export function injectMultipleProps (target, props) {
   for (const key in props) {
     injectProp(target, key, props[ key ])
   }
+  return target
 }

package/src/utils/private/rtl.js

@@ -3,15 +3,18 @@ let rtlHasScrollBug = false
 // mobile Chrome takes the crown for this
 if (!__QUASAR_SSR__) {
   const scroller = document.createElement('div')
-  const spacer = document.createElement('div')
-
   scroller.setAttribute('dir', 'rtl')
-  scroller.style.width = '1px'
-  scroller.style.height = '1px'
-  scroller.style.overflow = 'auto'
+  Object.assign(scroller.style, {
+    width: '1px',
+    height: '1px',
+    overflow: 'auto'
+  })
 
-  spacer.style.width = '1000px'
-  spacer.style.height = '1px'
+  const spacer = document.createElement('div')
+  Object.assign(spacer.style, {
+    width: '1000px',
+    height: '1px'
+  })
 
   document.body.appendChild(scroller)
   scroller.appendChild(spacer)

package/src/utils/private/vm.js

@@ -43,3 +43,7 @@ export function getNormalizedVNodes (vnodes) {
 export function vmHasRouter (vm) {
   return vm.appContext.config.globalProperties.$router !== void 0
 }
+
+export function vmIsDestroyed (vm) {
+  return vm.isUnmounted === true || vm.isDeactivated === true
+}

package/src/utils/run-sequential-promises.js

@@ -0,0 +1,115 @@
+
+function parsePromises (sequentialPromises) {
+  const isList = Array.isArray(sequentialPromises)
+
+  if (isList === true) {
+    const totalJobs = sequentialPromises.length
+    return {
+      isList,
+      totalJobs,
+      resultAggregator: Array(totalJobs).fill(null)
+    }
+  }
+
+  const resultKeys = Object.keys(sequentialPromises)
+  const resultAggregator = {}
+  resultKeys.forEach(keyName => { resultAggregator[ keyName ] = null })
+
+  return {
+    isList,
+    totalJobs: resultKeys.length,
+    resultAggregator,
+    resultKeys
+  }
+}
+
+/**
+ * Run a list of Promises sequentially, optionally on multiple threads.
+ *
+ * @param {*} sequentialPromises - Array of Functions or Object with Functions as values
+ *                          Array of Function form: [ (resultAggregator: Array) => Promise<any>, ... ]
+ *                          Object form: { [key: string]: (resultAggregator: object) => Promise<any>, ... }
+ * @param {*} opts - Optional options Object
+ *                   Object form: { threadsNumber?: number, abortOnFail?: boolean }
+ *                   Default: { threadsNumber: 1, abortOnFail: true }
+ *                   When configuring threadsNumber AND using http requests, be
+ *                       aware of the maximum threads that the hosting browser
+ *                       supports (usually 5); any number of threads above that
+ *                       won't add any real benefits
+ * @returns Promise<Array<Object> | Object>
+ *    With opts.abortOnFail set to true (which is default):
+ *        When sequentialPromises param is Array:
+ *          The Promise resolves with an Array of Objects of the following form:
+ *             [ { key: number, status: 'fulfilled', value: any }, ... ]
+ *          The Promise rejects with an Object of the following form:
+ *             { key: number, status: 'rejected', reason: Error, resultAggregator: array }
+ *        When sequentialPromises param is Object:
+ *          The Promise resolves with an Object of the following form:
+ *             { [key: string]: { key: string, status: 'fulfilled', value: any }, ... }
+ *          The Promise rejects with an Object of the following form:
+ *             { key: string, status: 'rejected', reason: Error, resultAggregator: object }
+ *    With opts.abortOnFail set to false:
+ *       The Promise is never rejected (no catch() needed)
+ *       The Promise resolves with:
+ *          An Array of Objects (when sequentialPromises param is also an Array) of the following form:
+ *             [ { key: number, status: 'fulfilled', value: any } | { status: 'rejected', reason: Error }, ... ]
+ *          An Object (when sequentialPromises param is also an Object) of the following form:
+ *             { [key: string]: { key: string, status: 'fulfilled', value: any } | { key: string, status: 'rejected', reason: Error }, ... }
+ */
+export default function runSequentialPromises (
+  sequentialPromises,
+  { threadsNumber = 1, abortOnFail = true } = {}
+) {
+  let jobIndex = -1, hasAborted = false
+
+  const { isList, totalJobs, resultAggregator, resultKeys } = parsePromises(sequentialPromises)
+
+  const getPromiseThread = () => new Promise((resolve, reject) => {
+    function runNextPromise () {
+      const currentJobIndex = ++jobIndex
+
+      if (hasAborted === true || currentJobIndex >= totalJobs) {
+        resolve()
+        return
+      }
+
+      const key = isList === true ? currentJobIndex : resultKeys[ currentJobIndex ]
+
+      sequentialPromises[ key ](resultAggregator)
+        .then(value => {
+          if (hasAborted === true) {
+            resolve()
+            return // early exit
+          }
+
+          resultAggregator[ key ] = { key, status: 'fulfilled', value }
+
+          // timeout so it doesn't interfere with the .catch() below
+          setTimeout(runNextPromise)
+        })
+        .catch(reason => {
+          if (hasAborted === true) {
+            resolve()
+            return // early exit
+          }
+
+          const result = { key, status: 'rejected', reason }
+          resultAggregator[ key ] = result
+
+          if (abortOnFail === true) {
+            hasAborted = true
+            reject({ ...result, resultAggregator })
+            return // early exit
+          }
+
+          // timeout so no interference
+          setTimeout(runNextPromise)
+        })
+    }
+
+    runNextPromise()
+  })
+
+  const threads = Array(threadsNumber).fill(getPromiseThread())
+  return Promise.all(threads).then(() => resultAggregator)
+}

package/src/utils.js

@@ -6,6 +6,7 @@ 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 EventBus from './utils/EventBus.js'
 import event, { noop } from './utils/event.js'
 import exportFile from './utils/export-file.js'
 import extend from './utils/extend.js'
@@ -16,6 +17,7 @@ import is from './utils/is.js'
 import morph from './utils/morph.js'
 import openURL from './utils/open-url.js'
 import patterns from './utils/patterns.js'
+import runSequentialPromises from './utils/run-sequential-promises.js'
 import scroll from './utils/scroll.js'
 import setCssVar from './utils/set-css-var.js'
 import throttle from './utils/throttle.js'
@@ -30,6 +32,7 @@ export {
   date,
   debounce,
   dom,
+  EventBus,
   event,
   exportFile,
   extend,
@@ -41,6 +44,7 @@ export {
   morph,
   openURL,
   patterns,
+  runSequentialPromises,
   scroll,
   setCssVar,
   throttle,