htmx-router 0.1.3 → 1.0.0-alpha.0

package/readme.md

@@ -1,279 +1,217 @@
-# htmX Router
-
-> A [remix.js](https://remix.run/docs/en/main/guides/routing) style file path router for htmX websites
-
-This library attempts to be as unopinionated as possible allowing for multiple escape hatches in-case there are certain times you want a different style of behaviour.
-
-This library does not rely on any heavy weight dependencies such as react, instead opting to be built on the lighter weight [typed-html](https://www.npmjs.com/package/typed-html) library for it's JSX rendering, and using [csstype](https://www.npmjs.com/package/csstype), just as a type interface to improve developer ergonomics.
+# htmx Router
+
+A simple file based router with support for dynamic + client islands, route-less endpoints, and built in CSS sheet generation.
+
+- [htmx Router](#htmx-router)
+	- [Setup](#setup)
+	- [Routing](#routing)
+		- [Route Module](#route-module)
+		- [Nested Route Rendering](#nested-route-rendering)
+		- [JSX Rendering](#jsx-rendering)
+	- [Route Contexts](#route-contexts)
+		- [Params](#params)
+		- [Cookies](#cookies)
+		- [Headers](#headers)
+		- [Request](#request)
+		- [URL](#url)
+	- [Style Sheets](#style-sheets)
+	- [Route-less Endpoint](#route-less-endpoint)
+	- [Islands](#islands)
+		- [Dynamic](#dynamic)
+		- [Client](#client)
+
+
+## Setup
+
+Create a `htmx-router.json` in the root of your project defining where you want your router file to be placed, and where your routes are.
+You can also define where you want to create your client component bindings, and for what target framework.
+```json
+{
+	"router": {
+		"folder": "./source/routes",
+		"output": "./source/router.tsx"
+	},
+	"client": {
+		"adapter": "react",
+		"source": "./source/client.tsx"
+	}
+}
+```
 
-You can also see an example site running this library [here](https://github.com/AjaniBilby/predictable) with source code as an extra helpful example. Please be mindful the slow loading of this site is actually due to Discord APIs, and the rendering is taking less than 2ms on a raspberry pi on my floor.
+Once you have done this, run `npx htmx-router` to generate the artifacts to start development.
+We recommand you copy the setup from `examples/react` for your `server.js`, `entry.server.ts`, and `entry.client.ts`.
 
-- [htmX Router](#htmx-router)
-  - [Routes](#routes)
-    - [Module Layout](#module-layout)
-      - [Auth Function](#auth-function)
-      - [Render Function](#render-function)
-      - [CatchError Function](#catcherror-function)
-  - [Router](#router)
-  - [Types](#types)
-    - [RenderArgs](#renderargs)
-      - [Outlet](#outlet)
-      - [setTitle](#settitle)
-      - [addMeta](#addmeta)
-      - [addLinks](#addlinks)
-      - [renderHeadHTML](#renderheadhtml)
-      - [shared](#shared)
-    - [ErrorResponse](#errorresponse)
-    - [Override](#override)
-    - [Redirect](#redirect)
-  - [Components](#components)
-    - [Link](#link)
-  - [StyleCSS](#stylecss)
+Don't forget that in all rendered routes you must include the `<RouterHeader/>` component in your head for hydration and `StyleClass`s to apply affectively.
 
-## Routes
 
-There are two requirements for this package behave correctly, you need a `root.jsx`/`.tsx`, in the same folder as a `routes` sub-folder. Plus any given route **must** have use the `route name` provided as the top element's `id` - which will be explained more in later.
+## Routing
 
-URLs are resolved based on the file structure of yur `routes` folder, you can choose to use nested folders or `.`s to have all of your files in a single folder if you choose - all examples will use the `.` layout for simplicity.
+Routing applies in a depth first order, where it will match in order:
+  1. The `_index`
+  2. Static sub-routes
+  3. Url path-param wildcards
+  4. Catchall slug
 
-If the url path `/user/1234/history` is requested, the router will create an outlet chain to your file tree (*this chain is actually just an array of modules, and the library works based on stack operations to reduce recursion and increase response times*).
+This allows for easy overriding and fallback behaviour. For instance with the routes.
 ```
-root.tsx
-routes
-├── _index.tsx
-├── user.tsx
-├── user.static-path.tsx
-└── user.$userID.tsx
+/user/$id.tsx
+/user/me.tsx
+/user/$.tsx
 ```
 
-Given the file tree above, when the root function calls it's [Outlet](#outlet) function, that will trigger `user` to render, and when user calls it's [Outlet](#outlet) function, that will trigger `user.$userID.tsx` to render as this sub route didn't match with any of the static options available, so instead it matched with the wild card route.
-
-Since there is no `user.$userID.history.tsx` file, if `user.$userID.tsx` calls [Outlet](#outlet) it will trigger a 404 error, which is actually generated by an internal hidden route placed at the end of an Outlet chain when it is not able to match the rest of a given URL.
-
-If we request `/user`, the root route will render, and the `user.tsx` route will render, with `user.tsx`'s [Outlet](#outlet) function actually returning a blank string. If we instead want this request to throw an error we should add a `user._index.tsx` file which on render always throws a `ErrorResponse`.
-
-### Module Layout
+It will match on the `/user/me` route if applicable, and otherwise will fallback to attempt to match on `/user/$id`, and if the wildcard route fails, it will try the generic slug route `/user/$.tsx`.
 
-The router will look for three functions when reading a module, [Render](#render), [CatchError](#catcherror), and [Auth](#auth). Any combination of all or none of these functions are allowed, with the only exception being your `root.tsx` which must have a [Render](#render) and a [CatchError](#catcherror) function.
+If a route returns `null` the router will continue the depth first search, allowing for dynamic flow through of the routes.
 
-#### Auth Function
+### Route Module
 
-```ts
-export async function Auth({shared}: RenderArgs) {
-	if (!shared.auth?.isAdmin) throw new ErrorResponse(401, 'Unauthorised', "Unauthorised Access");
-	return;
-}
+A route module must define a `parameters` export, which defines how the url path params should be parsed when attempting to match the route.
+You can use any function which takes a string, and returns something as the parser. You can also simply use JS-Builtin functions for this, and there is a special case with the `Number` function so it will reject on `NaN` values.
+```js
+export const parameters = { id: Number };
 ```
 
-This function is ran on all routes resolved by this file, and it's child routes - no matter if the route itself is masked or not rendered. This function must return nothing, and instead signals failure via throwing an error. With the successful case being nothing was thrown.
-
-#### Render Function
-
+A route can additionally define a loader, which is called on `GET` and `HEAD` requests
 ```ts
-export async function Render(routeName: string, {}: RenderArgs): Promise<string>
+export async function loader({}: RouteContext<typeof parameters>);
 ```
 
-The render function should follow the above function signature, the routeName string must be consumed if you're rendering a valid output, with the top most HTML element having the id assigned to this value. This helps the router dynamically insert new routes when using the [Link](#link) component.
-
-> **Note** that a render function may not always run for a given request, and may sometimes be ommited when the router determines the client already has this information in their DOM, and instead only response with the new data and where it should be inserted.
->
-> For authorisation checks which must always run for a given URL, please use the [Auth](#auth) function
-
-Optionally this function can also `throw`, in this case the thrown value will boil up until it hits a [CatchError](#catcherror), unless it throws certain types from this library such as `Redirect` or `Override` which will boil all the way to the top without triggering any [CatchError](#catcherror) functions.
-
-This allows a given route to return an arbitrary response without being nested within it's parent routes.
-
-#### CatchError Function
-
+With the `action` function being called for all other methods
 ```ts
-export async function CatchError(rn: string, {}: RenderArgs, e: ErrorResponse): Promise<string>
-```
-
-This function behaves almost identically to [Render](#render) in the way that it's results will be embed within it's parents unless an `Override` is thrown, and it takes a `routeName` which must be used in the root `HTML` element as the id. And it is given [RenderArgs](#renderargs).
-
-However this function **must not** call the [Outlet](#outlet) function within the [RenderArgs](#renderargs), as that will attempt to consume a failed child route as it's result.
-
-## Router
-
-The router itself can be generated via two different ways through the CLI from this library, dynamically or statically.
-
-```bash
-npx htmx-router ./source/website --dynamic
+export async function action({}: RouteContext<typeof parameters>);
 ```
 
-When the command is ran it will generate a router based on the directory provided which should contain your root file and routes folder. This command will generate a `router.ts` which we recommend you git ignore from your project.
-
-- **Static**: The static build will read your directories and statically import all of your routes into itself, allowing for easy bundling with tools such as `esbuild`
-- **Dynamic**: Will instead generate a file will on startup will read your directory every time, and dynamically import your routes, which will make it unsuitable for use with webpackers, but allows for quick revisions and working well with tools such as `nodemon`.
-
-
-Once your router is generated you can simply import it and use it like the example below:
+If any value is thrown by the parameter parsing, or the render functions (`loader`/`action`) it will boil up, attempting first to call an error function is supplied in the route, and otherwise boiling up to the nearest slug route's `error` function.
 ```ts
-const url = new URL(req.url || "/", "http://localhost");
-const out = await Router.render(req, res, url);
-if (out instanceof Redirect) {
-	res.statusCode = 302;
-	res.setHeader('Location', out.location);
-	return res.end();
-} else if (out instanceof Override) {
-	res.end(out.data);
-} else {
-	res.setHeader('Content-Type', 'text/html; charset=UTF-8');
-	res.end("<!DOCTYPE html>"+out);
-}
+export async function error(ctx: GenericContext, error: unknown);
 ```
 
-The `Router.render` function may output three possible types [Redirect](#redirect), [Override](#override), or a simple string. These two non-string types are to allow the boil up of overrides within routes, and allows you do handle them specific to your server environment.
+### Nested Route Rendering
 
-## Types
+The router will not do nested layouts, if that behaviour is required we recommend using the slug-shell pattern.
+Where you define a slug route, and export a `shell` function which takes the `JSX` rendered result from the sub route, and renders the upper route around it.
 
-### RenderArgs
+This allows flexibility at runtime on how nested route rendering behaves, and can also allow you to ensure you are not reloading data from the db which is already loaded by a sub-route based on how you parse up data through your slug shells.
 
-This class has been designed to work well with object unpacking for ease of use, typically it's used in a style like this for routes that only need information about the `req` and `res` objects.
+We recommend you look at [Predictable Bot](https://github.com/AjaniBilby/predictable) as an example of this pattern performed simply.
 
-```ts
-export async function Render(rn: string, {req, res}: RenderArgs) {
-  return "Hello World";
-}
-```
 
-However it also includes a bunch of functions to help with higher order features.
+### JSX Rendering
 
-#### Outlet
+htmx-router is jsx templating agnostic for SSR, instead only requiring a definition provided when creating your request handler, allowing you to BYO JSX templating.
+```js
+// @kitajs/html
+app.use('*', createRequestHandler.http({
+	build,
+	viteDevServer,
+	render: (res) => {
+		const headers = new Headers();
+		headers.set("Content-Type", "text/html; charset=UTF-8");
+		return new Response(String(res), { headers });
+	}
+}));
 
-The outlet function will call the child route to render, this function is asynchronous and will always return a string, or else it will throw. If there is nothing left in the outlet chain, it will return an empty string.
+// React
+app.use('*', createRequestHandler.http({
+	build,
+	viteDevServer,
+	render: (res) => {
+		const headers = new Headers();
+		headers.set("Content-Type", "text/html; charset=UTF-8");
+		return new Response(renderToString(res), { headers });
+	}
+}));
+```
 
-#### setTitle
+## Route Contexts
 
-This function will update the title that will be generated by the [renderHeadHTML](#renderheadhtml) function, as well as the trigger value for the title updater when using the [Link](#link) component.
+There are two kinds of route context, the `RouteContext<T>` which is the resolved route with parameterization, and the `GenericContext` which is used by error functions, and dynamic loads.
 
-You should consider when you call this function in conjunction to your [Outlet](#outlet) function, because if you run setTitle, after the outlet has been called it will override the title set by the child.
+### Params
 
-```tsx
-export async function Render(rn: string, {setTitle, Outlet}: RenderArgs) {
-	setTitle("Admin Panel");
-
-	return <div id={rn}>
-		<h1><Link to="/admin" style="color: inherit">
-			Admin Panel
-		</Link></h1>
-		{await Outlet()}
-	</div>;
-}
-```
+In the `GenericContext` this will simply be an object with string key value pairs for the parameters, and only the `RouteContext<T>` for `loader` and `action` will have the parameters pre-parsed by your `parameters` definition.
 
-#### addMeta
+### Cookies
 
-This function allows you to add meta tags which will be rendered by the [renderHeadHTML](#renderheadhtml) function.
-```ts
-addMeta([
-	{ property: "og:title", content: `${guild.name} - Predictions` },
-	{ property: "og:image", content: banner }
-], true);
-```
+The `RouteContext` and `GenericContext`s both provide a `cookie` object, with the cookie's pre-parsed from the request headers.
+It also has a built in `set(name, value, options)` function which will add the appropriate headers to the response for the cookie changes.
 
-If the second argument of this function is set to `true` this function will override any meta tags currently set, replacing them with the inputted tags instead.
+### Headers
 
-#### addLinks
+This is a header object useful for adding response headers when you haven't fully finished generating your response yet.
+These headers will merge with the response object created by the provided `render` function, with response headers overriding any conflicting `ctx.headers` values.
 
-This function behaves identically to [addMeta](#addmeta) but instead designed for link tags.
+### Request
 
-#### renderHeadHTML
+This is the original request object, including request headers.
 
-This renders out the set meta and link tags for use in the `root.tsx` module, it also includes an embed script for updating the title for dynamic loads from the [Link](#link) component.
+### URL
 
-#### shared
+The parsed `URL` object of the incoming request.
 
-There is also a blank object attached to all [RenderArgs](#renderargs) for sharing information between routes.
+## Style Sheets
 
-This can be used for various purposes, but one example is to hold onto decoded cookie values so that each session doesn't need to recompute them if they already have.
+htmx-router includes a `StyleClass` object, which can be used to define CSS classes without needing a unique name.
+StyleClasses should only be defined at the top level of a file, and not created within a function, or dynamically during runtime.
 
-Such an example would look like this
 ```ts
-import type { IncomingMessage } from "node:http";
-import * as cookie from "cookie";
-
-export function GetCookies(req: IncomingMessage, shared: any): Record<string, string> {
-	if (shared.cookie) return shared.cookie;
-
-	shared.cookies = cookie.parse(req.headers.cookie || "");
-	return shared.cookies;
+const myClass = new StyleClass(`myClass`, `
+.this:hover {
+	background-color: red;
 }
+`).name;
 ```
 
-```ts
-import type { GetCookies } from "../shared/cookie.ts";
+## Route-less Endpoint
 
-export function GetCookies(rn: string, {shared}: RenderArgs) {
-	const cookies = GetCookies(shared);
-  // do stuff....
-}
+This should be defined at the top level of your file, these endpoints can optionally be given an name which will help for debugging network requests, but they do not need to be unique.
+```ts
+const endpoint_url = new Endpoint((ctx: GenericContext) => {
+	return new Response("Hello World");
+}, "hello-world").url;
 ```
 
-### ErrorResponse
+## Islands
 
-This class is a way of HTTP-ifying error objects, and other error states, if an error is thrown by a [Render](#render) or an [Auth](#auth) function that isn't already wrapped by this type, the error will then become wrapped by this type.
+> Tip: Don't forget to wrap your islands in a hx-preserve to prevent losing state. And use `display: contents;` to make that wrapping div transparent for grid and other layout features.
 
-```ts
-export class ErrorResponse {
-	code   : number;
-	status : string;
-	data   : any;
-}
-```
+### Dynamic
 
-### Override
+A dynamic component takes params which will be converted into the props of the loader function, these props may only be string key string value pairs as they are encoded the the query string to allow for browser side caching.
 
-If a render function throws a value of this type, it will boil all the way up to the original render call allowing it to bypass any parent manipulation.
+The body of a dynamic component is the pre-rendered infill that will display while the client is loading the dynamic content.
 
-```ts
-export class Override {
-	data : string | Buffer | Uint8Array;
-}
-```
+```tsx
+async function MyProfile(params: {}, ctx: GenericContext): Promise<JSX.Element> {
+	ctx.headers.set('Cache-Control', "private, max-age=120");
+	const userID = ctx.cookie.get('userID');
+	if (!userID) return <></>;
 
-### Redirect
+	const user = await GetUser(userID);
+	if (!user) return <></>;
 
-This type behaves identically to override by is intended for boiling up specifically http redirect responses.
+	return <a href={`/user/${userID}`}>
+		<div safe>{user.name}</div>
+	</a>
+}
 
-```ts
-export class Redirect {
-	location: string;
+export async function loader({ params }: RouteContext<typeof parameters>) {
+	return <Dynamic params={{}} loader={MyProfile}>
+		put your ssr pre-rendered skeleton here
+	</Dynamic>
 }
 ```
 
-## Components
+### Client
 
-### Link
+Import all of the components you want to be able to use on the client side into your `client.tsx`, if you are running a dev server this file will automatically generate the clientized version, otherwise use the `npx htmx-router` command to regenerate these artifacts.
+
+Once a component has been clientized you can import it as use it like normal, however the body is now overwritten to it will render immediately on the server, and then all props will parsed to the client for it to be rendered properly in the browser.
 
-```ts
-export function Link(props: {
-	to: string,
-	target?: string,
-	style?: string
-}, contents: string[])
-```
 ```tsx
-<Link to={`/user/${id}`}>View Profile</Link>
+<Client.Counter>
+	<button>No yet hydrated...</button> {/* this will be overwritten in the browser once hydrated */}
+</Client.Counter>
 ```
 
-This component overrides a normal `<a>`, adding extra headers telling the server route it is coming from, based on this information the server can determine the minimal route that needs to be rendered to send back to the client and calculates just that sub route.
-
-Sending it back to the client telling htmX where to insert the new content.
-
-This element will encode as a standard `<a>` with some extra html attributes, meaning it won't affect SEO and bots attempting to scrape your website.
-
-
-## StyleCSS
-
-This is a helper function allowing you to give it a [CSS.Properties](https://www.npmjs.com/package/csstype) type, and render it into a string for [typed-html](https://www.npmjs.com/package/typed-html) to use.
-```tsx
-<div style={StyleCSS({
-  height: "100%",
-  width: "100%",
-  fontWeight: "bold",
-  fontSize: "5em",
-})}>
-  I AM BIG
-</div>
-```
+It is very important that you ensure your `Client` component has a single child element, if there are multiple child components the browser will only mount to the last child causing artifacting.

package/bin/404-route.d.ts

@@ -1,2 +0,0 @@
-import { RenderArgs } from "./render-args";
-export declare function Render(rn: string, { req }: RenderArgs): Promise<string>;

package/bin/404-route.js

@@ -1,8 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Render = void 0;
-const shared_1 = require("./shared");
-async function Render(rn, { req }) {
-    throw new shared_1.ErrorResponse(404, "Resource Not Found", req.url || "/");
-}
-exports.Render = Render;

package/bin/cli/dynamic.d.ts

@@ -1,2 +0,0 @@
-#!/usr/bin/env node
-export declare function BuildDynamic(cwd: string): void;

package/bin/cli/dynamic.js

@@ -1,47 +0,0 @@
-#!/usr/bin/env node
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.BuildDynamic = void 0;
-const fs_1 = require("fs");
-function BuildDynamic(cwd) {
-    const rootMatcher = new RegExp(/^root\.(j|t)sx?$/);
-    const root = (0, fs_1.readdirSync)(cwd)
-        .filter(x => rootMatcher.test(x))[0];
-    if (!root) {
-        console.log(`Missing root.jsx/tsx`);
-        process.exit(1);
-    }
-    let script = `import { RouteTree, IsAllowedExt } from "htmx-router";\n`;
-    script +=
-        `import { readdirSync } from "fs";
-import { extname, join, relative, resolve } from "path";
-
-function readDirRecursively(dir: string) {
-	const files = readdirSync(dir, { withFileTypes: true });
-
-	let filePaths: string[] = [];
-	for (const file of files) {
-		if (file.isDirectory()) {
-			filePaths = [...filePaths, ...readDirRecursively(join(dir, file.name))];
-		} else {
-			filePaths.push(join(dir, file.name));
-		}
-	}
-
-	return filePaths;
-}\n`;
-    script += `\nexport const Router = new RouteTree();\n`;
-    script += `import * as RootRoute from "./root";\n`;
-    script += `Router.assignRoot(RootRoute);\n\n`;
-    script += "const ctx = resolve(`${__dirname}/routes`);\n";
-    script += "const files = readDirRecursively(ctx);\n";
-    script += "for (const file of files){\n";
-    script += "\tconst ext = extname(file);\n";
-    script += "\tif (!IsAllowedExt(ext)) continue;\n";
-    script += "\tconst url = relative(ctx, file.slice(0, file.lastIndexOf(\".\")).replace(/\\\\/g, \"/\"));\n";
-    script += `\timport(file).then((mod) => Router.ingest(url, mod, [false]));\n`;
-    script += "}\n";
-    (0, fs_1.writeFileSync)(`${cwd}/router.ts`, script);
-    console.log(`Finished Building`);
-}
-exports.BuildDynamic = BuildDynamic;

package/bin/cli/static.d.ts

@@ -1,2 +0,0 @@
-#!/usr/bin/env node
-export declare function BuildStatic(cwd: string): void;

package/bin/cli/static.js

@@ -1,49 +0,0 @@
-#!/usr/bin/env node
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.BuildStatic = void 0;
-const fs_1 = require("fs");
-const path_1 = require("path");
-const router_1 = require("../router");
-function readDirRecursively(dir) {
-    const files = (0, fs_1.readdirSync)(dir, { withFileTypes: true });
-    let filePaths = [];
-    for (const file of files) {
-        if (file.isDirectory()) {
-            filePaths = [...filePaths, ...readDirRecursively((0, path_1.join)(dir, file.name))];
-        }
-        else {
-            filePaths.push((0, path_1.join)(dir, file.name));
-        }
-    }
-    return filePaths;
-}
-function BuildStatic(cwd) {
-    const rootMatcher = new RegExp(/^root\.(j|t)sx?$/);
-    const root = (0, fs_1.readdirSync)(cwd)
-        .filter(x => rootMatcher.test(x))[0];
-    if (!root) {
-        console.log(`Missing root.jsx/tsx`);
-        process.exit(1);
-    }
-    const DIR = './routes';
-    const files = readDirRecursively(`${cwd}/routes`)
-        .filter(x => (0, router_1.IsAllowedExt)((0, path_1.extname)(x)))
-        .map(x => (0, path_1.relative)(cwd, x.slice(0, x.lastIndexOf("."))).replace(/\\/g, "/"))
-        .sort();
-    let script = `import { RouteTree } from "htmx-router";\n`;
-    for (let i = 0; i < files.length; i++) {
-        const file = files[i];
-        script += `import * as Route${i} from "./${file}";\n`;
-    }
-    script += `import * as RootRoute from "./root";\n`;
-    script += `\nexport const Router = new RouteTree();\n`;
-    for (let i = 0; i < files.length; i++) {
-        const file = files[i];
-        script += `Router.ingest("${file.slice(DIR.length - 1)}", Route${i}, [false]);\n`;
-    }
-    script += `Router.assignRoot(RootRoute);\n`;
-    (0, fs_1.writeFileSync)(`${cwd}/router.ts`, script);
-    console.log(`Build with routes;\n` + files.map(x => `  - ${x}`).join("\n"));
-}
-exports.BuildStatic = BuildStatic;

package/bin/components.d.ts

@@ -1,6 +0,0 @@
-export declare function Link(props: {
-    to: string;
-    class?: string;
-    target?: string;
-    style?: string;
-}, contents: string[]): string;

package/bin/components.js

@@ -1,31 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Link = void 0;
-const elements = __importStar(require("typed-html"));
-function Link(props, contents) {
-    return elements.createElement("a", { target: props.target || "", class: props.class || "", style: props.style || "", href: props.to, "hx-get": props.to, "hx-headers": '{"Cache-Control": "no-cache"}' }, contents);
-}
-exports.Link = Link;

package/bin/render-args.d.ts

@@ -1,35 +0,0 @@
-/// <reference types="node" />
-import type http from "node:http";
-import { RouteLeaf } from "./router";
-type MetaHTML = {
-    [key: string]: string;
-};
-export declare enum MaskType {
-    show = 0,
-    headless = 1,
-    hide = 2
-}
-export declare class RenderArgs {
-    req: http.IncomingMessage;
-    res: http.ServerResponse;
-    title: string;
-    params: MetaHTML;
-    url: URL;
-    shared: {
-        [key: string]: any;
-    };
-    links: MetaHTML[];
-    meta: MetaHTML[];
-    _outletChain: RouteLeaf[];
-    _maskChain: MaskType[];
-    _maxChain: number;
-    constructor(req: http.IncomingMessage, res: http.ServerResponse, url: URL);
-    setTitle: (value: string) => void;
-    addLinks: (links: MetaHTML[], override?: boolean) => void;
-    addMeta: (links: MetaHTML[], override?: boolean) => void;
-    Outlet: () => Promise<string>;
-    _addOutlet(route: RouteLeaf): void;
-    _applyMask(mask: boolean[], depth: number): void;
-    renderHeadHTML: () => string;
-}
-export {};