quasar 1.20.0 → 1.20.2

package/src/mixins/validate.js

@@ -143,11 +143,13 @@ export default {
 
       const index = ++this.validateIndex
 
-      if (this.innerLoading !== true && this.lazyRules !== true) {
-        this.isDirty = true
-      }
+      const setDirty = this.innerLoading !== true
+        ? () => this.isDirty !== true && (this.isDirty = true)
+        : () => {}
 
       const update = (err, msg) => {
+        err === true && setDirty()
+
         if (this.innerError !== err) {
           this.innerError = err
         }
@@ -170,7 +172,7 @@ export default {
         let res
 
         if (typeof rule === 'function') {
-          res = rule(val)
+          res = rule(val, testPattern)
         }
         else if (typeof rule === 'string' && testPattern[rule] !== void 0) {
           res = testPattern[rule](val)

package/src/mixins/validate.json

@@ -24,7 +24,8 @@
       "desc": "Array of Functions/Strings; If String, then it must be a name of one of the embedded validation rules",
       "examples": [
         ":rules=\"[ val => val.length <= 3 || 'Please use maximum 3 characters' ]\"",
-        ":rules=\"[ 'fulltime' ]\""
+        ":rules=\"[ 'fulltime' ]\"",
+        ":rules=\"[ (val, rules) => rules.email(val) || 'Please enter a valid email address' ]\""
       ],
       "category": "behavior"
     },

package/src/utils/is.js

@@ -138,3 +138,11 @@ export function isRegexp (v) {
 export function isNumber (v) {
   return typeof v === 'number' && isFinite(v)
 }
+
+export default {
+  deepEqual: isDeepEqual,
+  object: isObject,
+  date: isDate,
+  regexp: isRegexp,
+  number: isNumber
+}

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 3); 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

@@ -5,6 +5,7 @@ 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 is from './utils/is.js'
 import exportFile from './utils/export-file.js'
 import extend from './utils/extend.js'
 import format from './utils/format.js'
@@ -12,6 +13,7 @@ import frameDebounce from './utils/frame-debounce.js'
 import openURL from './utils/open-url.js'
 import morph from './utils/morph.js'
 import patterns from './utils/patterns.js'
+import runSequentialPromises from './utils/run-sequential-promises.js'
 import scroll from './utils/scroll.js'
 import throttle from './utils/throttle.js'
 import uid from './utils/uid.js'
@@ -29,9 +31,11 @@ export {
   format,
   frameDebounce,
   noop,
+  is,
   openURL,
   morph,
   patterns,
+  runSequentialPromises,
   scroll,
   throttle,
   uid