@richie-router/react 0.0.1 → 0.1.2

package/dist/types/history.d.ts

@@ -0,0 +1,19 @@
+export interface HistoryLocation {
+    href: string;
+    pathname: string;
+    search: string;
+    hash: string;
+    state: unknown;
+}
+export interface RouterHistory {
+    readonly location: HistoryLocation;
+    listen(listener: () => void): () => void;
+    push(href: string, state?: unknown): void;
+    replace(href: string, state?: unknown): void;
+}
+export declare function createBrowserHistory(): RouterHistory;
+export declare function createHashHistory(): RouterHistory;
+export interface MemoryHistoryOptions {
+    initialEntries?: string[];
+}
+export declare function createMemoryHistory(options?: MemoryHistoryOptions): RouterHistory;

package/dist/types/index.d.ts

@@ -0,0 +1,2 @@
+export * from './history';
+export * from './router';

package/dist/types/router.d.ts

@@ -0,0 +1,263 @@
+import React from 'react';
+import { RouteNode, isNotFound, isRedirect, notFound, redirect } from '@richie-router/core';
+import type { AnyComponent, AnyRoute, DehydratedHeadState, HeadConfig, NormalizeRouteId, ParsedLocation, ResolveAllParams, RouteMatch, RouteOptions as CoreRouteOptions } from '@richie-router/core';
+import { createBrowserHistory, createHashHistory, createMemoryHistory } from './history';
+import type { MemoryHistoryOptions, RouterHistory } from './history';
+declare global {
+    interface Window {
+        __RICHIE_ROUTER_HEAD__?: DehydratedHeadState;
+    }
+}
+export interface Register {
+}
+type RegisteredRouteSearchSchema = Register extends {
+    routeSearchSchema: infer TRouteSearchSchema;
+} ? TRouteSearchSchema : Record<string, {}>;
+type RegisteredRouteTree = Register extends {
+    routeTree: infer TRouteTree;
+} ? TRouteTree : AnyRoute;
+interface DefaultFileTypes {
+    fullPaths: string;
+    to: string;
+    id: string;
+    fileRoutesById: Record<string, AnyRoute>;
+    fileRoutesByTo: Record<string, AnyRoute>;
+    fileRoutesByFullPath: Record<string, AnyRoute>;
+}
+type RegisteredFileTypes = RegisteredRouteTree extends {
+    __fileTypes: infer TFileTypes;
+} ? TFileTypes : DefaultFileTypes;
+type RegisteredRoutesByTo = RegisteredFileTypes extends {
+    fileRoutesByTo: infer TRoutesByTo;
+} ? TRoutesByTo : Record<string, AnyRoute>;
+export type RegisteredRouter = Register extends {
+    router: infer TRouter;
+} ? TRouter : Router<AnyRoute>;
+export type RoutePaths = RegisteredFileTypes extends {
+    to: infer TTo;
+} ? TTo & string : string;
+export type RouteById<TPath extends string> = TPath extends keyof RegisteredRoutesByTo ? RegisteredRoutesByTo[TPath] : never;
+type ParamsOfRoute<TRoute> = TRoute extends {
+    types: {
+        params: infer TParams;
+    };
+} ? TParams : Record<string, string>;
+type SearchOfRoute<TRoute> = TRoute extends {
+    types: {
+        search: infer TSearch;
+    };
+} ? TSearch : unknown;
+type MatchOfRoute<TRoute> = {
+    id: string;
+    pathname: string;
+    params: ParamsOfRoute<TRoute>;
+    route: TRoute;
+    search: SearchOfRoute<TRoute>;
+    to: TRoute extends {
+        types: {
+            to: infer TTo;
+        };
+    } ? TTo : string;
+};
+type SafeRouteByTo<TTo extends string> = [RouteById<TTo>] extends [never] ? AnyRoute : RouteById<TTo>;
+type ParamsForTo<TTo extends string> = ParamsOfRoute<SafeRouteByTo<TTo>>;
+type SearchForTo<TTo extends string> = SearchOfRoute<SafeRouteByTo<TTo>>;
+type SearchForRouteId<TPath extends string> = TPath extends keyof RegisteredRouteSearchSchema ? RegisteredRouteSearchSchema[TPath] : {};
+type ParamsInput<TParams> = TParams | ((previous: TParams) => TParams);
+type SearchInput<TSearch> = TSearch | ((previous: TSearch) => TSearch) | true;
+type ParamsOption<TParams> = keyof TParams extends never ? {
+    params?: never;
+} : {
+    params: ParamsInput<TParams>;
+};
+type ClientHeadOption<TPath extends string, TSearch> = HeadConfig | ((ctx: {
+    params: ResolveAllParams<TPath>;
+    search: TSearch;
+    matches: RouteMatch[];
+}) => HeadConfig);
+type RouteOptionsInput<TPath extends string, TSearch> = Omit<CoreRouteOptions<TPath, TSearch>, 'head'> & {
+    head?: ClientHeadOption<TPath, TSearch>;
+};
+type FileRouteInstance<TPath extends string, TSearch, TFileTypes = unknown, THasInlineHead extends boolean = boolean> = RouteNode<TPath, NormalizeRouteId<TPath>, ResolveAllParams<TPath>, TSearch, TFileTypes> & RouteApiMethods<RouteNode<TPath, NormalizeRouteId<TPath>, ResolveAllParams<TPath>, TSearch, TFileTypes>> & {
+    __hasInlineHead: THasInlineHead;
+};
+export interface TypedRouteMatch<TPath extends string, TSearch, TRoute extends AnyRoute = AnyRoute> extends Omit<RouteMatch<TRoute>, 'params' | 'search'> {
+    params: ResolveAllParams<TPath>;
+    search: TSearch;
+}
+interface RouteApiMethods<TRoute extends AnyRoute> {
+    useParams(): ParamsOfRoute<TRoute>;
+    useSearch(): SearchOfRoute<TRoute>;
+    useNavigate(): NavigateFn;
+    useMatch(): MatchOfRoute<TRoute>;
+}
+export interface NavigateBaseOptions {
+    from?: RoutePaths;
+    hash?: string;
+    replace?: boolean;
+    resetScroll?: boolean;
+    state?: Record<string, unknown>;
+    mask?: {
+        to: string;
+    };
+    ignoreBlocker?: boolean;
+}
+export type NavigateOptions<TTo extends RoutePaths = RoutePaths> = {
+    to: TTo;
+    search?: SearchInput<SearchForTo<TTo>>;
+} & NavigateBaseOptions & ParamsOption<ParamsForTo<TTo>>;
+export type NavigateFn = <TTo extends RoutePaths>(options: NavigateOptions<TTo>) => Promise<void>;
+export type LinkOwnProps<TTo extends RoutePaths> = NavigateOptions<TTo> & {
+    preload?: 'intent' | 'render' | false;
+    activeProps?: React.AnchorHTMLAttributes<HTMLAnchorElement>;
+    children?: React.ReactNode | ((ctx: {
+        isActive: boolean;
+    }) => React.ReactNode);
+};
+export type LinkProps<TTo extends RoutePaths = RoutePaths> = LinkOwnProps<TTo> & Omit<React.AnchorHTMLAttributes<HTMLAnchorElement>, keyof LinkOwnProps<TTo> | 'href'>;
+export interface RouterState {
+    status: 'idle' | 'loading';
+    location: ParsedLocation;
+    matches: RouteMatch[];
+    head: HeadConfig;
+    error: unknown;
+}
+export interface RouterOptions<TRouteTree extends AnyRoute> {
+    routeTree: TRouteTree;
+    history?: RouterHistory;
+    defaultPreload?: 'intent' | 'render' | false;
+    defaultPreloadDelay?: number;
+    defaultPendingMs?: number;
+    defaultPendingMinMs?: number;
+    defaultNotFoundComponent?: AnyComponent;
+    defaultErrorComponent?: AnyComponent;
+    scrollRestoration?: boolean;
+    scrollToTopSelectors?: string[];
+    headBasePath?: string;
+    trailingSlash?: 'always' | 'never' | 'preserve';
+    parseSearch?: (searchStr: string) => Record<string, unknown>;
+    stringifySearch?: (search: Record<string, unknown>) => string;
+    loadRouteHead?: (ctx: {
+        route: AnyRoute;
+        routeId: string;
+        params: Record<string, string>;
+        search: unknown;
+        location: ParsedLocation;
+        request?: Request;
+    }) => Promise<{
+        head: HeadConfig;
+        staleTime?: number;
+    }>;
+}
+type InternalRouteMatch = RouteMatch & {
+    id: string;
+};
+type Selector<TSelection> = (state: RouterState) => TSelection;
+export declare function createFileRoute<TPath extends string>(path: TPath): <TOptions extends RouteOptionsInput<TPath, SearchForRouteId<TPath>>>(options: TOptions) => FileRouteInstance<TPath, SearchForRouteId<TPath>, unknown, TOptions extends {
+    head: any;
+} ? true : false>;
+export declare function createRootRoute<TOptions extends RouteOptionsInput<'__root__', SearchForRouteId<'__root__'>>>(options: TOptions): FileRouteInstance<'__root__', SearchForRouteId<'__root__'>, unknown, TOptions extends {
+    head: any;
+} ? true : false>;
+export declare class Router<TRouteTree extends AnyRoute> {
+    readonly routeTree: TRouteTree;
+    readonly history: RouterHistory;
+    readonly options: RouterOptions<TRouteTree>;
+    state: RouterState;
+    readonly routesByFullPath: Map<string, AnyRoute>;
+    readonly routesByTo: Map<string, AnyRoute>;
+    private readonly listeners;
+    private readonly headCache;
+    private readonly parseSearch;
+    private readonly stringifySearch;
+    private started;
+    private unsubscribeHistory?;
+    constructor(options: RouterOptions<TRouteTree>);
+    getSnapshot: () => RouterState;
+    subscribe: (listener: () => void) => (() => void);
+    start(): void;
+    dispose(): void;
+    load(options?: {
+        request?: Request;
+    }): Promise<void>;
+    navigate<TTo extends RoutePaths>(options: NavigateOptions<TTo>): Promise<void>;
+    preloadRoute<TTo extends RoutePaths>(options: NavigateOptions<TTo>): Promise<void>;
+    invalidate(): Promise<void>;
+    buildHref<TTo extends RoutePaths>(options: NavigateOptions<TTo>): string;
+    private readLocation;
+    private applyTrailingSlash;
+    private notify;
+    private findMatchByTo;
+    buildMatches(location: ParsedLocation): InternalRouteMatch[];
+    private resolveSearch;
+    resolveLocation(location: ParsedLocation, options?: {
+        request?: Request;
+    }): Promise<{
+        matches: InternalRouteMatch[];
+        head: HeadConfig;
+        error: unknown;
+    }>;
+    private resolveLocationHead;
+    private loadRouteHead;
+    private fetchRouteHead;
+    private commitLocation;
+    private restoreScroll;
+    private handleHistoryChange;
+}
+export declare function createRouter<TRouteTree extends AnyRoute>(options: RouterOptions<TRouteTree>): Router<TRouteTree>;
+export declare function RouterProvider({ router }: {
+    router: RegisteredRouter;
+}): React.ReactElement;
+export declare function Outlet(): React.ReactNode;
+export declare function useRouter(): RegisteredRouter;
+export declare function useMatches(): RouteMatch[];
+export declare function useMatch<TFrom extends RoutePaths>(options?: {
+    from?: TFrom;
+}): MatchOfRoute<RouteById<TFrom>>;
+export declare function useParams<TFrom extends RoutePaths>(options?: {
+    from?: TFrom;
+}): ParamsOfRoute<RouteById<TFrom>>;
+export declare function useSearch<TFrom extends RoutePaths>(options?: {
+    from?: TFrom;
+}): SearchOfRoute<RouteById<TFrom>>;
+export declare function useNavigate(): NavigateFn;
+export declare function useLocation(): ParsedLocation;
+export declare function useRouterState<TSelection>(options: {
+    select: Selector<TSelection>;
+}): TSelection;
+export interface BlockerState {
+    status: 'idle' | 'blocked';
+    next: ParsedLocation | null;
+    proceed(): void;
+    reset(): void;
+}
+export declare function useBlocker(options: {
+    shouldBlockFn?: (ctx: {
+        current: ParsedLocation;
+        next: ParsedLocation | null;
+    }) => boolean;
+    withResolver?: boolean;
+    enableBeforeUnload?: boolean;
+}): BlockerState;
+export declare function Block(): null;
+export declare function useElementScrollRestoration(): {
+    ref: React.RefCallback<HTMLElement>;
+};
+export declare const Link: <TTo extends RoutePaths>(props: LinkProps<TTo> & {
+    ref?: React.Ref<HTMLAnchorElement>;
+}) => React.ReactElement;
+export declare function createLink<TProps extends {
+    href?: string;
+    children?: React.ReactNode;
+}>(Component: React.ComponentType<TProps>): <TTo extends RoutePaths>(props: LinkProps<TTo> & Omit<TProps, keyof LinkProps<TTo>>) => React.ReactElement;
+export declare function linkOptions<TTo extends RoutePaths>(options: NavigateOptions<TTo>): NavigateOptions<TTo>;
+export declare function getRouteApi<TTo extends RoutePaths>(to: TTo): {
+    useParams: () => ParamsOfRoute<RouteById<TTo>>;
+    useSearch: () => SearchOfRoute<RouteById<TTo>>;
+    useMatch: () => MatchOfRoute<RouteById<TTo>>;
+};
+export declare function createRouteMask<TMask extends {
+    to: string;
+}>(mask: TMask): TMask;
+export { redirect, notFound, isRedirect, isNotFound, createBrowserHistory, createHashHistory, createMemoryHistory, };
+export type { MemoryHistoryOptions };

