@analogjs/router 3.0.0-alpha.1 → 3.0.0-alpha.3

package/fesm2022/analogjs-router-server-actions.mjs

@@ -1,39 +1,27 @@
+//#region packages/router/server/actions/src/actions.ts
 function fail(status, errors) {
-    return new Response(JSON.stringify(errors), {
-        status,
-        headers: {
-            'X-Analog-Errors': 'true',
-        },
-    });
+	return new Response(JSON.stringify(errors), {
+		status,
+		headers: { "X-Analog-Errors": "true" }
+	});
 }
 function json(data, config) {
-    return new Response(JSON.stringify(data), {
-        headers: {
-            'Content-Type': 'application/json; charset=utf-8',
-        },
-        ...config,
-    });
+	return new Response(JSON.stringify(data), {
+		headers: { "Content-Type": "application/json; charset=utf-8" },
+		...config
+	});
 }
 function redirect(url, config = 302) {
-    if (typeof config === 'number') {
-        return new Response(null, {
-            status: config,
-            headers: {
-                Location: `${url}`,
-            },
-        });
-    }
-    return new Response(null, {
-        headers: {
-            Location: `${url}`,
-        },
-        ...config,
-    });
+	if (typeof config === "number") return new Response(null, {
+		status: config,
+		headers: { Location: `${url}` }
+	});
+	return new Response(null, {
+		headers: { Location: `${url}` },
+		...config
+	});
 }
-
-/**
- * Generated bundle index. Do not edit.
- */
-
+//#endregion
 export { fail, json, redirect };
-//# sourceMappingURL=analogjs-router-server-actions.mjs.map
+
+//# sourceMappingURL=analogjs-router-server-actions.mjs.map

package/fesm2022/analogjs-router-server.mjs

@@ -1,226 +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, INTERNAL_FETCH } from '@analogjs/router/tokens';
-import { bootstrapApplication } from '@angular/platform-browser';
-import { json } from 'node:stream/consumers';
-
+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;
+	return Array.isArray(value) ? value[0] : value;
 }
 function getRequestHeader(req, name) {
-    const headers = req.headers;
-    if (!headers) {
-        return undefined;
-    }
-    if (typeof headers === 'object' &&
-        headers !== null &&
-        'get' in headers &&
-        typeof headers.get === 'function') {
-        return headers.get(name) ?? undefined;
-    }
-    return getHeaderValue(headers[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);
-    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 },
-        { provide: INTERNAL_FETCH, useValue: fetch },
-    ];
+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 host = getRequestHeader(req, 'x-forwarded-host') ??
-        getRequestHeader(req, 'host') ??
-        'localhost';
-    const originalUrl = req.originalUrl || req.url || '/';
-    const parsedUrl = new URL('', `${protocol}://${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 = {}) {
-    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 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) {
-    // `ServerContext` is still backed by raw Node req/res, so read the header
-    // directly instead of reconstructing an H3Event just for lookup.
-    // In h3 v2 / Nitro v3, req may be undefined during fetch-based prerendering
-    // (where event.node is not populated), so guard with optional chaining.
-    const serverComponentId = serverContext.req?.headers?.['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';
-    // Server component requests POST JSON props from the client bridge, so parse
-    // the Node request body directly instead of rebuilding an H3Event wrapper.
-    const body = (await json(serverContext.req).catch(() => ({}))) || {};
-    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-tokens.mjs

@@ -1,29 +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 INTERNAL_FETCH = new InjectionToken('@analogjs/router Internal Server Fetch');
-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 });
+	return inject(INTERNAL_FETCH, { optional: true });
 }
 function injectAPIPrefix() {
-    return inject(API_PREFIX);
+	return inject(API_PREFIX);
 }
-
-/**
- * Generated bundle index. Do not edit.
- */
-
+//#endregion
 export { API_PREFIX, BASE_URL, INTERNAL_FETCH, REQUEST, RESPONSE, injectAPIPrefix, injectBaseURL, injectInternalServerFetch, injectRequest, injectResponse };
-//# sourceMappingURL=analogjs-router-tokens.mjs.map
+
+//# sourceMappingURL=analogjs-router-tokens.mjs.map