crelte 0.1.0

package/dist/init/client.js

@@ -0,0 +1,129 @@
+import { CrelteBuilder } from '../Crelte.js';
+import { loadFn, pluginsBeforeRender, setupPlugins } from './shared.js';
+import { tick } from 'svelte';
+const mainDataDefault = {
+    preloadOnMouseOver: false,
+    viewTransition: false,
+    playIntro: false,
+    // will be passed down to ClientRenderer
+    graphQlDebug: false,
+    debugTiming: false,
+};
+export function main(data) {
+    data = { ...mainDataDefault, ...data };
+    // rendering steps
+    // loadSites (first time)
+    // determine route (if site is empty on server redirect to correct language)
+    // loadData, entry (make globally available), pluginsData
+    // loadTemplate
+    // render
+    // on route change
+    // determine route
+    // entry, pluginsData
+    // loadTemplate
+    // update
+    // construct Crelte
+    const builder = new CrelteBuilder();
+    const endpoint = builder.ssrCache.get('ENDPOINT_URL');
+    builder.setupGraphQl(endpoint, {
+        debug: data.graphQlDebug,
+        debugTiming: data.debugTiming,
+    });
+    // on the client the cookies are always comming from document.cookie
+    builder.setupCookies('');
+    const csites = builder.ssrCache.get('crelteSites');
+    builder.setupRouter(csites, {
+        preloadOnMouseOver: data.preloadOnMouseOver,
+    });
+    const crelte = builder.build();
+    const serverError = crelte.ssrCache.get('ERROR');
+    if (serverError) {
+        // should this be called??
+        crelte.router._internal.initClient();
+        new data.errorPage.default({
+            target: document.body,
+            props: { ...serverError },
+            hydrate: true,
+            context: crelte._getContext(),
+        });
+        return;
+    }
+    // setup plugins
+    setupPlugins(crelte, data.app.plugins ?? []);
+    // setup load Data
+    crelte.router._internal.onLoad = (route, site, opts) => {
+        const cr = crelte.toRouted(route, site);
+        return loadFn(cr, data.app, data.entryQuery, data.globalQuery, opts);
+    };
+    // render Space
+    let appInstance;
+    const updateAppProps = (props) => {
+        if (!appInstance) {
+            appInstance = new data.app.default({
+                target: document.body,
+                props,
+                hydrate: true,
+                context: crelte._getContext(),
+                intro: data.playIntro,
+            });
+        }
+        else {
+            appInstance.$set(props);
+        }
+    };
+    let firstLoad = true;
+    crelte.router._internal.onLoaded = async (success, route, site, readyForProps) => {
+        const isFirstLoad = firstLoad;
+        firstLoad = false;
+        if (!success) {
+            // if this is not the first load we should reload the page
+            // we don't reload everytime because this might cause a reload loop
+            // and since the first load will probably just contain ssrCache data in almost all cases the first load will never faill
+            if (!isFirstLoad) {
+                // the load might contain a js error and we prefer the error
+                // page
+                window.location.reload();
+                return;
+            }
+            return handleLoadError(readyForProps());
+        }
+        const cr = crelte.toRouted(route, site);
+        const startTime = data.debugTiming ? Date.now() : null;
+        let render = async () => {
+            // we should trigger the route update here
+            pluginsBeforeRender(cr);
+            crelte.globals._updateSiteId(site.id);
+            updateAppProps(readyForProps());
+            await tick();
+            if (startTime) {
+                console.log('dom update took ' + (Date.now() - startTime) + 'ms');
+            }
+            crelte.router._internal.domReady(route);
+        };
+        // render with view Transition if enabled and not in hydration
+        if (data.viewTransition &&
+            appInstance &&
+            document.startViewTransition) {
+            render = () => document.startViewTransition(render);
+        }
+        await render();
+    };
+    crelte.router._internal.initClient();
+}
+function handleLoadError(e) {
+    console.log('loading or rendering the page failed with the error:');
+    console.error(e);
+    // Detect the browser language
+    // @ts-ignore
+    const userLang = navigator.language || navigator.userLanguage;
+    // Messages in different languages
+    const messages = {
+        en: 'An error has occurred. Please reload the page or try again later.',
+        de: 'Leider ist ein Fehler aufgetreten. Laden Sie die Seite neu, oder versuchen Sie es später noch mal.',
+        fr: 'Une erreur s’est produite. Veuillez recharger la page ou réessayer plus tard.',
+        it: 'Si è verificato un errore. Ricarica la pagina o riprova più tardi.',
+        nl: 'Er is een fout opgetreden. Herlaad de pagina of probeer het later opnieuw.',
+    };
+    const message = messages[userLang.split('-')[0]] ?? messages.en;
+    alert(message);
+}

