crelte 0.4.8 → 0.5.0-alpha.2

package/dist/routing/ServerRouter.d.ts

@@ -0,0 +1,23 @@
+import BaseRouter, { BaseRouterOptions } from './BaseRouter.js';
+import { Request, RequestOptions } from './index.js';
+import Route from './Route.js';
+import Site, { SiteFromGraphQl } from './Site.js';
+export default class ServerRouter extends BaseRouter {
+    acceptLang: string | null;
+    redirect: Request | null;
+    constructor(sites: SiteFromGraphQl[], opts: BaseRouterOptions);
+    defaultSite(): Site;
+    openRequest(req: Request): Promise<void>;
+    pushRequest(req: Request, _opts?: RequestOptions): Promise<void>;
+    replaceRequest(req: Request, _opts?: RequestOptions): Promise<void>;
+    /**
+     * This function always returns the request or a redirect one
+     *
+     * And then if no redirect happen the final route
+     *
+     * ## Throws
+     * If the request fails
+     */
+    init(url: string, acceptLang?: string): Promise<[Request, Route | null]>;
+}
+//# sourceMappingURL=ServerRouter.d.ts.map

package/dist/routing/ServerRouter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ServerRouter.d.ts","sourceRoot":"","sources":["../../src/routing/ServerRouter.ts"],"names":[],"mappings":"AAAA,OAAO,UAAU,EAAE,EAAE,iBAAiB,EAAE,MAAM,iBAAiB,CAAC;AAChE,OAAO,EAAE,OAAO,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC;AACrD,OAAO,KAAK,MAAM,YAAY,CAAC;AAC/B,OAAO,IAAI,EAAE,EAAE,eAAe,EAAE,MAAM,WAAW,CAAC;AAElD,MAAM,CAAC,OAAO,OAAO,YAAa,SAAQ,UAAU;IACnD,UAAU,EAAE,MAAM,GAAG,IAAI,CAAC;IAC1B,QAAQ,EAAE,OAAO,GAAG,IAAI,CAAC;gBAEb,KAAK,EAAE,eAAe,EAAE,EAAE,IAAI,EAAE,iBAAiB;IAO7D,WAAW,IAAI,IAAI;IAIb,WAAW,CAAC,GAAG,EAAE,OAAO;IAiBxB,WAAW,CAAC,GAAG,EAAE,OAAO,EAAE,KAAK,GAAE,cAAmB;IAKpD,cAAc,CAAC,GAAG,EAAE,OAAO,EAAE,KAAK,GAAE,cAAmB;IAK7D;;;;;;;OAOG;IACG,IAAI,CACT,GAAG,EAAE,MAAM,EACX,UAAU,CAAC,EAAE,MAAM,GACjB,OAAO,CAAC,CAAC,OAAO,EAAE,KAAK,GAAG,IAAI,CAAC,CAAC;CAmBnC"}

package/dist/routing/ServerRouter.js

@@ -0,0 +1,57 @@
+import BaseRouter from './BaseRouter.js';
+export default class ServerRouter extends BaseRouter {
+    acceptLang;
+    redirect;
+    constructor(sites, opts) {
+        super(sites, opts);
+        this.acceptLang = null;
+        this.redirect = null;
+    }
+    defaultSite() {
+        return this.siteByAcceptLang(this.acceptLang);
+    }
+    async openRequest(req) {
+        // only handle the first redirect
+        // this makes the behaviour the same as client router
+        // not true
+        // todo: the client only instatly redirects if it belongs to another
+        // site (aka needs to use window.location.href)
+        if (this.redirect)
+            return;
+        this.redirect = req;
+        this.cancelRequest();
+        // request was handled with a redirect so we don't have an entry
+        // templateData or anything else
+        // todo is that what we wan't to return. Because void would tell
+        // the user the request was cancelled
+    }
+    async pushRequest(req, _opts = {}) {
+        // todo not sure if that is what we want?
+        return await this.openRequest(req);
+    }
+    async replaceRequest(req, _opts = {}) {
+        // todo not sure if that is what we want?
+        return await this.openRequest(req);
+    }
+    /**
+     * This function always returns the request or a redirect one
+     *
+     * And then if no redirect happen the final route
+     *
+     * ## Throws
+     * If the request fails
+     */
+    async init(url, acceptLang) {
+        this.acceptLang = acceptLang ?? null;
+        const req = this.targetToRequest(url);
+        req.origin = 'init';
+        // throws if something goes wrong
+        const route = await this.handleRequest(req, () => { });
+        if (!route) {
+            if (!this.redirect)
+                throw new Error('if the request gets cancelled on the server there should be a redirect');
+            return [this.redirect, null];
+        }
+        return [req, route];
+    }
+}

