crelte 0.5.13 → 0.5.15

package/src/server/queries/routes.ts

@@ -4,6 +4,12 @@ import ServerRouter from '../ServerRouter.js';
 
 export type CacheIfFn = (response: any, vars: Record<string, any>) => boolean;
 
+/// Either throw or return a boolean
+export type ValidIfFn = (
+	vars: Record<string, any>,
+	sr: ServerRouter,
+) => void | boolean;
+
 /// Anything other than returning undefined will replace the response
 //
 // Note that even if you return undefined since the response is by reference
@@ -20,13 +26,14 @@ export type HandleFn = (
 ) => Promise<any> | any;
 
 /**
- * Returns the validated variables if some vars where defined
+ * Returns the validated variables if some vars were defined
  * else just returns all vars
  */
 export function validateVars(
 	qvars: Record<string, QueryVar> | null,
 	vars: any,
-	cs: ServerRouter,
+	validIfFn: ValidIfFn | null,
+	sr: ServerRouter,
 ): Record<string, any> {
 	if (!vars || typeof vars !== 'object')
 		throw new Error('expected an object as vars');
@@ -36,7 +43,14 @@ export function validateVars(
 	const nVars: Record<string, any> = {};
 
 	for (const [k, v] of Object.entries(qvars)) {
-		nVars[k] = v.validValue(vars[k], cs);
+		nVars[k] = v.validValue(vars[k], sr);
+	}
+
+	if (validIfFn) {
+		// or throw
+		const valid = validIfFn(nVars, sr);
+		if (typeof valid === 'boolean' && !valid)
+			throw new Error('invalid variables for query');
 	}
 
 	return nVars;

package/src/static/index.ts

@@ -12,7 +12,7 @@ export type CrelteStaticRequest = CrelteRequest & {
 	 *
 	 * @example
 	 * ```js
-	 * router.add('/blog/:slug', async (csr) => {
+	 * router.add('/blog/:slug', async csr => {
 	 *     const blogData = await fetchBlogData(csr.getParam('slug'));
 	 *
 	 *     return {

package/src/std/index.ts

@@ -10,6 +10,7 @@
  * - {@link std/stores}
  * - {@link std/sync}
  * - {@link std/rand}
+ * - {@link std/url}
  */
 
 /**

package/src/std/url/index.ts

@@ -0,0 +1,78 @@
+import { BaseRoute } from '../../routing/index.js';
+import { deleteSearchParam, pathnameEq, searchEq, toUrl } from './utils.js';
+
+/**
+ * Sets the search params of a URL based on the provided options.
+ *
+ * If a value is `null`, `undefined`, or an empty string, the corresponding
+ * search param will be deleted.
+ *
+ * #### Example
+ * ```js
+ * urlWithSearch(entry.url, { p: 1 });
+ * // or remove a value
+ * urlWithSearch(entry.url, { p: null });
+ * ```
+ */
+export function urlWithSearch(
+	url: BaseRoute | URL | string | null | undefined,
+	opts: Record<string, string | number | null | undefined>,
+): string | null {
+	if (!url) return null;
+
+	url = toUrl(url);
+
+	for (const [k, v] of Object.entries(opts)) {
+		if (!deleteSearchParam(v)) {
+			url.searchParams.set(k, v as string);
+		} else {
+			url.searchParams.delete(k);
+		}
+	}
+
+	return url.href;
+}
+
+/**
+ * Compares two URLs for equality.
+ * Normally search and hash are ignored.
+ *
+ * If either or both url is `null` or `undefined`, the function will return
+ * `false`.
+ *
+ * #### Example
+ * ```svelte
+ * <script>
+ *     import { getRoute } from 'crelte';
+ *
+ *     const route = getRoute();
+ * </script>
+ *
+ * <a href={item.url} class:active={urlEq($route, item.url)}>
+ *     {item.title}
+ * </a>
+ * ```
+ */
+export function urlEq(
+	a: BaseRoute | URL | string | null | undefined,
+	b: BaseRoute | URL | string | null | undefined,
+	opts?: { search?: boolean; hash?: boolean },
+): boolean {
+	if (!a || !b) return false;
+
+	a = toUrl(a);
+	b = toUrl(b);
+
+	// check origin and pathname
+	const baseMatches =
+		a.origin === b.origin && pathnameEq(a.pathname, b.pathname);
+	if (!baseMatches) return false;
+
+	// check search
+	if (opts?.search && !searchEq(a.searchParams, b.searchParams)) return false;
+
+	// check hash
+	if (opts?.hash && a.hash !== b.hash) return false;
+
+	return true;
+}

package/src/std/url/utils.ts

@@ -0,0 +1,48 @@
+import { BaseRoute } from '../../routing/index.js';
+
+/**
+ * Checks if a search param should be removed.
+ * This is the case if the value is `null`, `undefined`, or an empty string.
+ */
+export function deleteSearchParam(value: string | number | null | undefined) {
+	return (
+		typeof value === 'undefined' ||
+		value === null ||
+		(typeof value === 'string' && value === '')
+	);
+}
+
+/**
+ * Converts a `BaseRoute`, `URL`, or string to a `URL` object.
+ */
+export function toUrl(url: BaseRoute | URL | string): URL {
+	if (typeof url === 'string') return new URL(url);
+
+	if (url instanceof BaseRoute) return new URL(url.url);
+
+	return url;
+}
+
+/**
+ * Compares two `URLSearchParams` objects for equality.
+ */
+export function searchEq(a: URLSearchParams, b: URLSearchParams): boolean {
+	if (a.size !== b.size) return false;
+
+	// Clone to avoid mutating the original objects
+	const cloneA = new URLSearchParams(a);
+	const cloneB = new URLSearchParams(b);
+
+	cloneA.sort();
+	cloneB.sort();
+
+	return cloneA.toString() === cloneB.toString();
+}
+
+/**
+ * Compares two pathnames for equality, ignoring trailing slashes.
+ */
+export function pathnameEq(a: string, b: string): boolean {
+	// check for trailing slashes
+	return a === b || a === b + '/' || a + '/' === b;
+}

package/src/translations/index.ts

@@ -13,6 +13,7 @@ import {
 	createTranslations,
 	getTranslationsPlugin,
 	type TranslateFunction,
+	type TranslationVarValue,
 	type TranslateStore,
 	type Translations,
 	TranslationsPlugin,
@@ -50,6 +51,7 @@ export {
 	LoaderCreator,
 	TranslateStore,
 	TranslateFunction,
+	TranslationVarValue,
 	// loaders
 	createFileLoader,
 	createGlobalLoader,

package/src/translations/translationsPlugin.ts

@@ -7,8 +7,9 @@ import { getCrelte } from '../index.js';
 
 export type TranslateFunction = (
 	key: string,
-	// replacements?: Record<string, string>,
+	vars?: Record<string, TranslationVarValue>,
 ) => string;
+export type TranslationVarValue = string | number;
 export type TranslateStore = Readable<TranslateFunction>;
 export type Translations = Record<string, string>;
 export type TranslationsPluginOptions = {
@@ -89,18 +90,60 @@ export class TranslationsPlugin implements Plugin {
 	/** @hidden */
 	z_createTranslateStore(namespace: string): TranslateStore {
 		const store = derived(this.crelte.router.site, site => {
-			return (key: string) => {
+			return (
+				key: string,
+				vars?: Record<string, TranslationVarValue>,
+			) => {
 				const lang = site?.language ?? this.firstLang;
 				if (!lang) throw new Error('no lang');
 
 				const data = this.get(lang, namespace);
 				if (!data) console.error(`namespace '${namespace}' not loaded`);
-				return data?.[key] || key;
+
+				const text = data?.[key] || key;
+				if (!vars) return text;
+				return this.z_resolveVariables(text, vars);
 			};
 		});
 
 		return new Readable(store);
 	}
+
+	/** @hidden */
+	z_resolveVariables(
+		text: string,
+		vars: Record<string, TranslationVarValue> = {},
+	): string {
+		let result = '';
+		let index = 0;
+
+		while (index < text.length) {
+			const openIndex = text.indexOf('{', index);
+			if (openIndex === -1) {
+				result += text.slice(index);
+				break;
+			}
+
+			const closeIndex = text.indexOf('}', openIndex + 1);
+			if (closeIndex === -1) {
+				result += text.slice(index);
+				break;
+			}
+
+			result += text.slice(index, openIndex);
+
+			const key = text.slice(openIndex + 1, closeIndex);
+			if (key in vars) {
+				result += vars[key];
+			} else {
+				result += `{${key}}`;
+			}
+
+			index = closeIndex + 1;
+		}
+
+		return result;
+	}
 }
 
 /**

package/src/vite/index.ts

@@ -180,7 +180,7 @@ export default function crelte(opts?: CrelteOptions): Plugin {
 				publicDir: isSsrBuild ? false : 'public',
 				base: '/',
 				server: {
-					port: 8080,
+					port: config.server?.port ?? 8080,
 				},
 				optimizeDeps: {
 					exclude: ['crelte'],
@@ -338,7 +338,9 @@ async function serveVite(env: EnvData, vite: ViteDevServer) {
 		nReq: Connect.IncomingMessage,
 		res: ServerResponse,
 	) => {
-		const protocol = vite.config.server.https ? 'https' : 'http';
+		const protocol =
+			(nReq.headers['x-forwarded-proto'] as string | undefined) ??
+			(vite.config.server.https ? 'https' : 'http');
 		const baseUrl = protocol + '://' + nReq.headers['host'];
 
 		const req = requestToWebRequest(baseUrl, nReq);