waymark 0.1.1 → 0.2.0

package/dist/index.d.ts

@@ -1,4 +1,196 @@
-export * from "./route";
-export * from "./router";
-export * from "./react";
-export * from "./utils/router";
+import * as react2 from "react";
+import { AnchorHTMLAttributes, CSSProperties, ComponentType, ReactNode, RefAttributes } from "react";
+import * as regexparam0 from "regexparam";
+import * as type_fest0 from "type-fest";
+import { EmptyObject } from "type-fest";
+import { StandardSchemaV1 } from "@standard-schema/spec";
+
+//#region src/utils/types.d.ts
+type NormalizePath<P extends string> = RemoveTrailingSlash<DedupSlashes<`/${P}`>>;
+type DedupSlashes<P extends string> = P extends `${infer Prefix}//${infer Rest}` ? `${Prefix}${DedupSlashes<`/${Rest}`>}` : P;
+type RemoveTrailingSlash<P extends string> = P extends `${infer Prefix}/` ? Prefix extends "" ? "/" : Prefix : P;
+type MaybeKey<K extends string, T> = T extends EmptyObject ? { [P in K]?: EmptyObject } : {} extends T ? { [P in K]?: T } : { [P in K]: T };
+//#endregion
+//#region src/types.d.ts
+interface Register {}
+type RouteList = Register extends {
+  routes: infer RouteList extends ReadonlyArray<Route>;
+} ? RouteList : ReadonlyArray<Route>;
+type Handle = Register extends {
+  handle: infer Handle;
+} ? Handle : any;
+type Pattern = RouteList[number]["pattern"];
+type GetRoute<P extends Pattern> = Extract<RouteList[number], {
+  pattern: P;
+}>;
+type Params<P extends Pattern> = NonNullable<GetRoute<P>["_"]["_params"]>;
+type Search<P extends Pattern> = NonNullable<GetRoute<P>["_"]["_search"]>;
+type MatchOptions<P extends Pattern> = {
+  from: P | GetRoute<P>;
+  strict?: boolean;
+  params?: Partial<Params<P>>;
+};
+type Match<P extends Pattern = Pattern> = {
+  route: GetRoute<P>;
+  params: Params<P>;
+};
+type NavigateOptions<P extends Pattern> = {
+  to: P | GetRoute<P>;
+  replace?: boolean;
+  state?: any;
+} & MaybeKey<"params", Params<P>> & MaybeKey<"search", Search<P>>;
+interface HistoryPushOptions {
+  url: string;
+  replace?: boolean;
+  state?: any;
+}
+interface HistoryLike {
+  getPath: () => string;
+  getSearch: () => string;
+  getState: () => any;
+  go: (delta: number) => void;
+  push: (options: HistoryPushOptions) => void;
+  subscribe: (listener: () => void) => () => void;
+}
+type Updater<T extends object> = Partial<T> | ((prev: T) => Partial<T>);
+type ComponentLoader = () => Promise<ComponentType | {
+  default: ComponentType;
+}>;
+//#endregion
+//#region src/route.d.ts
+declare function route<P extends string>(pattern: P): Route<NormalizePath<P>, regexparam0.RouteParams<NormalizePath<P>> extends infer T ? { [KeyType in keyof T]: T[KeyType] } : never, {}>;
+declare class Route<P extends string = string, Ps extends {} = any, S extends {} = any> {
+  readonly pattern: P;
+  readonly _: {
+    _params?: Ps;
+    _search?: S;
+    keys: string[];
+    regex: RegExp;
+    looseRegex: RegExp;
+    weights: number[];
+    mapSearch: (search: Record<string, unknown>) => S;
+    handles: Handle[];
+    components: ComponentType[];
+    preloaded: boolean;
+    preloaders: (() => Promise<any>)[];
+  };
+  constructor(pattern: P, mapSearch: (search: Record<string, unknown>) => S, handles: Handle[], components: ComponentType[], preloaders: (() => Promise<any>)[]);
+  route<P2 extends string>(subPattern: P2): Route<NormalizePath<`${P}/${P2}`>, regexparam0.RouteParams<NormalizePath<`${P}/${P2}`>> extends infer T ? { [KeyType in keyof T]: T[KeyType] } : never, S>;
+  search<S2 extends {}>(mapper: ((search: S & Record<string, unknown>) => S2) | StandardSchemaV1<S & Record<string, unknown>, S2>): Route<P, Ps, (type_fest0.PickIndexSignature<S> extends infer T_1 ? { [Key in keyof T_1 as Key extends keyof type_fest0.PickIndexSignature<{ [K in keyof S2 as undefined extends S2[K] ? never : K]: S2[K] } & { [K_1 in keyof S2 as undefined extends S2[K_1] ? K_1 : never]?: S2[K_1] | undefined } extends infer T_2 ? { [KeyType_1 in keyof T_2]: T_2[KeyType_1] } : never> ? never : Key]: T_1[Key] } : never) & type_fest0.PickIndexSignature<{ [K in keyof S2 as undefined extends S2[K] ? never : K]: S2[K] } & { [K_1 in keyof S2 as undefined extends S2[K_1] ? K_1 : never]?: S2[K_1] | undefined } extends infer T_2 ? { [KeyType_1 in keyof T_2]: T_2[KeyType_1] } : never> & (type_fest0.OmitIndexSignature<S> extends infer T_3 ? { [Key_1 in keyof T_3 as Key_1 extends keyof type_fest0.OmitIndexSignature<{ [K in keyof S2 as undefined extends S2[K] ? never : K]: S2[K] } & { [K_1 in keyof S2 as undefined extends S2[K_1] ? K_1 : never]?: S2[K_1] | undefined } extends infer T_4 ? { [KeyType_1 in keyof T_4]: T_4[KeyType_1] } : never> ? never : Key_1]: T_3[Key_1] } : never) & type_fest0.OmitIndexSignature<{ [K in keyof S2 as undefined extends S2[K] ? never : K]: S2[K] } & { [K_1 in keyof S2 as undefined extends S2[K_1] ? K_1 : never]?: S2[K_1] | undefined } extends infer T_4 ? { [KeyType_1 in keyof T_4]: T_4[KeyType_1] } : never> extends infer T ? { [KeyType in keyof T]: T[KeyType] } : never>;
+  handle(handle: Handle): Route<P, Ps, S>;
+  preloader(preloader: () => Promise<any>): Route<P, Ps, S>;
+  component(component: ComponentType): Route<P, Ps, S>;
+  lazy(loader: ComponentLoader): Route<P, Ps, S>;
+  suspense(fallback: ComponentType): Route<P, Ps, S>;
+  error(fallback: ComponentType<{
+    error: unknown;
+  }>): Route<P, Ps, S>;
+  preload(): Promise<void>;
+  toString(): P;
+}
+//#endregion
+//#region src/react/components.d.ts
+type RouterRootProps = RouterOptions | {
+  router: Router;
+};
+declare function RouterRoot(props: RouterRootProps): ReactNode;
+declare function Outlet(): ReactNode;
+type NavigateProps<P extends Pattern> = NavigateOptions<P>;
+declare function Navigate<P extends Pattern>(props: NavigateProps<P>): null;
+type LinkProps<P extends Pattern> = NavigateOptions<P> & LinkOptions & AnchorHTMLAttributes<HTMLAnchorElement> & RefAttributes<HTMLAnchorElement> & {
+  asChild?: boolean;
+};
+interface LinkOptions {
+  strict?: boolean;
+  preload?: "intent" | "render" | "viewport" | false;
+  style?: CSSProperties;
+  className?: string;
+  activeStyle?: CSSProperties;
+  activeClassName?: string;
+}
+declare function Link<P extends Pattern>(props: LinkProps<P>): ReactNode;
+//#endregion
+//#region src/react/hooks.d.ts
+declare function useRouter(): Router;
+declare function useHandles(): Handle[];
+declare function useOutlet(): react2.ReactNode;
+declare function useSubscribe<T>(router: Router, getSnapshot: () => T): T;
+declare function useNavigate(): <P extends Pattern>(options: number | HistoryPushOptions | NavigateOptions<P>) => void;
+declare function useLocation(): {
+  path: string;
+  search: Record<string, unknown>;
+  state: any;
+};
+declare function useMatch<P extends Pattern>(options: MatchOptions<P>): Match<P> | null;
+declare function useParams<P extends Pattern>(from: P | GetRoute<P>): Params<P>;
+declare function useSearch<P extends Pattern>(from: P | GetRoute<P>): readonly [Search<P>, (update: Updater<Search<P>>, replace?: boolean) => void];
+//#endregion
+//#region src/react/contexts.d.ts
+declare const RouterContext: react2.Context<Router | null>;
+declare const MatchContext: react2.Context<Match | null>;
+declare const OutletContext: react2.Context<ReactNode>;
+//#endregion
+//#region src/router/router.d.ts
+interface RouterOptions {
+  basePath?: string;
+  routes: RouteList;
+  history?: HistoryLike;
+  defaultLinkOptions?: LinkOptions;
+}
+declare class Router {
+  readonly basePath: string;
+  readonly routes: RouteList;
+  readonly history: HistoryLike;
+  readonly defaultLinkOptions?: LinkOptions;
+  readonly _: {
+    routeMap: Map<string, Route>;
+  };
+  constructor(options: RouterOptions);
+  getRoute<P extends Pattern>(pattern: P | GetRoute<P>): GetRoute<P>;
+  match<P extends Pattern>(path: string, options: MatchOptions<P>): Match<P> | null;
+  matchAll(path: string): Match | null;
+  createUrl<P extends Pattern>(options: NavigateOptions<P>): string;
+  navigate<P extends Pattern>(options: NavigateOptions<P> | HistoryPushOptions | number): void;
+}
+//#endregion
+//#region src/router/browser-history.d.ts
+declare class BrowserHistory implements HistoryLike {
+  private static patchKey;
+  constructor();
+  getPath: () => string;
+  getSearch: () => string;
+  getState: () => any;
+  go: (delta: number) => void;
+  push: (options: HistoryPushOptions) => void;
+  subscribe: (listener: () => void) => () => void;
+}
+//#endregion
+//#region src/router/memory-history.d.ts
+interface MemoryLocation {
+  path: string;
+  search: string;
+  state: any;
+}
+declare class MemoryHistory implements HistoryLike {
+  private stack;
+  private index;
+  private listeners;
+  constructor(url?: string);
+  private getCurrent;
+  getPath: () => string;
+  getSearch: () => string;
+  getState: () => any;
+  go: (delta: number) => void;
+  push: (options: HistoryPushOptions) => void;
+  subscribe: (listener: () => void) => () => void;
+}
+//#endregion
+//#region src/router/hash-history.d.ts
+declare class HashHistory extends BrowserHistory {
+  private getHashUrl;
+  getPath: () => string;
+  getSearch: () => string;
+  push: (options: HistoryPushOptions) => void;
+}
+//#endregion
+export { BrowserHistory, ComponentLoader, GetRoute, Handle, HashHistory, HistoryLike, HistoryPushOptions, Link, LinkOptions, LinkProps, Match, MatchContext, MatchOptions, MemoryHistory, MemoryLocation, Navigate, NavigateOptions, NavigateProps, Outlet, OutletContext, Params, Pattern, Register, Route, RouteList, Router, RouterContext, RouterOptions, RouterRoot, RouterRootProps, Search, Updater, route, useHandles, useLocation, useMatch, useNavigate, useOutlet, useParams, useRouter, useSearch, useSubscribe };