package/dist/init/server.d.ts

@@ -0,0 +1,38 @@
+export type ServerData = {
+    url: string;
+    htmlTemplate: string;
+    ssrManifest: Record<string, string[]>;
+    acceptLang?: string;
+    endpoint: string;
+    craftWeb: string;
+    viteEnv: Map<string, string>;
+    cookies?: string;
+};
+export type MainData = {
+    app: any;
+    entryQuery: any;
+    globalQuery?: any;
+    serverData: ServerData;
+    graphQlDebug?: boolean;
+    debugTiming?: boolean;
+};
+export declare function main(data: MainData): Promise<{
+    status: number;
+    location?: string;
+    html?: string;
+    setCookies?: string[];
+}>;
+export type Error = {
+    status: number;
+    message: any;
+};
+export type MainErrorData = {
+    error: Error;
+    errorPage: any;
+    serverData: ServerData;
+};
+export declare function mainError(data: MainErrorData): Promise<{
+    status: number;
+    html?: string;
+}>;
+//# sourceMappingURL=server.d.ts.map

package/dist/init/server.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"server.d.ts","sourceRoot":"","sources":["../../../../src/init/server.ts"],"names":[],"mappings":"AAOA,MAAM,MAAM,UAAU,GAAG;IACxB,GAAG,EAAE,MAAM,CAAC;IACZ,YAAY,EAAE,MAAM,CAAC;IACrB,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,CAAC;IACtC,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,EAAE,MAAM,CAAC;IACjB,OAAO,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC7B,OAAO,CAAC,EAAE,MAAM,CAAC;CACjB,CAAC;AAEF,MAAM,MAAM,QAAQ,GAAG;IAEtB,GAAG,EAAE,GAAG,CAAC;IACT,UAAU,EAAE,GAAG,CAAC;IAChB,WAAW,CAAC,EAAE,GAAG,CAAC;IAElB,UAAU,EAAE,UAAU,CAAC;IAGvB,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,WAAW,CAAC,EAAE,OAAO,CAAC;CACtB,CAAC;AAEF,wBAAsB,IAAI,CAAC,IAAI,EAAE,QAAQ,GAAG,OAAO,CAAC;IACnD,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,UAAU,CAAC,EAAE,MAAM,EAAE,CAAC;CACtB,CAAC,CA4ED;AAED,MAAM,MAAM,KAAK,GAAG;IACnB,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,GAAG,CAAC;CACb,CAAC;AAEF,MAAM,MAAM,aAAa,GAAG;IAE3B,KAAK,EAAE,KAAK,CAAC;IACb,SAAS,EAAE,GAAG,CAAC;IAEf,UAAU,EAAE,UAAU,CAAC;CACvB,CAAC;AAEF,wBAAsB,SAAS,CAC9B,IAAI,EAAE,aAAa,GACjB,OAAO,CAAC;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,IAAI,CAAC,EAAE,MAAM,CAAA;CAAE,CAAC,CA0B5C"}

package/dist/init/server.js

