quasar 2.15.1 → 2.15.3

package/src/plugins/storage/SessionStorage.test.js

@@ -0,0 +1,323 @@
+import { describe, test, expect } from 'vitest'
+import { mount, config } from '@vue/test-utils'
+
+import SessionStorage from './SessionStorage.js'
+
+const mountPlugin = () => mount({ template: '<div />' })
+
+// We override Quasar install so it installs this plugin
+const quasarVuePlugin = config.global.plugins.find(entry => entry.name === 'Quasar')
+const { install } = quasarVuePlugin
+quasarVuePlugin.install = app => install(app, { plugins: { SessionStorage } })
+
+describe('[SessionStorage API]', () => {
+  describe('[Injection]', () => {
+    test('is injected into $q', () => {
+      const { vm: { $q } } = mountPlugin()
+
+      expect($q.sessionStorage).toBeDefined()
+      expect($q.sessionStorage).toBeTypeOf('object')
+      expect(Object.keys($q.sessionStorage)).not.toHaveLength(0)
+
+      expect(SessionStorage).toMatchObject($q.sessionStorage)
+    })
+  })
+
+  describe('[Methods]', () => {
+    describe('[(method)hasItem]', () => {
+      test('should be callable', () => {
+        mountPlugin()
+
+        expect(SessionStorage.hasItem('has')).toBe(false)
+        SessionStorage.setItem('has', 'rstoenescu')
+        expect(SessionStorage.hasItem('has')).toBe(true)
+      })
+
+      test('matches $q API', () => {
+        const { vm: { $q } } = mountPlugin()
+        expect($q.sessionStorage.hasItem).toBe(SessionStorage.hasItem)
+      })
+    })
+
+    describe('[(method)getLength]', () => {
+      test('should be callable', () => {
+        mountPlugin()
+
+        const len = SessionStorage.getLength()
+        expect(len).toBeTypeOf('number')
+
+        SessionStorage.setItem('getLength', 0)
+        expect(SessionStorage.getLength()).toBe(len + 1)
+      })
+
+      test('matches $q API', () => {
+        const { vm: { $q } } = mountPlugin()
+        expect($q.sessionStorage.getLength).toBe(SessionStorage.getLength)
+      })
+    })
+
+    describe('[(method)getItem]', () => {
+      test('should be callable', () => {
+        mountPlugin()
+
+        expect(
+          SessionStorage.getItem('getItem')
+        ).toBeNull()
+      })
+
+      test('matches $q API', () => {
+        const { vm: { $q } } = mountPlugin()
+        expect($q.sessionStorage.getItem).toBe(SessionStorage.getItem)
+      })
+    })
+
+    describe('[(method)getIndex]', () => {
+      test('should be callable', () => {
+        mountPlugin()
+
+        // ensure at least one element is defined
+        SessionStorage.setItem('getIndex', 'rstoenescu')
+
+        expect(
+          SessionStorage.getIndex(0)
+        ).$any([
+          expect.any(Number),
+          expect.any(Boolean),
+          expect.any(Date),
+          expect.any(RegExp),
+          expect.any(Function),
+          expect.any(Object),
+          expect.any(Array),
+          expect.any(String)
+        ])
+      })
+
+      test('matches $q API', () => {
+        const { vm: { $q } } = mountPlugin()
+        expect($q.sessionStorage.getIndex).toBe(SessionStorage.getIndex)
+      })
+    })
+
+    describe('[(method)getKey]', () => {
+      test('should be callable', () => {
+        mountPlugin()
+
+        // ensure at least one element is defined
+        SessionStorage.setItem('getKey', 'rstoenescu')
+
+        expect(
+          SessionStorage.getKey(0)
+        ).toBeTypeOf('string')
+      })
+
+      test('matches $q API', () => {
+        const { vm: { $q } } = mountPlugin()
+        expect($q.sessionStorage.getKey).toBe(SessionStorage.getKey)
+      })
+    })
+
+    describe('[(method)getAll]', () => {
+      test('should be callable', () => {
+        mountPlugin()
+
+        // ensure at least one element is defined
+        SessionStorage.setItem('getAll', 'rstoenescu')
+
+        const result = SessionStorage.getAll()
+        expect(result).toBeTypeOf('object')
+        expect(Object.keys(result)).not.toHaveLength(0)
+      })
+
+      test('matches $q API', () => {
+        const { vm: { $q } } = mountPlugin()
+        expect($q.sessionStorage.getAll).toBe(SessionStorage.getAll)
+      })
+    })
+
+    describe('[(method)getAllKeys]', () => {
+      test('should be callable', () => {
+        mountPlugin()
+
+        // ensure at least one element is defined
+        SessionStorage.setItem('getAllKeys', 'rstoenescu')
+
+        expect(
+          Array.isArray(SessionStorage.getAllKeys())
+        ).toBe(true)
+
+        expect(
+          SessionStorage.getAllKeys()
+        ).toContain('getAllKeys')
+      })
+
+      test('matches $q API', () => {
+        const { vm: { $q } } = mountPlugin()
+        expect($q.sessionStorage.getAllKeys).toBe(SessionStorage.getAllKeys)
+      })
+    })
+
+    describe('[(method)setItem]', () => {
+      test('should be callable', () => {
+        mountPlugin()
+
+        expect(
+          SessionStorage.setItem('set', 'rstoenescu')
+        ).toBeUndefined()
+
+        expect(
+          SessionStorage.getItem('set')
+        ).toBe('rstoenescu')
+      })
+
+      test('matches $q API', () => {
+        const { vm: { $q } } = mountPlugin()
+        expect($q.sessionStorage.setItem).toBe(SessionStorage.setItem)
+      })
+
+      test('can override value', () => {
+        mountPlugin()
+
+        expect(SessionStorage.setItem('set2', 'rstoenescu'))
+        expect(SessionStorage.getItem('set2')).toBe('rstoenescu')
+
+        expect(SessionStorage.setItem('set2', 'rstoenescu2'))
+        expect(SessionStorage.getItem('set2')).toBe('rstoenescu2')
+      })
+
+      test('can encode + decode a Number', () => {
+        mountPlugin()
+
+        SessionStorage.setItem('Number', 123)
+        expect(SessionStorage.getItem('Number')).toBe(123)
+      })
+
+      test('can encode + decode a Boolean', () => {
+        mountPlugin()
+
+        SessionStorage.setItem('Boolean', true)
+        expect(SessionStorage.getItem('Boolean')).toBe(true)
+      })
+
+      test('can encode + decode a Date', () => {
+        mountPlugin()
+        const date = new Date()
+
+        SessionStorage.setItem('Date', date)
+        expect(
+          SessionStorage.getItem('Date')
+        ).toStrictEqual(date)
+      })
+
+      test('can encode + decode a String', () => {
+        mountPlugin()
+
+        SessionStorage.setItem('String', 'rstoenescu')
+        expect(
+          SessionStorage.getItem('String')
+        ).toBe('rstoenescu')
+      })
+
+      test('can encode + decode a RegExp', () => {
+        mountPlugin()
+
+        SessionStorage.setItem('RegExp', /abc/)
+        expect(
+          SessionStorage.getItem('RegExp')
+        ).toStrictEqual(/abc/)
+      })
+
+      test('can encode + decode a Function', () => {
+        mountPlugin()
+        const fn = () => 5
+
+        SessionStorage.setItem('Function', fn)
+        expect(
+          SessionStorage.getItem('Function')
+        ).toBe(fn.toString())
+      })
+
+      test('can encode + decode an Object', () => {
+        mountPlugin()
+        const obj = { a: 1 }
+
+        SessionStorage.setItem('Object', obj)
+        expect(
+          SessionStorage.getItem('Object')
+        ).toStrictEqual(obj)
+      })
+
+      test('can encode + decode an Array', () => {
+        mountPlugin()
+        const arr = [ 1, 2, 3 ]
+
+        SessionStorage.setItem('Array', arr)
+        expect(
+          SessionStorage.getItem('Array')
+        ).toStrictEqual(arr)
+      })
+    })
+
+    describe('[(method)removeItem]', () => {
+      test('should be callable', () => {
+        mountPlugin()
+
+        SessionStorage.setItem('remove', 5)
+        expect(
+          SessionStorage.getItem('remove')
+        ).toBe(5)
+
+        expect(
+          SessionStorage.removeItem('remove')
+        ).toBeUndefined()
+
+        expect(
+          SessionStorage.getItem('remove')
+        ).toBeNull()
+      })
+
+      test('matches $q API', () => {
+        const { vm: { $q } } = mountPlugin()
+        expect($q.sessionStorage.removeItem).toBe(SessionStorage.removeItem)
+      })
+    })
+
+    describe('[(method)clear]', () => {
+      test('should be callable', () => {
+        mountPlugin()
+
+        SessionStorage.setItem('clear', 5)
+        expect(SessionStorage.getItem('clear')).toBe(5)
+
+        expect(SessionStorage.clear()).toBeUndefined()
+
+        expect(SessionStorage.getItem('clear')).toBeNull()
+        expect(SessionStorage.getLength()).toBe(0)
+      })
+
+      test('matches $q API', () => {
+        const { vm: { $q } } = mountPlugin()
+        expect($q.sessionStorage.clear).toBe(SessionStorage.clear)
+      })
+    })
+
+    describe('[(method)isEmpty]', () => {
+      test('should be callable', () => {
+        mountPlugin()
+
+        SessionStorage.setItem('isEmpty', 5)
+        expect(SessionStorage.getItem('isEmpty')).toBe(5)
+
+        expect(SessionStorage.isEmpty()).toBe(false)
+
+        SessionStorage.clear()
+
+        expect(SessionStorage.isEmpty()).toBe(true)
+      })
+
+      test('matches $q API', () => {
+        const { vm: { $q } } = mountPlugin()
+        expect($q.sessionStorage.isEmpty).toBe(SessionStorage.isEmpty)
+      })
+    })
+  })
+})

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,14 +4,15 @@
   },
 
   "methods": {
-    "has": {
+    "hasItem": {
       "desc": "Check if storage item exists",
+      "alias": "has",
       "params": {
         "key": {
           "type": "String",
           "desc": "Entry key",
           "required": true,
-          "examples": [ "userId" ]
+          "examples": [ "'userId'" ]
         }
       },
       "returns": {
@@ -22,6 +23,7 @@
 
     "getLength": {
       "desc": "Get storage number of entries",
+      "params": null,
       "returns": {
         "type": "Number",
         "desc": "Number of entries"
@@ -36,13 +38,13 @@
           "type": "String",
           "desc": "Entry key",
           "required": true,
-          "examples": [ "userId" ]
+          "examples": [ "'userId'" ]
         }
       },
       "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 ]
+        "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"
       }
     },
@@ -75,43 +77,44 @@
       "returns": {
         "type": [ "String", "null" ],
         "desc": "Storage key",
-        "examples": [ "userId" ]
+        "examples": [ "'userId'" ]
       }
     },
 
     "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",
           "desc": "Entry key",
           "required": true,
-          "examples": [ "userId" ]
+          "examples": [ "'userId'" ]
         },
 
         "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,29 +127,35 @@
             "type": "Any",
             "__exemption": [ "desc" ]
           },