package/dist/routing/utils.d.ts

@@ -1,2 +1,7 @@
 export declare function trimSlashEnd(str: string): string;
+/**
+ * if no match was found null is returned
+ * `matchAcceptLang('fr-CH, en;q=0.7, fr;q=0.8', ['en-GB'])` will return `en-GB`
+ */
+export declare function matchAcceptLang(acceptLang: string, langs: string[]): string | null;
 //# sourceMappingURL=utils.d.ts.map

package/dist/routing/utils.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../src/routing/utils.ts"],"names":[],"mappings":"AAAA,wBAAgB,YAAY,CAAC,GAAG,EAAE,MAAM,UAEvC"}
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../src/routing/utils.ts"],"names":[],"mappings":"AAAA,wBAAgB,YAAY,CAAC,GAAG,EAAE,MAAM,UAEvC;AA0BD;;;GAGG;AACH,wBAAgB,eAAe,CAC9B,UAAU,EAAE,MAAM,EAClB,KAAK,EAAE,MAAM,EAAE,GACb,MAAM,GAAG,IAAI,CAoBf"}

package/dist/routing/utils.js

@@ -1,3 +1,42 @@
 export function trimSlashEnd(str) {
     return str.endsWith('/') ? str.substring(0, str.length - 1) : str;
 }
+/**
+ * `parseAcceptLang('fr-CH, en;q=0.7, fr;q=0.8')` will return `[['fr-CH', 1], ['fr', 0.8], ['en', 0.7]]`
+ */
+function parseAcceptLang(acceptLang) {
+    return acceptLang
+        .split(',')
+        .map(d => {
+        // eslint-disable-next-line prefer-const
+        let [lang, pq] = d.split(';');
+        lang = lang.trim();
+        if (!lang)
+            return null;
+        let quality = 1;
+        if (pq?.startsWith('q=')) {
+            const q = parseFloat(pq.substring(2));
+            if (!isNaN(q))
+                quality = q;
+        }
+        return [lang, quality];
+    })
+        .filter(d => !!d)
+        .sort((a, b) => b[1] - a[1]);
+}
+/**
+ * if no match was found null is returned
+ * `matchAcceptLang('fr-CH, en;q=0.7, fr;q=0.8', ['en-GB'])` will return `en-GB`
+ */
+export function matchAcceptLang(acceptLang, langs) {
+    const qualities = new Map(parseAcceptLang(acceptLang).map(([l, q]) => [l.toLowerCase(), q]));
+    return langs.reduce((best, lang) => {
+        const lowerLang = lang.toLowerCase();
+        // this might splitting to much
+        const [p1, p2] = lowerLang.split('-');
+        const q1 = qualities.get(lowerLang) ?? 0;
+        const q2 = p2 ? (qualities.get(p1) ?? 0) : 0;
+        const q = Math.max(q1, q2);
+        return best.q < q ? { lang, q } : best;
+    }, { lang: null, q: 0 }).lang;
+}

package/dist/utils.d.ts

@@ -1,3 +1,4 @@
 export declare function objClone(obj: any): any;
