@gracile/engine 0.0.2

package/dist/routes/collect.d.ts

@@ -0,0 +1,4 @@
+import type { Route } from './route.js';
+export declare const routes: Map<string, Route>;
+export declare function collectRoutes(root: string): Promise<void>;
+//# sourceMappingURL=collect.d.ts.map

package/dist/routes/collect.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"collect.d.ts","sourceRoot":"","sources":["../../src/routes/collect.ts"],"names":[],"mappings":"AAWA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AAExC,eAAO,MAAM,MAAM,oBAA2B,CAAC;AAyD/C,wBAAsB,aAAa,CAAC,IAAI,EAAE,MAAM,iBA8E/C"}

package/dist/routes/collect.js

@@ -0,0 +1,111 @@
+import path, { join, relative } from 'node:path';
+import { logger } from '@gracile/internal-utils/logger';
+import * as paths from '@gracile/internal-utils/paths';
+import fastGlob from 'fast-glob';
+import c from 'picocolors';
+import { URLPattern } from 'urlpattern-polyfill/urlpattern';
+// import type { ViteDevServer } from 'vite';
+import { prepareSortableRoutes, routeComparator } from './comparator.js';
+import { REGEXES } from './load-module.js';
+export const routes = new Map();
+function extractRoutePatterns(absoluteFilePath) {
+    const routePathname = path
+        .relative('src/routes', paths.relativeToProject(absoluteFilePath))
+        .replace(/\.[j|t]s$/, '');
+    let pathParts = routePathname.split(process.platform === 'win32' ? '\\' : '/');
+    const last = pathParts.at(-1);
+    if (typeof last === 'undefined')
+        throw new Error('Cannot parse file path.');
+    if (
+    // NOTE: /foo/(foo) => /foo
+    /\((.*)\)/.test(last) ||
+        // NOTE: /foo/index => /foo
+        last === 'index')
+        pathParts.pop();
+    if (pathParts.length === 1 && pathParts.at(0) === 'index')
+        pathParts = [];
+    if (pathParts.length === 1 && pathParts.at(0) === '404')
+        pathParts = ['__404'];
+    let hasParams = false;
+    const pathRelNorm = pathParts.map((pathEntry) => {
+        let entry = pathEntry;
+        if (entry.match(REGEXES.rest)) {
+            hasParams = true;
+            return pathEntry.replace(REGEXES.rest, (_s, param) => `:${param}*`);
+        }
+        while (REGEXES.param.test(entry)) {
+            hasParams = true;
+            entry = entry.replace(REGEXES.param, (_s, param) => {
+                return `{:${param}}`;
+            });
+        }
+        return entry;
+    });
+    const trailingSlash = pathRelNorm.length > 0 ? '/' : '';
+    const normalizedUrlPattern = `/${pathRelNorm.join('/')}${trailingSlash}`;
+    return {
+        patternString: normalizedUrlPattern,
+        pattern: new URLPattern(normalizedUrlPattern, 'http://gracile/'),
+        hasParams,
+    };
+}
+export async function collectRoutes(root /* vite: ViteDevServer */) {
+    routes.clear();
+    const serverEntrypoints = await fastGlob([
+        'src/routes/**/*.{js,ts}',
+        '!**/src/routes/**/*.client.{js,ts}',
+        '!**/src/routes/**/*.document.{js,ts}',
+        '!**/src/routes/**/_*/**',
+        '!**/src/routes/**/_*',
+    ], { ignore: [], cwd: root, absolute: true });
+    // MARK: Routes priority order
+    const serverEntrypointsSorted = prepareSortableRoutes(serverEntrypoints)
+        .sort((a, b) => routeComparator(a, b))
+        .map((r) => r.route);
+    const serverPageClientAssets = await fastGlob([
+        //
+        'src/routes/**/*.{css,scss}',
+        'src/routes/**/*.client.{js,ts}',
+    ], { ignore: [], cwd: root, absolute: true });
+    logger.info(`\n${c.underline(`Found ${c.bold('routes')}`)}:\n` +
+        `${c.dim('- ')}${serverEntrypointsSorted
+            .map((f) => {
+            const pathParts = relative(join(root, 'src/routes'), f).split('/');
+            return pathParts
+                .map((part, index) => {
+                if (part.match(/\[\./))
+                    return c.cyan(c.italic(part));
+                if (part.match(/\[/))
+                    return c.cyan(part);
+                if (part.match(/\(/))
+                    return c.yellow(part);
+                if (index === pathParts.length - 1)
+                    return c.green(part);
+                return part;
+            })
+                .join(c.gray('/'));
+        })
+            .join(c.dim('\n- '))}\n`);
+    // MARK: Associate
+    serverEntrypointsSorted.forEach((filePath) => {
+        const routeWithPatterns = extractRoutePatterns(filePath);
+        routes.set(routeWithPatterns.patternString, {
+            filePath: paths.relativeToProject(filePath),
+            pattern: routeWithPatterns.pattern,
+            hasParams: routeWithPatterns.hasParams,
+            pageAssets: [],
+        });
+    });
+    serverPageClientAssets.forEach((filePath) => {
+        // NOTE: Exact extension needed client side by Vite.
+        const assetPathWithExt = paths.relativeToProject(filePath);
+        const associatedRoutePath = assetPathWithExt.replace(/\.(.*)$/, 
+        // FIXME: Don't need this anymore?
+        (_a, b) => `.${String(b)}`);
+        routes.forEach((route) => {
+            if (paths.removeAllExt(route.filePath) ===
+                paths.removeAllExt(associatedRoutePath))
+                route.pageAssets.push(assetPathWithExt);
+        });
+    });
+}

