@cnamts/synapse 0.0.9-alpha → 0.0.11-alpha

package/src/utils/localStorageUtility/index.ts

@@ -0,0 +1,201 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+/** @see https://developer.mozilla.org/en-US/docs/Web/API/Storage for native specifications */
+
+interface ControlItem {
+	version?: number
+	expiresAt?: number
+}
+
+/** @see https://gist.github.com/paulirish/5558557 */
+function isStorageAvailable(): boolean {
+	try {
+		const item = 'test'
+
+		localStorage.setItem(item, item)
+		localStorage.removeItem(item)
+
+		return true
+	}
+	catch {
+		return false
+	}
+}
+
+export class LocalStorageUtility {
+	readonly localStorageSupported: boolean
+
+	/** Integer number */
+	readonly version?: number
+
+	/** Passive expiration time in ms */
+	readonly expiration?: number
+
+	readonly prefix: string
+
+	private CONTROL_ITEM_KEY = 'vd-storage-control'
+
+	constructor(version?: number, expiration?: number, prefix = 'vd-') {
+		this.localStorageSupported = isStorageAvailable()
+
+		this.prefix = prefix
+
+		if (version && Number.isInteger(version)) {
+			this.version = version
+		}
+		else {
+			this.version = undefined
+		}
+
+		this.expiration = expiration
+
+		const isOldVersion = this.checkIfOldVersion()
+		const expired = this.checkIfExpired()
+
+		if (isOldVersion || expired) {
+			this.clear()
+			this.setControlItem()
+		}
+	}
+
+	get length(): number {
+		return this.getAll().length
+	}
+
+	key(n: number): string {
+		return this.getAllKeys()[n]
+	}
+
+	getItem<T = any>(key: string): T | null {
+		const controlItem = this.getControlItem()
+
+		if (!this.localStorageSupported && !controlItem) {
+			return null
+		}
+
+		const hasExpired = this.checkIfExpired()
+
+		if (hasExpired) {
+			this.clear()
+
+			return null
+		}
+
+		this.setControlItem()
+
+		return this.get(this.prefix + key)
+	}
+
+	setItem<T>(key: string, value: T): void {
+		if (this.localStorageSupported) {
+			this.set(this.prefix + key, value)
+			this.setControlItem()
+		}
+	}
+
+	removeItem(key: string): void {
+		this.filterStorage((storageKey) => {
+			if (storageKey === this.prefix + key) {
+				delete localStorage[storageKey]
+			}
+		})
+	}
+
+	clear(): void {
+		this.filterStorage((storageKey) => {
+			delete localStorage[storageKey]
+		})
+	}
+
+	getAll(): any[] {
+		const items = [] as any[]
+
+		this.filterStorage((storageKey) => {
+			items.push(this.get(storageKey))
+		})
+
+		return items
+	}
+
+	private getAllKeys(): string[] {
+		const keys = [] as string[]
+
+		this.filterStorage((storageKey) => {
+			keys.push(storageKey)
+		})
+
+		return keys
+	}
+
+	private filterStorage(callback: (storageKey: string) => void): void {
+		if (!this.localStorageSupported) {
+			return
+		}
+
+		for (const storageKey in localStorage) {
+			if (
+				storageKey.startsWith(this.prefix)
+				&& storageKey !== this.CONTROL_ITEM_KEY
+			) {
+				callback(storageKey)
+			}
+		}
+	}
+
+	/** Wrapper for localStorage.getItem that parses the result */
+	private get(key: string): any | null {
+		return JSON.parse(localStorage.getItem(key) || JSON.stringify(null))
+	}
+
+	/** Wrapper for localStorage.setItem that stringify the value */
+	private set(key: string, value: any): void {
+		localStorage.setItem(key, JSON.stringify(value))
+	}
+
+	private checkIfExpired(): boolean {
+		const controlItem = this.getControlItem()
+
+		if (!controlItem) {
+			return true
+		}
+
+		let timeExpired = false
+		let versionExpired = false
+
+		if (controlItem.expiresAt) {
+			timeExpired = controlItem.expiresAt < new Date().getTime()
+		}
+
+		if (controlItem.version && this.version) {
+			versionExpired = controlItem.version < this.version
+		}
+
+		return timeExpired || versionExpired
+	}
+
+	private getControlItem(): ControlItem | null {
+		if (this.localStorageSupported) {
+			return this.get(this.CONTROL_ITEM_KEY)
+		}
+
+		return null
+	}
+
+	private setControlItem(): void {
+		const expiresAt = this.expiration
+			? new Date().getTime() + this.expiration / 1
+			: undefined
+
+		const controlItemObj: ControlItem = {
+			version: this.version,
+			expiresAt,
+		}
+
+		if (this.localStorageSupported) {
+			this.set(this.CONTROL_ITEM_KEY, controlItemObj)
+		}
+	}
+
+	private checkIfOldVersion(): boolean {
+		return this.getControlItem() === null
+	}
+}

