@analogjs/router 2.4.0-beta.9 → 3.0.0-alpha.10

package/fesm2022/analogjs-router-server.mjs

@@ -1,199 +1,178 @@
-import { ɵresetCompiledComponents as _resetCompiledComponents, InjectionToken, assertInInjectionContext, inject, TransferState, makeStateKey, reflectComponentType, APP_ID, ɵConsole as _Console, enableProdMode } from '@angular/core';
-import { ɵSERVER_CONTEXT as _SERVER_CONTEXT, provideServerRendering, renderApplication } from '@angular/platform-server';
-import { REQUEST, RESPONSE, BASE_URL } from '@analogjs/router/tokens';
-import { bootstrapApplication } from '@angular/platform-browser';
-import { getHeader, createEvent, readBody } from 'h3';
-
-function provideServerContext({ req, res, }) {
-    const baseUrl = getBaseUrl(req);
-    if (import.meta.env.DEV) {
-        _resetCompiledComponents();
-    }
-    return [
-        { provide: _SERVER_CONTEXT, useValue: 'ssr-analog' },
-        { provide: REQUEST, useValue: req },
-        { provide: RESPONSE, useValue: res },
-        { provide: BASE_URL, useValue: baseUrl },
-    ];
+import { APP_ID, InjectionToken, TransferState, assertInInjectionContext, enableProdMode, inject, makeStateKey, reflectComponentType, ɵConsole } from "@angular/core";
+import { BASE_URL, INTERNAL_FETCH, REQUEST, RESPONSE } from "@analogjs/router/tokens";
+import { bootstrapApplication } from "@angular/platform-browser";
+import { provideServerRendering, renderApplication, ɵSERVER_CONTEXT } from "@angular/platform-server";
+import { json } from "node:stream/consumers";
+//#region packages/router/server/src/provide-server-context.ts
+function getHeaderValue(value) {
+	return Array.isArray(value) ? value[0] : value;
+}
+function getRequestHeader(req, name) {
+	const headers = req.headers;
+	if (!headers) return;
+	if (typeof headers === "object" && headers !== null && "get" in headers && typeof headers.get === "function") return headers.get(name) ?? void 0;
+	return getHeaderValue(headers[name]);
+}
+function provideServerContext({ req, res, fetch }) {
+	const baseUrl = getBaseUrl(req);
+	return [
+		{
+			provide: ɵSERVER_CONTEXT,
+			useValue: "ssr-analog"
+		},
+		{
+			provide: REQUEST,
+			useValue: req
+		},
+		{
+			provide: RESPONSE,
+			useValue: res
+		},
+		{
+			provide: BASE_URL,
+			useValue: baseUrl
+		},
+		{
+			provide: INTERNAL_FETCH,
+			useValue: fetch
+		}
+	];
 }
 function getBaseUrl(req) {
-    const protocol = getRequestProtocol(req);
-    const { originalUrl, headers } = req;
-    const parsedUrl = new URL('', `${protocol}://${headers.host}${originalUrl.endsWith('/')
-        ? originalUrl.substring(0, originalUrl.length - 1)
-        : originalUrl}`);
-    const baseUrl = parsedUrl.origin;
-    return baseUrl;
+	const protocol = getRequestProtocol(req);
+	const host = getRequestHeader(req, "x-forwarded-host") ?? getRequestHeader(req, "host") ?? "localhost";
+	const originalUrl = req.originalUrl || req.url || "/";
+	return new URL("", `${protocol}://${host}${originalUrl.endsWith("/") ? originalUrl.substring(0, originalUrl.length - 1) : originalUrl}`).origin;
 }
 function getRequestProtocol(req, opts = {}) {
-    if (opts.xForwardedProto !== false &&
-        req.headers['x-forwarded-proto'] === 'https') {
-        return 'https';
-    }
-    return req.connection?.encrypted ? 'https' : 'http';
+	const forwardedProto = getRequestHeader(req, "x-forwarded-proto")?.split(",")[0]?.trim();
+	if (opts.xForwardedProto !== false && forwardedProto === "https") return "https";
+	return req.connection?.encrypted ? "https" : "http";
 }
-
-const STATIC_PROPS = new InjectionToken('Static Props');
+//#endregion
+//#region packages/router/server/src/tokens.ts
+var STATIC_PROPS = new InjectionToken("Static Props");
 function provideStaticProps(props) {
-    return {
-        provide: STATIC_PROPS,
-        useFactory() {
-            return props;
-        },
-    };
+	return {
+		provide: STATIC_PROPS,
+		useFactory() {
+			return props;
+		}
+	};
 }
 function injectStaticProps() {
-    assertInInjectionContext(injectStaticProps);
-    return inject(STATIC_PROPS);
+	assertInInjectionContext(injectStaticProps);
+	return inject(STATIC_PROPS);
 }
 function injectStaticOutputs() {
-    const transferState = inject(TransferState);
-    const outputsKey = makeStateKey('_analog_output');
-    return {
-        set(data) {
-            transferState.set(outputsKey, data);
-        },
-    };
+	const transferState = inject(TransferState);
+	const outputsKey = makeStateKey("_analog_output");
+	return { set(data) {
+		transferState.set(outputsKey, data);
+	} };
 }
-
+//#endregion
+//#region packages/router/server/src/server-component-render.ts
 function serverComponentRequest(serverContext) {
-    const serverComponentId = getHeader(createEvent(serverContext.req, serverContext.res), 'X-Analog-Component');
-    if (!serverComponentId &&
-        serverContext.req.url &&
-        serverContext.req.url.startsWith('/_analog/components')) {
-        const componentId = serverContext.req.url.split('/')?.[3];
-        return componentId;
-    }
-    return serverComponentId;
+	const serverComponentId = serverContext.req?.headers?.["x-analog-component"];
+	if (!serverComponentId && serverContext.req?.url && serverContext.req.url.startsWith("/_analog/components")) return serverContext.req.url.split("/")?.[3];
+	return serverComponentId;
 }
-const components = import.meta.glob([
-    '/src/server/components/**/*.{ts,analog,ag}',
-]);
+var components = /* @__PURE__ */ Object.assign({});
 async function renderServerComponent(url, serverContext, config) {
-    const componentReqId = serverComponentRequest(serverContext);
-    const { componentLoader, componentId } = getComponentLoader(componentReqId);
-    if (!componentLoader) {
-        return new Response(`Server Component Not Found ${componentId}`, {
-            status: 404,
-        });
-    }
-    const component = (await componentLoader())['default'];
-    if (!component) {
-        return new Response(`No default export for ${componentId}`, {
-            status: 422,
-        });
-    }
-    const mirror = reflectComponentType(component);
-    const selector = mirror?.selector.split(',')?.[0] || 'server-component';
-    const event = createEvent(serverContext.req, serverContext.res);
-    const body = (await readBody(event)) || {};
-    const appId = `analog-server-${selector.toLowerCase()}-${new Date().getTime()}`;
-    const bootstrap = (context) => bootstrapApplication(component, {
-        providers: [
-            provideServerRendering(),
-            provideStaticProps(body),
-            { provide: _SERVER_CONTEXT, useValue: 'analog-server-component' },
-            {
-                provide: APP_ID,
-                useFactory() {
-                    return appId;
-                },
-            },
-            ...(config?.providers || []),
-        ],
-    }, context);
-    const html = await renderApplication(bootstrap, {
-        url,
-        document: `<${selector}></${selector}>`,
-        platformProviders: [
-            {
-                provide: _Console,
-                useFactory() {
-                    return {
-                        warn: () => { },
-                        log: () => { },
-                    };
-                },
-            },
-        ],
-    });
-    const outputs = retrieveTransferredState(html, appId);
-    const responseData = {
-        html,
-        outputs,
-    };
-    return new Response(JSON.stringify(responseData), {
-        headers: {
-            'X-Analog-Component': 'true',
-        },
-    });
+	const { componentLoader, componentId } = getComponentLoader(serverComponentRequest(serverContext));
+	if (!componentLoader) return new Response(`Server Component Not Found ${componentId}`, { status: 404 });
+	const component = (await componentLoader())["default"];
+	if (!component) return new Response(`No default export for ${componentId}`, { status: 422 });
+	const selector = reflectComponentType(component)?.selector.split(",")?.[0] || "server-component";
+	const body = await json(serverContext.req).catch(() => ({})) || {};
+	const appId = `analog-server-${selector.toLowerCase()}-${(/* @__PURE__ */ new Date()).getTime()}`;
+	const bootstrap = (context) => bootstrapApplication(component, { providers: [
+		provideServerRendering(),
+		provideStaticProps(body),
+		{
+			provide: ɵSERVER_CONTEXT,
+			useValue: "analog-server-component"
+		},
+		{
+			provide: APP_ID,
+			useFactory() {
+				return appId;
+			}
+		},
+		...config?.providers || []
+	] }, context);
+	const html = await renderApplication(bootstrap, {
+		url,
+		document: `<${selector}></${selector}>`,
+		platformProviders: [{
+			provide: ɵConsole,
+			useFactory() {
+				return {
+					warn: () => {},
+					log: () => {}
+				};
+			}
+		}]
+	});
+	const responseData = {
+		html,
+		outputs: retrieveTransferredState(html, appId)
+	};
+	return new Response(JSON.stringify(responseData), { headers: { "X-Analog-Component": "true" } });
 }
 function getComponentLoader(componentReqId) {
-    let _componentId = `/src/server/components/${componentReqId.toLowerCase()}`;
-    let componentLoader = undefined;
-    let componentId = _componentId;
-    if (components[`${_componentId}.ts`]) {
-        componentId = `${_componentId}.ts`;
-        componentLoader = components[componentId];
-    }
-    return { componentLoader, componentId };
+	const _componentId = `/src/server/components/${componentReqId.toLowerCase()}`;
+	let componentLoader = void 0;
+	let componentId = _componentId;
+	if (components[`${_componentId}.ts`]) {
+		componentId = `${_componentId}.ts`;
+		componentLoader = components[componentId];
+	}
+	return {
+		componentLoader,
+		componentId
+	};
 }
 function retrieveTransferredState(html, appId) {
-    const regex = new RegExp(`<script id="${appId}-state" type="application/json">(.*?)<\/script>`);
-    const match = html.match(regex);
-    if (match) {
-        const scriptContent = match[1];
-        if (scriptContent) {
-            try {
-                const parsedContent = JSON.parse(scriptContent);
-                return parsedContent._analog_output || {};
-            }
-            catch (e) {
-                console.warn('Exception while parsing static outputs for ' + appId, e);
-            }
-        }
-        return {};
-    }
-    else {
-        return {};
-    }
-}
-
-if (import.meta.env.PROD) {
-    enableProdMode();
+	const regex = new RegExp(`<script id="${appId}-state" type="application/json">(.*?)<\/script>`);
+	const match = html.match(regex);
+	if (match) {
+		const scriptContent = match[1];
+		if (scriptContent) try {
+			return JSON.parse(scriptContent)._analog_output || {};
+		} catch (e) {
+			console.warn("Exception while parsing static outputs for " + appId, e);
+		}
+		return {};
+	} else return {};
 }
+//#endregion
+//#region packages/router/server/src/render.ts
+enableProdMode();
 /**
- * Returns a function that accepts the navigation URL,
- * the root HTML, and server context.
- *
- * @param rootComponent
- * @param config
- * @param platformProviders
- * @returns Promise<string | Reponse>
- */
+* Returns a function that accepts the navigation URL,
+* the root HTML, and server context.
+*
+* @param rootComponent
+* @param config
+* @param platformProviders
+* @returns Promise<string | Reponse>
+*/
 function render(rootComponent, config, platformProviders = []) {
-    function bootstrap(context) {
-        return bootstrapApplication(rootComponent, config, context);
-    }
-    return async function render(url, document, serverContext) {
-        if (serverComponentRequest(serverContext)) {
-            return await renderServerComponent(url, serverContext);
-        }
-        const html = await renderApplication(bootstrap, {
-            document,
-            url,
-            platformProviders: [
-                provideServerContext(serverContext),
-                platformProviders,
-            ],
-        });
-        return html;
-    };
+	function bootstrap(context) {
+		return bootstrapApplication(rootComponent, config, context);
+	}
+	return async function render(url, document, serverContext) {
+		if (serverComponentRequest(serverContext)) return await renderServerComponent(url, serverContext);
+		return await renderApplication(bootstrap, {
+			document,
+			url,
+			platformProviders: [provideServerContext(serverContext), platformProviders]
+		});
+	};
 }
-
-/**
- * Generated bundle index. Do not edit.
- */
-
+//#endregion
 export { injectStaticOutputs, injectStaticProps, provideServerContext, render, renderServerComponent, serverComponentRequest };
-//# sourceMappingURL=analogjs-router-server.mjs.map
+
+//# sourceMappingURL=analogjs-router-server.mjs.map

package/fesm2022/analogjs-router-tanstack-query.mjs

@@ -0,0 +1,58 @@
+import { ENVIRONMENT_INITIALIZER, TransferState, inject, makeEnvironmentProviders, makeStateKey } from "@angular/core";
+import { lastValueFrom } from "rxjs";
+import { QueryClient, hydrate } from "@tanstack/angular-query-experimental";
+//#region packages/router/tanstack-query/src/provide-analog-query.ts
+var ANALOG_QUERY_STATE_KEY = makeStateKey("analog_query_state");
+function provideAnalogQuery() {
+	return makeEnvironmentProviders([{
+		provide: ENVIRONMENT_INITIALIZER,
+		multi: true,
+		useValue() {
+			const transferState = inject(TransferState);
+			const client = inject(QueryClient);
+			const dehydratedState = transferState.get(ANALOG_QUERY_STATE_KEY, null);
+			if (dehydratedState) {
+				hydrate(client, dehydratedState);
+				transferState.remove(ANALOG_QUERY_STATE_KEY);
+			}
+		}
+	}]);
+}
+//#endregion
+//#region packages/router/tanstack-query/src/server-query.ts
+function buildUrl(base, params) {
+	if (!params) return base;
+	const parts = [];
+	for (const [key, value] of Object.entries(params)) {
+		if (value === void 0 || value === null) continue;
+		const k = encodeURIComponent(key);
+		if (Array.isArray(value)) for (const item of value) parts.push(`${k}=${encodeURIComponent(String(item))}`);
+		else parts.push(`${k}=${encodeURIComponent(String(value))}`);
+	}
+	if (parts.length === 0) return base;
+	return `${base}${base.includes("?") ? "&" : "?"}${parts.join("&")}`;
+}
+function serverQueryOptions(http, url, options) {
+	const { query, ...rest } = options;
+	return {
+		...rest,
+		queryFn: () => lastValueFrom(http.get(buildUrl(url, query)))
+	};
+}
+function serverMutationOptions(http, url, options) {
+	return {
+		mutationFn: (body) => lastValueFrom(http.post(url, body)),
+		...options
+	};
+}
+function serverInfiniteQueryOptions(http, url, options) {
+	const { query: buildQuery, ...rest } = options;
+	return {
+		...rest,
+		queryFn: (context) => lastValueFrom(http.get(buildUrl(url, buildQuery(context))))
+	};
+}
+//#endregion
+export { ANALOG_QUERY_STATE_KEY, provideAnalogQuery, serverInfiniteQueryOptions, serverMutationOptions, serverQueryOptions };
+
+//# sourceMappingURL=analogjs-router-tanstack-query.mjs.map

package/fesm2022/analogjs-router-tokens.mjs

@@ -1,25 +1,26 @@
-import { InjectionToken, inject } from '@angular/core';
-
-const REQUEST = new InjectionToken('@analogjs/router Server Request');
-const RESPONSE = new InjectionToken('@analogjs/router Server Response');
-const BASE_URL = new InjectionToken('@analogjs/router Base URL');
-const API_PREFIX = new InjectionToken('@analogjs/router API Prefix');
+import { InjectionToken, inject } from "@angular/core";
+//#region packages/router/tokens/src/index.ts
+var REQUEST = new InjectionToken("@analogjs/router Server Request");
+var RESPONSE = new InjectionToken("@analogjs/router Server Response");
+var BASE_URL = new InjectionToken("@analogjs/router Base URL");
+var INTERNAL_FETCH = new InjectionToken("@analogjs/router Internal Server Fetch");
+var API_PREFIX = new InjectionToken("@analogjs/router API Prefix");
 function injectRequest() {
-    return inject(REQUEST, { optional: true });
+	return inject(REQUEST, { optional: true });
 }
 function injectResponse() {
-    return inject(RESPONSE, { optional: true });
+	return inject(RESPONSE, { optional: true });
 }
 function injectBaseURL() {
-    return inject(BASE_URL, { optional: true });
+	return inject(BASE_URL, { optional: true });
+}
+function injectInternalServerFetch() {
+	return inject(INTERNAL_FETCH, { optional: true });
 }
 function injectAPIPrefix() {
-    return inject(API_PREFIX);
+	return inject(API_PREFIX);
 }
+//#endregion
+export { API_PREFIX, BASE_URL, INTERNAL_FETCH, REQUEST, RESPONSE, injectAPIPrefix, injectBaseURL, injectInternalServerFetch, injectRequest, injectResponse };
 
-/**
- * Generated bundle index. Do not edit.
- */
-
-export { API_PREFIX, BASE_URL, REQUEST, RESPONSE, injectAPIPrefix, injectBaseURL, injectRequest, injectResponse };
-//# sourceMappingURL=analogjs-router-tokens.mjs.map
+//# sourceMappingURL=analogjs-router-tokens.mjs.map