package/dist/routes/comparator.d.ts

@@ -0,0 +1,35 @@
+interface RoutePart {
+    content: string;
+    dynamic: boolean;
+    spread: boolean;
+    allDynamic: boolean;
+}
+export interface RouteCompareObject {
+    route: string;
+    segments: RoutePart[];
+}
+/**
+ * Comparator for sorting routes in resolution order.
+ *
+ * The routes are sorted in by the following rules in order, following the first rule that
+ * applies:
+ * - More specific routes are sorted before less specific routes. Here, "specific" means
+ *   the number of segments in the route, so a parent route is always sorted after its children.
+ *   For example, `/foo/bar` is sorted before `/foo`.
+ *   Index routes, originating from a file named `index.astro`, are considered to have one more
+ *   segment than the URL they represent.
+ * - Static routes are sorted before dynamic routes.
+ *   For example, `/foo/bar` is sorted before `/foo/[bar]`.
+ * - Dynamic routes with single parameters are sorted before dynamic routes with rest parameters.
+ *   For example, `/foo/[bar]` is sorted before `/foo/[...bar]`.
+ * - Prerendered routes are sorted before non-prerendered routes.
+ * - Endpoints are sorted before pages.
+ *   For example, a file `/foo.ts` is sorted before `/bar.astro`.
+ * - If both routes are equal regarding all previous conditions, they are sorted alphabetically.
+ *   For example, `/bar` is sorted before `/foo`.
+ *   The definition of "alphabetically" is dependent on the default locale of the running system.
+ */
+export declare function routeComparator(a: RouteCompareObject, b: RouteCompareObject): number;
+export declare function prepareSortableRoutes(routes: string[]): RouteCompareObject[];
+export {};
+//# sourceMappingURL=comparator.d.ts.map

package/dist/routes/comparator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"comparator.d.ts","sourceRoot":"","sources":["../../src/routes/comparator.ts"],"names":[],"mappings":"AAIA,UAAU,SAAS;IAClB,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,OAAO,CAAC;IACjB,MAAM,EAAE,OAAO,CAAC;IAEhB,UAAU,EAAE,OAAO,CAAC;CACpB;AAED,MAAM,WAAW,kBAAkB;IAClC,KAAK,EAAE,MAAM,CAAC;IACd,QAAQ,EAAE,SAAS,EAAE,CAAC;CACtB;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,eAAe,CAAC,CAAC,EAAE,kBAAkB,EAAE,CAAC,EAAE,kBAAkB,UA2F3E;AAED,wBAAgB,qBAAqB,CAAC,MAAM,EAAE,MAAM,EAAE,wBAuCrD"}