@@ -0,0 +1,95 @@
+import { CrelteBuilder } from '../Crelte.js';
+import { loadFn, pluginsBeforeRender, setupPlugins } from './shared.js';
+import SsrComponents from '../ssr/SsrComponents.js';
+import SsrCache from '../ssr/SsrCache.js';
+export async function main(data) {
+    const builder = new CrelteBuilder();
+    // setup viteEnv
+    data.serverData.viteEnv.forEach((v, k) => {
+        builder.ssrCache.set(k, v);
+    });
+    const endpoint = data.serverData.endpoint;
+    builder.ssrCache.set('ENDPOINT_URL', endpoint);
+    builder.ssrCache.set('CRAFT_WEB_URL', data.serverData.craftWeb);
+    builder.setupGraphQl(endpoint, {
+        debug: data.graphQlDebug,
+        debugTiming: data.debugTiming,
+    });
+    const cookies = data.serverData.cookies ?? '';
+    builder.setupCookies(cookies);
+    const csites = await loadSites(builder);
+    builder.ssrCache.set('crelteSites', csites);
+    builder.setupRouter(csites);
+    const crelte = builder.build();
+    // setup plugins
+    setupPlugins(crelte, data.app.plugins ?? []);
+    // setup load Data
+    crelte.router._internal.onLoad = (route, site) => {
+        const cr = crelte.toRouted(route, site);
+        return loadFn(cr, data.app, data.entryQuery, data.globalQuery);
+    };
+    const { success, redirect, route, site, props } = await crelte.router._internal.initServer(data.serverData.url, data.serverData.acceptLang);
+    if (!success)
+        throw props;
+    if (redirect) {
+        return {
+            status: 302,
+            location: route.url.toString(),
+        };
+    }
+    const context = crelte._getContext();
+    const ssrComponents = new SsrComponents();
+    ssrComponents.addToContext(context);
+    pluginsBeforeRender(crelte.toRouted(route, site));
+    crelte.globals._updateSiteId(site.id);
+    // eslint-disable-next-line prefer-const
+    let { html, head } = data.app.default.render(props, { context });
+    head += ssrComponents.toHead(data.serverData.ssrManifest);
+    head += crelte.ssrCache._exportToHead();
+    let htmlTemplate = data.serverData.htmlTemplate;
+    htmlTemplate = htmlTemplate.replace('<!--page-lang-->', site.language);
+    const finalHtml = htmlTemplate
+        .replace('</head>', head + '\n\t</head>')
+        .replace('<!--ssr-body-->', html);
+    const entry = props.entry;
+    return {
+        status: entry.sectionHandle === 'error' ? parseInt(entry.typeHandle) : 200,
+        html: finalHtml,
+        setCookies: crelte.cookies._getSetCookiesHeaders(),
+    };
+}
+export async function mainError(data) {
+    const ssrCache = new SsrCache();
+    const context = new Map();
+    const ssrComponents = new SsrComponents();
+    ssrComponents.addToContext(context);
+    ssrCache.set('ERROR', data.error);
+    // eslint-disable-next-line prefer-const
+    let { html, head } = data.errorPage.default.render(data.error, { context });
+    head += ssrComponents.toHead(data.serverData.ssrManifest);
+    head += ssrCache._exportToHead();
+    let htmlTemplate = data.serverData.htmlTemplate;
+    htmlTemplate = htmlTemplate.replace('<!--page-lang-->', 'de');
+    const finalHtml = htmlTemplate
+        .replace('<!--ssr-head-->', head)
+        .replace('<!--ssr-body-->', html);
+    return {
+        status: data.error.status,
+        html: finalHtml,
+    };
+}
+// requires, GraphQl, SsrCache
+async function loadSites(builder) {
+    if (!builder.graphQl)
+        throw new Error();
+    if ('CRAFT_SITES_CACHED' in globalThis) {
+        // @ts-ignore
+        return globalThis['CRAFT_SITES_CACHED'];
+    }
+    const resp = (await builder.graphQl.request('query { crelteSites { id baseUrl language name handle primary } }', {}, 
+    // don't cache since we cache ourself
+    { caching: false }));
+    // @ts-ignore
+    globalThis['CRAFT_SITES_CACHED'] = resp.crelteSites;
+    return resp.crelteSites;
+}