package/src/utils/localStorageUtility/tests/localStorageUtility.spec.ts

@@ -0,0 +1,180 @@
+import { describe, it, expect, beforeEach } from 'vitest'
+// Disable lint rule because it's clearer to just call new Class
+// instead of putting it in a non-used var
+
+import { LocalStorageUtility } from '../'
+
+/** Get the controlItem (not parsed) in localStorage */
+function getControlItem() {
+	return localStorage.getItem('vd-storage-control')
+}
+
+const testString = 'test'
+
+/** JSON.stringify({}) */
+const normalizedObject = JSON.stringify({})
+
+/** JSON.stringify('test') */
+const normalizedString = JSON.stringify(testString)
+
+describe('LocalStorageUtility', () => {
+	beforeEach(() => localStorage.clear())
+
+	it('should set control object when instantiated', () => {
+		new LocalStorageUtility()
+
+		expect(getControlItem()).toBe(normalizedObject)
+	})
+
+	it('should clear all previous objects when instantiated and control item does not exists', () => {
+		localStorage.setItem('vd-test', normalizedString)
+
+		new LocalStorageUtility()
+
+		expect(localStorage.getItem('vd-test')).toBe(null)
+	})
+
+	it('should check the control object when already instantiated', () => {
+		new LocalStorageUtility()
+
+		// Call it a second time to simulate a page refresh
+		new LocalStorageUtility()
+
+		expect(getControlItem()).toBe(normalizedObject)
+	})
+
+	it('should clear previous items when bumping version', () => {
+		new LocalStorageUtility(1)
+
+		localStorage.setItem('vd-test', normalizedObject)
+
+		expect(localStorage.getItem('vd-test')).toBe(normalizedObject)
+
+		// Bump the version
+		new LocalStorageUtility(2)
+
+		expect(localStorage.getItem('vd-test')).toBe(null)
+	})
+
+	it('should set an item', () => {
+		const localStorageUtility = new LocalStorageUtility()
+
+		localStorageUtility.setItem('test', testString)
+
+		expect(localStorage.getItem('vd-test')).toBe(normalizedString)
+	})
+
+	it('should get an item', () => {
+		const localStorageUtility = new LocalStorageUtility()
+
+		localStorage.setItem('vd-test', normalizedString)
+
+		expect(localStorageUtility.getItem('test')).toBe(testString)
+	})
+
+	it('should should get the length', () => {
+		const localStorageUtility = new LocalStorageUtility()
+
+		localStorage.setItem('vd-test', normalizedString)
+
+		expect(localStorageUtility.length).toBe(1)
+	})
+
+	it('should get all data items', () => {
+		const localStorageUtility = new LocalStorageUtility()
+
+		localStorage.setItem('vd-test-1', normalizedString)
+		localStorage.setItem('vd-test-2', normalizedString)
+
+		const expected = [testString, testString]
+
+		expect(localStorageUtility.getAll()).toEqual(expected)
+	})
+
+	it('should remove an item', () => {
+		const localStorageUtility = new LocalStorageUtility()
+
+		localStorage.setItem('vd-test-1', normalizedString)
+		localStorage.setItem('vd-test-2', normalizedString)
+
+		localStorageUtility.removeItem('test-1')
+		// Try to remove a non existing item
+		localStorageUtility.removeItem('test')
+
+		expect(localStorage.getItem('vd-test-1')).toBe(null)
+	})
+
+	it('should clear items', () => {
+		const localStorageUtility = new LocalStorageUtility()
+
+		localStorage.setItem('vd-test-1', normalizedString)
+		localStorage.setItem('vd-test-2', normalizedString)
+
+		localStorageUtility.clear()
+
+		expect(localStorage.getItem('vd-test-1')).toBe(null)
+		expect(localStorage.getItem('vd-test-2')).toBe(null)
+
+		// It shouldn't clear the control item
+		expect(localStorage.getItem('vd-storage-control')).not.toBe(null)
+	})
+
+	it('should get the name of the nth key in the storage', () => {
+		const localStorageUtility = new LocalStorageUtility()
+
+		localStorage.setItem('vd-test-1', normalizedString)
+		localStorage.setItem('vd-test-2', normalizedString)
+
+		expect(localStorageUtility.key(1)).toEqual('vd-test-2')
+	})
+
+	it('should return null when an item does not exists', () => {
+		const localStorageUtility = new LocalStorageUtility()
+
+		expect(localStorageUtility.getItem('test')).toBe(null)
+	})
+
+	it('should work with a custom prefix', () => {
+		const localStorageUtility = new LocalStorageUtility(
+			undefined,
+			undefined,
+			'test-',
+		)
+
+		localStorageUtility.setItem('test', testString)
+
+		expect(localStorage.getItem('test-test')).toBe(normalizedString)
+	})
+
+	it('should set an item correctly with expiration', () => {
+		const localStorageUtility = new LocalStorageUtility(undefined, 10)
+
+		localStorageUtility.setItem('test', testString)
+
+		expect(localStorageUtility.getItem('test')).toBe(testString)
+	})
+
+	it('should remove all items when expired', () => {
+		// Negative expiration = expired by default
+		const localStorageUtility = new LocalStorageUtility(undefined, -1)
+
+		// Simulate previously stored item
+		localStorage.setItem('vd-test-1', normalizedString)
+
+		localStorageUtility.setItem('test', testString)
+
+		expect(localStorageUtility.getItem('test')).toBe(null)
+		expect(localStorage.getItem('vd-test-1')).toBe(null)
+	})
+
+	it('should not fail when localStorage is not available', () => {
+		Object.defineProperty(window, 'localStorage', {
+			value: undefined,
+		})
+
+		const localStorageUtility = new LocalStorageUtility()
+
+		expect(localStorageUtility.getItem('test')).toBe(null)
+		expect(localStorageUtility.setItem('test', 'test')).toBeUndefined()
+	})
+})