package/dist/routes/comparator.js

@@ -0,0 +1,132 @@
+// Sorting algorithm taken and adapted from https://github.com/withastro/astro/blob/f6bddd3a155cd10a9f85c92d43b1af8b74786a42/packages/astro/src/core/routing/priority.ts
+import { REGEXES } from './load-module.js';
+/**
+ * Comparator for sorting routes in resolution order.
+ *
+ * The routes are sorted in by the following rules in order, following the first rule that
+ * applies:
+ * - More specific routes are sorted before less specific routes. Here, "specific" means
+ *   the number of segments in the route, so a parent route is always sorted after its children.
+ *   For example, `/foo/bar` is sorted before `/foo`.
+ *   Index routes, originating from a file named `index.astro`, are considered to have one more
+ *   segment than the URL they represent.
+ * - Static routes are sorted before dynamic routes.
+ *   For example, `/foo/bar` is sorted before `/foo/[bar]`.
+ * - Dynamic routes with single parameters are sorted before dynamic routes with rest parameters.
+ *   For example, `/foo/[bar]` is sorted before `/foo/[...bar]`.
+ * - Prerendered routes are sorted before non-prerendered routes.
+ * - Endpoints are sorted before pages.
+ *   For example, a file `/foo.ts` is sorted before `/bar.astro`.
+ * - If both routes are equal regarding all previous conditions, they are sorted alphabetically.
+ *   For example, `/bar` is sorted before `/foo`.
+ *   The definition of "alphabetically" is dependent on the default locale of the running system.
+ */
+export function routeComparator(a, b) {
+    const commonLength = Math.min(a.segments.length, b.segments.length);
+    for (let index = 0; index < commonLength; index += 1) {
+        const aSegment = a.segments[index];
+        const bSegment = b.segments[index];
+        // if (index > commonLength - 3)
+        // 	console.log({
+        // 		// aAllDynamic,
+        // 		// bAllDynamic,
+        // 		aS: aSegment,
+        // 		bS: bSegment,
+        // 	});
+        const aIsStatic = !aSegment.dynamic && !aSegment.spread;
+        const bIsStatic = !bSegment.dynamic && !bSegment.spread;
+        if (aIsStatic && bIsStatic) {
+            // Both segments are static, they are sorted alphabetically if they are different
+            const aContent = aSegment.content;
+            const bContent = bSegment.content;
+            if (aContent !== bContent) {
+                return aContent.localeCompare(bContent);
+            }
+        }
+        // Sort static routes before dynamic routes
+        if (aIsStatic !== bIsStatic) {
+            return aIsStatic ? -1 : 1;
+        }
+        const aAllDynamic = aSegment.allDynamic;
+        const bAllDynamic = bSegment.allDynamic;
+        // Some route might have partial dynamic segments, e.g. game-[title].astro
+        // These routes should have higher priority against route that have **only** dynamic segments, e.g. [title].astro
+        if (aAllDynamic !== bAllDynamic) {
+            return aAllDynamic ? 1 : -1;
+        }
+        const aHasSpread = aSegment.spread;
+        const bHasSpread = bSegment.spread;
+        // Sort dynamic routes with rest parameters after dynamic routes with single parameters
+        // (also after static, but that is already covered by the previous condition)
+        if (aHasSpread !== bHasSpread) {
+            return aHasSpread ? 1 : -1;
+        }
+    }
+    const aLength = a.segments.length;
+    const bLength = b.segments.length;
+    if (aLength !== bLength) {
+        const aEndsInRest = a.segments.at(-1)?.spread;
+        const bEndsInRest = b.segments.at(-1)?.spread;
+        if (aEndsInRest !== bEndsInRest && Math.abs(aLength - bLength) === 1) {
+            // If only one of the routes ends in a rest parameter
+            // and the difference in length is exactly 1
+            // and the shorter route is the one that ends in a rest parameter
+            // the shorter route is considered more specific.
+            // I.e. `/foo` is considered more specific than `/foo/[...bar]`
+            if (aLength > bLength && aEndsInRest) {
+                // b: /foo
+                // a: /foo/[...bar]
+                return 1;
+            }
+            if (bLength > aLength && bEndsInRest) {
+                // a: /foo
+                // b: /foo/[...bar]
+                return -1;
+            }
+        }
+        // Sort routes by length
+        return aLength > bLength ? -1 : 1;
+    }
+    // NOTE: Might be used at some point for static endpoints etc.
+    // // Sort endpoints before pages
+    // if ((a.type === 'endpoint') !== (b.type === 'endpoint')) {
+    // 	return a.type === 'endpoint' ? -1 : 1;
+    // }
+    // Both routes have segments with the same properties
+    return a.route.localeCompare(b.route);
+}
+export function prepareSortableRoutes(routes) {
+    const routesParsed = routes.map((route) => {
+        const segments = route.split('/').map((part) => {
+            const segment = {
+                content: part,
+                dynamic: false,
+                spread: false,
+                allDynamic: false,
+            };
+            if (REGEXES.restWithExt.test(part)) {
+                segment.spread = true;
+            }
+            if (REGEXES.param.test(part)) {
+                segment.dynamic = true;
+            }
+            const params = part
+                .replace(/\.(js|ts)$/, '')
+                .split(REGEXES.dynamicSplit)
+                .filter((e) => e !== '');
+            if (params.length > 1) {
+                segment.allDynamic = false;
+            }
+            else if (params.length === 1) {
+                segment.allDynamic = true;
+            }
+            return segment;
+        });
+        // console.log({ segments });
+        return {
+            route,
+            segments,
+        };
+    });
+    return routesParsed;
+}