package/dist/init/shared.d.ts

@@ -0,0 +1,29 @@
+import CrelteRouted, { GraphQlQuery } from '../CrelteRouted.js';
+import Crelte from '../Crelte.js';
+import { LoadData } from '../loadData/index.js';
+import { PluginCreator } from '../plugins/Plugins.js';
+import { LoadOptions } from '../routing/PageLoader.js';
+interface App<D, E, T> {
+    loadGlobalData?: LoadData<D>;
+    loadEntryData?: LoadData<any>;
+    templates?: Record<string, LazyTemplateModule<E, T>>;
+}
+interface TemplateModule<E, T> {
+    default: any;
+    loadData?(cr: CrelteRouted, entry: E): Promise<T>;
+}
+type LazyTemplateModule<E, T> = (() => Promise<TemplateModule<E, T>>) | TemplateModule<E, T>;
+export declare function setupPlugins(crelte: Crelte, plugins: PluginCreator[]): void;
+export declare function pluginsBeforeRender(cr: CrelteRouted): void;
+/**
+ * Get the entry from the page
+ *
+ * entries should export sectionHandle and typeHandle
+ *
+ * products should alias productTypeHandle with typeHandle,
+ * sectionHandle will be automatically set to product
+ */
+export declare function getEntry(page: any): any;
+export declare function loadFn<D, E, T>(cr: CrelteRouted, app: App<D, E, T>, entryQuery: GraphQlQuery, globalQuery?: GraphQlQuery, loadOpts?: LoadOptions): Promise<any>;
+export {};
+//# sourceMappingURL=shared.d.ts.map

package/dist/init/shared.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shared.d.ts","sourceRoot":"","sources":["../../../../src/init/shared.ts"],"names":[],"mappings":"AAAA,OAAO,YAAY,EAAE,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAChE,OAAO,MAAM,MAAM,cAAc,CAAC;AAClC,OAAO,EAAE,QAAQ,EAAgB,MAAM,sBAAsB,CAAC;AAC9D,OAAO,EAAE,aAAa,EAAE,MAAM,uBAAuB,CAAC;AACtD,OAAO,EAAE,WAAW,EAAE,MAAM,0BAA0B,CAAC;AAEvD,UAAU,GAAG,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC;IACpB,cAAc,CAAC,EAAE,QAAQ,CAAC,CAAC,CAAC,CAAC;IAG7B,aAAa,CAAC,EAAE,QAAQ,CAAC,GAAG,CAAC,CAAC;IAE9B,SAAS,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,kBAAkB,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC;CACrD;AAED,UAAU,cAAc,CAAC,CAAC,EAAE,CAAC;IAE5B,OAAO,EAAE,GAAG,CAAC;IAEb,QAAQ,CAAC,CAAC,EAAE,EAAE,YAAY,EAAE,KAAK,EAAE,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,CAAC;CAClD;AAED,KAAK,kBAAkB,CAAC,CAAC,EAAE,CAAC,IACzB,CAAC,MAAM,OAAO,CAAC,cAAc,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,GACrC,cAAc,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;AAExB,wBAAgB,YAAY,CAAC,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,aAAa,EAAE,QAKpE;AAED,wBAAgB,mBAAmB,CAAC,EAAE,EAAE,YAAY,GAAG,IAAI,CAE1D;AAED;;;;;;;GAOG;AACH,wBAAgB,QAAQ,CAAC,IAAI,EAAE,GAAG,GAAG,GAAG,CAYvC;AAED,wBAAsB,MAAM,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EACnC,EAAE,EAAE,YAAY,EAChB,GAAG,EAAE,GAAG,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,EACjB,UAAU,EAAE,YAAY,EACxB,WAAW,CAAC,EAAE,YAAY,EAC1B,QAAQ,CAAC,EAAE,WAAW,GACpB,OAAO,CAAC,GAAG,CAAC,CAsGd"}