package/package.json

@@ -1,10 +1,49 @@
 {
   "name": "@richie-router/react",
-  "version": "0.0.1",
-  "description": "OIDC trusted publishing setup package for @richie-router/react",
+  "version": "0.1.2",
+  "description": "React runtime, components, and hooks for Richie Router",
+  "sideEffects": false,
+  "exports": {
+    "./package.json": "./package.json",
+    ".": {
+      "types": "./dist/types/index.d.ts",
+      "import": "./dist/esm/index.mjs",
+      "require": "./dist/cjs/index.cjs",
+      "default": "./dist/esm/index.mjs"
+    }
+  },
+  "dependencies": {
+    "@richie-router/core": "^0.1.2"
+  },
+  "peerDependencies": {
+    "react": "^19"
+  },
+  "author": "Richie <oss@ricsam.dev>",
+  "homepage": "https://docs.ricsam.dev/richie-router",
+  "bugs": {
+    "url": "https://github.com/ricsam/richie-router/issues"
+  },
   "keywords": [
-    "oidc",
-    "trusted-publishing",
-    "setup"
-  ]
-}
+    "router",
+    "react",
+    "typescript",
+    "bun",
+    "file-based-routing",
+    "type-safe"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/ricsam/richie-router.git",
+    "directory": "packages/react"
+  },
+  "main": "./dist/cjs/index.cjs",
+  "module": "./dist/esm/index.mjs",
+  "types": "./dist/types/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "publishConfig": {
+    "access": "public",
+    "provenance": true
+  }
+}

