@regardio/js 0.6.0 → 0.7.1

package/dist/text/index.mjs

@@ -0,0 +1,223 @@
+//#region src/text/bytes.ts
+function formatBytes(bytes, decimals = 2) {
+	if (!+bytes) return "0 Bytes";
+	/** Converts on base 10
+	* In binary - change k to 1024
+	*/
+	const k = 1e3;
+	const dm = decimals < 0 ? 0 : decimals;
+	const sizes = [
+		"Bytes",
+		"KB",
+		"MB",
+		"GB",
+		"TB",
+		"PB",
+		"EB",
+		"ZB",
+		"YB"
+	];
+	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
+/**
+* Locale-specific typographic quote styles
+* Using Unicode escape sequences to avoid encoding issues
+* @see https://en.wikipedia.org/wiki/Quotation_mark#Summary_table
+*/
+const quoteStyles = {
+	cs: {
+		close: "”",
+		closeSingle: "’",
+		open: "„",
+		openSingle: "‚"
+	},
+	da: {
+		close: "«",
+		closeSingle: "›",
+		open: "»",
+		openSingle: "‹"
+	},
+	de: {
+		close: "”",
+		closeSingle: "’",
+		open: "„",
+		openSingle: "‚"
+	},
+	"de-ch": {
+		close: "»",
+		closeSingle: "›",
+		open: "«",
+		openSingle: "‹"
+	},
+	en: {
+		close: "”",
+		closeSingle: "’",
+		open: "“",
+		openSingle: "‘"
+	},
+	es: {
+		close: "»",
+		closeSingle: "”",
+		open: "«",
+		openSingle: "“"
+	},
+	fi: {
+		close: "”",
+		closeSingle: "’",
+		open: "”",
+		openSingle: "’"
+	},
+	fr: {
+		close: " »",
+		closeSingle: " ›",
+		open: "« ",
+		openSingle: "‹ "
+	},
+	hu: {
+		close: "”",
+		closeSingle: "’",
+		open: "„",
+		openSingle: "‚"
+	},
+	it: {
+		close: "»",
+		closeSingle: "”",
+		open: "«",
+		openSingle: "“"
+	},
+	ja: {
+		close: "」",
+		closeSingle: "』",
+		open: "「",
+		openSingle: "『"
+	},
+	nl: {
+		close: "’",
+		closeSingle: "’",
+		open: "‘",
+		openSingle: "‘"
+	},
+	no: {
+		close: "«",
+		closeSingle: "›",
+		open: "»",
+		openSingle: "‹"
+	},
+	pl: {
+		close: "”",
+		closeSingle: "’",
+		open: "„",
+		openSingle: "‚"
+	},
+	pt: {
+		close: "»",
+		closeSingle: "”",
+		open: "«",
+		openSingle: "“"
+	},
+	ru: {
+		close: "»",
+		closeSingle: "’",
+		open: "«",
+		openSingle: "‚"
+	},
+	sv: {
+		close: "”",
+		closeSingle: "’",
+		open: "”",
+		openSingle: "’"
+	},
+	zh: {
+		close: "」",
+		closeSingle: "』",
+		open: "「",
+		openSingle: "『"
+	}
+};
+/**
+* Get the quote style for a given locale.
+* Falls back to base language if region-specific style not found,
+* then to English style as default.
+*/
+function getQuoteStyle(locale) {
+	const normalized = locale.toLowerCase();
+	const exactMatch = quoteStyles[normalized];
+	if (exactMatch) return exactMatch;
+	const baseLanguage = normalized.split("-")[0];
+	if (baseLanguage) {
+		const baseMatch = quoteStyles[baseLanguage];
+		if (baseMatch) return baseMatch;
+	}
+	return quoteStyles.en;
+}
+/**
+* Replace straight quotes with typographically correct quotes for the given locale.
+*
+* @param text - The text containing straight quotes
+* @param locale - The locale to use for quote style (e.g., 'en', 'de', 'fr')
+* @returns Text with typographic quotes
+*
+* @example
+* typographicQuotes('"Hello"', 'en') // → '"Hello"'
+* typographicQuotes('"Hello"', 'de') // → '„Hello"'
+* typographicQuotes('"Hello"', 'fr') // → '« Hello »'
+*/
+function typographicQuotes(text, locale) {
+	const style = getQuoteStyle(locale);
+	let result = text.replace(/"([^"]*)"/g, `${style.open}$1${style.close}`);
+	result = result.replace(/'([^']*)'/g, `${style.openSingle}$1${style.closeSingle}`);
+	return result;
+}
+function toBoolean(value) {
+	if (typeof value === "boolean") return value;
+	return value === "true" || value === "1";
+}
+/**
+* Replace &shy; HTML entity with Unicode soft hyphen
+*/
+function replaceShyInString(input) {
+	return input.replace(/&shy;/g, "­");
+}
+/**
+* Split text into sentences
+*/
+function splitIntoSentences(text) {
+	return text.split(/(?<=[.!?])\s+/);
+}
+/**
+* Split text into words
+*/
+function splitIntoWords(text) {
+	return text.split(/\s+/);
+}
+/**
+* Truncate text to a maximum length
+*/
+function truncateText(text, maxLength, suffix = "...") {
+	if (text.length <= maxLength) return text;
+	return text.slice(0, maxLength - suffix.length) + suffix;
+}
+const authorRegex = /^(.*?)\s*(?:<([^>]+)>)?\s*(?:\(([^)]+)\))?$/;
+/**
+* Parse an author string in the format "Name <email> (url)"
+*/
+function parseAuthorString(input) {
+	const match = input.match(authorRegex);
+	if (match) {
+		const [, name, email, url] = match;
+		const result = {};
+		if (email) result.email = email;
+		const trimmedName = name?.trim();
+		if (trimmedName) result.name = trimmedName;
+		if (url) result.url = url;
+		return result;
+	}
+	return {};
+}
+
+//#endregion
+export { formatBytes, parseAuthorString, replaceShyInString, splitIntoSentences, splitIntoWords, toBoolean, truncateText, typographicQuotes };