package/dist/init/shared.js

@@ -0,0 +1,154 @@
+import { callLoadData } from '../loadData/index.js';
+export function setupPlugins(crelte, plugins) {
+    for (const plugin of plugins) {
+        const p = plugin(crelte);
+        crelte.plugins.add(p);
+    }
+}
+export function pluginsBeforeRender(cr) {
+    cr.events.trigger('beforeRender', cr);
+}
+/**
+ * Get the entry from the page
+ *
+ * entries should export sectionHandle and typeHandle
+ *
+ * products should alias productTypeHandle with typeHandle,
+ * sectionHandle will be automatically set to product
+ */
+export function getEntry(page) {
+    if (page?.entry)
+        return { ...page.entry };
+    if (page?.product)
+        return {
+            sectionHandle: 'product',
+            ...page.product,
+        };
+    return {
+        sectionHandle: 'error',
+        typeHandle: '404',
+    };
+}
+export async function loadFn(cr, app, entryQuery, globalQuery, loadOpts) {
+    let dataProm = null;
+    // @ts-ignore
+    if (app.loadData) {
+        throw new Error('loadData is ambigous, choose loadGlobalData or ' +
+            'loadEntryData depending on if you need access to entry or not?');
+    }
+    if (app.loadGlobalData) {
+        dataProm = callLoadData(app.loadGlobalData, cr);
+    }
+    let globalProm = null;
+    if (globalQuery && !cr.globals._wasLoaded()) {
+        globalProm = (async () => {
+            const res = await cr.query(globalQuery);
+            // we need to do this sorcery here and can't wait until all
+            // globals functions are done, because some global function
+            // might want to use globals, and for that the function
+            // getOrWait exists on Globals
+            cr.globals._setData(cr.site.id, res);
+            return res;
+        })();
+    }
+    let pageProm = null;
+    if (cr.route.site) {
+        let uri = decodeURI(cr.route.uri);
+        if (uri.startsWith('/'))
+            uri = uri.substring(1);
+        if (uri === '' || uri === '/')
+            uri = '__home__';
+        pageProm = cr.query(entryQuery, {
+            uri,
+            siteId: cr.route.site.id,
+        });
+    }
+    const pluginsLoadGlobalData = cr.events.trigger('loadGlobalData', cr);
+    // loading progress is at 20%
+    loadOpts?.setProgress(0.2);
+    const [data, global, page] = await Promise.all([
+        dataProm,
+        globalProm,
+        pageProm,
+        ...pluginsLoadGlobalData,
+    ]);
+    if (global) {
+        cr.globals._setData(cr.site.id, global);
+    }
+    else if (!cr.globals._wasLoaded()) {
+        // we need to set the global data to an empty object
+        // so any waiters get's triggered
+        cr.globals._setData(cr.site.id, {});
+    }
+    // allow cr to get the global data
+    cr._globalDataLoaded();
+    const entry = getEntry(page);
+    let template;
+    if (app.templates) {
+        template = await loadTemplate(app.templates, entry);
+    }
+    else {
+        throw new Error('App must have templates or loadTemplate method');
+    }
+    // loading progress is at 60%
+    loadOpts?.setProgress(0.6);
+    const pluginsLoadData = cr.events.trigger('loadData', cr, entry);
+    let loadDataProm = null;
+    if (template.loadData) {
+        loadDataProm = callLoadData(template.loadData, cr, entry);
+    }
+    let entryDataProm = null;
+    if (app.loadEntryData) {
+        entryDataProm = callLoadData(app.loadEntryData, cr, entry);
+    }
+    const [templateData, entryData] = await Promise.all([
+        loadDataProm,
+        entryDataProm,
+        ...pluginsLoadData,
+    ]);
+    // loading progress is at 100%
+    loadOpts?.setProgress(1);
+    return {
+        ...data,
+        ...entryData,
+        entry,
+        template: template.default,
+        templateData: templateData,
+    };
+}
+function parseFilename(path) {
+    // 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];
+}
+async function loadTemplate(rawModules, entry) {
+    // parse modules
+    const modules = new Map(Object.entries(rawModules)
+        .map(([path, mod]) => {
+        const [name, _ext] = parseFilename(path);
+        return [name, mod];
+    })
+        .filter(([name, _mod]) => !!name));
+    const entr = entry;
+    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;
+}

