rari 0.5.29 → 0.6.0

package/dist/RariRequest-CCo4Z2pl.mjs

@@ -0,0 +1,156 @@
+//#region src/proxy/RariRequest.ts
+var RequestCookiesImpl = class {
+	cookies;
+	pendingDeletes;
+	pendingSets;
+	constructor(cookieHeader) {
+		this.cookies = /* @__PURE__ */ new Map();
+		this.pendingDeletes = /* @__PURE__ */ new Set();
+		this.pendingSets = /* @__PURE__ */ new Map();
+		if (cookieHeader) this.parseCookieHeader(cookieHeader);
+	}
+	parseCookieHeader(header) {
+		const pairs = header.split(";").map((pair) => pair.trim());
+		for (const pair of pairs) {
+			const [name, ...valueParts] = pair.split("=");
+			if (name) {
+				const value = valueParts.join("=");
+				this.cookies.set(name, {
+					name,
+					value
+				});
+			}
+		}
+	}
+	get(name) {
+		if (this.pendingDeletes.has(name)) return void 0;
+		const pending = this.pendingSets.get(name);
+		if (pending) return {
+			name: pending.name,
+			value: pending.value,
+			path: pending.options?.path
+		};
+		return this.cookies.get(name);
+	}
+	getAll() {
+		const result = [];
+		this.cookies.forEach((cookie) => {
+			if (!this.pendingDeletes.has(cookie.name)) result.push(cookie);
+		});
+		this.pendingSets.forEach((cookie) => {
+			result.push({
+				name: cookie.name,
+				value: cookie.value,
+				path: cookie.options?.path
+			});
+		});
+		return result;
+	}
+	has(name) {
+		if (this.pendingDeletes.has(name)) return false;
+		return this.pendingSets.has(name) || this.cookies.has(name);
+	}
+	delete(name) {
+		this.pendingDeletes.add(name);
+		this.pendingSets.delete(name);
+	}
+	set(nameOrOptions, value, options) {
+		if (typeof nameOrOptions === "string") {
+			this.pendingSets.set(nameOrOptions, {
+				name: nameOrOptions,
+				value,
+				options
+			});
+			this.pendingDeletes.delete(nameOrOptions);
+		} else {
+			const { name, value: val, ...opts } = nameOrOptions;
+			this.pendingSets.set(name, {
+				name,
+				value: val,
+				options: opts
+			});
+			this.pendingDeletes.delete(name);
+		}
+	}
+	getPendingChanges() {
+		return {
+			deletes: Array.from(this.pendingDeletes),
+			sets: Array.from(this.pendingSets.values())
+		};
+	}
+};
+var RariURLImpl = class {
+	url;
+	constructor(url) {
+		this.url = typeof url === "string" ? new URL(url) : url;
+	}
+	get href() {
+		return this.url.href;
+	}
+	get origin() {
+		return this.url.origin;
+	}
+	get protocol() {
+		return this.url.protocol;
+	}
+	get hostname() {
+		return this.url.hostname;
+	}
+	get port() {
+		return this.url.port;
+	}
+	get pathname() {
+		return this.url.pathname;
+	}
+	set pathname(value) {
+		this.url.pathname = value;
+	}
+	get search() {
+		return this.url.search;
+	}
+	set search(value) {
+		this.url.search = value;
+	}
+	get searchParams() {
+		return this.url.searchParams;
+	}
+	get hash() {
+		return this.url.hash;
+	}
+	set hash(value) {
+		this.url.hash = value;
+	}
+	toString() {
+		return this.url.toString();
+	}
+};
+var RariRequest = class RariRequest {
+	url;
+	method;
+	headers;
+	cookies;
+	rariUrl;
+	ip;
+	geo;
+	constructor(input, init) {
+		if (input instanceof Request) {
+			this.url = input.url;
+			this.method = input.method;
+			this.headers = new Headers(input.headers);
+		} else {
+			this.url = typeof input === "string" ? input : input.toString();
+			this.method = init?.method || "GET";
+			this.headers = new Headers(init?.headers);
+		}
+		this.rariUrl = new RariURLImpl(this.url);
+		this.cookies = new RequestCookiesImpl(this.headers.get("cookie") || void 0);
+		this.ip = init?.ip;
+		this.geo = init?.geo;
+	}
+	static fromRequest(request, options) {
+		return new RariRequest(request, options);
+	}
+};
+
+//#endregion
+export { RariRequest as t };

