@regardio/js 0.7.9 → 0.8.1

package/README.md

@@ -74,15 +74,49 @@ HTTP, cookie, and routing utilities.
 
 ```ts
 import {
-  getCookieValue,
-  setCookieValue,
+  // Client-side cookies (async - Cookie Store API + fallback)
+  getCookie,
+  setCookie,
+  deleteCookie,
+  // Client-side cookies (sync - document.cookie only)
+  getCookieSync,
+  setCookieSync,
+  deleteCookieSync,
+  // Server-side cookies (Request/Response)
+  parseCookies,
+  serializeCookie,
+  getCookieFromRequest,
+  setCookieOnResponse,
+  deleteCookieFromResponse,
+  getAllCookiesFromRequest,
+  // HTTP utilities
   createDomain,
   getCleanUrl,
   isRouteActive,
 } from '@regardio/js/http';
 
-setCookieValue('theme', 'dark', { path: '/', secure: true });
-const theme = getCookieValue('theme');
+// Client-side async: Cookie Store API with document.cookie fallback
+await setCookie('theme', 'dark', { path: '/', secure: true, sameSite: 'lax' });
+const theme = await getCookie('theme');
+await setCookie('theme', 'light', { path: '/' }); // Update by setting again
+await deleteCookie('theme', { path: '/' });
+
+// Client-side sync: document.cookie only (no async/await needed)
+setCookieSync('theme', 'dark', { path: '/', secure: true, sameSite: 'lax' });
+const themeSync = getCookieSync('theme');
+setCookieSync('theme', 'light', { path: '/' }); // Update by setting again
+deleteCookieSync('theme', { path: '/' });
+
+// Server-side: Request/Response cookie handling
+const session = getCookieFromRequest(request, 'session');
+const allCookies = getAllCookiesFromRequest(request);
+const response = setCookieOnResponse(
+  new Response('OK'),
+  'session',
+  'abc123',
+  { httpOnly: true, secure: true, sameSite: 'lax' }
+);
+
 const domain = createDomain(request); // "https://example.com"
 isRouteActive('/account', '/account/settings', false); // true
 ```

package/dist/assert/index.mjs

@@ -38,7 +38,6 @@ function invariantResponse(condition, message, responseInit) {
 		...responseInit
 	});
 }
-
 //#endregion
 //#region src/assert/verify-file-accept.ts
 /**
@@ -52,6 +51,5 @@ function verifyAccept(type, accept) {
 	const allowed = accept.split(",").map((x) => x.trim());
 	return allowed.includes(type) || allowed.includes(`${type.split("/")[0]}/*`);
 }
-
 //#endregion
-export { invariant, invariantResponse, verifyAccept };
+export { invariant, invariantResponse, verifyAccept };

package/dist/encoding/index.mjs

@@ -20,6 +20,5 @@ function generateRandomBase64() {
 	crypto.getRandomValues(array);
 	return btoa(String.fromCharCode(...array));
 }
-
 //#endregion
-export { generateRandomBase64, urlBase64ToUint8Array };
+export { generateRandomBase64, urlBase64ToUint8Array };

package/dist/http/index.d.mts

@@ -1,23 +1,93 @@
 //#region src/http/cookie.d.ts
+interface CookieOptions {
+  domain?: string;
+  expires?: Date;
+  path?: string;
+  sameSite?: "strict" | "lax" | "none";
+  secure?: boolean;
+}
 /**
-* Helper function to set cookies in a more controlled way
+* Set a cookie using Cookie Store API with document.cookie fallback
 * @param name - The name of the cookie
 * @param value - The value to set
 * @param options - Cookie options
 */