package/dist/loadData/Globals.d.ts

@@ -0,0 +1,33 @@
+export type GlobalWaiters = [(g: Global<any> | null) => void];
+export default class Globals {
+    private waiters;
+    private entries;
+    private loaded;
+    private prevSiteId;
+    constructor();
+    get(name: string): Global<any> | null;
+    getAsync(name: string): Promise<Global<any> | null> | Global<any> | null;
+    _wasLoaded(): boolean;
+    _setData(siteId: number, data: any): void;
+    _globalsBySite(siteId: number): Map<string, any>;
+    _updateSiteId(siteId: number): void;
+}
+export interface GlobalData {
+    siteId?: number;
+}
+export declare class Global<T extends GlobalData> {
+    private inner;
+    private languages;
+    constructor(name: string, data: T[] | T, siteId: number);
+    /**
+     * The function get's called once with the current value and then when the
+     * values changes
+     *
+     * @return a function which should be called to unsubscribe
+     */
+    subscribe(fn: (val: T) => void): () => void;
+    get(): T;
+    bySiteId(siteId: number): T | null;
+    _updateSiteId(siteId: number): void;
+}
+//# sourceMappingURL=Globals.d.ts.map

package/dist/loadData/Globals.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Globals.d.ts","sourceRoot":"","sources":["../../../../src/loadData/Globals.ts"],"names":[],"mappings":"AAUA,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,CAAC,EAAE,MAAM,CAAC,GAAG,CAAC,GAAG,IAAI,KAAK,IAAI,CAAC,CAAC;AAE9D,MAAM,CAAC,OAAO,OAAO,OAAO;IAG3B,OAAO,CAAC,OAAO,CAA6B;IAC5C,OAAO,CAAC,OAAO,CAA2B;IAC1C,OAAO,CAAC,MAAM,CAAU;IACxB,OAAO,CAAC,UAAU,CAAgB;;IASlC,GAAG,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAAC,GAAG,CAAC,GAAG,IAAI;IAMrC,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,GAAG,CAAC,GAAG,IAAI,CAAC,GAAG,MAAM,CAAC,GAAG,CAAC,GAAG,IAAI;IAexE,UAAU,IAAI,OAAO;IAQrB,QAAQ,CAAC,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,GAAG;IAgBlC,cAAc,CAAC,MAAM,EAAE,MAAM,GAAG,GAAG,CAAC,MAAM,EAAE,GAAG,CAAC;IAUhD,aAAa,CAAC,MAAM,EAAE,MAAM;CAM5B;AAED,MAAM,WAAW,UAAU;IAC1B,MAAM,CAAC,EAAE,MAAM,CAAC;CAChB;AAED,qBAAa,MAAM,CAAC,CAAC,SAAS,UAAU;IACvC,OAAO,CAAC,KAAK,CAAc;IAE3B,OAAO,CAAC,SAAS,CAAa;gBAElB,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,CAAC,EAAE,GAAG,CAAC,EAAE,MAAM,EAAE,MAAM;IAsBvD;;;;;OAKG;IACH,SAAS,CAAC,EAAE,EAAE,CAAC,GAAG,EAAE,CAAC,KAAK,IAAI,GAAG,MAAM,IAAI;IAI3C,GAAG,IAAI,CAAC;IAKR,QAAQ,CAAC,MAAM,EAAE,MAAM,GAAG,CAAC,GAAG,IAAI;IAOlC,aAAa,CAAC,MAAM,EAAE,MAAM;CAM5B"}

