@kavach/cookie 1.0.0-next.25 → 1.0.0-next.27

package/spec/serialize.spec.js

@@ -1,168 +1,157 @@
 import { describe, expect, it } from 'vitest'
-import cookie from '../src/index.js'
+import { parse, serialize } from '../src/index.js'
 
 describe('Cookie Serialize', () => {
+	const identity = (v) => v
+
 	it('basic', () => {
-		expect(cookie.serialize('foo', 'bar')).toEqual('foo=bar')
-		expect(cookie.serialize('foo', 'bar baz')).toEqual('foo=bar%20baz')
-		expect(cookie.serialize('foo', '')).toEqual('foo=')
-		expect(cookie.serialize.bind(cookie, 'foo\n', 'bar')).toThrowError(
+		expect(serialize('foo', 'bar')).toEqual('foo=bar')
+		expect(serialize('foo', 'bar baz')).toEqual('foo=bar%20baz')
+		expect(serialize('foo', '')).toEqual('foo=')
+		expect(() => serialize('foo\n', 'bar')).toThrowError(
 			/argument name is invalid/
 		)
-		expect(cookie.serialize.bind(cookie, 'foo\u280a', 'bar')).toThrowError(
+		expect(() => serialize('foo\n', 'bar')).toThrowError(
 			/argument name is invalid/
 		)
-		expect(
-			cookie.serialize.bind(cookie, 'foo', 'bar', { encode: 42 })
-		).toThrowError(/option encode is invalid/)
+		expect(() => serialize('foo\u280a', 'bar')).toThrowError(
+			/argument name is invalid/
+		)
+		expect(() => serialize('foo', 'bar', { encode: 42 })).toThrowError(
+			/option encode is invalid/
+		)
 	})
 
 	it('path', () => {
-		expect(cookie.serialize('foo', 'bar', { path: '/' })).toEqual(
-			'foo=bar; Path=/'
-		)
-		expect(
-			cookie.serialize.bind(cookie, 'foo', 'bar', {
+		expect(serialize('foo', 'bar', { path: '/' })).toEqual('foo=bar; Path=/')
+		expect(() =>
+			serialize('foo', 'bar', {
 				path: '/\n'
 			})
 		).toThrowError(/option path is invalid/)
 	})
 
 	it('secure', () => {
-		expect(cookie.serialize('foo', 'bar', { secure: true })).toEqual(
-			'foo=bar; Secure'
-		)
-		expect(cookie.serialize('foo', 'bar', { secure: false })).toEqual('foo=bar')
+		expect(serialize('foo', 'bar', { secure: true })).toEqual('foo=bar; Secure')
+		expect(serialize('foo', 'bar', { secure: false })).toEqual('foo=bar')
 	})
 
 	it('domain', () => {
-		expect(cookie.serialize('foo', 'bar', { domain: 'example.com' })).toEqual(
+		expect(serialize('foo', 'bar', { domain: 'example.com' })).toEqual(
 			'foo=bar; Domain=example.com'
 		)
-		expect(
-			cookie.serialize.bind(cookie, 'foo', 'bar', {
+		expect(() =>
+			serialize('foo', 'bar', {
 				domain: 'example.com\n'
 			})
 		).toThrowError(/option domain is invalid/)
 	})
 
 	it('httpOnly', () => {
-		expect(cookie.serialize('foo', 'bar', { httpOnly: true })).toEqual(
+		expect(serialize('foo', 'bar', { httpOnly: true })).toEqual(
 			'foo=bar; HttpOnly'
 		)
 	})
 
 	it('maxAge', () => {
 		expect(() =>
-			cookie.serialize('foo', 'bar', {
+			serialize('foo', 'bar', {
 				maxAge: 'buzz'
 			})
 		).toThrowError(/option maxAge is invalid/)
 
 		expect(() =>
-			cookie.serialize('foo', 'bar', {
+			serialize('foo', 'bar', {
 				maxAge: Infinity
 			})
 		).toThrowError(/option maxAge is invalid/)
 
-		expect(cookie.serialize('foo', 'bar', { maxAge: 1000 })).toEqual(
+		expect(serialize('foo', 'bar', { maxAge: 1000 })).toEqual(
 			'foo=bar; Max-Age=1000'
 		)
-		expect(cookie.serialize('foo', 'bar', { maxAge: '1000' })).toEqual(
+		expect(serialize('foo', 'bar', { maxAge: '1000' })).toEqual(
 			'foo=bar; Max-Age=1000'
 		)
-		expect(cookie.serialize('foo', 'bar', { maxAge: 0 })).toEqual(
+		expect(serialize('foo', 'bar', { maxAge: 0 })).toEqual('foo=bar; Max-Age=0')
+		expect(serialize('foo', 'bar', { maxAge: '0' })).toEqual(
 			'foo=bar; Max-Age=0'
 		)
-		expect(cookie.serialize('foo', 'bar', { maxAge: '0' })).toEqual(
-			'foo=bar; Max-Age=0'
-		)
-		expect(cookie.serialize('foo', 'bar', { maxAge: null })).toEqual('foo=bar')
-		expect(cookie.serialize('foo', 'bar', { maxAge: undefined })).toEqual(
-			'foo=bar'
-		)
-		expect(cookie.serialize('foo', 'bar', { maxAge: 3.14 })).toEqual(
+		expect(serialize('foo', 'bar', { maxAge: null })).toEqual('foo=bar')
+		expect(serialize('foo', 'bar')).toEqual('foo=bar')
+		expect(serialize('foo', 'bar', { maxAge: 3.14 })).toEqual(
 			'foo=bar; Max-Age=3'
 		)
 	})
 
 	it('expires', () => {
 		expect(
-			cookie.serialize('foo', 'bar', {
+			serialize('foo', 'bar', {
 				expires: new Date(Date.UTC(2000, 11, 24, 10, 30, 59, 900))
 			})
 		).toEqual('foo=bar; Expires=Sun, 24 Dec 2000 10:30:59 GMT')
 
-		expect(
-			cookie.serialize.bind(cookie, 'foo', 'bar', {
+		expect(() =>
+			serialize('foo', 'bar', {
 				expires: Date.now()
 			})
 		).toThrowError(/option expires is invalid/)
 	})
 
 	it('sameSite', () => {
-		expect(cookie.serialize('foo', 'bar', { sameSite: true })).toEqual(
+		expect(serialize('foo', 'bar', { sameSite: true })).toEqual(
 			'foo=bar; SameSite=Strict'
 		)
-		expect(cookie.serialize('foo', 'bar', { sameSite: 'Strict' })).toEqual(
+		expect(serialize('foo', 'bar', { sameSite: 'Strict' })).toEqual(
 			'foo=bar; SameSite=Strict'
 		)
-		expect(cookie.serialize('foo', 'bar', { sameSite: 'strict' })).toEqual(
+		expect(serialize('foo', 'bar', { sameSite: 'strict' })).toEqual(
 			'foo=bar; SameSite=Strict'
 		)
-		expect(cookie.serialize('foo', 'bar', { sameSite: 'Lax' })).toEqual(
+		expect(serialize('foo', 'bar', { sameSite: 'Lax' })).toEqual(
 			'foo=bar; SameSite=Lax'
 		)
-		expect(cookie.serialize('foo', 'bar', { sameSite: 'lax' })).toEqual(
+		expect(serialize('foo', 'bar', { sameSite: 'lax' })).toEqual(
 			'foo=bar; SameSite=Lax'
 		)
-		expect(cookie.serialize('foo', 'bar', { sameSite: 'None' })).toEqual(
+		expect(serialize('foo', 'bar', { sameSite: 'None' })).toEqual(
 			'foo=bar; SameSite=None'
 		)
-		expect(cookie.serialize('foo', 'bar', { sameSite: 'none' })).toEqual(
+		expect(serialize('foo', 'bar', { sameSite: 'none' })).toEqual(
 			'foo=bar; SameSite=None'
 		)
-		expect(cookie.serialize('foo', 'bar', { sameSite: false })).toEqual(
-			'foo=bar'
-		)
+		expect(serialize('foo', 'bar', { sameSite: false })).toEqual('foo=bar')
 
-		expect(
-			cookie.serialize.bind(cookie, 'foo', 'bar', {
+		expect(() =>
+			serialize('foo', 'bar', {
 				sameSite: 'foo'
 			})
 		).toThrowError(/option sameSite is invalid/)
 	})
 
 	it('escaping', () => {
-		expect(cookie.serialize('cat', '+ ')).toEqual('cat=%2B%20')
+		expect(serialize('cat', '+ ')).toEqual('cat=%2B%20')
 	})
 
 	it('parse->serialize', () => {
-		expect(
-			cookie.parse(cookie.serialize('cat', 'foo=123&name=baz five'))
-		).toEqual({
+		expect(parse(serialize('cat', 'foo=123&name=baz five'))).toEqual({
 			cat: 'foo=123&name=baz five'
 		})
 
-		expect(cookie.parse(cookie.serialize('cat', ' ";/'))).toEqual({
+		expect(parse(serialize('cat', ' ";/'))).toEqual({
 			cat: ' ";/'
 		})
 	})
 
 	it('unencoded', () => {
 		expect(
-			cookie.serialize('cat', '+ ', {
-				encode: function (value) {
-					return value
-				}
+			serialize('cat', '+ ', {
+				encode: identity
 			})
 		).toEqual('cat=+ ')
 
-		expect(
-			cookie.serialize.bind(cookie, 'cat', '+ \n', {
-				encode: function (value) {
-					return value
-				}
+		expect(() =>
+			serialize('cat', '+ \n', {
+				encode: identity
 			})
 		).toThrowError(/argument val is invalid/)
 	})

package/src/index.js

@@ -14,9 +14,9 @@
  * @private
  */
 
-var decode = decodeURIComponent
-var encode = encodeURIComponent
-var pairSplitRegExp = /; */
+const decode = decodeURIComponent
+const encode = encodeURIComponent
+const pairSplitRegExp = /; */
 
 /**
  * RegExp to match field-content in RFC 7230 sec 3.2
@@ -27,7 +27,7 @@ var pairSplitRegExp = /; */
  */
 
 // eslint-disable-next-line no-control-regex
-var fieldContentRegExp = /^[\u0009\u0020-\u007e\u0080-\u00ff]+$/
+const fieldContentRegExp = /^[\u0009\u0020-\u007e\u0080-\u00ff]+$/u
 
 /**
  * Parse a cookie header.
@@ -40,36 +40,36 @@ var fieldContentRegExp = /^[\u0009\u0020-\u007e\u0080-\u00ff]+$/
  * @return {object}
  * @public
  */
-
+// eslint-disable-next-line
 export function parse(str, options) {
 	if (typeof str !== 'string') {
 		throw new TypeError('argument str must be a string')
 	}
 
-	var obj = {}
-	var opt = options || {}
-	var pairs = str.split(pairSplitRegExp)
-	var dec = opt.decode || decode
+	const obj = {}
+	const opt = options || {}
+	const pairs = str.split(pairSplitRegExp)
+	const dec = opt.decode || decode
 
-	for (var i = 0; i < pairs.length; i++) {
-		var pair = pairs[i]
-		var eq_idx = pair.indexOf('=')
+	for (let i = 0; i < pairs.length; i++) {
+		const pair = pairs[i]
+		let eq_idx = pair.indexOf('=')
 
 		// skip things that don't look like key=value
 		if (eq_idx < 0) {
 			continue
 		}
 
-		var key = pair.slice(0, eq_idx).trim()
-		var val = pair.slice(++eq_idx, pair.length).trim()
+		const key = pair.slice(0, eq_idx).trim()
+		let val = pair.slice(++eq_idx, pair.length).trim()
 
 		// quoted values
-		if (val[0] == '"') {
+		if (val[0] === '"') {
 			val = val.slice(1, -1)
 		}
 
 		// only assign once
-		if (undefined == obj[key]) {
+		if (obj[key] === undefined) {
 			obj[key] = tryDecode(val, dec)
 		}
 	}
@@ -92,10 +92,10 @@ export function parse(str, options) {
  * @return {string}
  * @public
  */
-
+// eslint-disable-next-line
 export function serialize(name, val, options) {
-	var opt = options || {}
-	var enc = opt.encode || encode
+	const opt = { maxAge: null, ...(options || {}) }
+	const enc = opt.encode || encode
 
 	if (typeof enc !== 'function') {
 		throw new TypeError('option encode is invalid')
@@ -105,22 +105,22 @@ export function serialize(name, val, options) {
 		throw new TypeError('argument name is invalid')
 	}
 
-	var value = enc(val)
+	const value = enc(val)
 
 	if (value && !fieldContentRegExp.test(value)) {
 		throw new TypeError('argument val is invalid')
 	}
 
-	var str = name + '=' + value
+	let str = `${name}=${value}`
 
-	if (opt.maxAge != null) {
-		var maxAge = opt.maxAge - 0
+	if (opt.maxAge !== null) {
+		const maxAge = opt.maxAge - 0
 
 		if (isNaN(maxAge) || !isFinite(maxAge)) {
 			throw new TypeError('option maxAge is invalid')
 		}
 
-		str += '; Max-Age=' + Math.floor(maxAge)
+		str += `; Max-Age=${Math.floor(maxAge)}`
 	}
 
 	if (opt.domain) {
@@ -128,7 +128,7 @@ export function serialize(name, val, options) {
 			throw new TypeError('option domain is invalid')
 		}
 
-		str += '; Domain=' + opt.domain
+		str += `; Domain=${opt.domain}`
 	}
 
 	if (opt.path) {
@@ -136,7 +136,7 @@ export function serialize(name, val, options) {
 			throw new TypeError('option path is invalid')
 		}
 
-		str += '; Path=' + opt.path
+		str += `; Path=${opt.path}`
 	}
 
 	if (opt.expires) {
@@ -144,7 +144,7 @@ export function serialize(name, val, options) {
 			throw new TypeError('option expires is invalid')
 		}
 
-		str += '; Expires=' + opt.expires.toUTCString()
+		str += `; Expires=${opt.expires.toUTCString()}`
 	}
 
 	if (opt.httpOnly) {
@@ -156,7 +156,7 @@ export function serialize(name, val, options) {
 	}
 
 	if (opt.sameSite) {
-		var sameSite =
+		const sameSite =
 			typeof opt.sameSite === 'string'
 				? opt.sameSite.toLowerCase()
 				: opt.sameSite
@@ -186,19 +186,18 @@ export function serialize(name, val, options) {
  * Try decoding a string using a decoding function.
  *
  * @param {string} str
- * @param {function} decode
- * @private
+ * @param {function} decodeFn
+ * @returns {string}
  */
-
-function tryDecode(str, decode) {
+function tryDecode(str, decodeFn) {
 	try {
-		return decode(str)
+		return decodeFn(str)
 	} catch (e) {
 		return str
 	}
 }
 
-export default {
-	parse,
-	serialize
-}
+// export default {
+// 	parse,
+// 	serialize
+// }

package/CHANGELOG.md

@@ -1,16 +0,0 @@
-# @kavach/cookie
-
-## 1.0.0-next.6
-
-### Patch Changes
-
-- Added store for auth status and used alerts to display status on demo page.
-
-## 1.0.0-next.5
-
-### Patch Changes
-
-- chore: release 1.0.0-next.4
-- Split core package into logger and deflector
-- 1a35ad0: Resolved linter errors.
-- Releasing the next version.