package/dist/routes/load-module.d.ts

@@ -0,0 +1,11 @@
+import type { ViteDevServer } from 'vite';
+import * as R from './route.js';
+export declare const REGEXES: {
+    param: RegExp;
+    rest: RegExp;
+    restWithExt: RegExp;
+    dynamicSplit: RegExp;
+    index: RegExp;
+};
+export declare function loadForeignRouteObject(vite: ViteDevServer, routePath: string): Promise<R.RouteModule>;
+//# sourceMappingURL=load-module.d.ts.map

package/dist/routes/load-module.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"load-module.d.ts","sourceRoot":"","sources":["../../src/routes/load-module.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,MAAM,CAAC;AAE1C,OAAO,KAAK,CAAC,MAAM,YAAY,CAAC;AAGhC,eAAO,MAAM,OAAO;;;;;;CASnB,CAAC;AAEF,wBAAsB,sBAAsB,CAC3C,IAAI,EAAE,aAAa,EACnB,SAAS,EAAE,MAAM,0BAiBjB"}

package/dist/routes/load-module.js

@@ -0,0 +1,23 @@
+import * as R from './route.js';
+// const ROUTE_SPREAD = /^\.{3}.+$/;
+export const REGEXES = {
+    //
+    param: /\[(.*?)\]/,
+    rest: /^\[\.\.\.(.*)\]$/,
+    restWithExt: /^\[\.\.\.(.*)\]\.[j|t]s$/,
+    dynamicSplit: /\[(.+?\(.+?\)|.+?)\]/,
+    // index: /^(index\.(js|ts)|\((.*)\)\.(js|ts))$/,
+    index: /\((.*)\)/,
+};
+export async function loadForeignRouteObject(vite, routePath) {
+    // NOTE: Check and assert unknown userland module to correct RouteModule instance (in the engine's realm)
+    const rm = await vite.ssrLoadModule(routePath);
+    const routeModuleFactory = rm['default'];
+    const errorBase = `Incorrect route module ${routePath}!`;
+    if (typeof routeModuleFactory !== 'function')
+        throw new Error(`${errorBase} Not a function.`);
+    const routeModule = routeModuleFactory(R.RouteModule);
+    if (routeModule instanceof R.RouteModule === false)
+        throw new Error(`${errorBase} Not a RouteModule.`);
+    return routeModule;
+}

package/dist/routes/match.d.ts

