waymark 0.1.0 → 0.1.1

package/dist/index.d.ts

@@ -1 +1,4 @@
-export declare const a = 5;
+export * from "./route";
+export * from "./router";
+export * from "./react";
+export * from "./utils/router";

package/dist/index.js

@@ -1,2 +1,4 @@
-console.log("Hello via Bun!");
-export const a = 5;
+export * from "./route";
+export * from "./router";
+export * from "./react";
+export * from "./utils/router";

package/dist/react/components.d.ts

@@ -0,0 +1,20 @@
+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

@@ -0,0 +1,107 @@
+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

@@ -0,0 +1,4 @@
+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

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

package/dist/react/hooks.d.ts

@@ -0,0 +1,13 @@
+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

@@ -0,0 +1,54 @@
+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

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

package/dist/react/index.js

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

package/dist/route.d.ts

@@ -0,0 +1,27 @@
+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

@@ -0,0 +1,57 @@
+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

@@ -0,0 +1,11 @@
+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;
+}

package/dist/router/browser-history.js

@@ -0,0 +1,48 @@
+import { getHref, normalizeSearch } from "../utils";
+export class BrowserHistory {
+    static patchKey = Symbol.for("waymark_history_patch_v01");
+    constructor() {
+        if (typeof history !== "undefined" &&
+            !Object.hasOwn(window, BrowserHistory.patchKey)) {
+            for (const type of [pushStateEvent, replaceStateEvent]) {
+                const original = history[type];
+                history[type] = function (...args) {
+                    const result = original.apply(this, args);
+                    const event = new Event(type);
+                    event.arguments = args;
+                    dispatchEvent(event);
+                    return result;
+                };
+            }
+            Object.assign(window, {
+                [BrowserHistory.patchKey]: true
+            });
+        }
+    }
+    getPath = () => location.pathname;
+    getSearch = () => normalizeSearch(location.search);
+    getState = () => history.state;
+    go = (delta) => history.go(delta);
+    push = (options) => {
+        const { path, search, replace, state } = options;
+        const href = getHref(path, search);
+        history[replace ? replaceStateEvent : pushStateEvent](state, "", href);
+    };
+    subscribe = (listener) => {
+        events.forEach(event => window.addEventListener(event, listener));
+        return () => {
+            events.forEach(event => window.removeEventListener(event, listener));
+        };
+    };
+}
+// Events
+const popStateEvent = "popstate";
+const pushStateEvent = "pushState";
+const replaceStateEvent = "replaceState";
+const hashChangeEvent = "hashchange";
+const events = [
+    popStateEvent,
+    pushStateEvent,
+    replaceStateEvent,
+    hashChangeEvent
+];

package/dist/router/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./router";
+export * from "./browser-history";
+export * from "./memory-history";

package/dist/router/index.js

@@ -0,0 +1,3 @@
+export * from "./router";
+export * from "./browser-history";
+export * from "./memory-history";

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

@@ -0,0 +1,18 @@
+import { type HistoryLike, type HistoryPushOptions } from "../utils";
+export interface MemoryLocation {
+    path: string;
+    search: string;
+    state: any;
+}
+export declare class MemoryHistory implements HistoryLike {
+    private stack;
+    private index;
+    private listeners;
+    constructor(initial?: Partial<MemoryLocation>);
+    getPath: () => string;
+    getSearch: () => string;
+    getState: () => any;
+    go: (delta: number) => void;
+    push: (options: HistoryPushOptions) => void;
+    subscribe: (listener: () => void) => () => void;
+}

package/dist/router/memory-history.js

@@ -0,0 +1,39 @@
+import { clamp, normalizeSearch } from "../utils";
+export class MemoryHistory {
+    stack = [];
+    index = 0;
+    listeners = new Set();
+    constructor(initial = {}) {
+        const { path = "/", search = "", state } = initial;
+        this.stack.push({ path, search: normalizeSearch(search), state });
+    }
+    getPath = () => this.stack[this.index].path;
+    getSearch = () => this.stack[this.index].search;
+    getState = () => this.stack[this.index].state;
+    go = (delta) => {
+        this.index = clamp(this.index + delta, 0, this.stack.length - 1);
+        this.listeners.forEach(listener => listener());
+    };
+    push = (options) => {
+        const { path, search = "", replace, state } = options;
+        const location = {
+            path,
+            search: normalizeSearch(search),
+            state
+        };
+        this.stack = this.stack.slice(0, this.index + 1);
+        if (replace) {
+            this.stack[this.index] = location;
+        }
+        else {
+            this.index = this.stack.push(location) - 1;
+        }
+        this.listeners.forEach(listener => listener());
+    };
+    subscribe = (listener) => {
+        this.listeners.add(listener);
+        return () => {
+            this.listeners.delete(listener);
+        };
+    };
+}