package/dist/index.js

@@ -1,4 +1 @@
-export * from "./route";
-export * from "./router";
-export * from "./react";
-export * from "./utils/router";
+import{Component as e,Suspense as t,cloneElement as n,createContext as r,isValidElement as i,lazy as a,memo as o,useCallback as s,useContext as c,useEffect as l,useLayoutEffect as u,useMemo as d,useRef as ee,useState as f,useSyncExternalStore as p}from"react";import{inject as m,parse as h}from"regexparam";import{jsx as g}from"react/jsx-runtime";function _(e){return`/${e}`.replaceAll(/\/+/g,`/`).replace(/(.+)\/$/,`$1`)}function v(e){return e.split(`/`).slice(1).map(e=>e.includes(`*`)?0:e.includes(`:`)?1:2)}function y(e){return typeof e==`function`?e:t=>{let n=e[`~standard`].validate(t);if(n instanceof Promise)throw Error(`[Waymark] Validation must be synchronous`);if(n.issues)throw Error(`[Waymark] Validation failed`,{cause:n.issues});return n.value}}function b(e){return e.startsWith(`?`)?e.slice(1):e}function x(e){return Object.entries(e).filter(([e,t])=>t!==void 0).map(([e,t])=>`${e}=${encodeURIComponent(C(t))}`).join(`&`)}function S(e){let t=new URLSearchParams(e);return Object.fromEntries([...t.entries()].map(([e,t])=>(t=decodeURIComponent(t),[e,w(t)?JSON.parse(t):t])))}function C(e){return typeof e==`string`&&!w(e)?e:JSON.stringify(e)}function w(e){try{return JSON.parse(e),!0}catch{return!1}}function T(e,t){return _(`${t}/${e}`)}function E(e,t){return(e===t||e.startsWith(`${t}/`))&&(e=e.slice(t.length)||`/`),e}function D(e,t){return[e,x(t)].filter(Boolean).join(`?`)}function O(e){let{pathname:t,search:n}=new URL(e,`http://w`);return{path:t,search:b(n)}}function k(e,t,n,r){let i=e.exec(E(n,r));if(!i)return null;let a={};return t.forEach((e,t)=>{let n=i[t+1];n&&(a[e]=n)}),a}function A(e){return[...e].sort((e,t)=>{let n=e.route._.weights,r=t.route._.weights,i=Math.max(n.length,r.length);for(let e=0;e<i;e++){let t=n[e]??-1,i=r[e]??-1;if(t!==i)return i-t}return 0})}const j=r(null),M=r(null),N=r(null);function P(){let e=c(j);if(!e)throw Error(`[Waymark] useRouter must be used within a router context`);return e}function F(){let e=c(M);return d(()=>e?.route._.handles??[],[e])}function I(){return c(N)}function L(e,t){return p(e.history.subscribe,t,t)}function R(){let e=P();return d(()=>e.navigate.bind(e),[e])}function z(){let e=P(),t=L(e,e.history.getPath),n=L(e,e.history.getSearch),r=L(e,e.history.getState);return d(()=>({path:t,search:S(n),state:r}),[t,n,r])}function B(e){let t=P(),n=L(t,t.history.getPath);return d(()=>t.match(n,e),[t,n,e])}function te(e){let t=B({from:e});if(!t)throw Error(`[Waymark] Can't read params for non-matching route: ${e}`);return t.params}function ne(e){let t=B({from:e});if(!t)throw Error(`[Waymark] Can't read search for non-matching route: ${e}`);let n=s(e=>t.route._.mapSearch(S(e)),[t.route]),r=P(),i=L(r,r.history.getSearch);return[d(()=>n(i),[n,i]),s((e,t)=>{let i=n(r.history.getSearch());e=typeof e==`function`?e(i):e;let a=D(r.history.getPath(),{...i,...e});r.navigate({url:a,replace:t})},[r,n])]}var V=class e{static patchKey=Symbol.for(`waymark_history_patch_v01`);constructor(){if(typeof history<`u`&&!Object.hasOwn(window,e.patchKey)){for(let e of[H,U]){let t=history[e];history[e]=function(...n){let r=t.apply(this,n),i=new Event(e);return i.arguments=n,dispatchEvent(i),r}}Object.assign(window,{[e.patchKey]:!0})}}getPath=()=>location.pathname;getSearch=()=>b(location.search);getState=()=>history.state;go=e=>history.go(e);push=e=>{let{url:t,replace:n,state:r}=e;history[n?U:H](r,``,t)};subscribe=e=>(W.forEach(t=>window.addEventListener(t,e)),()=>{W.forEach(t=>window.removeEventListener(t,e))})};const H=`pushState`,U=`replaceState`,W=[`popstate`,H,U,`hashchange`];var G=class{basePath;routes;history;defaultLinkOptions;_;constructor(e){let{basePath:t=`/`,routes:n,history:r,defaultLinkOptions:i}=e;this.basePath=_(t),this.routes=n,this.history=r??new V,this.defaultLinkOptions=i,this._={routeMap:new Map(n.map(e=>[e.pattern,e]))}}getRoute(e){if(typeof e!=`string`)return e;let t=this._.routeMap.get(e);if(!t)throw Error(`[Waymark] Route not found for pattern: ${e}`);return t}match(e,t){let{from:n,strict:r,params:i}=t,a=this.getRoute(n),o=k(r?a._.regex:a._.looseRegex,a._.keys,e,this.basePath);return!o||i&&Object.keys(i).some(e=>i[e]!==o[e])?null:{route:a,params:o}}matchAll(e){return A(this.routes.map(t=>this.match(e,{from:t,strict:!0})).filter(e=>!!e))[0]??null}createUrl(e){let{to:t,params:n={},search:r={}}=e,{pattern:i}=this.getRoute(t);return D(T(m(i,n),this.basePath),r)}navigate(e){if(typeof e==`number`)this.history.go(e);else if(`url`in e)this.history.push(e);else{let{replace:t,state:n}=e;this.history.push({url:this.createUrl(e),replace:t,state:n})}}},K=class{stack=[];index=0;listeners=new Set;constructor(e=`/`){this.stack.push({...O(e),state:void 0})}getCurrent=()=>this.stack[this.index];getPath=()=>this.getCurrent().path;getSearch=()=>this.getCurrent().search;getState=()=>this.getCurrent().state;go=e=>{let t=this.index+e;this.stack[t]&&(this.index=t,this.listeners.forEach(e=>e()))};push=e=>{let{url:t,replace:n,state:r}=e,i={...O(t),state:r};this.stack=this.stack.slice(0,this.index+1),n?this.stack[this.index]=i:this.index=this.stack.push(i)-1,this.listeners.forEach(e=>e())};subscribe=e=>(this.listeners.add(e),()=>{this.listeners.delete(e)})},q=class extends V{getHashUrl=()=>location.hash.slice(1)||`/`;getPath=()=>O(this.getHashUrl()).path;getSearch=()=>O(this.getHashUrl()).search;push=e=>{let{url:t,replace:n,state:r}=e;history[n?`replaceState`:`pushState`](r,``,`#${t}`)}};function J(e){let[t]=f(()=>`router`in e?e.router:new G(e)),n=L(t,t.history.getPath),r=d(()=>t.matchAll(n),[t,n]);return r||console.error(`[Waymark] No matching route found for path:`,n),d(()=>g(j.Provider,{value:t,children:g(M.Provider,{value:r,children:r?.route._.components.reduceRight((e,t)=>g(N.Provider,{value:e,children:g(t,{})}),null)})}),[t,r])}function Y(){return I()}function X(e){let t=R();return u(()=>t(e),[]),null}function Z(e){let t=P(),{to:r,replace:a,state:o,params:s,search:c,strict:u,preload:f,style:p,className:m,activeStyle:h,activeClassName:_,asChild:v,children:y,...b}={...t.defaultLinkOptions,...e},x=ee(null),S=t.createUrl(e),C=d(()=>t.getRoute(e.to),[t,e.to]),w=!!B({from:C,strict:u,params:s}),T=d(()=>({"data-active":w,style:{...p,...w&&h},className:[m,w&&_].filter(Boolean).join(` `)||void 0}),[w,p,m,h,_]);l(()=>{if(f===`render`)C.preload();else if(f===`viewport`&&x.current){let e=new IntersectionObserver(t=>{t.forEach(t=>{t.isIntersecting&&(C.preload(),e.disconnect())})});return e.observe(x.current),()=>e.disconnect()}},[f,C]);let E=e=>{b.onClick?.(e),!(e.ctrlKey||e.metaKey||e.shiftKey||e.altKey||e.button!==0||e.defaultPrevented)&&(e.preventDefault(),t.navigate({url:S,replace:a,state:o}))},D=e=>{b.onFocus?.(e),f===`intent`&&!e.defaultPrevented&&C.preload()},O=e=>{b.onPointerEnter?.(e),f===`intent`&&!e.defaultPrevented&&C.preload()},k={...b,...T,ref:re(b.ref,x),href:S,onClick:E,onFocus:D,onPointerEnter:O};return v&&i(y)?n(y,k):g(`a`,{...k,children:y})}function re(...e){let t=e.filter(e=>!!e);return t.length<=1?t[0]??null:e=>{let n=[];for(let r of t){let t=Q(r,e);n.push(t??(()=>Q(r,null)))}return()=>n.forEach(e=>e())}}function Q(e,t){if(typeof e==`function`)return e(t);e&&(e.current=t)}function ie(e){return()=>g(t,{fallback:g(e,{}),children:I()})}function ae(t){class n extends e{constructor(e){super(e),this.state={children:e.children,error:null}}static getDerivedStateFromError(e){return{error:[e]}}static getDerivedStateFromProps(e,t){return e.children===t.children?t:{children:e.children,error:null}}render(){return this.state.error?g(t,{error:this.state.error[0]}):this.props.children}}return()=>g(n,{children:I()})}function oe(e){return new $(_(e),e=>e,[],[],[])}var $=class e{pattern;_;constructor(e,t,n,r,i){let{keys:a,pattern:o}=h(e),s=h(e,!0).pattern,c=v(e);this.pattern=e,this._={keys:a,regex:o,looseRegex:s,weights:c,mapSearch:t,handles:n,components:r,preloaded:!1,preloaders:i}}route(t){let{mapSearch:n,handles:r,components:i,preloaders:a}=this._;return new e(_(`${this.pattern}/${t}`),n,r,i,a)}search(t){let{mapSearch:n,handles:r,components:i,preloaders:a}=this._;return t=y(t),new e(this.pattern,e=>{let r=n(e);return{...r,...t(r)}},r,i,a)}handle(t){let{mapSearch:n,handles:r,components:i,preloaders:a}=this._;return new e(this.pattern,n,[...r,t],i,a)}preloader(t){let{mapSearch:n,handles:r,components:i,preloaders:a}=this._;return new e(this.pattern,n,r,i,[...a,t])}component(t){let{mapSearch:n,handles:r,components:i,preloaders:a}=this._;return new e(this.pattern,n,r,[...i,o(t)],a)}lazy(e){let t=a(async()=>{let t=await e();return{default:o(`default`in t?t.default:t)}});return this.preloader(e).component(t)}suspense(e){return this.component(ie(e))}error(e){return this.component(ae(e))}async preload(){let{preloaded:e,preloaders:t}=this._;e||(this._.preloaded=!0,await Promise.all(t.map(e=>e())))}toString(){return this.pattern}};export{V as BrowserHistory,q as HashHistory,Z as Link,M as MatchContext,K as MemoryHistory,X as Navigate,Y as Outlet,N as OutletContext,$ as Route,G as Router,j as RouterContext,J as RouterRoot,oe as route,F as useHandles,z as useLocation,B as useMatch,R as useNavigate,I as useOutlet,te as useParams,P as useRouter,ne as useSearch,L as useSubscribe};