-          "examples": [ "john12" ]
+          "examples": [ "'john12'" ]
         }
-      }
+      },
+      "returns": null
     },
 
-    "remove": {
+    "removeItem": {
       "desc": "Remove a storage item",
+      "alias": "remove",
       "params": {
         "key": {
           "type": "String",
           "desc": "Storage key",
           "required": true,
-          "examples": [ "userId" ]
+          "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

@@ -1,18 +1,20 @@
-import AddressbarColor from './plugins/AddressbarColor.js'
-import AppFullscreen from './plugins/AppFullscreen.js'
-import AppVisibility from './plugins/AppVisibility.js'
-import BottomSheet from './plugins/BottomSheet.js'
-import Cookies from './plugins/Cookies.js'
-import Dark from './plugins/Dark.js'
-import Dialog from './plugins/Dialog.js'
-import LoadingBar from './plugins/LoadingBar.js'
-import Loading from './plugins/Loading.js'
-import Meta from './plugins/Meta.js'
-import Notify from './plugins/Notify.js'
-import Platform from './plugins/Platform.js'
-import Screen from './plugins/Screen.js'
-import LocalStorage from './plugins/LocalStorage.js'
-import SessionStorage from './plugins/SessionStorage.js'
+import AddressbarColor from './plugins/addressbar/AddressbarColor.js'
+import AppFullscreen from './plugins/app-fullscreen/AppFullscreen.js'
+import AppVisibility from './plugins/app-visibility/AppVisibility.js'
+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 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/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,