package/dist/router/router.d.ts

@@ -0,0 +1,31 @@
+import type { LinkOptions } from "../react";
+import { type Routes, type PatternRoute, type RouteList, type Patterns, type NavigateOptions, type HistoryLike, type RouteParams, type RouteSearch } from "../utils";
+export interface RouterOptions {
+    history?: HistoryLike;
+    basePath?: string;
+    routes: RouteList;
+    defaultLinkOptions?: LinkOptions;
+}
+export declare class Router {
+    history: HistoryLike;
+    basePath: string;
+    routes: RouteList;
+    defaultLinkOptions?: LinkOptions;
+    _: {
+        routeMap: Map<string, Routes>;
+    };
+    constructor(options: RouterOptions);
+    getPath(cpath: string): string;
+    getCanonicalPath(path: string): string;
+    matchPath(path: string): Routes | undefined;
+    getRoute<P extends Patterns>(pattern: P): PatternRoute<P>;
+    composePath<P extends Patterns>(options: NavigateOptions<P>): {
+        path: string;
+        search: string;
+    };
+    decomposePath<R extends Routes>(route: R, path: string, search: string): {
+        params: RouteParams<R>;
+        search: RouteSearch<R>;
+    };
+    navigate<P extends Patterns>(options: NavigateOptions<P> | number): void;
+}

package/dist/router/router.js

@@ -0,0 +1,64 @@
+import { inject } from "regexparam";
+import { BrowserHistory } from "./browser-history";
+import { normalizePath, extract, stringifySearch, parseSearch } from "../utils";
+export class Router {
+    history;
+    basePath;
+    routes;
+    defaultLinkOptions;
+    _;
+    constructor(options) {
+        this.history = options.history ?? new BrowserHistory();
+        this.basePath = normalizePath(options.basePath ?? "/");
+        this.routes = options.routes;
+        this.defaultLinkOptions = options.defaultLinkOptions;
+        this._ = {
+            routeMap: new Map(options.routes.map(route => [route._.pattern, route]))
+        };
+    }
+    getPath(cpath) {
+        return normalizePath(`${this.basePath}/${cpath}`);
+    }
+    getCanonicalPath(path) {
+        if (path === this.basePath || path.startsWith(`${this.basePath}/`)) {
+            path = path.slice(this.basePath.length) || "/";
+        }
+        return path;
+    }
+    matchPath(path) {
+        const cpath = this.getCanonicalPath(path);
+        return this.routes.find(route => route._.regex.test(cpath));
+    }
+    getRoute(pattern) {
+        const route = this._.routeMap.get(pattern);
+        if (!route) {
+            throw new Error(`[Waymark] Route not found for pattern: ${pattern}`);
+        }
+        return route;
+    }
+    composePath(options) {
+        const { to, params, search } = options;
+        return {
+            path: this.getPath(params ? inject(to, params) : to),
+            search: search ? stringifySearch(search) : ""
+        };
+    }
+    decomposePath(route, path, search) {
+        const { keys, looseRegex, mapSearch } = route._;
+        const cpath = this.getCanonicalPath(path);
+        return {
+            params: extract(cpath, looseRegex, keys),
+            search: mapSearch(parseSearch(search))
+        };
+    }
+    navigate(options) {
+        if (typeof options === "number") {
+            this.history.go(options);
+        }
+        else {
+            const { path, search } = this.composePath(options);
+            const { replace, state } = options;
+            this.history.push({ path, search, replace, state });
+        }
+    }
+}

package/dist/utils/index.d.ts

@@ -0,0 +1,5 @@
+export * from "./path";
+export * from "./router";
+export * from "./search";
+export * from "./react";
+export * from "./misc";

package/dist/utils/index.js

@@ -0,0 +1,5 @@
+export * from "./path";
+export * from "./router";
+export * from "./search";
+export * from "./react";
+export * from "./misc";

package/dist/utils/misc.d.ts