+export declare function isPromise<T>(p: Promise<T> | T): p is Promise<T>;
 export declare const circles: Record<string, any>;
 //# sourceMappingURL=utils.d.ts.map

package/dist/utils.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../src/utils.ts"],"names":[],"mappings":"AAGA,wBAAgB,QAAQ,CAAC,GAAG,EAAE,GAAG,GAAG,GAAG,CAMtC;AAGD,eAAO,MAAM,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAM,CAAC"}
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../src/utils.ts"],"names":[],"mappings":"AAGA,wBAAgB,QAAQ,CAAC,GAAG,EAAE,GAAG,GAAG,GAAG,CAMtC;AAED,wBAAgB,SAAS,CAAC,CAAC,EAAE,CAAC,EAAE,OAAO,CAAC,CAAC,CAAC,GAAG,CAAC,GAAG,CAAC,IAAI,OAAO,CAAC,CAAC,CAAC,CAE/D;AAGD,eAAO,MAAM,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAM,CAAC"}

package/dist/utils.js

@@ -6,5 +6,8 @@ export function objClone(obj) {
     }
     return JSON.parse(JSON.stringify(obj));
 }
+export function isPromise(p) {
+    return typeof p?.then === 'function';
+}
 // this allows us to fix cyclic dependencies
 export const circles = {};

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "crelte",
-	"version": "0.4.8",
+	"version": "0.5.0-alpha.2",
 	"author": "Crelte <support@crelte.com>",
 	"type": "module",
 	"scripts": {
@@ -78,16 +78,17 @@
 		}
 	},
 	"dependencies": {
-		"crelte-std": "^0.1.1",
-		"svelte": "^4.2.12",
+		"crelte-std": "^0.1.2",
 		"trouter": "^4.0.0"
 	},
+	"peerDependencies": {
+		"svelte": "^4.0.0 || ^5.0.0"
+	},
 	"devDependencies": {
 		"@sveltejs/package": "^2.3.1",
-		"@sveltejs/vite-plugin-svelte": "^3.0.0",
+		"@sveltejs/vite-plugin-svelte": "^4.0.0",
 		"svelte-check": "^4.1.4",
 		"typescript-svelte-plugin": "^0.3.45",
-		"vite": "^5.0",
-		"vitest": "^2.0.0"
+		"vitest": "^3.0.0"
 	}
 }

package/src/Crelte.ts

@@ -1,17 +1,16 @@
-import ClientCookies from './cookies/ClientCookies.js';
 import { Cookies } from './cookies/index.js';
-import ServerCookies from './cookies/ServerCookies.js';
 import GraphQl, { GraphQlQuery } from './graphql/GraphQl.js';
-import Globals, { Global } from './loadData/Globals.js';
+import Globals from './loadData/Globals.js';
 import Events from './plugins/Events.js';
 import Plugins, { Plugin } from './plugins/Plugins.js';
 import type Route from './routing/Route.js';
 import type Request from './routing/Request.js';
 import Router from './routing/Router.js';
-import { SiteFromGraphQl } from './routing/Site.js';
 import SsrCache from './ssr/SsrCache.js';
 import { type CrelteRequest } from './index.js';
 import { circles } from './utils.js';