@@ -0,0 +1,16 @@
+import type { ViteDevServer } from 'vite';
+import * as R from './route.js';
+type Params = Record<string, string | undefined>;
+export type RouteInfos = {
+    params: Params;
+    props: unknown;
+    routeModule: Readonly<R.RouteModule>;
+    foundRoute: R.Route;
+    pathname: string;
+};
+export declare function getRoute(options: {
+    url: string;
+    vite: ViteDevServer;
+}): Promise<RouteInfos>;
+export {};
+//# sourceMappingURL=match.d.ts.map

package/dist/routes/match.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"match.d.ts","sourceRoot":"","sources":["../../src/routes/match.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,MAAM,CAAC;AAI1C,OAAO,KAAK,CAAC,MAAM,YAAY,CAAC;AAEhC,KAAK,MAAM,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,CAAC,CAAC;AA+EjD,MAAM,MAAM,UAAU,GAAG;IACxB,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,EAAE,OAAO,CAAC;IACf,WAAW,EAAE,QAAQ,CAAC,CAAC,CAAC,WAAW,CAAC,CAAC;IACrC,UAAU,EAAE,CAAC,CAAC,KAAK,CAAC;IACpB,QAAQ,EAAE,MAAM,CAAC;CACjB,CAAC;AACF,wBAAsB,QAAQ,CAAC,OAAO,EAAE;IACvC,GAAG,EAAE,MAAM,CAAC;IACZ,IAAI,EAAE,aAAa,CAAC;CACpB,GAAG,OAAO,CAAC,UAAU,CAAC,CAqBtB"}

package/dist/routes/match.js

@@ -0,0 +1,63 @@
+import { routes } from './collect.js';
+import { loadForeignRouteObject } from './load-module.js';
+import * as R from './route.js';
+function matchRouteFromUrl(url) {
+    let match;
+    let foundRoute;
+    const pathname = new URL(url).pathname;
+    // eslint-disable-next-line no-restricted-syntax
+    for (const [, route] of routes) {
+        if (match)
+            break;
+        const matchResult = route.pattern.exec(`http://gracile${pathname}`) || undefined;
+        if (matchResult) {
+            match = matchResult;
+            foundRoute = route;
+        }
+    }
+    if (!match || !foundRoute)
+        throw new Error(`No route matching for ${url}`, { cause: 404 });
+    const params = match.pathname?.groups;
+    return { match, foundRoute, params, pathname };
+}
+function extractStaticPaths(options) {
+    if (!options.foundRoute.hasParams)
+        return null;
+    if (!options.routeModule.staticPaths)
+        return null;
+    const routeStaticPaths = options.routeModule.staticPaths;
+    let props;
+    const staticPaths = routeStaticPaths();
+    let hasCorrectParams = false;
+    staticPaths.forEach((providedRouteOptions) => {
+        const routeOptions = providedRouteOptions;
+        const matchingKeys = Object.entries(routeOptions.params).filter(([key, val]) => options.params[key] === val);
+        if (matchingKeys.length === Object.keys(options.params).length) {
+            hasCorrectParams = true;
+            if (routeOptions.props)
+                props = routeOptions.props;
+        }
+    });
+    if (hasCorrectParams === false)
+        throw new Error(`Incorrect route parameters for \`${options.pathname}\`.\n` +
+            `Check \`staticPaths\` for \`${options.foundRoute.filePath}\`.`);
+    return { staticPaths, props };
+}
+export async function getRoute(options) {
+    const { foundRoute, pathname, params } = matchRouteFromUrl(options.url);
+    const routePath = foundRoute.filePath;
+    const routeModule = await loadForeignRouteObject(options.vite, routePath);
+    const staticPaths = extractStaticPaths({
+        routeModule,
+        foundRoute,
+        pathname,
+        params,
+    });
+    return {
+        params,
+        props: staticPaths?.props,
+        routeModule,
+        foundRoute,
+        pathname,
+    };
+}

package/dist/routes/route.d.ts