@@ -0,0 +1,17 @@
+import type { Simplify, EmptyObject } from "type-fest";
+import type { StandardSchemaV1 } from "@standard-schema/spec";
+export type MaybeKey<K extends string, T> = T extends EmptyObject ? {
+    [P in K]?: undefined;
+} : {} extends T ? {
+    [P in K]?: T;
+} : {
+    [P in K]: T;
+};
+export type OptionalOnUndefined<T extends object> = Simplify<{
+    [K in keyof T as undefined extends T[K] ? never : K]: T[K];
+} & {
+    [K in keyof T as undefined extends T[K] ? K : never]?: T[K];
+}>;
+export declare function getHref(path: string, search?: string): string;
+export declare function clamp(value: number, min: number, max: number): number;
+export declare function validator<Input, Output>(validate: ((input: Input) => Output) | StandardSchemaV1<Input, Output>): (input: Input) => Output;

package/dist/utils/misc.js

@@ -0,0 +1,27 @@
+export function getHref(path, search) {
+    return `${path}${search ? `?${search}` : ""}`;
+}
+export function clamp(value, min, max) {
+    return Math.max(min, Math.min(value, max));
+}
+export function validator(validate) {
+    if (typeof validate === "function") {
+        return validate;
+    }
+    else {
+        return (input) => {
+            const result = validate["~standard"].validate(input);
+            if (result instanceof Promise) {
+                throw new Error("[Waymark] Validation must be synchronous");
+            }
+            else if (result.issues) {
+                throw new Error("[Waymark] Validation failed", {
+                    cause: result.issues
+                });
+            }
+            else {
+                return result.value;
+            }
+        };
+    }
+}

package/dist/utils/path.d.ts

@@ -0,0 +1,9 @@
+import type { RouteParams } from "regexparam";
+import type { Simplify } from "type-fest";
+export type ParsePattern<P extends string> = Simplify<RouteParams<P>>;
+export 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;
+export declare function normalizePath<P extends string>(path: P): NormalizePath<P>;
+export declare function extract(cpath: string, looseRegex: RegExp, keys: string[]): Record<string, string>;
+export {};

package/dist/utils/path.js

@@ -0,0 +1,19 @@
+export function normalizePath(path) {
+    const normalized = `/${path}`
+        .replaceAll(/\/+/g, "/")
+        .replace(/(.+)\/$/, "$1");
+    return normalized;
+}
+export function extract(cpath, looseRegex, keys) {
+    const out = {};
+    const matches = looseRegex.exec(cpath);
+    if (matches) {
+        keys.forEach((key, i) => {
+            const match = matches[i + 1];
+            if (match) {
+                out[key] = match;
+            }
+        });
+    }
+    return out;
+}

package/dist/utils/react.d.ts

@@ -0,0 +1,10 @@
+import { type Ref, type ComponentType } from "react";
+export type Updater<T extends object> = Partial<T> | ((prev: T) => Partial<T>);
+export type ComponentLoader = () => Promise<ComponentType | {
+    default: ComponentType;
+}>;
+export declare function defaultLinkActive(currentPath: string, targetPath: string): boolean;
+export declare function mergeRefs<T>(...inputRefs: (Ref<T> | undefined)[]): Ref<T>;
+export declare function errorBoundary(component: ComponentType<{
+    error: unknown;
+}>): ComponentType;

package/dist/utils/react.js

@@ -0,0 +1,50 @@
+import { createElement, Component } from "react";
+import { useOutlet } from "../react";
+export function defaultLinkActive(currentPath, targetPath) {
+    return currentPath.startsWith(targetPath);
+}
+export function mergeRefs(...inputRefs) {
+    const filtered = inputRefs.filter(r => !!r);
+    if (filtered.length <= 1) {
+        return filtered[0] ?? null;
+    }
+    return value => {
+        const cleanups = [];
+        for (const ref of filtered) {
+            const cleanup = assignRef(ref, value);
+            cleanups.push(cleanup ?? (() => assignRef(ref, null)));
+        }
+        return () => cleanups.forEach(cleanup => cleanup());
+    };
+}
+function assignRef(ref, value) {
+    if (typeof ref === "function") {
+        return ref(value);
+    }
+    else if (ref) {
+        ref.current = value;
+    }
+}
+export function errorBoundary(component) {
+    class Catch extends Component {
+        constructor(props) {
+            super(props);
+            this.state = { children: props.children, error: null };
+        }
+        static getDerivedStateFromError(error) {
+            return { error: [error] };
+        }
+        static getDerivedStateFromProps(props, state) {
+            if (props.children !== state.children) {
+                return { children: props.children, error: null };
+            }
+            return state;
+        }
+        render() {
+            return this.state.error
+                ? createElement(component, { error: this.state.error[0] })
+                : this.props.children;
+        }
+    }
+    return () => createElement(Catch, { children: useOutlet() });
+}