+import BaseRouter from './routing/BaseRouter.js';
+import { Readable } from 'crelte-std/stores';
 
 export type Config = {
 	/**
@@ -70,7 +69,7 @@ export class CrelteBuilder {
 	graphQl?: GraphQl;
 	router?: Router;
 	globals: Globals;
-	cookies: Cookies;
+	cookies?: Cookies;
 
 	constructor(config: Config) {
 		this.config = { ...defaultConfig, ...config };
@@ -79,10 +78,6 @@ export class CrelteBuilder {
 		this.plugins = new Plugins();
 		this.events = new Events();
 		this.globals = new Globals();
-		// @ts-ignore
-		this.cookies = import.meta.env.SSR
-			? new ServerCookies()
-			: new ClientCookies();
 	}
 
 	setupGraphQl(endpoint: string) {
@@ -93,15 +88,12 @@ export class CrelteBuilder {
 		});
 	}
 
-	setupRouter(sites: SiteFromGraphQl[]) {
-		this.router = new Router(sites, {
-			preloadOnMouseOver: this.config.preloadOnMouseOver,
-			debugTiming: this.config.debugTiming,
-		});
+	setupRouter(router: BaseRouter) {
+		this.router = new Router(router);
 	}
 
-	setupCookies(cookies: string) {
-		this.cookies._init(cookies);
+	setupCookies(cookies: Cookies) {
+		this.cookies = cookies;
 	}
 
 	build(): Crelte {
@@ -155,7 +147,7 @@ export default class Crelte {
 	protected _cookies: Cookies;
 
 	constructor(builder: CrelteBuilder | Crelte) {
-		if (!builder.graphQl || !builder.router)
+		if (!builder.graphQl || !builder.router || !builder.cookies)
 			throw new Error('builder not ready');
 
 		this._ssrCache = builder.ssrCache;
@@ -243,7 +235,7 @@ export default class Crelte {
 	 * always return null. In that context you should use
 	 * `CrelteRequest.getGlobalAsync`
 	 */
-	getGlobalStore<T = any>(name: string): Global<T> | null {
+	getGlobalStore<T = any>(name: string): Readable<T> | null {
 		return this.globals.getStore(name) ?? null;
 	}
 
@@ -256,6 +248,8 @@ export default class Crelte {
 	 * to use in loadData context
 	 */
 	toRequest(req?: Route | Request): CrelteRequest {
+		// todo can we remove this function or is it still relevant?
+
 		// we do this to avoid cyclic dependencies
 		return circles.requestFromCrelte(this, req);
 	}

package/src/CrelteRequest.ts

@@ -4,10 +4,15 @@ import Site from './routing/Site.js';
 import Request from './routing/Request.js';
 import Route from './routing/Route.js';
 import { circles } from './utils.js';
+import Globals from './loadData/Globals.js';
+import { Router } from './routing/index.js';
 
 export default class CrelteRequest extends Crelte {
 	/**
 	 * The current request
+	 *
+	 * ## Warning
+	 * Do not override this
 	 */
 	req: Request;
 
@@ -71,7 +76,7 @@ export default class CrelteRequest extends Crelte {
 	 * `.getGlobalAsync`
 	 */
 	getGlobal<T = any>(name: string): T | null {
-		return this.globals.get(name, this.site.id);
+		return this.globals.get(name);
 	}
 
 	/**
@@ -82,9 +87,13 @@ export default class CrelteRequest extends Crelte {
 	 * you can use `.getGlobal` which does return a Promise
 	 */
 	async getGlobalAsync<T = any>(name: string): Promise<T | null> {
-		return this.globals.getAsync(name, this.site.id);
+		return this.globals.getAsync(name);
 	}
 
+	// todo we should override getPlugin making it possible for the plugin
+	// to attach a CrelteRequest to itself
+	// for that we should call cloneWithRequest(cr: CrelteRequest)
+
 	/**
 	 * Run a GraphQl Query
 	 *
@@ -104,6 +113,16 @@ export default class CrelteRequest extends Crelte {
 			...opts,
 		});
 	}
+
+	/** @hidden */
+	_setRouter(router: Router) {
+		this._router = router;
+	}
+
+	/** @hidden */
+	_setGlobals(globals: Globals) {
+		this._globals = globals;
+	}
 }
 
 export function requestFromCrelte(

package/src/cookies/ClientCookies.ts

@@ -7,8 +7,6 @@ import { parseCookies, setCookieToString } from './utils.js';
 export default class ClientCookies implements Cookies {
 	constructor() {}
 
-	_init(_cookies: string): void {}
-
 	get(name: string): string | null {
 		const cookies = getCookies();
 		return cookies.get(name) ?? null;

package/src/cookies/ServerCookies.ts

@@ -9,14 +9,9 @@ export default class ServerCookies implements Cookies {
 	requestCookies: Map<string, string>;
 	setCookies: Map<string, SetCookie>;
 
-	constructor() {
-		this.requestCookies = new Map();
-		this.setCookies = new Map();
-	}
-
-	_init(cookies: string): void {
-		// parse the cookies
+	constructor(cookies: string) {
 		this.requestCookies = parseCookies(cookies);
+		this.setCookies = new Map();
 	}
 
 	/// Rethrns the value of the cookie with the given name, or null if it doesn't exist.

package/src/cookies/index.ts

@@ -24,7 +24,4 @@ export interface Cookies {
 	 * removes the cookie
 	 */
 	remove(name: string): void;
-
-	/** @hidden */
-	_init(cookies: string): void;
 }

package/src/graphql/GraphQl.ts

@@ -1,3 +1,4 @@
+import BaseRoute from '../routing/BaseRoute.js';
 import Route from '../routing/Route.js';
 import SsrCache, { calcKey as ssrCacheCalcKey } from '../ssr/SsrCache.js';
 
@@ -75,7 +76,7 @@ export type GraphQlRequestOptions = {
 	 * !! the route here might not contain a site even if the types
 	 * says it does. CrelteServer does not know about site
 	 */
-	route?: Route | URL;
+	route?: BaseRoute | URL;
 	ignoreStatusCode?: boolean;
 	previewToken?: string;
 	siteToken?: string;

package/src/index.ts

@@ -6,7 +6,6 @@ import type Site from './routing/Site.js';
 import type GraphQl from './graphql/GraphQl.js';
 import Crelte, { type QueryOptions, type Config } from './Crelte.js';
 import CrelteRequest from './CrelteRequest.js';
-import type { Global } from './loadData/Globals.js';
 import type { Cookies } from './cookies/index.js';
 import type { Readable } from 'crelte-std/stores';
 import {
@@ -97,6 +96,19 @@ export function getSite(): Readable<Site> {
 	return getRouter().site as Readable<Site>;
 }
 
+/**
+ * Get a store with the current entry
+ *
+ * ## Note
+ * This only works during component initialisation.
+ */
+export function getEntry(): Readable<Entry> {
+	/// the entry will never be null because it is only null in the
+	// first loadData call and that happens before any component
+	// initialisation
+	return getRouter().entry as Readable<Entry>;
+}
+
 /**
  * returns an env variable from the craft/.env file.
  * All env variables need to start with VITE_
@@ -138,7 +150,7 @@ export function getLoadingProgress(): Readable<number> {
  * ## Note
  * This only works during component initialisation.
  */
-export function getGlobal<T = any>(name: string): Global<T> | null {
+export function getGlobal<T = any>(name: string): Readable<T> | null {
 	return getCrelte().globals.getStore(name);
 }
 
@@ -158,11 +170,9 @@ export function getCookies(): Cookies {
  * ## Note
  * This only works during component initialisation.
  */
-export function onRoute(fn: (route: Route, crelte: Crelte) => void) {
+export function onRoute(fn: (route: Route) => void) {
 	const crelte = getCrelte();
-	const rmListener = crelte.router.onRoute(route => {
-		fn(route, crelte);
-	});
+	const rmListener = crelte.router.onRoute(route => fn(route));
 
 	onDestroy(rmListener);
 }
@@ -175,9 +185,7 @@ export function onRoute(fn: (route: Route, crelte: Crelte) => void) {
  */
 export function onRequest(fn: (cr: CrelteRequest) => void) {
 	const crelte = getCrelte();
-	const rmListener = crelte.router.onRequest(req => {
-		fn(new CrelteRequest(crelte, req));
-	});
+	const rmListener = crelte.router.onRequest(cr => fn(cr));
 
 	onDestroy(rmListener);
 }

package/src/init/InternalApp.ts

@@ -0,0 +1,134 @@
+import { Entry } from '../entry/index.js';
+import { Crelte } from '../index.js';
+import { LoadData } from '../loadData/index.js';
+import { PluginCreator } from '../plugins/index.js';
+
+export interface App {
+	plugins?: PluginCreator[];
+
+	templates?: Record<string, LazyTemplateModule>;
+
+	loadGlobalData?: LoadData<null>;
+
+	loadEntry: LoadData<null>;
+
+	// todo: add a generic
+	loadEntryData?: LoadData<Entry>;
+
+	// entryRoutes?: EntryRoutes;
+
+	init?: (crelte: Crelte) => void;
+}
+
+export interface TemplateModule {
+	// svelte component
+	default: any;
+
+	loadData?: LoadData<Entry>;
+}
+
+export type LazyTemplateModule =
+	| (() => Promise<TemplateModule>)
+	| TemplateModule;
+
+export type TemplateModules = Map<string, LazyTemplateModule>;
+
+export default class InternalApp {
+	inner: App;
+	templateModules: TemplateModules;
+
+	constructor(inner: App) {
+		this.inner = inner;
+		this.templateModules = prepareTemplates(inner.templates ?? {});
+
+		// @ts-ignore
+		if (inner.loadData) {
+			throw new Error(
+				'loadData is ambigous, choose loadGlobalData or ' +
+					'loadEntryData depending on if you need access to the entry or not?',
+			);
+		}
+
+		if (!inner.loadEntry) {
+			throw new Error(
+				'loadEntry is required in the app. `export const loadEntry ' +
+					'= entryQuery;`',
+			);
+		}
+	}
+
+	get plugins(): PluginCreator[] {
+		return this.inner.plugins ?? [];
+	}
+
+	get loadGlobalData(): LoadData<null> | undefined {
+		return this.inner.loadGlobalData;
+	}
+
+	init(crelte: Crelte): void {
+		this.inner.init?.(crelte);
+	}
+
+	get loadEntry(): LoadData<null> {
+		return this.inner.loadEntry;
+	}
+
+	async loadTemplate(entry: Entry): Promise<TemplateModule> {
+		const modules = this.templateModules;
+		const entr = entry as any;
+		const handle = `${entr.sectionHandle}-${entr.typeHandle}`;
+
+		if (
+			// @ts-ignore
+			import.meta.env.DEV &&
+			!modules.has(handle) &&
+			!modules.has(entr.sectionHandle)
+		) {
+			console.error(
+				`Template not found: <${handle}>, expecting file: ${handle}.svelte or ${entr.sectionHandle}.svelte`,
+			);
+		}
+
+		const loadMod =
+			modules.get(handle) ??
+			modules.get(entr.sectionHandle) ??
+			modules.get('error-404');
+		if (!loadMod) throw new Error('could not find error-404 template');
+
+		if (typeof loadMod === 'function') {
+			return await loadMod();
+		}
+		return loadMod;
+	}
+
+	get loadEntryData(): LoadData<Entry> | null {
+		return this.inner.loadEntryData;
+	}
+}
+
+function prepareTemplates(
+	rawModules: Record<string, LazyTemplateModule>,
+): Map<string, LazyTemplateModule> {
+	// parse modules
+	return new Map(
+		Object.entries(rawModules)
+			.map(([path, mod]) => {
+				const [name, _ext] = parseFilename(path);
+				return [name, mod] as [string, LazyTemplateModule];
+			})
+			.filter(([name, _mod]) => !!name),
+	);
+}
+
+function parseFilename(path: string): [string, string] {
+	// get filename with extension
+	const slash = path.lastIndexOf('/');
+	const filename = path.substring(slash + 1);
+
+	const extPos = filename.lastIndexOf('.');
+
+	const name = filename.substring(0, extPos);
+	const ext = filename.substring(extPos + 1);
+
+	return [name, ext];
+}