-declare function setCookieValue(name: string, value: string, options?: {
+declare function setCookie(name: string, value: string, options?: CookieOptions): Promise<void>;
+/**
+* Get a cookie by name using Cookie Store API with document.cookie fallback
+* @param name - The name of the cookie to get
+* @returns The cookie value or null if not found
+*/
+declare function getCookie(name: string): Promise<string | null>;
+/**
+* Update a cookie (alias for setCookie for clarity)
+* @param name - The name of the cookie
+* @param value - The new value to set
+* @param options - Cookie options
+*/
+declare function updateCookie(name: string, value: string, options?: CookieOptions): Promise<void>;
+/**
+* Delete a cookie by name using Cookie Store API with document.cookie fallback
+* @param name - The name of the cookie to delete
+* @param options - Cookie options (path and domain should match the original cookie)
+*/
+declare function deleteCookie(name: string, options?: Pick<CookieOptions, "path" | "domain">): Promise<void>;
+//#endregion
+//#region src/http/cookie.server.d.ts
+interface CookieSerializeOptions {
+  domain?: string;
+  encode?: (value: string) => string;
   expires?: Date;
+  httpOnly?: boolean;
+  maxAge?: number;
   path?: string;
-  sameSite?: string;
+  sameSite?: "strict" | "lax" | "none" | boolean;
   secure?: boolean;
-  domain?: string;
-}): void;
+}
 /**
-* Get a cookie value by name
-* @param name - The name of the cookie to get
+* Parse cookies from a Cookie header string
+* @param cookieHeader - The Cookie header value (e.g., "session=abc123; theme=dark")
+* @returns Object with cookie name-value pairs
+*/
+declare function parseCookies(cookieHeader: string | null | undefined): Record<string, string>;
+/**
+* Serialize a cookie into a Set-Cookie header value
+* @param name - The cookie name
+* @param value - The cookie value
+* @param options - Cookie options
+* @returns Set-Cookie header value
+*/
+declare function serializeCookie(name: string, value: string, options?: CookieSerializeOptions): string;
+/**
+* Get a cookie value from a Request object
+* @param request - The Request object
+* @param name - The cookie name to retrieve
 * @returns The cookie value or null if not found
 */
-declare function getCookieValue(name: string): string | null;
+declare function getCookieFromRequest(request: Request, name: string): string | null;
+/**
+* Set a cookie on a Response object by adding a Set-Cookie header
+* @param response - The Response object to modify
+* @param name - The cookie name
+* @param value - The cookie value
+* @param options - Cookie options
+* @returns A new Response with the Set-Cookie header added
+*/
+declare function setCookieOnResponse(response: Response, name: string, value: string, options?: CookieSerializeOptions): Response;
+/**
+* Delete a cookie on a Response object by setting it with an expired date
+* @param response - The Response object to modify
+* @param name - The cookie name to delete
+* @param options - Cookie options (path and domain should match the original cookie)
+* @returns A new Response with the Set-Cookie header to delete the cookie
+*/
+declare function deleteCookieFromResponse(response: Response, name: string, options?: Pick<CookieSerializeOptions, "path" | "domain">): Response;
+/**
+* Get all cookies from a Request object
+* @param request - The Request object
+* @returns Object with all cookie name-value pairs
+*/
+declare function getAllCookiesFromRequest(request: Request): Record<string, string>;
 //#endregion
 //#region src/http/domain.d.ts
 /**
@@ -50,4 +120,4 @@ declare function checkIfRouteIsActive(targetLink: string, currentRoute: string,
 //#region src/http/request-helpers.d.ts
 declare function getCleanUrl(request: Request): string;
 //#endregion
-export { checkIfRouteIsActive, createDomain, getCleanUrl, getCookieValue, isRouteActive, setCookieValue };
+export { type CookieOptions, type CookieSerializeOptions, checkIfRouteIsActive, createDomain, deleteCookie, deleteCookieFromResponse, getAllCookiesFromRequest, getCleanUrl, getCookie, getCookieFromRequest, isRouteActive, parseCookies, serializeCookie, setCookie, setCookieOnResponse, updateCookie };

package/dist/http/index.mjs

@@ -1,46 +1,198 @@
+import { parse, serialize } from "cookie-es";
 //#region src/http/cookie.ts
+function hasCookieStore() {
+	return typeof window !== "undefined" && "cookieStore" in window;
+}
+function buildCookieString(name, value, options) {
+	let cookieString = `${encodeURIComponent(name)}=${encodeURIComponent(value)}`;
+	if (options.expires) cookieString += `; expires=${options.expires.toUTCString()}`;
+	if (options.path) cookieString += `; path=${options.path}`;
+	if (options.sameSite) cookieString += `; SameSite=${options.sameSite}`;
+	if (options.secure) cookieString += "; Secure";
+	if (options.domain) cookieString += `; domain=${options.domain}`;
+	return cookieString;
+}
+function setViaCookieStore(name, value, options) {
+	const cookieInit = {
+		domain: options.domain,
+		name,
+		path: options.path,
+		sameSite: options.sameSite,
+		value
+	};
+	if (options.expires) cookieInit.expires = options.expires.getTime();
+	return window.cookieStore.set(cookieInit);
+}
+function setViaDocumentCookie(name, value, options) {
+	const cookieString = buildCookieString(name, value, options);
+	document.cookie = cookieString;
+}
+async function getViaCookieStore(name) {
+	return (await window.cookieStore.get(name))?.value ?? null;
+}
+function getViaDocumentCookie(name) {
+	const parts = `; ${document.cookie}`.split(`; ${name}=`);
+	if (parts.length === 2) {
+		const cookieValue = parts.pop()?.split(";").shift();
+		return cookieValue ? decodeURIComponent(cookieValue) : null;
+	}
+	return null;
+}
 /**
-* Helper function to set cookies in a more controlled way
+* Set a cookie using Cookie Store API with document.cookie fallback
 * @param name - The name of the cookie
 * @param value - The value to set
 * @param options - Cookie options
 */
