@gracile/engine 0.0.2

package/LICENSE

@@ -0,0 +1,15 @@
+ISC License
+
+Copyright (c) 2024 Julian Cataldo — https://gracile.js.org
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted, provided that the above
+copyright notice and this permission notice appear in all copies.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.

package/README.md

@@ -0,0 +1,9 @@
+# Gracile — Engine
+
+A thin, full-stack, **web** framework.
+
+---
+
+- [Documentation website (gracile.netlify.app)](https://gracile.js.org/)
+- [Documentation website repository](https://github.com/gracile-web/website)
+- [Starter projects repository](https://github.com/gracile-web/starter-projects)

package/ambient.d.ts

@@ -0,0 +1 @@
+/// <reference types="vite/client" />

package/dist/assertions.d.ts

@@ -0,0 +1,12 @@
+import { type ServerRenderedTemplate } from '@lit-labs/ssr';
+import type { TemplateResult } from 'lit';
+export type UnknownObject = Record<string, unknown>;
+/**
+ * Used for user provided modules with unknown/possibly malformed shapes.
+ * Avoid this for well typed sources.
+ */
+export declare function isUnknownObject(input: unknown): input is UnknownObject;
+export declare function isLitTemplate(input: unknown): input is TemplateResult<1>;
+export declare function isLitNormalTemplate(input: unknown): input is TemplateResult<1>;
+export declare function isLitServerTemplate(input: unknown): input is ServerRenderedTemplate;
+//# sourceMappingURL=assertions.d.ts.map

package/dist/assertions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"assertions.d.ts","sourceRoot":"","sources":["../src/assertions.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,sBAAsB,EAAE,MAAM,eAAe,CAAC;AAC5D,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,KAAK,CAAC;AAE1C,MAAM,MAAM,aAAa,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;AAEpD;;;GAGG;AACH,wBAAgB,eAAe,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,aAAa,CAEtE;AAED,wBAAgB,aAAa,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,cAAc,CAAC,CAAC,CAAC,CAWxE;AAED,wBAAgB,mBAAmB,CAClC,KAAK,EAAE,OAAO,GACZ,KAAK,IAAI,cAAc,CAAC,CAAC,CAAC,CAE5B;AAED,wBAAgB,mBAAmB,CAClC,KAAK,EAAE,OAAO,GACZ,KAAK,IAAI,sBAAsB,CAOjC"}

package/dist/assertions.js

@@ -0,0 +1,27 @@
+import {} from '@lit-labs/ssr';
+/**
+ * Used for user provided modules with unknown/possibly malformed shapes.
+ * Avoid this for well typed sources.
+ */
+export function isUnknownObject(input) {
+    return typeof input === 'object' && input !== null && !Array.isArray(input);
+}
+export function isLitTemplate(input) {
+    return ((typeof input === 'object' &&
+        input &&
+        '_$litType$' in input &&
+        // eslint-disable-next-line no-underscore-dangle
+        input._$litType$ === 1 &&
+        'strings' in input &&
+        Array.isArray(input.strings)) ||
+        false);
+}
+export function isLitNormalTemplate(input) {
+    return isLitTemplate(input) && '_$litServerRenderMode' in input === false;
+}
+export function isLitServerTemplate(input) {
+    return (isLitTemplate(input) &&
+        '_$litServerRenderMode' in input &&
+        // eslint-disable-next-line no-underscore-dangle
+        input._$litServerRenderMode === 1);
+}

package/dist/build/build.d.ts

@@ -0,0 +1,2 @@
+export declare function build(root?: string): Promise<void>;
+//# sourceMappingURL=build.d.ts.map

package/dist/build/build.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"build.d.ts","sourceRoot":"","sources":["../../src/build/build.ts"],"names":[],"mappings":"AAKA,wBAAsB,KAAK,CAAC,IAAI,CAAC,EAAE,MAAM,iBAIxC"}

package/dist/build/build.js

@@ -0,0 +1,7 @@
+import { logger } from '@gracile/internal-utils/logger';
+import c from 'picocolors';
+import { viteBuild } from '../vite/build.js';
+export async function build(root) {
+    logger.info(c.gray('\n— Build mode —\n'));
+    await viteBuild(root ?? process.cwd());
+}

package/dist/build/static.d.ts

@@ -0,0 +1,8 @@
+import type { ViteDevServer } from 'vite';
+export interface RouteDefinition {
+    absoluteId: string;
+    name: string;
+    html: string;
+}
+export declare function renderRoutes(vite: ViteDevServer, root?: string): Promise<RouteDefinition[]>;
+//# sourceMappingURL=static.d.ts.map

package/dist/build/static.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"static.d.ts","sourceRoot":"","sources":["../../src/build/static.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,MAAM,CAAC;AAM1C,MAAM,WAAW,eAAe;IAC/B,UAAU,EAAE,MAAM,CAAC;IACnB,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;CACb;AAeD,wBAAsB,YAAY,CAAC,IAAI,EAAE,aAAa,EAAE,IAAI,SAAgB,8BAwG3E"}

package/dist/build/static.js

@@ -0,0 +1,82 @@
+import { Buffer } from 'node:buffer';
+import path, { join } from 'node:path';
+import { logger } from '@gracile/internal-utils/logger';
+import c from 'picocolors';
+import { renderRouteTempalte } from '../render/route-template.js';
+import { collectRoutes, routes } from '../routes/collect.js';
+import { loadForeignRouteObject } from '../routes/load-module.js';
+async function streamToString(stream) {
+    const chunks = [];
+    // eslint-disable-next-line no-restricted-syntax
+    for await (const chunk of stream) {
+        if (typeof chunk === 'string') {
+            chunks.push(Buffer.from(chunk));
+        }
+        else
+            throw new Error('Wrong buffer');
+    }
+    return Buffer.concat(chunks).toString('utf-8');
+}
+export async function renderRoutes(vite, root = process.cwd()) {
+    logger.info(c.green('Rendering routes…'), { timestamp: true });
+    // MARK: Collect
+    await collectRoutes(root /* vite */);
+    logger.info(c.green('Rendering routes finished'), { timestamp: true });
+    const renderedRoutes = [];
+    // MARK: Iterate modules
+    await Promise.all([...routes].map(async ([patternString, options]) => {
+        const routeModule = await loadForeignRouteObject(vite, options.filePath);
+        const routeStaticPaths = routeModule.staticPaths?.();
+        // MARK: Extract data
+        await Promise.all((routeStaticPaths ?? [patternString]).map(async (staticPathOptions) => {
+            let pathnameWithParams = patternString;
+            let params = {};
+            let props;
+            // MARK: Convert pattern
+            // to real route with static parameters + get props. for after
+            if (typeof staticPathOptions === 'object') {
+                params = staticPathOptions.params;
+                props = staticPathOptions.props;
+                Object.entries(staticPathOptions.params).forEach(([paramName, value]) => {
+                    if (typeof value === 'string' || typeof value === 'undefined')
+                        pathnameWithParams = pathnameWithParams
+                            .replace(`:${paramName}*`, value || '')
+                            .replace(`{:${paramName}}`, value || '');
+                });
+            }
+            // MARK: Prepare
+            // NOTE: Unused for now
+            const isErrorPage = pathnameWithParams.match(/\/__(.*)$/); /* Could add more (error, etc) */
+            const base = isErrorPage
+                ? path.dirname(pathnameWithParams.slice(1))
+                : pathnameWithParams.slice(1);
+            const name = path.join(base, isErrorPage
+                ? `${pathnameWithParams.split('/').at(-2)?.replace('__', '')}.html`
+                : 'index.html');
+            const url = new URL(pathnameWithParams, 'http://gracile-static');
+            // MARK: Render
+            const { output } = await renderRouteTempalte(
+            //
+            { url: url.href }, vite, 'build', {
+                routeModule,
+                params,
+                foundRoute: options,
+                pathname: pathnameWithParams,
+                props,
+            });
+            const htmlString = await streamToString(output);
+            const existing = renderedRoutes.find((rendered) => rendered?.name === name);
+            if (existing)
+                throw new Error(`${c.red(`"${existing.name}" page was defined twice!`)}\n`);
+            renderedRoutes.push({
+                // NOTE:
+                // Vite's internal build-html plugin only expects *absolute* ids.
+                // See https://github.com/vitejs/vite/issues/13406#issuecomment-1801659561
+                absoluteId: join(root, name),
+                name,
+                html: htmlString,
+            });
+        }));
+    }));
+    return renderedRoutes;
+}

package/dist/dev/dev.d.ts

@@ -0,0 +1,6 @@
+export declare function dev(options: {
+    port?: number | undefined;
+    root?: string;
+    expose?: boolean | undefined;
+}): Promise<void>;
+//# sourceMappingURL=dev.d.ts.map

package/dist/dev/dev.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dev.d.ts","sourceRoot":"","sources":["../../src/dev/dev.ts"],"names":[],"mappings":"AAQA,wBAAsB,GAAG,CAAC,OAAO,EAAE;IAClC,IAAI,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAC1B,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,MAAM,CAAC,EAAE,OAAO,GAAG,SAAS,CAAC;CAC7B,iBAeA"}

package/dist/dev/dev.js

@@ -0,0 +1,14 @@
+import { logger } from '@gracile/internal-utils/logger';
+import c from 'picocolors';
+import { getConfigs } from '../vite/config.js';
+import { startServer } from './server.js';
+const DEFAULT_DEV_SERVER_PORT = 9090;
+export async function dev(options) {
+    logger.info(c.gray('\n— Development mode —\n'));
+    const { userConfigGracile } = await getConfigs(options.root ?? process.cwd(), 'dev');
+    const port = options.port ?? userConfigGracile?.port ?? DEFAULT_DEV_SERVER_PORT;
+    startServer({
+        ...options,
+        port,
+    }).catch((e) => logger.error(String(e)));
+}

package/dist/dev/request.d.ts

@@ -0,0 +1,4 @@
+import type { NextFunction, Request as ExpressRequest, Response as ExpressResponse } from 'express';
+import type { ViteDevServer } from 'vite';
+export declare function createDevRequestHandler(vite: ViteDevServer): (req: ExpressRequest, res: ExpressResponse, next: NextFunction) => Promise<void | ExpressResponse<any, Record<string, any>>>;
+//# sourceMappingURL=request.d.ts.map

package/dist/dev/request.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"request.d.ts","sourceRoot":"","sources":["../../src/dev/request.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EACX,YAAY,EACZ,OAAO,IAAI,cAAc,EACzB,QAAQ,IAAI,eAAe,EAC3B,MAAM,SAAS,CAAC;AAEjB,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,MAAM,CAAC;AAc1C,wBAAgB,uBAAuB,CAAC,IAAI,EAAE,aAAa,SAEpD,cAAc,OACd,eAAe,QACd,YAAY,+DA+LnB"}

package/dist/dev/request.js

@@ -0,0 +1,151 @@
+import { Writable } from 'node:stream';
+import { logger } from '@gracile/internal-utils/logger';
+import { createServerAdapter } from '@whatwg-node/server';
+import c from 'picocolors';
+import { /*  errorInline, */ errorPage } from '../errors/templates.js';
+import { renderRouteTempalte, } from '../render/route-template.js';
+import { getRoute } from '../routes/match.js';
+import { renderSsrTemplate } from '../vite/utils.js';
+// NOTE: Find a more canonical way to ponyfill the Node HTTP request to standard Request
+// @ts-expect-error Abusing this feature!
+const adapter = createServerAdapter((request) => request);
+export function createDevRequestHandler(vite) {
+    return async (req, res, next) => {
+        const url = req.originalUrl;
+        logger.info(`[${c.yellow(req.method)}] ${c.yellow(url)}`, {
+            timestamp: true,
+        });
+        // MARK: Skip unwanted requests
+        if (
+        //
+        url.endsWith('favicon.ico') ||
+            url.endsWith('favicon.svg'))
+            return next();
+        const requestPonyfilled = (await Promise.resolve(adapter.handleNodeRequest(req)));
+        async function renderPageFn(handlerInfos, routeInfos) {
+            const { output } = await renderRouteTempalte(requestPonyfilled, vite, 'dev', routeInfos, handlerInfos);
+            return output;
+        }
+        try {
+            // MARK: Get route infos
+            const moduleInfos = await getRoute({
+                url: requestPonyfilled.url,
+                vite,
+            });
+            let output;
+            // TODO: should move this to `special-file` so we don't recalculate on each request
+            // + we would be able to do some route codegen.
+            const response = {};
+            // MARK: Server handler
+            const handler = moduleInfos.routeModule.handler;
+            if ('handler' in moduleInfos.routeModule &&
+                typeof handler !== 'undefined') {
+                const options = {
+                    request: requestPonyfilled,
+                    url: new URL(requestPonyfilled.url),
+                    response,
+                    params: moduleInfos.params,
+                };
+                // MARK: Top level handler
+                if (typeof handler === 'function') {
+                    const handlerOutput = (await Promise.resolve(handler(options)));
+                    if (handlerOutput instanceof Response)
+                        output = handlerOutput;
+                    else
+                        throw new Error('Catch-all handler must return a Response object.');
+                    // MARK: Handler with method
+                }
+                else if (requestPonyfilled.method in handler) {
+                    const handlerWithMethod = handler[requestPonyfilled.method];
+                    if (typeof handlerWithMethod !== 'function')
+                        throw Error('Handler must be a function.');
+                    const handlerOutput = await Promise.resolve(handlerWithMethod(options));
+                    if (handlerOutput instanceof Response)
+                        output = handlerOutput;
+                    else {
+                        output = await renderPageFn({
+                            data: handlerOutput,
+                            method: requestPonyfilled.method,
+                        }, moduleInfos);
+                    }
+                    // MARK: No GET, render page
+                }
+                else if (handler &&
+                    'GET' in handler === false &&
+                    requestPonyfilled.method === 'GET') {
+                    output = await renderPageFn({ data: null, method: 'GET' }, moduleInfos);
+                }
+                // MARK: No handler, render page
+            }
+            else {
+                output = await renderPageFn({ data: null, method: 'GET' }, moduleInfos);
+            }
+            // MARK: Return response
+            // NOTE: try directly with the requestPonyfill. This might not be necessary
+            if (output instanceof Response) {
+                if (output.status >= 300 && output.status <= 303) {
+                    const location = output.headers.get('location');
+                    if (location)
+                        return res.redirect(location);
+                }
+                output.headers?.forEach((content, header) => res.set(header, content));
+                if (output.status)
+                    res.statusCode = output.status;
+                if (output.statusText)
+                    res.statusMessage = output.statusText;
+                // TODO: use this with page only?
+                // if (output.bodyUsed === false)
+                //   throw new Error('Missing body.');
+                if (output.body)
+                    output.body
+                        .pipeTo(Writable.toWeb(res))
+                        .catch((e) => logger.error(String(e)));
+                else
+                    throw new Error('Missing body.');
+                // MARK: Stream page render
+            }
+            else {
+                new Headers(response.headers)?.forEach((content, header) => res.set(header, content));
+                if (response.status)
+                    res.statusCode = response.status;
+                if (response.statusText)
+                    res.statusMessage = response.statusText;
+                res.set({ 'Content-Type': 'text/html' });
+                // MARK: Page stream error
+                output
+                    ?.on('error', (error) => {
+                    const errorMessage = `There was an error while rendering a template chunk on server-side.\n` +
+                        `It was omitted from the resulting HTML.`;
+                    logger.error(errorMessage);
+                    logger.error(error.message);
+                    res.statusCode = 500;
+                    res.statusMessage = errorMessage;
+                    /* NOTE: Safety closing tags, maybe add more */
+                    // Maybe just returning nothing is better to not break the page?
+                    // Should send a overlay message anyway via WebSocket
+                    // vite.ws.send()
+                    setTimeout(() => {
+                        vite.hot.send('gracile:ssr-error', {
+                            message: errorMessage,
+                        });
+                    }, 500);
+                    res.end('' /* errorInline(error) */);
+                })
+                    .pipe(res);
+            }
+            // MARK: Errors
+        }
+        catch (e) {
+            const error = e;
+            vite.ssrFixStacktrace(error);
+            if (error.cause === 404) {
+                return res.status(404).end('404');
+                // TODO: use a nice framework service page
+                // .redirect(new URL('/__404/', requestPonyfilled.url).href)
+            }
+            const errorTemplate = await renderSsrTemplate(errorPage(error));
+            res.status(500).end(await vite.transformIndexHtml(url, errorTemplate));
+        }
+        return next();
+    };
+}

package/dist/dev/server.d.ts

@@ -0,0 +1,10 @@
+import type { Server } from 'node:http';
+export declare function startServer(options: {
+    port?: number | undefined;
+    root?: string;
+    expose?: boolean | undefined;
+}): Promise<{
+    port: number;
+    instance: Server<typeof import("http").IncomingMessage, typeof import("http").ServerResponse>;
+}>;
+//# sourceMappingURL=server.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"server.d.ts","sourceRoot":"","sources":["../../src/dev/server.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,WAAW,CAAC;AAyCxC,wBAAsB,WAAW,CAAC,OAAO,EAAE;IAC1C,IAAI,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAC1B,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,MAAM,CAAC,EAAE,OAAO,GAAG,SAAS,CAAC;CAC7B;;;GAqCA"}

package/dist/dev/server.js

@@ -0,0 +1,54 @@
+import { logger } from '@gracile/internal-utils/logger';
+import { setCurrentWorkingDirectory } from '@gracile/internal-utils/paths';
+import express, {} from 'express';
+import c from 'picocolors';
+import { collectRoutes, routes } from '../routes/collect.js';
+import { createViteServer } from '../vite/server.js';
+import { createDevRequestHandler } from './request.js';
+async function createServer(_hmrPort, root = process.cwd()) {
+    logger.info(c.green('starting engine…'), {
+        timestamp: true,
+    });
+    setCurrentWorkingDirectory(root);
+    const app = express();
+    const vite = await createViteServer(root, 'dev');
+    app.use(vite.middlewares);
+    app.get('/__routes', (req, res) => {
+        return res.json([...routes]);
+    });
+    await collectRoutes(root /* vite */);
+    vite.watcher.on('all', (event, _file) => {
+        if (['add', 'unlink'].includes(event))
+            collectRoutes(root /* , vite */).catch((e) => logger.error(String(e)));
+    });
+    const handler = createDevRequestHandler(vite);
+    /* NOTE: Types are wrong! Should accept an async request handler. */
+    app.use('*', handler);
+    return { app, vite };
+}
+export async function startServer(options) {
+    const port = options.port ?? 9090;
+    const server = await createServer(port + 1, options.root);
+    // NOTE: `0` will auto-alocate a random available port.
+    let resultingPort = port;
+    let resultingHost;
+    const instance = await new Promise((resolve) => {
+        const inst = server.app.listen(port, options.expose ? '0.0.0.0' : '127.0.0.1', () => {
+            logger.info(c.green('development server started'), { timestamp: true });
+            resolve(inst);
+            const addressInfo = inst.address();
+            if (typeof addressInfo === 'object' && addressInfo) {
+                resultingPort = addressInfo.port;
+                // NOTE: this is not ideal. Should have the real bounded IP,
+                // like with Vite's `resolvedUrls` (unavailable in middleware mode)
+                resultingHost = addressInfo.address;
+            }
+            logger.info(`
+${c.dim('┃')} Local    ${c.cyan(`http://localhost:${resultingPort}/`)}
+${c.dim('┃')} Network  ${options.expose ? c.cyan(`http://${resultingHost}:${resultingPort}/`) : c.dim(`use ${c.bold('--host')} to expose`)}
+`);
+            resolve(inst);
+        });
+    });
+    return { port: resultingPort, instance };
+}

package/dist/errors/templates.d.ts

@@ -0,0 +1,3 @@
+export declare function errorInline(error: Error): import("@lit-labs/ssr").ServerRenderedTemplate;
+export declare function errorPage(error: Error): import("@lit-labs/ssr").ServerRenderedTemplate;
+//# sourceMappingURL=templates.d.ts.map

package/dist/errors/templates.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"templates.d.ts","sourceRoot":"","sources":["../../src/errors/templates.ts"],"names":[],"mappings":"AAEA,wBAAgB,WAAW,CAAC,KAAK,EAAE,KAAK,kDASvC;AAED,wBAAgB,SAAS,CAAC,KAAK,EAAE,KAAK,kDAyDrC"}

package/dist/errors/templates.js

@@ -0,0 +1,69 @@
+import { html } from '@lit-labs/ssr';
+export function errorInline(error) {
+    return html `<!--  --></a>
+  <div data-ssr-error>
+    <strong style="color: red">SSR Template error!</strong>
+    <details>
+      <summary style="user-select: none; cursor: pointer">Stack trace</summary>
+      <pre style="overflow: auto">${error.stack}</pre>
+    </details>
+  </div>`;
+}
+export function errorPage(error) {
+    return html `
+		<!--  -->
+
+		<!doctype html>
+		<html lang="en">
+			<head>
+				<meta charset="UTF-8" />
+				<meta name="viewport" content="width=device-width, initial-scale=1.0" />
+
+				<title>Error</title>
+			</head>
+			<body>
+				<style>
+					html {
+						color-scheme: dark;
+						font-size: 16px;
+						line-height: 1.23rem;
+						font-family: system-ui;
+					}
+					body {
+						padding: 1rem;
+					}
+
+					pre {
+						padding: 1rem;
+
+						overflow-y: auto;
+					}
+					button {
+						font-size: 2rem;
+					}
+
+					h1 {
+						color: tomato;
+					}
+				</style>
+
+				<main>
+					<h1>😵 An error has occurred!</h1>
+					<button id="reload">Reload</button>
+					<!--  -->
+					<hr />
+
+					<pre>${error.stack}</pre>
+					<!-- <pre>$ {e.name}</pre> -->
+					<!-- <pre>$ {e.message}</pre> -->
+					<!-- <pre>$ {e.cause}</pre> -->
+					<hr />
+				</main>
+
+				<script>
+					reload.addEventListener('click', () => document.location.reload());
+				</script>
+			</body>
+		</html>
+	`;
+}

package/dist/preview.d.ts

@@ -0,0 +1,6 @@
+export declare function preview({ port, expose, root, }: {
+    port?: number | undefined;
+    expose?: boolean | undefined;
+    root?: string;
+}): Promise<void>;
+//# sourceMappingURL=preview.d.ts.map

package/dist/preview.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"preview.d.ts","sourceRoot":"","sources":["../src/preview.ts"],"names":[],"mappings":"AAMA,wBAAsB,OAAO,CAAC,EAC7B,IAAI,EACJ,MAAM,EACN,IAAI,GACJ,EAAE;IACF,IAAI,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAC1B,MAAM,CAAC,EAAE,OAAO,GAAG,SAAS,CAAC;IAC7B,IAAI,CAAC,EAAE,MAAM,CAAC;CACd,iBASA"}

package/dist/preview.js

@@ -0,0 +1,9 @@
+import { logger } from '@gracile/internal-utils/logger';
+import c from 'picocolors';
+import { getConfigs } from './vite/config.js';
+import { vitePreview } from './vite/server.js';
+export async function preview({ port, expose, root, }) {
+    logger.info(c.gray('\n— Preview mode —\n'));
+    const { userConfigGracile } = await getConfigs(root ?? process.cwd(), 'build');
+    await vitePreview(port ?? userConfigGracile?.port ?? 9797, expose);
+}

package/dist/render/route-template.d.ts

@@ -0,0 +1,15 @@
+import { Readable } from 'node:stream';
+import type { ViteDevServer } from 'vite';
+import type { RouteInfos } from '../routes/match.js';
+import type { StaticRequest } from '../routes/route.js';
+export declare const SSR_OUTLET_MARKER = "<route-template-outlet></route-template-outlet>";
+export declare const PAGE_ASSETS_MARKER = "<!--__GRACILE_PAGE_ASSETS__-->";
+export declare const pageAssets: import("@lit-labs/ssr").ServerRenderedTemplate;
+export type HandlerInfos = {
+    data: unknown;
+    method: string;
+};
+export declare function renderRouteTempalte(request: Request | StaticRequest, vite: ViteDevServer, mode: 'dev' | 'build', routeInfos: RouteInfos, handlerInfos?: HandlerInfos): Promise<{
+    output: Readable;
+}>;
+//# sourceMappingURL=route-template.d.ts.map

package/dist/render/route-template.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"route-template.d.ts","sourceRoot":"","sources":["../../src/render/route-template.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AAKvC,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,MAAM,CAAC;AAG1C,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAC;AACrD,OAAO,KAAK,EAAuB,aAAa,EAAE,MAAM,oBAAoB,CAAC;AAa7E,eAAO,MAAM,iBAAiB,oDACoB,CAAC;AAGnD,eAAO,MAAM,kBAAkB,mCAAmC,CAAC;AAEnE,eAAO,MAAM,UAAU,gDAA6C,CAAC;AAErE,MAAM,MAAM,YAAY,GAAG;IAAE,IAAI,EAAE,OAAO,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,CAAC;AAE7D,wBAAsB,mBAAmB,CACxC,OAAO,EAAE,OAAO,GAAG,aAAa,EAChC,IAAI,EAAE,aAAa,EACnB,IAAI,EAAE,KAAK,GAAG,OAAO,EACrB,UAAU,EAAE,UAAU,EACtB,YAAY,CAAC,EAAE,YAAY;;GAiH3B"}

package/dist/render/route-template.js

@@ -0,0 +1,83 @@
+import { Readable } from 'node:stream';
+import { html } from '@gracile/internal-utils/dummy-literals';
+import { html as LitSsrHtml, render as renderLitSsr } from '@lit-labs/ssr';
+import { collectResult } from '@lit-labs/ssr/lib/render-result.js';
+import { isLitServerTemplate, isLitTemplate } from '../assertions.js';
+async function* concatStreams(...readables) {
+    // eslint-disable-next-line no-restricted-syntax
+    for (const readable of readables) {
+        // eslint-disable-next-line no-restricted-syntax, no-await-in-loop
+        for await (const chunk of readable) {
+            yield chunk;
+        }
+    }
+}
+// export const SSR_OUTLET_MARKER = '________SSR_OUTLET________';
+export const SSR_OUTLET_MARKER = '<route-template-outlet></route-template-outlet>';
+// const SSR_OUTLET = unsafeHTML(SSR_OUTLET_MARKER);
+export const PAGE_ASSETS_MARKER = '<!--__GRACILE_PAGE_ASSETS__-->';
+// FIXME: cannot be used with `unsafeHTML`, so must be duplicated…
+export const pageAssets = LitSsrHtml `<!--__GRACILE_PAGE_ASSETS__-->`;
+export async function renderRouteTempalte(request, vite, mode, routeInfos, handlerInfos) {
+    // MARK: Context
+    const context = {
+        url: new URL(request.url),
+        params: routeInfos.params,
+        props: handlerInfos?.data
+            ? {
+                [handlerInfos.method]: handlerInfos.data,
+            }
+            : routeInfos.props,
+    };
+    // MARK: Fragment
+    if (!routeInfos.routeModule.document) {
+        const fragmentOutput = await Promise.resolve(routeInfos.routeModule.template?.(context));
+        if (isLitTemplate(fragmentOutput) === false)
+            throw Error(`Wrong template result for fragment template ${routeInfos.foundRoute.filePath}.`);
+        const fragmentRender = renderLitSsr(fragmentOutput);
+        // NOTE: Should use RenderResultReadable instead?
+        const output = Readable.from(fragmentRender);
+        return { output };
+    }
+    // MARK: Document
+    if (!routeInfos.routeModule.document ||
+        typeof routeInfos.routeModule.document !== 'function')
+        throw new Error(`Route document must be a function ${routeInfos.foundRoute.filePath}.`);
+    const baseDocTemplateResult = await Promise.resolve(routeInfos.routeModule.document?.(context));
+    if (isLitServerTemplate(baseDocTemplateResult) === false)
+        throw new Error(`Incorrect document template result for ${routeInfos.foundRoute.filePath}.`);
+    const baseDocRendered = await collectResult(renderLitSsr(baseDocTemplateResult));
+    // MARK: Sibling assets
+    const baseDocRenderedWithAssets = baseDocRendered.replace(PAGE_ASSETS_MARKER, html `
+			<!-- PAGE ASSETS -->
+			${routeInfos.foundRoute.pageAssets.map((path) => {
+        //
+        if (/\.(js|ts)$/.test(path)) {
+            return html `<script type="module" src="/${path}"></script>`;
+        }
+        if (/\.(scss|css)$/.test(path)) {
+            return html `<link rel="stylesheet" href="/${path}" />`;
+        }
+        throw new Error('Unknown asset.');
+    })}
+			<!-- /PAGE ASSETS -->
+		`);
+    // MARK: Base document
+    const baseDocHtml = mode === 'dev'
+        ? await vite.transformIndexHtml(routeInfos.pathname, baseDocRenderedWithAssets)
+        : baseDocRenderedWithAssets;
+    const index = baseDocHtml.indexOf(SSR_OUTLET_MARKER);
+    const baseDocRenderStreamPre = Readable.from(baseDocHtml.substring(0, index));
+    const baseDocRenderStreamPost = Readable.from(baseDocHtml.substring(index + SSR_OUTLET_MARKER.length + 1));
+    // MARK: Page
+    if (routeInfos.routeModule.template) {
+        const routeOutput = (await Promise.resolve(routeInfos.routeModule.template(context)));
+        if (isLitTemplate(routeOutput) === false)
+            throw Error(`Wrong template result for page template ${routeInfos.foundRoute.filePath}.`);
+        const renderStream = Readable.from(renderLitSsr(routeOutput));
+        const output = Readable.from(concatStreams(baseDocRenderStreamPre, renderStream, baseDocRenderStreamPost));
+        return { output };
+    }
+    const output = Readable.from(baseDocHtml);
+    return { output };
+}