@solidjs/router 0.4.2

package/dist/components.jsx

@@ -0,0 +1,111 @@
+/*@refresh skip*/
+import { children, createMemo, createRoot, mergeProps, on, Show, splitProps } from "solid-js";
+import { isServer } from "solid-js/web";
+import { pathIntegration, staticIntegration } from "./integration";
+import { createBranches, createRouteContext, createRouterContext, getRouteMatches, RouteContextObj, RouterContextObj, useHref, useLocation, useNavigate, useResolvedPath, useRoute, useRouter } from "./routing";
+import { joinPaths } from "./utils";
+export const Router = (props) => {
+    const { source, url, base, data, out } = props;
+    const integration = source || (isServer ? staticIntegration({ value: url || "" }) : pathIntegration());
+    const routerState = createRouterContext(integration, base, data, out);
+    return (<RouterContextObj.Provider value={routerState}>{props.children}</RouterContextObj.Provider>);
+};
+export const Routes = (props) => {
+    const router = useRouter();
+    const parentRoute = useRoute();
+    const routeDefs = children(() => props.children);
+    const branches = createMemo(() => createBranches(routeDefs(), joinPaths(parentRoute.pattern, props.base || ""), Outlet));
+    const matches = createMemo(() => getRouteMatches(branches(), router.location.pathname));
+    if (router.out) {
+        router.out.matches.push(matches().map(({ route, path, params }) => ({
+            originalPath: route.originalPath,
+            pattern: route.pattern,
+            path,
+            params
+        })));
+    }
+    const disposers = [];
+    let root;
+    const routeStates = createMemo(on(matches, (nextMatches, prevMatches, prev) => {
+        let equal = prevMatches && nextMatches.length === prevMatches.length;
+        const next = [];
+        for (let i = 0, len = nextMatches.length; i < len; i++) {
+            const prevMatch = prevMatches && prevMatches[i];
+            const nextMatch = nextMatches[i];
+            if (prev && prevMatch && nextMatch.route.key === prevMatch.route.key) {
+                next[i] = prev[i];
+            }
+            else {
+                equal = false;
+                if (disposers[i]) {
+                    disposers[i]();
+                }
+                createRoot(dispose => {
+                    disposers[i] = dispose;
+                    next[i] = createRouteContext(router, next[i - 1] || parentRoute, () => routeStates()[i + 1], () => matches()[i]);
+                });
+            }
+        }
+        disposers.splice(nextMatches.length).forEach(dispose => dispose());
+        if (prev && equal) {
+            return prev;
+        }
+        root = next[0];
+        return next;
+    }));
+    return (<Show when={routeStates() && root}>
+      {route => <RouteContextObj.Provider value={route}>{route.outlet()}</RouteContextObj.Provider>}
+    </Show>);
+};
+export const useRoutes = (routes, base) => {
+    return () => <Routes base={base}>{routes}</Routes>;
+};
+export const Route = (props) => {
+    const childRoutes = children(() => props.children);
+    return mergeProps(props, {
+        get children() {
+            return childRoutes();
+        }
+    });
+};
+export const Outlet = () => {
+    const route = useRoute();
+    return (<Show when={route.child}>
+      {child => <RouteContextObj.Provider value={child}>{child.outlet()}</RouteContextObj.Provider>}
+    </Show>);
+};
+function LinkBase(props) {
+    const [, rest] = splitProps(props, ["children", "to", "href", "state"]);
+    const href = useHref(() => props.to);
+    return (<a {...rest} href={href() || props.href} state={JSON.stringify(props.state)}>
+      {props.children}
+    </a>);
+}
+export function Link(props) {
+    const to = useResolvedPath(() => props.href);
+    return <LinkBase {...props} to={to()}/>;
+}
+export function NavLink(props) {
+    props = mergeProps({ inactiveClass: "inactive", activeClass: "active" }, props);
+    const [, rest] = splitProps(props, ["activeClass", "inactiveClass", "end"]);
+    const location = useLocation();
+    const to = useResolvedPath(() => props.href);
+    const isActive = createMemo(() => {
+        const to_ = to();
+        if (to_ === undefined) {
+            return false;
+        }
+        const path = to_.split(/[?#]/, 1)[0].toLowerCase();
+        const loc = location.pathname.toLowerCase();
+        return props.end ? path === loc : loc.startsWith(path);
+    });
+    return (<LinkBase {...rest} to={to()} classList={{ [props.inactiveClass]: !isActive(), [props.activeClass]: isActive(), ...rest.classList }} aria-current={isActive() ? "page" : undefined}/>);
+}
+export function Navigate(props) {
+    const navigate = useNavigate();
+    const location = useLocation();
+    const { href, state } = props;
+    const path = typeof href === "function" ? href({ navigate, location }) : href;
+    navigate(path, { replace: true, state });
+    return null;
+}

package/dist/index.d.ts

@@ -0,0 +1,5 @@
+export * from "./components";
+export * from "./integration";
+export { useRouteData, useHref, useIsRouting, useLocation, useMatch, useNavigate, useParams, useResolvedPath, useSearchParams } from "./routing";
+export { mergeSearchString as _mergeSearchString } from "./utils";
+export type { Location, LocationChange, LocationChangeSignal, NavigateOptions, Navigator, OutputMatch, Params, RouteDataFunc, RouteDataFuncArgs, RouteDefinition, RouterIntegration, RouterOutput, RouterUtils, SetParams } from "./types";