-function setCookieValue(name, value, options = {}) {
+async function setCookie(name, value, options = {}) {
 	if (typeof window === "undefined") {
 		console.warn("Cannot set cookie on server side");
 		return;
 	}
-	let cookieString = `${encodeURIComponent(name)}=${encodeURIComponent(value)}`;
-	if (options.expires) cookieString += `; expires=${options.expires.toUTCString()}`;
-	if (options.path) cookieString += `; path=${options.path}`;
-	if (options.sameSite) cookieString += `; SameSite=${options.sameSite}`;
-	if (options.secure) cookieString += "; Secure";
-	if (options.domain) cookieString += `; domain=${options.domain}`;
 	try {
-		document.cookie = cookieString;
+		if (hasCookieStore()) await setViaCookieStore(name, value, options);
+		else setViaDocumentCookie(name, value, options);
 	} catch (error) {
 		if (error instanceof Error) console.error(`Failed to set cookie '${name}':`, error.message);
 		else console.error(`Failed to set cookie '${name}': Unknown error`);
 	}
 }
 /**
-* Get a cookie value by name
+* Get a cookie by name using Cookie Store API with document.cookie fallback
 * @param name - The name of the cookie to get
 * @returns The cookie value or null if not found
 */
-function getCookieValue(name) {
+async function getCookie(name) {
 	if (typeof window === "undefined") {
 		console.warn("Cannot get cookie on server side");
 		return null;
 	}
-	const parts = `; ${document.cookie}`.split(`; ${name}=`);
-	if (parts.length === 2) {
-		const cookieValue = parts.pop()?.split(";").shift();
-		return cookieValue ? decodeURIComponent(cookieValue) : null;
+	try {
+		if (hasCookieStore()) return await getViaCookieStore(name);
+		return getViaDocumentCookie(name);
+	} catch (error) {
+		if (error instanceof Error) console.error(`Failed to get cookie '${name}':`, error.message);
+		else console.error(`Failed to get cookie '${name}': Unknown error`);
+		return null;
 	}
-	return null;
 }
-
+/**
+* Update a cookie (alias for setCookie for clarity)
+* @param name - The name of the cookie
+* @param value - The new value to set
+* @param options - Cookie options
+*/
+function updateCookie(name, value, options = {}) {
+	return setCookie(name, value, options);
+}
+/**
+* Delete a cookie by name using Cookie Store API with document.cookie fallback
+* @param name - The name of the cookie to delete
+* @param options - Cookie options (path and domain should match the original cookie)
+*/
+async function deleteCookie(name, options = {}) {
+	if (typeof window === "undefined") {
+		console.warn("Cannot delete cookie on server side");
+		return;
+	}
+	try {
+		if (hasCookieStore()) await window.cookieStore.delete({
+			domain: options.domain,
+			name,
+			path: options.path
+		});
+		else {
+			const expires = /* @__PURE__ */ new Date(0);
+			setViaDocumentCookie(name, "", {
+				...options,
+				expires
+			});
+		}
+	} catch (error) {
+		if (error instanceof Error) console.error(`Failed to delete cookie '${name}':`, error.message);
+		else console.error(`Failed to delete cookie '${name}': Unknown error`);
+	}
+}
+//#endregion
+//#region src/http/cookie.server.ts
+/**
+* Parse cookies from a Cookie header string
+* @param cookieHeader - The Cookie header value (e.g., "session=abc123; theme=dark")
+* @returns Object with cookie name-value pairs
+*/
+function parseCookies(cookieHeader) {
+	if (!cookieHeader) return {};
+	try {
+		return parse(cookieHeader);
+	} catch (error) {
+		if (error instanceof Error) console.error("Failed to parse cookies:", error.message);
+		return {};
+	}
+}
+/**
+* Serialize a cookie into a Set-Cookie header value
+* @param name - The cookie name
+* @param value - The cookie value
+* @param options - Cookie options
+* @returns Set-Cookie header value
+*/
+function serializeCookie(name, value, options = {}) {
+	try {
+		return serialize(name, value, options);
+	} catch (error) {
+		if (error instanceof Error) console.error(`Failed to serialize cookie '${name}':`, error.message);
+		throw error;
+	}
+}
+/**
+* Get a cookie value from a Request object
+* @param request - The Request object
+* @param name - The cookie name to retrieve
+* @returns The cookie value or null if not found
+*/
+function getCookieFromRequest(request, name) {
+	return parseCookies(request.headers.get("Cookie"))[name] ?? null;
+}
+/**
+* Set a cookie on a Response object by adding a Set-Cookie header
+* @param response - The Response object to modify
+* @param name - The cookie name
+* @param value - The cookie value
+* @param options - Cookie options
+* @returns A new Response with the Set-Cookie header added
+*/
+function setCookieOnResponse(response, name, value, options = {}) {
+	const setCookieValue = serializeCookie(name, value, options);
+	const headers = new Headers(response.headers);
+	headers.append("Set-Cookie", setCookieValue);
+	return new Response(response.body, {
+		headers,
+		status: response.status,
+		statusText: response.statusText
+	});
+}
+/**
+* Delete a cookie on a Response object by setting it with an expired date
+* @param response - The Response object to modify
+* @param name - The cookie name to delete
+* @param options - Cookie options (path and domain should match the original cookie)
+* @returns A new Response with the Set-Cookie header to delete the cookie
+*/
+function deleteCookieFromResponse(response, name, options = {}) {
+	return setCookieOnResponse(response, name, "", {
+		...options,
+		expires: /* @__PURE__ */ new Date(0),
+		maxAge: 0
+	});
+}
+/**
+* Get all cookies from a Request object
+* @param request - The Request object
+* @returns Object with all cookie name-value pairs
+*/
+function getAllCookiesFromRequest(request) {
+	return parseCookies(request.headers.get("Cookie"));
+}
 //#endregion
 //#region src/http/domain.ts
 /**
@@ -58,7 +210,6 @@ const createDomain = (request) => {
 	if (url.hostname === "localhost") return `http://${url.host}`;
 	return `https://${url.host}`;
 };
-
 //#endregion
 //#region src/http/is-route-active.ts
 const ROOT_PATH = "/";
@@ -107,7 +258,6 @@ function numberOfMatchingSegments(href, segments) {
 function isRoot(path) {
 	return path === ROOT_PATH;
 }
-
 //#endregion
 //#region src/http/request-helpers.ts
 function getCleanUrl(request) {
@@ -117,6 +267,5 @@ function getCleanUrl(request) {
 	});
 	return url.toString();
 }
-
 //#endregion
-export { checkIfRouteIsActive, createDomain, getCleanUrl, getCookieValue, isRouteActive, setCookieValue };
+export { checkIfRouteIsActive, createDomain, deleteCookie, deleteCookieFromResponse, getAllCookiesFromRequest, getCleanUrl, getCookie, getCookieFromRequest, isRouteActive, parseCookies, serializeCookie, setCookie, setCookieOnResponse, updateCookie };

package/dist/intl/index.mjs

@@ -1,5 +1,4 @@
 import { parseAcceptLanguage } from "intl-parse-accept-language";
-
 //#region src/intl/language-detector.ts
 var LanguageDetectorLingui = class {
 	detector;
@@ -119,6 +118,5 @@ function getHeaders(requestOrHeaders) {
 	if (requestOrHeaders instanceof Request) return requestOrHeaders.headers;
 	return requestOrHeaders;
 }
-
 //#endregion
-export { LanguageDetector, LanguageDetectorLingui };
+export { LanguageDetector, LanguageDetectorLingui };

package/dist/text/index.mjs

@@ -20,7 +20,6 @@ function formatBytes(bytes, decimals = 2) {
 	const i = Math.floor(Math.log(bytes) / Math.log(k));
 	return `${Number.parseFloat((bytes / k ** i).toFixed(dm))} ${sizes[i]}`;
 }
-
 //#endregion
 //#region src/text/text.ts
 /**
@@ -218,6 +217,5 @@ function parseAuthorString(input) {
 	}
 	return {};
 }
-
 //#endregion
-export { formatBytes, parseAuthorString, replaceShyInString, splitIntoSentences, splitIntoWords, toBoolean, truncateText, typographicQuotes };
+export { formatBytes, parseAuthorString, replaceShyInString, splitIntoSentences, splitIntoWords, toBoolean, truncateText, typographicQuotes };

package/dist/time/index.mjs

@@ -8,7 +8,6 @@ function delay(ms) {
 		return setTimeout(resolve, ms);
 	});
 }
-
 //#endregion
 //#region src/time/measure.ts
 async function measure(key, callback) {
@@ -22,7 +21,6 @@ async function measure(key, callback) {
 		console.log(`${key} took ${end - start}ms`);
 	}
 }
-
 //#endregion
 //#region src/time/time.ts
 function timeAgo(input) {
@@ -149,6 +147,5 @@ function friendlyDuration(minutes, locale, short = false) {
 const dateTimeInUnix = (date) => {
 	return Math.floor(date / 1e3);
 };
-
 //#endregion
-export { dateTimeInUnix, delay, friendlyDuration, measure, oneDayFromNow, oneMinuteFromNow, oneWeekFromNow, timeAgo };
+export { dateTimeInUnix, delay, friendlyDuration, measure, oneDayFromNow, oneMinuteFromNow, oneWeekFromNow, timeAgo };

package/package.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://www.schemastore.org/package.json",
   "name": "@regardio/js",
-  "version": "0.7.9",
+  "version": "0.8.1",
   "private": false,
   "description": "Regardio JavaScript utilities",
   "keywords": [
@@ -76,16 +76,17 @@
     "typecheck": "exec-tsc --noEmit"
   },
   "dependencies": {
+    "cookie-es": "2.0.0",
     "intl-parse-accept-language": "1.0.0",
     "react-router": "7.13.1"
   },
   "devDependencies": {
-    "@regardio/dev": "1.16.0",
+    "@regardio/dev": "1.16.2",
     "@total-typescript/ts-reset": "0.6.1",
-    "@types/node": "25.3.2",
+    "@types/node": "25.4.0",
     "@vitest/coverage-v8": "4.0.18",
     "@vitest/ui": "4.0.18",
-    "tsdown": "0.20.3",
+    "tsdown": "0.21.1",
     "vitest": "4.0.18"
   }
 }