package/package.json

@@ -1,12 +1,18 @@
 {
   "name": "waymark",
-  "version": "0.1.1",
-  "description": "Simplest strongly typed router for React",
+  "version": "0.2.0",
+  "license": "MIT",
+  "author": "strblr",
+  "description": "Lightweight type-safe router for React",
   "type": "module",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
-  "license": "MIT",
-  "author": "strblr",
+  "exports": {
+    ".": {
+      "default": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
   "repository": {
     "type": "git",
     "url": "https://github.com/strblr/waymark"
@@ -16,33 +22,39 @@
   "keywords": [
     "react",
     "router",
-    "wouter",
     "typescript",
     "type",
     "typed",
+    "strongly-typed",
+    "type-safe",
     "navigate",
     "navigation",
+    "route",
+    "history",
     "search",
     "params",
-    "strongly-typed",
-    "react-router",
-    "react-router-dom"
+    "simple",
+    "tiny",
+    "lightweight",
+    "minimal"
   ],
   "scripts": {
-    "build": "tsc",
-    "prepublishOnly": "bun run build"
+    "build": "tsdown --minify --platform browser",
+    "copy-readme": "cp ../../README.md README.md",
+    "prepublishOnly": "bun run build && bun run copy-readme"
   },
   "devDependencies": {
-    "@standard-schema/spec": "^1.1.0",
-    "@types/bun": "latest",
-    "@types/react": "^19.2.8",
-    "type-fest": "^5.4.1",
+    "@types/bun": "^1.3.6",
+    "@types/react": "^19.2.9",
+    "tsdown": "^0.20.1",
     "typescript": "^5.9.3"
   },
   "peerDependencies": {
     "react": ">=18"
   },
   "dependencies": {
-    "regexparam": "^3.0.0"
+    "@standard-schema/spec": "^1.1.0",
+    "regexparam": "^3.0.0",
+    "type-fest": "^5.4.1"
   }
 }

package/tsdown.config.ts

@@ -0,0 +1,8 @@
+import { defineConfig } from "tsdown";
+
+export default defineConfig({
+  entry: ["./src/index.ts"],
+  report: {
+    brotli: true
+  }
+});

package/dist/react/components.d.ts

@@ -1,20 +0,0 @@
-import { type ReactNode, type AnchorHTMLAttributes, type CSSProperties, type RefAttributes } from "react";
-import { Router, type RouterOptions } from "../router";
-import { type Patterns, type NavigateOptions } from "../utils";
-export type RouterRootProps = RouterOptions | {
-    router: Router;
-};
-export declare function RouterRoot(props: RouterRootProps): ReactNode;
-export declare function Outlet(): ReactNode;
-export type NavigateProps<P extends Patterns> = NavigateOptions<P>;
-export declare function Navigate<P extends Patterns>(props: NavigateProps<P>): null;
-export type LinkProps<P extends Patterns> = NavigateOptions<P> & LinkOptions & AnchorHTMLAttributes<HTMLAnchorElement> & RefAttributes<HTMLAnchorElement> & {
-    asChild?: boolean;
-};
-export interface LinkOptions {
-    preload?: "intent" | "render" | "viewport" | false;
-    active?: (currentPath: string, targetPath: string) => boolean;
-    activeStyle?: CSSProperties;
-    activeClassName?: string;
-}
-export declare function Link<P extends Patterns>(props: LinkProps<P>): ReactNode;

package/dist/react/components.js

@@ -1,107 +0,0 @@
-import { useMemo, useState, useLayoutEffect, useRef, useEffect, createElement, isValidElement, cloneElement } from "react";
-import { routerContext, outletContext } from "./contexts";
-import { useRouter, useOutlet, _useSubscribe } from "./hooks";
-import { Router } from "../router";
-import { getHref, mergeRefs, defaultLinkActive } from "../utils";
-export function RouterRoot(props) {
-    const [router] = useState(() => "router" in props ? props.router : new Router(props));
-    const path = _useSubscribe(router, router.history.getPath);
-    const route = useMemo(() => router.matchPath(path), [router, path]);
-    if (!route) {
-        console.error("[Waymark] No route found for path:", path);
-    }
-    return useMemo(() => {
-        return createElement(routerContext.Provider, { value: router }, route?._.components.reduceRight((acc, comp) => createElement(outletContext.Provider, { value: acc }, createElement(comp)), null));
-    }, [router, route]);
-}
-// Outlet
-export function Outlet() {
-    return useOutlet();
-}
-export function Navigate(props) {
-    const router = useRouter();
-    useLayoutEffect(() => router.navigate(props), []);
-    return null;
-}
-export function Link(props) {
-    const ref = useRef(null);
-    const router = useRouter();
-    const { path, search } = router.composePath(props);
-    const currentPath = _useSubscribe(router, router.history.getPath);
-    const route = useMemo(() => router.matchPath(path), [router, path]);
-    const { to, replace, state, params, search: search_, preload, active, activeStyle, activeClassName, asChild, style, className, children, ...rest } = {
-        active: defaultLinkActive,
-        ...router.defaultLinkOptions,
-        ...props
-    };
-    const activeProps = useMemo(() => {
-        const isActive = active(currentPath, path);
-        return {
-            ["data-active"]: isActive,
-            style: { ...style, ...(isActive && activeStyle) },
-            className: [className, isActive && activeClassName].filter(Boolean).join(" ") ||
-                undefined
-        };
-    }, [
-        active,
-        path,
-        currentPath,
-        style,
-        className,
-        activeStyle,
-        activeClassName
-    ]);
-    useEffect(() => {
-        if (preload === "render") {
-            route?.preload();
-        }
-        else if (preload === "viewport" && ref.current) {
-            const observer = new IntersectionObserver(entries => {
-                entries.forEach(entry => {
-                    if (entry.isIntersecting) {
-                        route?.preload();
-                        observer.disconnect();
-                    }
-                });
-            });
-            observer.observe(ref.current);
-            return () => observer.disconnect();
-        }
-    }, [preload, route]);
-    const onClick = (event) => {
-        rest.onClick?.(event);
-        if (event.ctrlKey ||
-            event.metaKey ||
-            event.shiftKey ||
-            event.altKey ||
-            event.button !== 0 ||
-            event.defaultPrevented)
-            return;
-        event.preventDefault();
-        router.history.push({ path, search, replace, state });
-    };
-    const onFocus = (event) => {
-        rest.onFocus?.(event);
-        if (preload === "intent" && !event.defaultPrevented) {
-            route?.preload();
-        }
-    };
-    const onPointerEnter = (event) => {
-        rest.onPointerEnter?.(event);
-        if (preload === "intent" && !event.defaultPrevented) {
-            route?.preload();
-        }
-    };
-    const anchorProps = {
-        ...rest,
-        ...activeProps,
-        ref: mergeRefs(rest.ref, ref),
-        href: getHref(path, search),
-        onClick,
-        onFocus,
-        onPointerEnter
-    };
-    return asChild && isValidElement(children)
-        ? cloneElement(children, anchorProps)
-        : createElement("a", { ...anchorProps, children });
-}

package/dist/react/contexts.d.ts

@@ -1,4 +0,0 @@
-import { type ReactNode } from "react";
-import type { Router } from "../router";
-export declare const routerContext: import("react").Context<Router | undefined>;
-export declare const outletContext: import("react").Context<ReactNode>;

package/dist/react/contexts.js

@@ -1,3 +0,0 @@
-import { createContext } from "react";
-export const routerContext = createContext(undefined);
-export const outletContext = createContext(null);

package/dist/react/hooks.d.ts

@@ -1,13 +0,0 @@
-import type { Router } from "../router";
-import type { Routes, RouteSearch, Updater } from "../utils";
-export declare function useRouter(): Router;
-export declare function useOutlet(): import("react").ReactNode;
-export declare function useLocation(): {
-    path: string;
-    search: URLSearchParams;
-    state: any;
-};
-export declare function useNavigate(): <P extends import("..").Patterns>(options: number | import("..").NavigateOptions<P>) => void;
-export declare function useParams<R extends Routes>(route: R): import("..").RouteParams<R>;
-export declare function useSearch<R extends Routes>(route: R): readonly [RouteSearch<R>, (update: Updater<RouteSearch<R>>, replace?: boolean) => void];
-export declare function _useSubscribe<T>(router: Router, getSnapshot: () => T): T;

package/dist/react/hooks.js

@@ -1,54 +0,0 @@
-import { useCallback, useContext, useMemo, useSyncExternalStore } from "react";
-import { outletContext, routerContext } from "./contexts";
-// useRouter
-export function useRouter() {
-    const router = useContext(routerContext);
-    if (!router) {
-        throw new Error("[Waymark] useRouter must be used within a router context");
-    }
-    return router;
-}
-// useOutlet
-export function useOutlet() {
-    return useContext(outletContext);
-}
-// useLocation
-export function useLocation() {
-    const router = useRouter();
-    const path = _useSubscribe(router, router.history.getPath);
-    const search = _useSubscribe(router, router.history.getSearch);
-    const state = _useSubscribe(router, router.history.getState);
-    return useMemo(() => ({ path, search: new URLSearchParams(search), state }), [path, search, state]);
-}
-// useNavigate
-export function useNavigate() {
-    const router = useRouter();
-    return useMemo(() => router.navigate.bind(router), [router]);
-}
-// useParams
-export function useParams(route) {
-    const router = useRouter();
-    const path = _useSubscribe(router, router.history.getPath);
-    return useMemo(() => router.decomposePath(route, path, router.history.getSearch()).params, [router, route, path]);
-}
-// useSearch
-export function useSearch(route) {
-    const router = useRouter();
-    const search = _useSubscribe(router, router.history.getSearch);
-    const parsed = useMemo(() => router.decomposePath(route, router.history.getPath(), search).search, [router, route, search]);
-    const setSearch = useCallback((update, replace) => {
-        const { params, search } = router.decomposePath(route, router.history.getPath(), router.history.getSearch());
-        update = typeof update === "function" ? update(search) : update;
-        router.navigate({
-            to: route._.pattern,
-            params,
-            search: { ...search, ...update },
-            replace
-        });
-    }, [router, route]);
-    return [parsed, setSearch];
-}
-// _useSubscribe
-export function _useSubscribe(router, getSnapshot) {
-    return useSyncExternalStore(router.history.subscribe, getSnapshot, getSnapshot);
-}

package/dist/react/index.d.ts

@@ -1,3 +0,0 @@
-export * from "./components";
-export * from "./hooks";
-export * from "./contexts";

package/dist/react/index.js

@@ -1,3 +0,0 @@
-export * from "./components";
-export * from "./hooks";
-export * from "./contexts";

package/dist/route.d.ts

@@ -1,27 +0,0 @@
-import { type ComponentType } from "react";
-import type { StandardSchemaV1 } from "@standard-schema/spec";
-import { type NormalizePath, type ComponentLoader } from "./utils";
-export declare class Route<P extends string, Ps extends {}, S extends {}> {
-    _: {
-        pattern: P;
-        _params?: Ps;
-        _search?: S;
-        keys: string[];
-        regex: RegExp;
-        looseRegex: RegExp;
-        mapSearch: (search: Record<string, unknown>) => S;
-        components: ComponentType[];
-        preloaded: boolean;
-        preloaders: (() => Promise<any>)[];
-    };
-    constructor(pattern: P, mapSearch: (search: Record<string, unknown>) => S, components: ComponentType[], preloaders: (() => Promise<any>)[]);
-    route<P2 extends string>(subPattern: P2): Route<NormalizePath<`${P}/${P2}`>, import("regexparam").RouteParams<NormalizePath<`${P}/${P2}`>> extends infer T ? { [KeyType in keyof T]: T[KeyType]; } : never, S>;
-    search<S2 extends {}>(mapper: ((search: S & Record<string, unknown>) => S2) | StandardSchemaV1<S & Record<string, unknown>, S2>): Route<P, Ps, (import("type-fest").PickIndexSignature<S> extends infer T_1 ? { [Key in keyof T_1 as Key extends keyof import("type-fest").PickIndexSignature<{ [K in keyof S2 as undefined extends S2[K] ? never : K]: S2[K]; } & { [K_1 in keyof S2 as undefined extends S2[K_1] ? K_1 : never]?: S2[K_1] | undefined; } extends infer T_2 ? { [KeyType_1 in keyof T_2]: T_2[KeyType_1]; } : never> ? never : Key]: T_1[Key]; } : never) & import("type-fest").PickIndexSignature<{ [K in keyof S2 as undefined extends S2[K] ? never : K]: S2[K]; } & { [K_1 in keyof S2 as undefined extends S2[K_1] ? K_1 : never]?: S2[K_1] | undefined; } extends infer T_2 ? { [KeyType_1 in keyof T_2]: T_2[KeyType_1]; } : never> & (import("type-fest").OmitIndexSignature<S> extends infer T_3 ? { [Key_1 in keyof T_3 as Key_1 extends keyof import("type-fest").OmitIndexSignature<{ [K in keyof S2 as undefined extends S2[K] ? never : K]: S2[K]; } & { [K_1 in keyof S2 as undefined extends S2[K_1] ? K_1 : never]?: S2[K_1] | undefined; } extends infer T_4 ? { [KeyType_1 in keyof T_4]: T_4[KeyType_1]; } : never> ? never : Key_1]: T_3[Key_1]; } : never) & import("type-fest").OmitIndexSignature<{ [K in keyof S2 as undefined extends S2[K] ? never : K]: S2[K]; } & { [K_1 in keyof S2 as undefined extends S2[K_1] ? K_1 : never]?: S2[K_1] | undefined; } extends infer T_4 ? { [KeyType_1 in keyof T_4]: T_4[KeyType_1]; } : never> extends infer T ? { [KeyType in keyof T]: T[KeyType]; } : never>;
-    component(component: ComponentType): Route<P, Ps, S>;
-    lazy(loader: ComponentLoader): Route<P, Ps, S>;
-    error(component: ComponentType<{
-        error: unknown;
-    }>): Route<P, Ps, S>;
-    preload(): Promise<void>;
-}
-export declare function route<P extends string>(pattern: P): Route<NormalizePath<P>, import("regexparam").RouteParams<NormalizePath<P>> extends infer T ? { [KeyType in keyof T]: T[KeyType]; } : never, {}>;

package/dist/route.js

@@ -1,57 +0,0 @@
-import { lazy } from "react";
-import { parse } from "regexparam";
-import { normalizePath, validator, errorBoundary } from "./utils";
-export class Route {
-    _;
-    constructor(pattern, mapSearch, components, preloaders) {
-        const { keys, pattern: regex } = parse(pattern);
-        const looseRegex = parse(pattern, true).pattern;
-        this._ = {
-            pattern,
-            keys,
-            regex,
-            looseRegex,
-            mapSearch,
-            components,
-            preloaded: false,
-            preloaders
-        };
-    }
-    route(subPattern) {
-        const { pattern, mapSearch, components, preloaders } = this._;
-        return new Route(normalizePath(`${pattern}/${subPattern}`), mapSearch, components, preloaders);
-    }
-    search(mapper) {
-        const { pattern, mapSearch, components, preloaders } = this._;
-        mapper = validator(mapper);
-        return new Route(pattern, search => {
-            const mapped = mapSearch(search);
-            return { ...mapped, ...mapper(mapped) };
-        }, components, preloaders);
-    }
-    component(component) {
-        const { pattern, mapSearch, components, preloaders } = this._;
-        return new Route(pattern, mapSearch, [...components, component], preloaders);
-    }
-    lazy(loader) {
-        const { pattern, mapSearch, components, preloaders } = this._;
-        const lazyLoader = async () => {
-            const result = await loader();
-            return "default" in result ? result : { default: result };
-        };
-        return new Route(pattern, mapSearch, [...components, lazy(lazyLoader)], [...preloaders, loader]);
-    }
-    error(component) {
-        return this.component(errorBoundary(component));
-    }
-    async preload() {
-        const { preloaded, preloaders } = this._;
-        if (preloaded)
-            return;
-        this._.preloaded = true;
-        await Promise.all(preloaders.map(loader => loader()));
-    }
-}
-export function route(pattern) {
-    return new Route(normalizePath(pattern), search => search, [], []);
-}

package/dist/router/browser-history.d.ts

@@ -1,11 +0,0 @@
-import { type HistoryLike, type HistoryPushOptions } from "../utils";
-export declare class BrowserHistory implements HistoryLike {
-    private static patchKey;
-    constructor();
-    getPath: () => string;
-    getSearch: () => string;
-    getState: () => any;
-    go: (delta: number) => void;
-    push: (options: HistoryPushOptions) => void;
-    subscribe: (listener: () => void) => () => void;
-}