package/dist/RariRequest-Cfba2VzK.mjs

@@ -0,0 +1,3 @@
+import { t as RariRequest } from "./RariRequest-CCo4Z2pl.mjs";
+
+export { RariRequest };

package/dist/app-routes-BZjZ4Vwn.mjs

@@ -0,0 +1,3 @@
+import { t as generateAppRouteManifest } from "./app-routes-DngkPk-T.mjs";
+
+export { generateAppRouteManifest };

package/dist/cli.mjs

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { t as __require } from "./chunk-DFPPfDFE.mjs";
+import { t as __require } from "./chunk-CVb4hTOq.mjs";
 import { existsSync } from "node:fs";
 import { join } from "node:path";
 import process from "node:process";
@@ -187,7 +187,7 @@ async function deployToRailway() {
 		logError(`Already running in ${getPlatformName()} environment. Use "rari start" instead.`);
 		process.exit(1);
 	}
-	const { createRailwayDeployment } = await import("./railway-B8SUWVNF.mjs");
+	const { createRailwayDeployment } = await import("./railway-O2zC15UA.mjs");
 	await createRailwayDeployment();
 }
 async function deployToRender() {
@@ -196,7 +196,7 @@ async function deployToRender() {
 		logError(`Already running in ${getPlatformName()} environment. Use "rari start" instead.`);
 		process.exit(1);
 	}
-	const { createRenderDeployment } = await import("./render-CnuI67F1.mjs");
+	const { createRenderDeployment } = await import("./render-0G06nNDC.mjs");
 	await createRenderDeployment();
 }
 async function main() {

package/dist/client.d.mts

@@ -1,2 +1,134 @@
-import { $ as PageProps, A as NavigationErrorOverlayProps, B as AppRouteEntry, C as clearPropsCacheForComponent, D as extractStaticParams, E as extractServerPropsWithCache, F as createNavigationError, G as GenerateMetadata, H as AppRouteMatch, I as fetchWithTimeout, J as LayoutProps, K as GenerateStaticParams, L as LayoutErrorBoundary, M as NavigationErrorHandler, N as NavigationErrorHandlerOptions, O as hasServerSideDataFetching, P as NavigationErrorType, Q as NotFoundProps, R as ClientRouter, S as clearPropsCache, T as extractServerProps, U as ErrorEntry, V as AppRouteManifest, W as ErrorProps, X as LoadingProps, Y as LoadingEntry, Z as NotFoundEntry, _ as RouteInfoRequest, a as LoadingSpinner, b as ServerPropsResult, c as createErrorBoundary, d as PreservedState, et as RouteSegment, f as ScrollPosition, g as RouteInfoError, h as routeInfoCache, i as HttpRuntimeClient, j as NavigationError, k as NavigationErrorOverlay, l as createHttpRuntimeClient, m as StatePreserverConfig, n as DefaultLoading, o as NotFound, p as StatePreserver, q as LayoutEntry, r as ErrorBoundary, s as RuntimeClient, t as DefaultError, tt as RouteSegmentType, u as createLoadingBoundary, v as RouteInfoResponse, w as extractMetadata, x as StaticParamsResult, y as MetadataResult, z as ClientRouterProps } from "./runtime-client-DS02_tXZ.mjs";
-export { type AppRouteEntry, type AppRouteManifest, type AppRouteMatch, ClientRouter, type ClientRouterProps, DefaultError, DefaultLoading, ErrorBoundary, type ErrorEntry, type ErrorProps, type GenerateMetadata, type GenerateStaticParams, HttpRuntimeClient, type LayoutEntry, LayoutErrorBoundary, type LayoutProps, type LoadingEntry, type LoadingProps, LoadingSpinner, type MetadataResult, type NavigationError, NavigationErrorHandler, type NavigationErrorHandlerOptions, NavigationErrorOverlay, type NavigationErrorOverlayProps, type NavigationErrorType, NotFound, type NotFoundEntry, type NotFoundProps, type PageProps, type PreservedState, RouteInfoError, RouteInfoRequest, RouteInfoResponse, type RouteSegment, type RouteSegmentType, type RuntimeClient, type ScrollPosition, type ServerPropsResult, StatePreserver, type StatePreserverConfig, type StaticParamsResult, clearPropsCache, clearPropsCacheForComponent, createErrorBoundary, createHttpRuntimeClient, createLoadingBoundary, createNavigationError, extractMetadata, extractServerProps, extractServerPropsWithCache, extractStaticParams, fetchWithTimeout, hasServerSideDataFetching, routeInfoCache };
+import { A as LoadingEntry, C as AppRouteMatch, D as GenerateStaticParams, E as GenerateMetadata, M as PageProps, N as RouteSegment, O as LayoutEntry, P as RouteSegmentType, S as AppRouteManifest, T as ErrorProps, _ as extractServerProps, a as LoadingSpinner, b as hasServerSideDataFetching, c as createErrorBoundary, d as MetadataResult, f as ServerPropsResult, g as extractMetadata, h as clearPropsCacheForComponent, i as HttpRuntimeClient, j as NotFoundEntry, k as LayoutProps, l as createHttpRuntimeClient, m as clearPropsCache, n as DefaultLoading, o as NotFound, p as StaticParamsResult, r as ErrorBoundary, s as RuntimeClient, t as DefaultError, u as createLoadingBoundary, v as extractServerPropsWithCache, w as ErrorEntry, x as AppRouteEntry, y as extractStaticParams } from "./runtime-client-q41T0L1o.mjs";
+import React, { Component, ErrorInfo, ReactNode } from "react";
+import * as react_jsx_runtime0 from "react/jsx-runtime";
+
+//#region src/router/ClientRouter.d.ts
+interface ClientRouterProps {
+  children: React.ReactNode;
+  initialRoute: string;
+}
+declare function ClientRouter({
+  children,
+  initialRoute
+}: ClientRouterProps): react_jsx_runtime0.JSX.Element;
+//#endregion
+//#region src/router/LayoutErrorBoundary.d.ts
+interface LayoutErrorBoundaryProps {
+  children: ReactNode;
+  layoutPath: string;
+  fallback?: (error: Error, reset: () => void) => ReactNode;
+  onError?: (error: Error, errorInfo: ErrorInfo) => void;
+}
+interface LayoutErrorBoundaryState {
+  hasError: boolean;
+  error: Error | null;
+}
+declare class LayoutErrorBoundary extends Component<LayoutErrorBoundaryProps, LayoutErrorBoundaryState> {
+  constructor(props: LayoutErrorBoundaryProps);
+  static getDerivedStateFromError(error: Error): LayoutErrorBoundaryState;
+  componentDidCatch(error: Error, errorInfo: ErrorInfo): void;
+  reset: () => void;
+  render(): ReactNode;
+}
+//#endregion
+//#region src/router/navigation-error-handler.d.ts
+type NavigationErrorType = 'fetch-error' | 'timeout' | 'abort' | 'parse-error' | 'network-error' | 'not-found' | 'server-error';
+interface NavigationError {
+  type: NavigationErrorType;
+  message: string;
+  originalError?: Error;
+  statusCode?: number;
+  url?: string;
+  timestamp: number;
+  retryable: boolean;
+}
+interface NavigationErrorHandlerOptions {
+  timeout?: number;
+  maxRetries?: number;
+  onError?: (error: NavigationError) => void;
+  onRetry?: (attempt: number, error: NavigationError) => void;
+}
+declare class NavigationErrorHandler {
+  private options;
+  private retryCount;
+  constructor(options?: NavigationErrorHandlerOptions);
+  handleError(error: unknown, url: string): NavigationError;
+  canRetry(error: NavigationError, url: string): boolean;
+  incrementRetry(url: string): number;
+  resetRetry(url: string): void;
+  getRetryCount(url: string): number;
+  clearRetries(): void;
+}
+//#endregion
+//#region src/router/NavigationErrorOverlay.d.ts
+interface NavigationErrorOverlayProps {
+  error: NavigationError;
+  onRetry?: () => void;
+  onReload?: () => void;
+  onDismiss?: () => void;
+  retryCount?: number;
+  maxRetries?: number;
+}
+declare function NavigationErrorOverlay({
+  error,
+  onRetry,
+  onReload,
+  onDismiss,
+  retryCount,
+  maxRetries
+}: NavigationErrorOverlayProps): react_jsx_runtime0.JSX.Element;
+//#endregion
+//#region src/router/route-info-types.d.ts
+interface RouteInfoRequest {
+  path: string;
+}
+interface RouteInfoResponse {
+  exists: boolean;
+  layouts: string[];
+  loading: string | null;
+  isDynamic: boolean;
+  params?: string[];
+}
+interface RouteInfoError {
+  error: string;
+  code: 'NOT_FOUND' | 'INVALID_PATH' | 'SERVER_ERROR';
+}
+//#endregion
+//#region src/router/StatePreserver.d.ts
+interface ScrollPosition {
+  x: number;
+  y: number;
+  element: string;
+}
+interface PreservedState {
+  scrollPositions: Map<string, ScrollPosition>;
+  formData: Map<string, FormData>;
+  focusedElement: string | null;
+}
+interface StatePreserverConfig {
+  maxHistorySize?: number;
+  scrollableSelector?: string;
+}
+declare class StatePreserver {
+  private stateHistory;
+  private routeAccessOrder;
+  private maxHistorySize;
+  private scrollableSelector;
+  constructor(config?: StatePreserverConfig);
+  captureState(route: string): PreservedState;
+  private captureScrollPositions;
+  private captureFormData;
+  private captureFocusedElement;
+  private storeState;
+  getHistorySize(): number;
+  hasState(route: string): boolean;
+  getState(route: string): PreservedState | undefined;
+  clearAll(): void;
+  clearState(route: string): void;
+  restoreState(route: string): boolean;
+  private restoreScrollPositions;
+  private restoreFormData;
+  private restoreFocus;
+}
+//#endregion
+export { type AppRouteEntry, type AppRouteManifest, type AppRouteMatch, ClientRouter, type ClientRouterProps, DefaultError, DefaultLoading, ErrorBoundary, type ErrorEntry, type ErrorProps, type GenerateMetadata, type GenerateStaticParams, HttpRuntimeClient, type LayoutEntry, LayoutErrorBoundary, type LayoutProps, type LoadingEntry, LoadingSpinner, type MetadataResult, type NavigationError, NavigationErrorHandler, type NavigationErrorHandlerOptions, NavigationErrorOverlay, type NavigationErrorOverlayProps, type NavigationErrorType, NotFound, type NotFoundEntry, type PageProps, type PreservedState, RouteInfoError, RouteInfoRequest, RouteInfoResponse, type RouteSegment, type RouteSegmentType, type RuntimeClient, type ScrollPosition, type ServerPropsResult, StatePreserver, type StatePreserverConfig, type StaticParamsResult, clearPropsCache, clearPropsCacheForComponent, createErrorBoundary, createHttpRuntimeClient, createLoadingBoundary, extractMetadata, extractServerProps, extractServerPropsWithCache, extractStaticParams, hasServerSideDataFetching };