package/dist/utils/router.d.ts

@@ -0,0 +1,37 @@
+import type { Route } from "../route";
+import type { MaybeKey } from "./misc";
+export interface RegisterRoutes {
+}
+export type RouteList = RegisterRoutes extends {
+    routes: infer RouteList extends ReadonlyArray<Route<string, any, any>>;
+} ? RouteList : ReadonlyArray<Route<string, any, any>>;
+export type Routes = RouteList[number];
+export type Patterns = Routes["_"]["pattern"];
+export type RouteParams<R extends Routes> = NonNullable<R["_"]["_params"]>;
+export type RouteSearch<R extends Routes> = NonNullable<R["_"]["_search"]>;
+export type PatternParams<P extends Patterns> = RouteParams<PatternRoute<P>>;
+export type PatternSearch<P extends Patterns> = RouteSearch<PatternRoute<P>>;
+export type PatternRoute<P extends Patterns> = Extract<Routes, {
+    _: {
+        pattern: P;
+    };
+}>;
+export type NavigateOptions<P extends Patterns> = {
+    to: P;
+    replace?: boolean;
+    state?: any;
+} & MaybeKey<"params", PatternParams<P>> & MaybeKey<"search", PatternSearch<P>>;
+export interface HistoryPushOptions {
+    path: string;
+    search?: string;
+    replace?: boolean;
+    state?: any;
+}
+export interface HistoryLike {
+    getPath: () => string;
+    getSearch: () => string;
+    getState: () => any;
+    go: (delta: number) => void;
+    push: (options: HistoryPushOptions) => void;
+    subscribe: (listener: () => void) => () => void;
+}

package/dist/utils/router.js

@@ -0,0 +1 @@
+export {};

package/dist/utils/search.d.ts

@@ -0,0 +1,3 @@
+export declare function normalizeSearch(search: string): string;
+export declare function stringifySearch(search: Record<string, unknown>): string;
+export declare function parseSearch(search: string): Record<string, unknown>;

package/dist/utils/search.js

@@ -0,0 +1,31 @@
+export function normalizeSearch(search) {
+    return search.startsWith("?") ? search.slice(1) : search;
+}
+export function stringifySearch(search) {
+    return Object.entries(search)
+        .filter(([_, value]) => value !== undefined)
+        .map(([key, value]) => `${key}=${encodeURIComponent(toValueString(value))}`)
+        .join("&");
+}
+export function parseSearch(search) {
+    const urlSearch = new URLSearchParams(search);
+    return Object.fromEntries([...urlSearch.entries()].map(([key, value]) => {
+        value = decodeURIComponent(value);
+        return [key, isJSONString(value) ? JSON.parse(value) : value];
+    }));
+}
+function toValueString(value) {
+    if (typeof value === "string" && !isJSONString(value)) {
+        return value;
+    }
+    return JSON.stringify(value);
+}
+function isJSONString(value) {
+    try {
+        JSON.parse(value);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "waymark",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "description": "Simplest strongly typed router for React",
   "type": "module",
   "main": "dist/index.js",
@@ -33,10 +33,16 @@
     "prepublishOnly": "bun run build"
   },
   "devDependencies": {
+    "@standard-schema/spec": "^1.1.0",
     "@types/bun": "latest",
+    "@types/react": "^19.2.8",
+    "type-fest": "^5.4.1",
     "typescript": "^5.9.3"
   },
   "peerDependencies": {
     "react": ">=18"
+  },
+  "dependencies": {
+    "regexparam": "^3.0.0"
   }
 }

package/src/index.ts

@@ -1,2 +0,0 @@
-console.log("Hello via Bun!");
-export const a = 5;

package/tsconfig.json

@@ -1,19 +0,0 @@
-{
-  "compilerOptions": {
-    "target": "ES2022",
-    "lib": ["ESNext", "DOM"],
-    "module": "ESNext",
-    "moduleResolution": "Bundler",
-    "declaration": true,
-    "strict": true,
-    "esModuleInterop": true,
-    "skipLibCheck": true,
-    "forceConsistentCasingInFileNames": true,
-    "noUnusedLocals": true,
-    "noUnusedParameters": true,
-    "noFallthroughCasesInSwitch": true,
-    "outDir": "./dist"
-  },
-  "include": ["src"],
-  "exclude": ["node_modules", "dist", "**/*.test.ts"]
-}