package/src/utils/ruleMessage/index.ts

@@ -0,0 +1,14 @@
+import type { ErrorMessages, GenericFnOpt } from '@/utils/rules/types'
+
+/** Get the value of an error message */
+export function ruleMessage<T>(
+	errorMessages: ErrorMessages<T>,
+	key: string,
+	args: T[] = [],
+): string {
+	if (typeof errorMessages[key] === 'function') {
+		return (errorMessages[key] as GenericFnOpt<T>)(...args)
+	}
+
+	return errorMessages[key] as string
+}

package/src/utils/ruleMessage/tests/ruleMessages.spec.ts

@@ -0,0 +1,28 @@
+import { describe, it, expect } from 'vitest'
+import { ruleMessage } from '../'
+
+describe('ruleMessage', () => {
+	it('returns the requested message when it is an object', () => {
+		const messages = {
+			default: 'test',
+		}
+
+		expect(ruleMessage(messages, 'default')).toBe('test')
+	})
+
+	it('returns the requested message when it is a function', () => {
+		const messages = {
+			default: () => 'test',
+		}
+
+		expect(ruleMessage(messages, 'default')).toBe('test')
+	})
+
+	it('returns the requested message when it is a function with parameters', () => {
+		const messages = {
+			default: (value: number) => 'test' + value,
+		}
+
+		expect(ruleMessage(messages, 'default', [10])).toBe('test10')
+	})
+})

package/src/utils/rules/email/index.ts

@@ -0,0 +1,26 @@
+import { ruleMessage } from '@/utils/ruleMessage'
+import type {
+	ValidationRule,
+	ValidationResult,
+	ErrorMessages,
+	Value,
+} from '@/utils/rules/types'
+
+import { isEmailValid } from '../../functions/isEmailValid'
+
+import { defaultErrorMessages } from './locales'
+
+/** Check that the value is a valid email */
+export function emailFn(
+	errorMessages: ErrorMessages = defaultErrorMessages,
+): ValidationRule {
+	return (value: Value): ValidationResult => {
+		if (!value) {
+			return true
+		}
+
+		return isEmailValid(value) || ruleMessage(errorMessages, 'default')
+	}
+}
+
+export const email = emailFn()

package/src/utils/rules/email/locales.ts

@@ -0,0 +1,5 @@
+import type { ErrorMessages } from '@/utils/rules/types'
+
+export const defaultErrorMessages: ErrorMessages = {
+	default: 'Le format de l’adresse email n’est pas valide.',
+}

package/src/utils/rules/email/tests/email.spec.ts

@@ -0,0 +1,24 @@
+import { email, emailFn } from '../'
+import { describe, it, expect } from 'vitest'
+
+describe('email', () => {
+	it('returns an error when the email is invalid', () => {
+		expect(typeof email('test')).toBe('string')
+	})
+
+	it('returns true when the email is valid', () => {
+		expect(email('test@example.com')).toBe(true)
+	})
+
+	it('returns true if the value is falsy', () => {
+		expect(email('')).toBe(true)
+	})
+
+	it('works with custom error messages', () => {
+		const rule = emailFn({
+			default: 'test',
+		})
+
+		expect(rule('test')).toBe('test')
+	})
+})