package/README.md

@@ -1,45 +0,0 @@
-# @richie-router/react
-
-## ⚠️ IMPORTANT NOTICE ⚠️
-
-**This package is created solely for the purpose of setting up OIDC (OpenID Connect) trusted publishing with npm.**
-
-This is **NOT** a functional package and contains **NO** code or functionality beyond the OIDC setup configuration.
-
-## Purpose
-
-This package exists to:
-1. Configure OIDC trusted publishing for the package name `@richie-router/react`
-2. Enable secure, token-less publishing from CI/CD workflows
-3. Establish provenance for packages published under this name
-
-## What is OIDC Trusted Publishing?
-
-OIDC trusted publishing allows package maintainers to publish packages directly from their CI/CD workflows without needing to manage npm access tokens. Instead, it uses OpenID Connect to establish trust between the CI/CD provider (like GitHub Actions) and npm.
-
-## Setup Instructions
-
-To properly configure OIDC trusted publishing for this package:
-
-1. Go to [npmjs.com](https://www.npmjs.com/) and navigate to your package settings
-2. Configure the trusted publisher (e.g., GitHub Actions)
-3. Specify the repository and workflow that should be allowed to publish
-4. Use the configured workflow to publish your actual package
-
-## DO NOT USE THIS PACKAGE
-
-This package is a placeholder for OIDC configuration only. It:
-- Contains no executable code
-- Provides no functionality
-- Should not be installed as a dependency
-- Exists only for administrative purposes
-
-## More Information
-
-For more details about npm's trusted publishing feature, see:
-- [npm Trusted Publishing Documentation](https://docs.npmjs.com/generating-provenance-statements)
-- [GitHub Actions OIDC Documentation](https://docs.github.com/en/actions/deployment/security-hardening-your-deployments/about-security-hardening-with-openid-connect)
-
----
-
-**Maintained for OIDC setup purposes only**