package/dist/loadData/Globals.js

@@ -0,0 +1,119 @@
+/*
+// returns a store which get's updated as soon as the site changes
+const emergency = getGlobal('emergency');
+
+// returns the data based on the current site (no store)
+cr.getGlobal('emergency')
+*/
+import { Writable } from 'crelte-std/stores';
+export default class Globals {
+    // while the globals are not loaded if somebody calls
+    // getOrWait then we need to store the waiters
+    waiters;
+    entries;
+    loaded;
+    prevSiteId;
+    constructor() {
+        this.waiters = new Map();
+        this.entries = new Map();
+        this.loaded = false;
+        this.prevSiteId = null;
+    }
+    get(name) {
+        return this.entries.get(name) ?? null;
+    }
+    // call this only in loadGlobalData when by default the global
+    // is not available
+    getAsync(name) {
+        if (this.loaded)
+            return this.get(name);
+        let waiter = this.waiters.get(name);
+        if (!waiter) {
+            waiter = [];
+            this.waiters.set(name, waiter);
+        }
+        return new Promise(resolve => {
+            waiter.push(resolve);
+        });
+    }
+    // hidden
+    _wasLoaded() {
+        return this.loaded;
+    }
+    // hidden
+    // data is the data from the global graphql
+    // so it contains some keys and data which should be parsed
+    // and created a store for each key
+    _setData(siteId, data) {
+        const wasLoaded = this.loaded;
+        this.loaded = true;
+        for (const [key, value] of Object.entries(data)) {
+            this.entries.set(key, new Global(key, value, siteId));
+        }
+        if (!wasLoaded) {
+            this.waiters.forEach((waiters, key) => {
+                waiters.forEach(waiter => waiter(this.get(key)));
+            });
+            this.waiters.clear();
+        }
+    }
+    _globalsBySite(siteId) {
+        const map = new Map();
+        for (const [key, global] of this.entries) {
+            map.set(key, global.bySiteId(siteId));
+        }
+        return map;
+    }
+    _updateSiteId(siteId) {
+        // todo we should only trigger
+        if (this.prevSiteId === siteId)
+            return;
+        this.entries.forEach(global => global._updateSiteId(siteId));
+    }
+}
+export class Global {
+    inner;
+    /// if languages is null this means we always have the same data
+    languages;
+    constructor(name, data, siteId) {
+        this.languages = null;
+        let inner;
+        if (Array.isArray(data)) {
+            // make sure the data contains an object with the property
+            // siteId
+            this.languages = data;
+            inner = data.find(d => d.siteId === siteId);
+            if (!inner?.siteId) {
+                throw new Error(`The global query ${name} does not contain the required siteId property`);
+            }
+        }
+        else {
+            inner = data;
+        }
+        this.inner = new Writable(inner);
+    }
+    /**
+     * The function get's called once with the current value and then when the
+     * values changes
+     *
+     * @return a function which should be called to unsubscribe
+     */
+    subscribe(fn) {
+        return this.inner.subscribe(fn);
+    }
+    get() {
+        return this.inner.get();
+    }
+    /// if you pass a siteId which comes from craft then you will never receive null
+    bySiteId(siteId) {
+        if (this.languages)
+            return this.languages.find(d => d.siteId === siteId) ?? null;
+        return this.inner.get();
+    }
+    _updateSiteId(siteId) {
+        if (!this.languages)
+            return;
+        const inner = this.languages.find(d => d.siteId === siteId);
+        this.inner.set(inner);
+    }
+}