@@ -0,0 +1,63 @@
+import type { ServerRenderedTemplate } from '@lit-labs/ssr';
+import type { TemplateResult } from 'lit';
+export type MethodHtml = 'GET' | 'POST';
+export type MethodNonHtml = 'QUERY' | 'PUT' | 'PATCH' | 'DELETE';
+export type Method = MethodHtml & MethodNonHtml;
+export type ModuleOptions = {
+    staticPaths?: StaticPathsGeneric;
+    handler?: HandlerGeneric;
+    template?: (context: RouteContextGeneric) => RouteTemplateResult;
+    document?: DocumentTemplate<RouteContextGeneric>;
+};
+export declare class RouteModule {
+    #private;
+    get staticPaths(): StaticPathsGeneric | undefined;
+    get handler(): Handler<object | Response | undefined> | Partial<Record<MethodHtml, Handler<object | Response | undefined>> & Record<MethodNonHtml, Handler<Response>>> | undefined;
+    get document(): DocumentTemplate<RouteContextGeneric> | undefined;
+    get template(): ((context: RouteContextGeneric) => RouteTemplateResult) | undefined;
+    constructor(options: ModuleOptions);
+}
+export type Params = Record<string, string | undefined>;
+export type Handler<Data extends HandlerData | HandlerDataHtml = never> = (context: {
+    url: URL;
+    /**
+     * Parameters from dynamic route.
+     *
+     * E.g. `src/routes/foo/[bar]/[baz].ts` -\> `{ bar: string; baz: string; }`
+     */
+    params: Params;
+    request: Request;
+    /**
+     * Let you mutate the downstream **page** response.
+     *
+     * It doesn't take effect if you're returning the
+     * response yourself before (within your request handler).
+     * */
+    response: ResponseInit;
+}) => MaybePromise<Data> | MaybePromise<void>;
+export type HandlerGeneric = Handler<HandlerData | HandlerDataHtml> | Partial<Record<MethodHtml, Handler<HandlerData | HandlerDataHtml>> & Record<MethodNonHtml, Handler<Response>>>;
+export type StaticPathsGeneric = () => StaticPathOptionsGeneric[];
+export type HandlerData = Response | undefined;
+export type HandlerDataHtml = HandlerData | object;
+export type StaticPathOptionsGeneric = {
+    params: Params;
+    props: unknown;
+};
+export type MaybePromise<T> = Promise<T> | T;
+export type StaticRequest = Pick<Request, 'url'>;
+export type RouteContextGeneric = {
+    url: URL;
+    params: Params;
+    props: unknown;
+};
+export type DocumentResult = MaybePromise<ServerRenderedTemplate>;
+export type RouteTemplateResult = MaybePromise<TemplateResult<1> | ServerRenderedTemplate>;
+export type DocumentTemplate<RouteContext extends RouteContextGeneric = RouteContextGeneric> = (context: RouteContext) => DocumentResult;
+export type BodyTemplate<RouteContext> = (context: RouteContext) => RouteTemplateResult;
+export interface Route {
+    filePath: string;
+    pattern: URLPattern;
+    hasParams: boolean;
+    pageAssets: string[];
+}
+//# sourceMappingURL=route.d.ts.map

package/dist/routes/route.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"route.d.ts","sourceRoot":"","sources":["../../src/routes/route.ts"],"names":[],"mappings":"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"}

package/dist/routes/route.js

@@ -0,0 +1,32 @@
+// TODO: put in engine
+export class RouteModule {
+    #staticPaths;
+    get staticPaths() {
+        return this.#staticPaths;
+    }
+    #handler;
+    get handler() {
+        return this.#handler;
+    }
+    #document;
+    get document() {
+        return this.#document;
+    }
+    #template;
+    get template() {
+        return this.#template;
+    }
+    constructor(options) {
+        if (typeof options.staticPaths === 'function')
+            this.#staticPaths = options.staticPaths;
+        if ((typeof options.handler === 'object' ||
+            typeof options.handler === 'function') &&
+            options.handler)
+            this.#handler = options.handler;
+        // if (options.fragment) this.#fragment = options.fragment;
+        if (typeof options.template === 'function')
+            this.#template = options.template;
+        if (typeof options.document === 'function')
+            this.#document = options.document;
+    }
+}