package/dist/time/index.d.mts

@@ -0,0 +1,22 @@
+//#region src/time/delay.d.ts
+/** Delays using a promise
+* @param ms Milisecods of delay
+* @return Promise
+*/
+declare function delay(ms: number): Promise<void>;
+//#endregion
+//#region src/time/measure.d.ts
+declare function measure<Result>(key: string, callback: () => Result | Promise<Result>): Promise<Result>;
+//#endregion
+//#region src/time/time.d.ts
+declare function timeAgo(input: Date | string): string;
+declare const oneWeekFromNow: () => Date;
+declare const oneDayFromNow: () => Date;
+declare const oneMinuteFromNow: () => Date;
+declare function friendlyDuration(minutes: number | null, locale: string, short?: boolean): {
+  key: string;
+  vars: Record<string, string | number>;
+} | null;
+declare const dateTimeInUnix: (date: number) => number;
+//#endregion
+export { dateTimeInUnix, delay, friendlyDuration, measure, oneDayFromNow, oneMinuteFromNow, oneWeekFromNow, timeAgo };

package/dist/time/index.mjs

@@ -0,0 +1,154 @@
+//#region src/time/delay.ts
+/** Delays using a promise
+* @param ms Milisecods of delay
+* @return Promise
+*/
+function delay(ms) {
+	return new Promise((resolve) => {
+		return setTimeout(resolve, ms);
+	});
+}
+
+//#endregion
+//#region src/time/measure.ts
+async function measure(key, callback) {
+	const start = Date.now();
+	try {
+		let result = callback();
+		if (result instanceof Promise) result = await result;
+		return result;
+	} finally {
+		const end = Date.now();
+		console.log(`${key} took ${end - start}ms`);
+	}
+}
+
+//#endregion
+//#region src/time/time.ts
+function timeAgo(input) {
+	const date = new Date(input);
+	const formatter = new Intl.RelativeTimeFormat("en");
+	const ranges = {
+		days: 3600 * 24,
+		hours: 3600,
+		minutes: 60,
+		months: 3600 * 24 * 30,
+		seconds: 1,
+		weeks: 3600 * 24 * 7,
+		years: 3600 * 24 * 365
+	};
+	const secondsElapsed = (date.getTime() - Date.now()) / 1e3;
+	for (const key of Object.keys(ranges)) if (ranges[key] < Math.abs(secondsElapsed)) {
+		const delta = secondsElapsed / ranges[key];
+		return formatter.format(Math.round(delta), key);
+	}
+	return "Just now";
+}
+const oneWeekFromNow = () => {
+	const now = /* @__PURE__ */ new Date();
+	return new Date(now.getTime() + 10080 * 60 * 1e3);
+};
+const oneDayFromNow = () => {
+	const now = /* @__PURE__ */ new Date();
+	return new Date(now.getTime() + 1440 * 60 * 1e3);
+};
+const oneMinuteFromNow = () => {
+	const now = /* @__PURE__ */ new Date();
+	return new Date(now.getTime() + 60 * 1e3);
+};
+function friendlyDuration(minutes, locale, short = false) {
+	const numberFormatter = new Intl.NumberFormat(locale);
+	if (!minutes) return null;
+	if (short) {
+		if (minutes > 120) {
+			const hours = Math.floor(minutes / 60);
+			const remainingMinutes = minutes % 60;
+			if (remainingMinutes > 0) return {
+				key: "common:duration.hoursAndMinutesShort",
+				vars: {
+					hours: numberFormatter.format(hours),
+					minutes: numberFormatter.format(remainingMinutes)
+				}
+			};
+			return {
+				key: "common:duration.hoursShort",
+				vars: { hours: numberFormatter.format(hours) }
+			};
+		}
+		return {
+			key: "common:duration.minutesShort",
+			vars: { minutes: numberFormatter.format(minutes) }
+		};
+	}
+	if (minutes >= 525600) {
+		const years = Math.floor(minutes / 525600);
+		return {
+			key: "common:duration.years",
+			vars: {
+				count: years,
+				value: numberFormatter.format(years)
+			}
+		};
+	}
+	if (minutes >= 43200) {
+		const months = Math.floor(minutes / 43200);
+		return {
+			key: "common:duration.months",
+			vars: {
+				count: months,
+				value: numberFormatter.format(months)
+			}
+		};
+	}
+	if (minutes >= 10080) {
+		const weeks = Math.floor(minutes / 10080);
+		return {
+			key: "common:duration.weeks",
+			vars: {
+				count: weeks,
+				value: numberFormatter.format(weeks)
+			}
+		};
+	}
+	if (minutes >= 1440) {
+		const days = Math.floor(minutes / 1440);
+		return {
+			key: "common:duration.days",
+			vars: {
+				count: days,
+				value: numberFormatter.format(days)
+			}
+		};
+	}
+	if (minutes >= 240) {
+		const hours = Math.floor(minutes / 60);
+		const remainingMinutes = minutes % 60;
+		if (remainingMinutes > 0) return {
+			key: "common:duration.hoursAndMinutes",
+			vars: {
+				hours: numberFormatter.format(hours),
+				minutes: numberFormatter.format(remainingMinutes)
+			}
+		};
+		return {
+			key: "common:duration.hours",
+			vars: {
+				count: hours,
+				value: numberFormatter.format(hours)
+			}
+		};
+	}
+	return {
+		key: "common:duration.minutes",
+		vars: {
+			count: minutes,
+			value: numberFormatter.format(minutes)
+		}
+	};
+}
+const dateTimeInUnix = (date) => {
+	return Math.floor(date / 1e3);
+};
+
+//#endregion
+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.6.0",
+  "version": "0.7.1",
   "private": false,
   "description": "Regardio JavaScript utilities",
   "keywords": [
@@ -28,37 +28,37 @@
   "type": "module",
   "exports": {
     "./assert": {
-      "types": "./dist/assert/index.d.ts",
-      "import": "./dist/assert/index.js"
+      "types": "./dist/assert/index.d.mts",
+      "import": "./dist/assert/index.mjs"
     },
     "./encoding": {
-      "types": "./dist/encoding/index.d.ts",
-      "import": "./dist/encoding/index.js"
+      "types": "./dist/encoding/index.d.mts",
+      "import": "./dist/encoding/index.mjs"
     },
     "./http": {
-      "types": "./dist/http/index.d.ts",
-      "import": "./dist/http/index.js"
+      "types": "./dist/http/index.d.mts",
+      "import": "./dist/http/index.mjs"
     },
     "./intl": {
-      "types": "./dist/intl/index.d.ts",
-      "import": "./dist/intl/index.js"
+      "types": "./dist/intl/index.d.mts",
+      "import": "./dist/intl/index.mjs"
     },
     "./text": {
-      "types": "./dist/text/index.d.ts",
-      "import": "./dist/text/index.js"
+      "types": "./dist/text/index.d.mts",
+      "import": "./dist/text/index.mjs"
     },
     "./time": {
-      "types": "./dist/time/index.d.ts",
-      "import": "./dist/time/index.js"
+      "types": "./dist/time/index.d.mts",
+      "import": "./dist/time/index.mjs"
     }
   },
   "files": [
     "dist"
   ],
   "scripts": {
-    "build": "tsup && post-build-exports && pnpm fix",
+    "build": "tsdown && pnpm fix",
     "clean": "exec-clean .turbo dist",
-    "dev": "tsup --watch",
+    "dev": "tsdown --watch",
     "fix": "exec-p fix:*",
     "fix:biome": "lint-biome check --write --unsafe .",
     "fix:md": "lint-md --fix",
@@ -80,13 +80,13 @@
     "react-router": "7.12.0"
   },
   "devDependencies": {
-    "@regardio/dev": "1.11.1",
+    "@regardio/dev": "1.12.1",
     "@total-typescript/ts-reset": "0.6.1",
-    "@types/node": "25.0.3",
-    "@vitest/coverage-v8": "4.0.16",
-    "@vitest/ui": "4.0.16",
-    "tsup": "8.5.1",
-    "vitest": "4.0.16"
+    "@types/node": "25.0.8",
+    "@vitest/coverage-v8": "4.0.17",
+    "@vitest/ui": "4.0.17",
+    "tsdown": "0.20.0-beta.3",
+    "vitest": "4.0.17"
   },
   "publishConfig": {
     "access": "public"

package/dist/assert/index.d.ts

@@ -1,43 +0,0 @@
-/**
- * Provide a condition and if that condition is falsey, this throws an error
- * with the given message.
- *
- * inspired by invariant from 'tiny-invariant' except will still include the
- * message in production.
- *
- * @example
- * invariant(typeof value === 'string', `value must be a string`)
- *
- * @param condition The condition to check
- * @param message The message to throw (or a callback to generate the message)
- *
- * @throws {Error} if condition is falsey
- */
-declare function invariant(condition: unknown, message: string | (() => string)): asserts condition;
-/**
- * Provide a condition and if that condition is falsey, this throws a 400
- * Response with the given message.
- *
- * inspired by invariant from 'tiny-invariant'
- *
- * @example
- * invariantResponse(typeof value === 'string', `value must be a string`)
- *
- * @param condition The condition to check
- * @param message The message to throw (or a callback to generate the message)
- * @param responseInit Additional response init options if a response is thrown
- *
- * @throws {Response} if condition is falsey
- */
-declare function invariantResponse(condition: unknown, message: string | (() => string), responseInit?: ResponseInit): asserts condition;
-
-/**
- * Check if a mime type matches the set given in accept
- *
- * @param type the mime type to test, ex image/png
- * @param accept the mime types to accept, ex audio/*,video/*,image/png
- * @returns true if the mime is accepted, false otherwise
- */
-declare function verifyAccept(type: string, accept: string): boolean;
-
-export { invariant, invariantResponse, verifyAccept };

package/dist/assert/index.js

@@ -1,22 +0,0 @@
-// src/assert/invariant.ts
-function invariant(condition, message) {
-  if (!condition) {
-    throw new Error(typeof message === "function" ? message() : message);
-  }
-}
-function invariantResponse(condition, message, responseInit) {
-  if (!condition) {
-    throw new Response(typeof message === "function" ? message() : message, {
-      status: 400,
-      ...responseInit
-    });
-  }
-}
-
-// src/assert/verify-file-accept.ts
-function verifyAccept(type, accept) {
-  const allowed = accept.split(",").map((x) => x.trim());
-  return allowed.includes(type) || allowed.includes(`${type.split("/")[0]}/*`);
-}
-
-export { invariant, invariantResponse, verifyAccept };

package/dist/encoding/index.d.ts

@@ -1,13 +0,0 @@
-/**
- * Converts a base64 string to a Uint8Array
- * @param base64String The base64 string to convert
- * @returns A Uint8Array containing the decoded data
- */
-declare const urlBase64ToUint8Array: (base64String: string) => Uint8Array;
-/**
- * Generate a cryptographically secure random base64 string.
- * @returns A base64-encoded random string (16 bytes of entropy)
- */
-declare function generateRandomBase64(): string;
-
-export { generateRandomBase64, urlBase64ToUint8Array };

package/dist/encoding/index.js

@@ -1,18 +0,0 @@
-// src/encoding/base64.ts
-var urlBase64ToUint8Array = (base64String) => {
-  const padding = "=".repeat((4 - base64String.length % 4) % 4);
-  const base64 = (base64String + padding).replace(/-/g, "+").replace(/_/g, "/");
-  const rawData = window.atob(base64);
-  const outputArray = new Uint8Array(rawData.length);
-  for (let i = 0; i < rawData.length; ++i) {
-    outputArray[i] = rawData.charCodeAt(i);
-  }
-  return outputArray;
-};
-function generateRandomBase64() {
-  const array = new Uint8Array(16);
-  crypto.getRandomValues(array);
-  return btoa(String.fromCharCode(...array));
-}
-
-export { generateRandomBase64, urlBase64ToUint8Array };

package/dist/http/index.d.ts

@@ -1,49 +0,0 @@
-/**
- * Helper function to set cookies in a more controlled way
- * @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?: {
-    expires?: Date;
-    path?: string;
-    sameSite?: string;
-    secure?: boolean;
-    domain?: string;
-}): void;
-/**
- * Get a cookie value by name
- * @param name - The name of the cookie to get
- * @returns The cookie value or null if not found
- */
-declare function getCookieValue(name: string): string | null;
-
-/**
- * Helper utility used to extract the domain from the request even if it's
- * behind a proxy. This is useful for sitemaps and other things.
- * @param request Request object
- * @returns Current domain
- */
-declare const createDomain: (request: Request) => string;
-
-/**
- * @name isRouteActive
- * @description A function to check if a route is active. This is used to
- * @param end
- * @param path
- * @param currentPath
- */
-declare function isRouteActive(path: string, currentPath: string, end?: boolean | ((path: string) => boolean) | undefined): boolean;
-/**
- * @name checkIfRouteIsActive
- * @description A function to check if a route is active. This is used to
- * highlight the active link in the navigation.
- * @param targetLink - The link to check against
- * @param currentRoute - the current route
- * @param depth - how far down should segments be matched?
- */
-declare function checkIfRouteIsActive(targetLink: string, currentRoute: string, depth?: number): boolean;
-
-declare function getCleanUrl(request: Request): string;
-
-export { checkIfRouteIsActive, createDomain, getCleanUrl, getCookieValue, isRouteActive, setCookieValue };