quasar 2.15.2 → 2.15.3

package/src/{utils/private → plugins/storage/engine}/web-storage.js

@@ -1,9 +1,9 @@
-import { noop } from '../event.js'
-import { isDate, isRegexp } from '../is.js'
+import { noop } from '../../../utils/event/event.js'
+import { isDate, isRegexp } from '../../../utils/is/is.js'
 
 function encode (value) {
   if (isDate(value) === true) {
-    return '__q_date|' + value.toUTCString()
+    return '__q_date|' + value.getTime()
   }
   if (isRegexp(value) === true) {
     return '__q_expr|' + value.source
@@ -41,7 +41,8 @@ function decode (value) {
 
   switch (type) {
     case '__q_date':
-      return new Date(source)
+      const number = Number(source)
+      return new Date(Number.isNaN(number) === true ? source : number)
 
     case '__q_expr':
       return new RegExp(source)
@@ -70,15 +71,18 @@ export function getEmptyStorage () {
   const getVal = () => null
 
   return {
-    has: () => false,
+    has: () => false, // alias for hasItem; TODO: remove in Qv3
+    hasItem: () => false,
     getLength: () => 0,
     getItem: getVal,
     getIndex: getVal,
     getKey: getVal,
     getAll: () => {},
     getAllKeys: () => [],
-    set: noop,
-    remove: noop,
+    set: noop, // alias for setItem; TODO: remove in Qv3
+    setItem: noop,
+    remove: noop, // alias for removeItem; TODO: remove in Qv3
+    removeItem: noop,
     clear: noop,
     isEmpty: () => true
   }
@@ -94,8 +98,13 @@ export function getStorage (type) {
         : null
     }
 
+  const hasItem = key => webStorage.getItem(key) !== null
+  const setItem = (key, value) => { webStorage.setItem(key, encode(value)) }
+  const removeItem = key => { webStorage.removeItem(key) }
+
   return {
-    has: key => webStorage.getItem(key) !== null,
+    has: hasItem, // TODO: remove in Qv3
+    hasItem,
     getLength: () => webStorage.length,
     getItem: get,
     getIndex: index => {
@@ -128,8 +137,10 @@ export function getStorage (type) {
 
       return result
     },
-    set: (key, value) => { webStorage.setItem(key, encode(value)) },
-    remove: key => { webStorage.removeItem(key) },
+    set: setItem, // TODO: remove in Qv3
+    setItem,
+    remove: removeItem, // TODO: remove in Qv3
+    removeItem,
     clear: () => { webStorage.clear() },
     isEmpty: () => webStorage.length === 0
   }

package/src/{utils/private → plugins/storage/engine}/web-storage.json

@@ -4,8 +4,9 @@
   },
 
   "methods": {
-    "has": {
+    "hasItem": {
       "desc": "Check if storage item exists",
+      "alias": "has",
       "params": {
         "key": {
           "type": "String",
@@ -22,6 +23,7 @@
 
     "getLength": {
       "desc": "Get storage number of entries",
+      "params": null,
       "returns": {
         "type": "Number",
         "desc": "Number of entries"
@@ -40,7 +42,7 @@
         }
       },
       "returns": {
-        "type": [ "Date", "RegExp", "Number", "Boolean", "Function", "Object", "Array", "String", "null" ],
+        "type": [ "Number", "Boolean", "Date", "RegExp", "Function", "Object", "Array", "String", "null" ],
         "desc": "Storage item value",
         "examples": [ "'john12'", "702" ]
       }
@@ -57,7 +59,7 @@
         }
       },
       "returns": {
-        "type": [ "Number", "null" ],
+        "type": [ "Number", "Boolean", "Date", "RegExp", "Function", "Object", "Array", "String", "null" ],
         "desc": "Storage item index"
       }
     },
@@ -81,25 +83,28 @@
 
     "getAll": {
       "desc": "Retrieve all items in storage",
+      "params": null,
       "returns": {
         "type": "Object",
         "desc": "Object syntax: item name as Object key and its value",
-        "examples": [ "{ userId: 'jon12', timesLoggedIn: 14 }" ]
+        "examples": [ "{ userId: 'rstoenescu', timesLoggedIn: 14 }" ]
       }
     },
 
     "getAllKeys": {
       "tsType": "WebStorageGetAllKeysMethodType",
       "desc": "Retrieve all keys in storage",
+      "params": null,
       "returns": {
         "type": "Array",
         "desc": "Storage keys (Array of Strings)",
-        "examples": [ "['userId', 'password']" ]
+        "examples": [ "[ 'userId', 'password' ]" ]
       }
     },
 
-    "set": {
+    "setItem": {
       "desc": "Set item in storage",
+      "alias": "set",
       "params": {
         "key": {
           "type": "String",
@@ -109,7 +114,7 @@
         },
 
         "value": {
-          "type": [ "Date", "RegExp", "Number", "Boolean", "Function", "Object", "Array", "String", "null" ],
+          "type": [ "Number", "Boolean", "Date", "RegExp", "Function", "Object", "Array", "String", "null" ],
           "desc": "Entry value",
           "required": true,
           "params": {
@@ -124,11 +129,13 @@
           },
           "examples": [ "'john12'" ]
         }
-      }
+      },
+      "returns": null
     },
 
-    "remove": {
+    "removeItem": {
       "desc": "Remove a storage item",
+      "alias": "remove",
       "params": {
         "key": {
           "type": "String",
@@ -136,15 +143,19 @@
           "required": true,
           "examples": [ "'userId'" ]
         }
-      }
+      },
+      "returns": null
     },
 
     "clear": {
-      "desc": "Remove everything from the storage"
+      "desc": "Remove everything from the storage",
+      "params": null,
+      "returns": null
     },
 
     "isEmpty": {
       "desc": "Determine if storage has any items",
+      "params": null,
       "returns": {
         "type": "Boolean",
         "desc": "Tells if storage is empty or not"

package/src/plugins/storage/engine/web-storage.test.js

@@ -0,0 +1,43 @@
+import { describe, test, expect } from 'vitest'
+
+import { getEmptyStorage, getStorage } from './web-storage.js'
+
+const objectDefinition = {
+  has: expect.any(Function), // alias of has
+  hasItem: expect.any(Function),
+  getLength: expect.any(Function),
+  getItem: expect.any(Function),
+  getIndex: expect.any(Function),
+  getKey: expect.any(Function),
+  getAll: expect.any(Function),
+  getAllKeys: expect.any(Function),
+  set: expect.any(Function), // alias of setItem
+  setItem: expect.any(Function),
+  remove: expect.any(Function), // alias of removeItem
+  removeItem: expect.any(Function),
+  clear: expect.any(Function),
+  isEmpty: expect.any(Function)
+}
+
+describe('[webStorage API]', () => {
+  describe('[Functions]', () => {
+    describe('[(function)getEmptyStorage]', () => {
+      test('has correct return value', () => {
+        const result = getEmptyStorage()
+        expect(result).toStrictEqual(objectDefinition)
+      })
+    })
+
+    describe('[(function)getStorage]', () => {
+      test('has correct return value for local', () => {
+        const local = getStorage('local')
+        expect(local).toStrictEqual(objectDefinition)
+      })
+
+      test('has correct return value for session', () => {
+        const session = getStorage('session')
+        expect(session).toStrictEqual(objectDefinition)
+      })
+    })
+  })
+})

package/src/plugins.js

@@ -5,14 +5,16 @@ import BottomSheet from './plugins/bottom-sheet/BottomSheet.js'
 import Cookies from './plugins/cookies/Cookies.js'
 import Dark from './plugins/dark/Dark.js'
 import Dialog from './plugins/dialog/Dialog.js'
-import LoadingBar from './plugins/loading-bar/LoadingBar.js'
+import IconSet from './plugins/icon-set/IconSet.js'
+import Lang from './plugins/lang/Lang.js'
 import Loading from './plugins/loading/Loading.js'
+import LoadingBar from './plugins/loading-bar/LoadingBar.js'
 import Meta from './plugins/meta/Meta.js'
 import Notify from './plugins/notify/Notify.js'
 import Platform from './plugins/platform/Platform.js'
 import Screen from './plugins/screen/Screen.js'
-import LocalStorage from './plugins/local-storage/LocalStorage.js'
-import SessionStorage from './plugins/session-storage/SessionStorage.js'
+import LocalStorage from './plugins/storage/LocalStorage.js'
+import SessionStorage from './plugins/storage/SessionStorage.js'
 
 export {
   AddressbarColor,
@@ -22,8 +24,10 @@ export {
   Cookies,
   Dark,
   Dialog,
-  LoadingBar,
+  IconSet,
+  Lang,
   Loading,
+  LoadingBar,
   Meta,
   Notify,
   Platform,

package/src/utils/EventBus/EventBus.test.js

@@ -0,0 +1,108 @@
+import { describe, test, expect, vi } from 'vitest'
+
+import EventBus from './EventBus.js'
+
+describe('[EventBus API]', () => {
+  describe('[Classes]', () => {
+    describe('[(class)default]', () => {
+      test('can be instantiated', () => {
+        const instance = new EventBus()
+        expect(instance).toMatchObject({
+          on: expect.any(Function),
+          once: expect.any(Function),
+          emit: expect.any(Function),
+          off: expect.any(Function)
+        })
+      })
+
+      test('can subscribe and emit an event', () => {
+        const instance = new EventBus()
+        const callback = vi.fn()
+
+        instance.on('test', callback)
+        instance.emit('test', 'testing')
+
+        expect(callback).toHaveBeenCalledWith('testing')
+      })
+
+      test('can subscribe and emit an event once', () => {
+        const instance = new EventBus()
+        const callback = vi.fn()
+
+        instance.once('test', callback)
+        instance.emit('test', 'testing')
+        instance.emit('test', 'testing')
+
+        expect(callback).toHaveBeenCalledTimes(1)
+        expect(callback).toHaveBeenCalledWith('testing')
+      })
+
+      test('can unsubscribe from an event', () => {
+        const instance = new EventBus()
+        const callback = vi.fn()
+
+        instance.on('test', callback)
+        instance.emit('test', 'testing')
+        instance.off('test', callback)
+        instance.emit('test', 'testing')
+
+        expect(callback).toHaveBeenCalledTimes(1)
+      })
+
+      test('can unsubscribe from all events', () => {
+        const instance = new EventBus()
+        const callback1 = vi.fn()
+        const callback2 = vi.fn()
+
+        instance.on('test1', callback1)
+        instance.on('test2', callback2)
+        instance.emit('test1', 'testing1')
+        instance.emit('test2', 'testing2')
+        instance.off('test1')
+        instance.off('test2')
+        instance.emit('test1', 'testing1')
+        instance.emit('test2', 'testing2')
+
+        expect(callback1).toHaveBeenCalledTimes(1)
+        expect(callback2).toHaveBeenCalledTimes(1)
+      })
+
+      test('can subscribe to multiple events', () => {
+        const instance = new EventBus()
+        const callback1 = vi.fn()
+        const callback2 = vi.fn()
+
+        instance.on('test1', callback1)
+        instance.on('test2', callback2)
+        instance.emit('test1', 'testing1')
+        instance.emit('test2', 'testing2')
+
+        expect(callback1).toHaveBeenCalledWith('testing1')
+        expect(callback2).toHaveBeenCalledWith('testing2')
+      })
+
+      test('arguments preservation', () => {
+        const instance = new EventBus()
+        const callback = vi.fn()
+
+        instance.on('test', callback)
+        instance.emit('test', 1, 2, '3')
+
+        expect(callback).toHaveBeenCalledWith(1, 2, '3')
+      })
+
+      test('is chainable', () => {
+        const instance = new EventBus()
+        const callback = vi.fn()
+
+        instance
+          .on('test', callback)
+          .emit('test', 1, 2, 'testing')
+          .off('test', callback)
+
+        expect(callback).toHaveBeenCalledTimes(1)
+        expect(callback).toHaveBeenCalledWith(1, 2, 'testing')
+      })
+    })
+  })
+})

package/src/utils/clone/clone.test.js

@@ -0,0 +1,111 @@
+import { describe, test, expect } from 'vitest'
+
+import clone from './clone.js'
+
+describe('[clone API]', () => {
+  describe('[Functions]', () => {
+    describe('[(function)default]', () => {
+      test.each([
+        [ 'Number', 5 ],
+        [ 'String', 'a' ],
+        [ 'Boolean', true ],
+        [ 'Null', null ],
+        [ 'Undefined', undefined ],
+        [ 'NaN', NaN ],
+        [ 'Infinity', Infinity ]
+      ])('clone(%s)', (_, value) => {
+        const result = clone(value)
+
+        expect(
+          result
+        ).toBe(value)
+      })
+
+      test('clone(Date)', () => {
+        const date = new Date(150)
+        const result = clone(date)
+
+        expect(
+          result.getTime()
+        ).toBe(date.getTime())
+
+        expect(
+          result
+        ).not.toBe(date)
+      })
+
+      test('clone(RegExp)', () => {
+        const regex = /./
+        const result = clone(regex)
+
+        expect(
+          result.source
+        ).toBe(regex.source)
+
+        expect(
+          result.flags
+        ).toBe(regex.flags)
+
+        expect(
+          result
+        ).not.toBe(regex)
+      })
+
+      test('clone(Array)', () => {
+        const array = [ 1, 2, 3 ]
+        const result = clone(array)
+
+        expect(
+          result
+        ).toStrictEqual(array)
+
+        expect(
+          result
+        ).not.toBe(array)
+      })
+
+      test('clone(Object)', () => {
+        const object = { a: true, b: false }
+        const result = clone(object)
+
+        expect(
+          result
+        ).toStrictEqual(object)
+
+        expect(
+          result
+        ).not.toBe(object)
+      })
+
+      test('clone(Set)', () => {
+        const set = new Set([ 1, 2, 3 ])
+        const result = clone(set)
+
+        expect(
+          Array.from(result.values())
+        ).toStrictEqual(
+          Array.from(set.values())
+        )
+
+        expect(
+          result
+        ).not.toBe(set)
+      })
+
+      test('clone(Map)', () => {
+        const map = new Map([ [ 1, 'one' ], [ 2, 'two' ] ])
+        const result = clone(map)
+
+        expect(
+          Array.from(result.entries())
+        ).toStrictEqual(
+          Array.from(map.entries())
+        )
+
+        expect(
+          result
+        ).not.toBe(map)
+      })
+    })
+  })
+})