package/dist/loadData/index.d.ts

@@ -0,0 +1,25 @@
+/**
+ *
+ */
+import type CrelteRouted from '../CrelteRouted.js';
+import { type GraphQlQuery } from '../graphql/GraphQl.js';
+import type Globals from './Globals.js';
+import type { Global } from './Globals.js';
+export type { Globals, Global };
+export type LoadData<T> = ((cr: CrelteRouted, ...args: any[]) => Promise<T>) | GraphQlQuery | T;
+export declare function callLoadData(ld: LoadData<unknown>, cr: CrelteRouted, ...args: any[]): Promise<unknown>;
+/**
+ * Spread the data of two loadData functions.
+ *
+ * ## Example
+ * ```
+ * export const loadData = mergeLoadData(
+ * 		{
+ * 			filter: (cr) => cr.route.search.get('filter'),
+ * 		},
+ * 		(cr) => cr.query(myQuery, { siteId: cr.site.id })
+ * )
+ * ```
+ */
+export declare function mergeLoadData(...lds: LoadData<object>[]): LoadData<object>;
+//# sourceMappingURL=index.d.ts.map

package/dist/loadData/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/loadData/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,KAAK,YAAY,MAAM,oBAAoB,CAAC;AACnD,OAAO,EAAkB,KAAK,YAAY,EAAE,MAAM,uBAAuB,CAAC;AAC1E,OAAO,KAAK,OAAO,MAAM,cAAc,CAAC;AACxC,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,cAAc,CAAC;AAE3C,YAAY,EAAE,OAAO,EAAE,MAAM,EAAE,CAAC;AAEhC,MAAM,MAAM,QAAQ,CAAC,CAAC,IACnB,CAAC,CAAC,EAAE,EAAE,YAAY,EAAE,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,OAAO,CAAC,CAAC,CAAC,CAAC,GAClD,YAAY,GACZ,CAAC,CAAC;AAEL,wBAAsB,YAAY,CACjC,EAAE,EAAE,QAAQ,CAAC,OAAO,CAAC,EACrB,EAAE,EAAE,YAAY,EAChB,GAAG,IAAI,EAAE,GAAG,EAAE,GACZ,OAAO,CAAC,OAAO,CAAC,CAuBlB;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,aAAa,CAAC,GAAG,GAAG,EAAE,QAAQ,CAAC,MAAM,CAAC,EAAE,GAAG,QAAQ,CAAC,MAAM,CAAC,CAQ1E"}

package/dist/loadData/index.js

@@ -0,0 +1,39 @@
+/**
+ *
+ */
+import { isGraphQlQuery } from '../graphql/GraphQl.js';
+export async function callLoadData(ld, cr, ...args) {
+    // either we have a function
+    if (typeof ld === 'function') {
+        return await ld(cr, ...args);
+    }
+    // or a graphql query
+    if (isGraphQlQuery(ld)) {
+        return await cr.query(ld);
+    }
+    // or an object
+    if (typeof ld === 'object' && ld !== null) {
+        const data = await Promise.all(Object.values(ld).map(nld => callLoadData(nld, cr, ...args)));
+        return Object.fromEntries(Object.keys(ld).map((key, i) => [key, data[i]]));
+    }
+    return ld;
+}
+/**
+ * Spread the data of two loadData functions.
+ *
+ * ## Example
+ * ```
+ * export const loadData = mergeLoadData(
+ * 		{
+ * 			filter: (cr) => cr.route.search.get('filter'),
+ * 		},
+ * 		(cr) => cr.query(myQuery, { siteId: cr.site.id })
+ * )
+ * ```
+ */
+export function mergeLoadData(...lds) {
+    return async (cr, ...args) => {
+        const datas = await Promise.all(lds.map(ld => callLoadData(ld, cr, ...args)));
+        return datas.reduce((acc, data) => ({ ...acc, ...data }), {});
+    };
+}