rari 0.15.4 → 0.15.6

package/dist/type-guards-CTkEL8zw.mjs

@@ -0,0 +1 @@
+function e(e){return typeof e==`object`&&!!e&&!Array.isArray(e)}function t(e){return e instanceof Error&&`code`in e}function n(e){return typeof e==`function`}function r(t){try{let n=JSON.parse(t);return e(n)?n:null}catch{return null}}function i(e){let t=e.packageManager;return typeof t==`string`?t.startsWith(`pnpm`)?`pnpm`:t.startsWith(`yarn`)?`yarn`:t.startsWith(`bun`)?`bun`:t.startsWith(`npm`)?`npm`:null:null}function a(t){let n=e(t.dependencies)?t.dependencies:{},r=e(t.devDependencies)?t.devDependencies:{},i={...n,...r};return typeof i[`vite-plus`]==`string`?`vp`:typeof i.vite==`string`?`vite`:null}function o(e,t){if(!(e instanceof CustomEvent))return;let n=e.detail;if(t(n))return n}function s(e){return t(e)?e.code:void 0}function c(t,n){let i=r(t);if(!i)return null;let a=i[n];return Array.isArray(a)?a.filter(e):null}function l(t){return Array.isArray(t)?t.every(t=>{if(!e(t))return!1;let{find:n,replacement:r}=t;return(typeof n==`string`||n instanceof RegExp)&&typeof r==`string`}):!1}function u(t){return typeof t==`function`||e(t)&&(`$$typeof`in t||`render`in t)}function d(e){return`type`in e}function f(e){return Array.isArray(e)&&typeof e[0]==`string`}function p(t){return e(t)&&t.$$typeof===Symbol.for(`react.client.reference`)}function m(t){return e(t)&&typeof t.$$id==`string`}function h(e){return e.props}function g(e){return Object.entries(e).flatMap(([e,t])=>typeof t==`string`?[{find:e,replacement:t}]:[])}function _(t){return e(t)&&typeof t.route==`string`&&typeof t.navigationId==`number`&&typeof t.timestamp==`number`&&typeof t.key==`string`}function v(e){return Array.isArray(e)&&e.every(e=>typeof e==`string`)}function y(t){return Array.isArray(t)?t.every(t=>e(t)?Object.values(t).every(e=>typeof e==`string`||v(e)):!1):!1}function b(e){console.warn(`[rari] generateStaticParams() in ${e} returned invalid params. Expected Array<Record<string, string | string[]>> (e.g. [{ slug: "post" }]). Static routes for this page will not be generated.`)}export{i as _,m as a,u as c,_ as d,d as f,r as g,c as h,h as i,f as l,y as m,o as n,l as o,e as p,s as r,p as s,g as t,n as u,a as v,b as y};

package/dist/types-BYob0lqv.d.mts

@@ -0,0 +1,185 @@
+/// <reference types="vite-plus/client" />
+//#region src/ambient.d.ts
+declare module 'virtual:react-flight-client' {
+  export interface Thenable<T> extends Promise<T> {
+    readonly status?: 'pending' | 'fulfilled' | 'rejected';
+    readonly value?: T;
+    readonly reason?: unknown;
+  }
+  export function createServerReference<A extends unknown[] = unknown[], R = unknown>(id: string, callServer: (id: string, args: A) => Promise<R>, encodeFormAction?: (args: A) => Promise<FormData | string>): unknown;
+  export function createFromReadableStream<T>(stream: ReadableStream<Uint8Array>, options?: Readonly<{
+    readonly callServer?: (id: string, args: readonly unknown[]) => Promise<unknown>;
+    readonly moduleMap?: unknown;
+    readonly moduleLoading?: unknown;
+  }>): Thenable<T>;
+  export function createFromFetch<T>(promiseForResponse: Promise<Response>, options?: Readonly<{
+    readonly callServer?: (id: string, args: readonly unknown[]) => Promise<unknown>;
+    readonly temporaryReferences?: Map<string, unknown>;
+  }>): Promise<T>;
+  export function createTemporaryReferenceSet(): Map<string, unknown>;
+  export function encodeReply(value: unknown, options?: Readonly<{
+    readonly temporaryReferences?: Map<string, unknown>;
+    readonly signal?: AbortSignal;
+  }>): Promise<FormData | string>;
+}
+declare module 'react-server-dom-webpack/client' {
+  export type { Thenable } from 'virtual:react-flight-client';
+  export { createFromReadableStream, createServerReference, encodeReply } from 'virtual:react-flight-client';
+}
+declare module 'react-server-dom-webpack/server' {
+  export function registerClientReference<T>(clientReference: T, id: string, exportName: string): T;
+  export function createClientModuleProxy(moduleId: string): unknown;
+  export function registerServerReference<T>(serverReference: T, id: string, exportName: string | null): T;
+}
+declare global {
+  interface RequestInit {
+    rari?: {
+      revalidate?: number | false;
+      tags?: string[];
+      timeout?: number;
+    };
+  }
+  interface GlobalThis {
+    '~rariExecuteProxy'?: (request: Readonly<{
+      readonly url: string;
+      readonly method: string;
+      readonly headers: {
+        readonly [key: string]: string;
+      };
+    }>) => Promise<{
+      continue: boolean;
+      redirect?: {
+        destination: string;
+        permanent: boolean;
+      };
+      rewrite?: string;
+      requestHeaders?: Record<string, string | string[]>;
+      responseHeaders?: Record<string, string | string[]>;
+      response?: {
+        status: number;
+        headers: Record<string, string | string[]>;
+        body?: string;
+      };
+    }>;
+  }
+}
+//#endregion
+//#region src/router/build/api-routes.d.ts
+interface RouteContext<TParams extends Record<string, string> = Record<string, string>> {
+  readonly params: TParams;
+}
+type RouteHandler<TParams extends Record<string, string> = Record<string, string>> = (request: Request, context?: RouteContext<TParams>) => Response | Promise<Response>;
+interface ApiRouteHandlers<TParams extends Record<string, string> = Record<string, string>> {
+  GET?: RouteHandler<TParams>;
+  POST?: RouteHandler<TParams>;
+  PUT?: RouteHandler<TParams>;
+  DELETE?: RouteHandler<TParams>;
+  PATCH?: RouteHandler<TParams>;
+  HEAD?: RouteHandler<TParams>;
+  OPTIONS?: RouteHandler<TParams>;
+}
+declare class ApiResponse extends Response {
+  static json(data: unknown, init?: ResponseInit): Response;
+  static redirect(url: string, status?: number): Response;
+  static noContent(init?: ResponseInit): Response;
+}
+//#endregion
+//#region src/router/metadata/types.d.ts
+interface RobotsRule {
+  readonly userAgent?: string | readonly string[];
+  readonly allow?: string | readonly string[];
+  readonly disallow?: string | readonly string[];
+  readonly crawlDelay?: number;
+}
+interface Robots {
+  readonly rules: RobotsRule | readonly RobotsRule[];
+  readonly sitemap?: string | readonly string[];
+  readonly host?: string;
+}
+interface SitemapImage {
+  readonly loc: string;
+  readonly title?: string;
+  readonly caption?: string;
+  readonly geoLocation?: string;
+  readonly license?: string;
+}
+interface SitemapVideo {
+  readonly title: string;
+  readonly thumbnail_loc: string;
+  readonly description: string;
+  readonly content_loc?: string;
+  readonly player_loc?: string;
+  readonly duration?: number;
+  readonly expiration_date?: string;
+  readonly rating?: number;
+  readonly view_count?: number;
+  readonly publication_date?: string;
+  readonly family_friendly?: boolean;
+  readonly restriction?: {
+    readonly relationship: 'allow' | 'deny';
+    readonly content: string;
+  };
+  readonly platform?: {
+    readonly relationship: 'allow' | 'deny';
+    readonly content: string;
+  };
+  readonly requires_subscription?: boolean;
+  readonly uploader?: {
+    readonly name: string;
+    readonly info?: string;
+  };
+  readonly live?: boolean;
+  readonly tag?: readonly string[];
+}
+interface SitemapEntry {
+  readonly url: string;
+  readonly lastModified?: string | Date;
+  readonly changeFrequency?: 'always' | 'hourly' | 'daily' | 'weekly' | 'monthly' | 'yearly' | 'never';
+  readonly priority?: number;
+  readonly alternates?: {
+    readonly languages?: {
+      readonly [key: string]: string;
+    };
+  };
+  readonly images?: readonly (string | SitemapImage)[];
+  readonly videos?: readonly SitemapVideo[];
+}
+type Sitemap = readonly SitemapEntry[];
+interface FeedEntry {
+  readonly title: string;
+  readonly url: string;
+  readonly description?: string;
+  readonly content?: string;
+  readonly author?: string | {
+    readonly name: string;
+    readonly email?: string;
+    readonly url?: string;
+  };
+  readonly pubDate?: string | Date;
+  readonly guid?: string;
+  readonly categories?: readonly string[];
+  readonly enclosure?: {
+    readonly url: string;
+    readonly length?: number;
+    readonly type?: string;
+  };
+}
+interface Feed {
+  readonly title: string;
+  readonly description: string;
+  readonly link: string;
+  readonly language?: string;
+  readonly copyright?: string;
+  readonly lastBuildDate?: string | Date;
+  readonly ttl?: number;
+  readonly image?: {
+    readonly url: string;
+    readonly title: string;
+    readonly link: string;
+    readonly width?: number;
+    readonly height?: number;
+  };
+  readonly items: readonly FeedEntry[];
+}
+//#endregion
+export { Sitemap as a, SitemapVideo as c, RouteContext as d, RouteHandler as f, RobotsRule as i, ApiResponse as l, FeedEntry as n, SitemapEntry as o, Robots as r, SitemapImage as s, Feed as t, ApiRouteHandlers as u };

package/dist/types-DAdRjhuk.d.mts

@@ -0,0 +1,130 @@
+//#region src/proxy/http/response.d.ts
+declare class RariResponse extends Response {
+  readonly cookies: ResponseCookies;
+  constructor(body?: BodyInit | null, init?: ResponseInit);
+  static next(init?: Readonly<{
+    readonly request?: {
+      readonly headers?: Headers | {
+        readonly [key: string]: string;
+      };
+    };
+  }>): RariResponse;
+  static redirect(url: string | URL, status?: number): RariResponse;
+  static rewrite(destination: string | URL): RariResponse;
+  static json(data: unknown, init?: ResponseInit): RariResponse;
+}
+//#endregion
+//#region src/proxy/http/types.d.ts
+interface RariRequest {
+  readonly url: string;
+  readonly method: string;
+  readonly headers: Headers;
+  readonly cookies: RequestCookies;
+  readonly rariUrl: RariURL;
+  readonly ip?: string;
+  readonly geo?: Readonly<{
+    city?: string;
+    country?: string;
+    region?: string;
+    latitude?: string;
+    longitude?: string;
+  }>;
+}
+interface RariURL {
+  readonly href: string;
+  readonly origin: string;
+  readonly protocol: string;
+  readonly hostname: string;
+  readonly port: string;
+  readonly pathname: string;
+  readonly search: string;
+  readonly searchParams: URLSearchParams;
+  readonly hash: string;
+}
+interface RequestCookies {
+  readonly get: (name: string) => Readonly<{
+    name: string;
+    value: string;
+    path?: string;
+  }> | undefined;
+  readonly getAll: () => ReadonlyArray<Readonly<{
+    name: string;
+    value: string;
+    path?: string;
+  }>>;
+  readonly has: (name: string) => boolean;
+  readonly delete: (name: string) => void;
+  readonly set: ((name: string, value: string, options?: Readonly<CookieOptions>) => void) & ((options: Readonly<{
+    name: string;
+    value: string;
+  } & CookieOptions>) => void);
+}
+interface ResponseCookies {
+  readonly get: (name: string) => Readonly<{
+    name: string;
+    value: string;
+    path?: string;
+  }> | undefined;
+  readonly getAll: () => ReadonlyArray<Readonly<{
+    name: string;
+    value: string;
+    path?: string;
+  }>>;
+  readonly set: ((name: string, value: string, options?: Readonly<CookieOptions>) => void) & ((options: Readonly<{
+    name: string;
+    value: string;
+  } & CookieOptions>) => void);
+  readonly delete: (name: string) => void;
+  readonly toSetCookieHeaders: () => string[];
+}
+interface CookieOptions {
+  readonly path?: string;
+  readonly domain?: string;
+  readonly maxAge?: number;
+  readonly expires?: Date;
+  readonly httpOnly?: boolean;
+  readonly secure?: boolean;
+  readonly sameSite?: 'strict' | 'lax' | 'none';
+}
+interface RariFetchEvent {
+  readonly waitUntil: (promise: Promise<unknown>) => void;
+}
+type ProxyFunctionResult = Response | RariResponse | null | undefined;
+type ProxyFunction = (request: RariRequest, event?: RariFetchEvent) => Promise<ProxyFunctionResult> | ProxyFunctionResult;
+interface ProxyCondition {
+  readonly type: 'header' | 'query' | 'cookie';
+  readonly key: string;
+  readonly value?: string;
+}
+type ProxyRuleCondition = ProxyCondition | {
+  readonly type: 'host';
+  readonly key: string;
+  readonly value?: string;
+};
+interface ProxyMatcher {
+  readonly source: string;
+  readonly locale?: boolean;
+  readonly has?: ReadonlyArray<ProxyRuleCondition>;
+  readonly missing?: ReadonlyArray<ProxyRuleCondition>;
+}
+interface ProxyConfig {
+  readonly matcher?: string | readonly string[] | ProxyMatcher | readonly ProxyMatcher[];
+}
+interface ProxyModule {
+  readonly proxy?: ProxyFunction;
+  readonly default?: ProxyFunction;
+  readonly config?: ProxyConfig;
+}
+interface ProxyResult {
+  readonly continue: boolean;
+  readonly response?: Response;
+  readonly requestHeaders?: Readonly<Record<string, string | readonly string[]>>;
+  readonly responseHeaders?: Readonly<Record<string, string | readonly string[]>>;
+  readonly rewrite?: string;
+  readonly redirect?: {
+    readonly destination: string;
+    readonly permanent: boolean;
+  };
+}
+//#endregion
+export { ProxyModule as a, RariURL as c, RariResponse as d, ProxyMatcher as i, RequestCookies as l, ProxyConfig as n, ProxyResult as o, ProxyFunction as r, RariFetchEvent as s, CookieOptions as t, ResponseCookies as u };

package/dist/{types-DlF9FHQc.d.mts → types-DCEyvFz7.d.mts}

@@ -1,5 +1,4 @@
 import { ReactNode } from "react";
-
 //#region src/router/build/types.d.ts
 type RouteSegmentType = 'static' | 'dynamic' | 'catch-all' | 'optional-catch-all';
 interface RouteSegment {
@@ -162,35 +161,39 @@ interface RouteMetadata {
   };
 }
 type Metadata = RouteMetadata;
-type RouteParams = Record<string, string | string[]>;
-type SearchParams = Record<string, string | string[] | undefined>;
-interface PageProps<TParams extends RouteParams = RouteParams, TSearchParams extends SearchParams = SearchParams> {
+interface RouteParams {
+  readonly [key: string]: string | readonly string[];
+}
+interface SearchParams {
+  readonly [key: string]: string | readonly string[] | undefined;
+}
+type PageProps<TParams extends RouteParams = RouteParams, TSearchParams extends SearchParams = SearchParams> = Readonly<{
   params: TParams;
   searchParams: TSearchParams;
-}
-interface LayoutProps<TParams extends RouteParams = RouteParams> {
+}>;
+type LayoutProps<TParams extends RouteParams = RouteParams> = Readonly<{
   children: ReactNode;
   params?: TParams;
   pathname?: string;
-}
+}>;
 interface ErrorProps {
-  error: Error;
-  reset: () => void;
+  readonly error: Error;
+  readonly reset: () => void;
 }
 interface AppRouteMatch {
-  route: AppRouteEntry;
-  params: RouteParams;
-  searchParams: SearchParams;
-  layouts: LayoutEntry[];
-  loading?: LoadingEntry;
-  error?: ErrorEntry;
-  templates: TemplateEntry[];
-  pathname: string;
+  readonly route: AppRouteEntry;
+  readonly params: RouteParams;
+  readonly searchParams: SearchParams;
+  readonly layouts: readonly LayoutEntry[];
+  readonly loading?: LoadingEntry;
+  readonly error?: ErrorEntry;
+  readonly templates: readonly TemplateEntry[];
+  readonly pathname: string;
 }
-type GenerateMetadata<TParams extends RouteParams = RouteParams, TSearchParams extends SearchParams = SearchParams> = (props: {
+type GenerateMetadata<TParams extends RouteParams = RouteParams, TSearchParams extends SearchParams = SearchParams> = (props: Readonly<{
   params: TParams;
   searchParams: TSearchParams;
-}) => RouteMetadata | Promise<RouteMetadata>;
+}>) => RouteMetadata | Promise<RouteMetadata>;
 type GenerateStaticParams<TParams extends RouteParams = RouteParams> = () => TParams[] | Promise<TParams[]>;
 //#endregion
 export { ErrorProps as a, LayoutEntry as c, Metadata as d, NotFoundEntry as f, TemplateEntry as g, RouteSegmentType as h, ErrorEntry as i, LayoutProps as l, RouteSegment as m, AppRouteManifest as n, GenerateMetadata as o, PageProps as p, AppRouteMatch as r, GenerateStaticParams as s, AppRouteEntry as t, LoadingEntry as u };

package/dist/types-_vPM8QuJ.d.mts

@@ -0,0 +1,125 @@
+//#region src/runtime/shared/types.d.ts
+interface CookieOptions {
+  readonly path?: string;
+  readonly domain?: string;
+  readonly expires?: Date;
+  readonly maxAge?: number;
+  readonly httpOnly?: boolean;
+  readonly secure?: boolean;
+  readonly sameSite?: boolean | 'lax' | 'strict' | 'none';
+  readonly priority?: 'low' | 'medium' | 'high';
+  readonly partitioned?: boolean;
+}
+interface ReadonlyCookie {
+  readonly name: string;
+  readonly value: string;
+}
+interface ReadonlyHeaders {
+  readonly get: (name: string) => string | null;
+  readonly has: (name: string) => boolean;
+  readonly entries: () => IterableIterator<[string, string]>;
+  readonly forEach: (callback: (value: string, key: string) => void) => void;
+  readonly keys: () => IterableIterator<string>;
+  readonly values: () => IterableIterator<string>;
+}
+interface CookieStore {
+  readonly get: (name: string) => ReadonlyCookie | undefined;
+  readonly getAll: (name?: string) => readonly ReadonlyCookie[];
+  readonly has: (name: string) => boolean;
+  readonly set: ((name: string, value: string, options?: Readonly<CookieOptions>) => void) & ((options: Readonly<{
+    name: string;
+    value: string;
+  } & CookieOptions>) => void);
+  readonly delete: (name: string) => void;
+  readonly toString: () => string;
+}
+interface ComponentInfo {
+  id: string;
+  path: string;
+  type: string;
+  component?: any;
+  registered: boolean;
+  loader?: () => Promise<any>;
+  loading?: boolean;
+  loadPromise?: Promise<any>;
+  loadError?: unknown;
+  exportName?: string;
+  displayName?: string;
+}
+interface GlobalWithRari {
+  '~rari'?: {
+    isDevelopment?: boolean;
+    navigationId?: number;
+    AppRouterProvider?: any;
+    ClientRouter?: any;
+    getClientComponent?: (id: string) => Promise<any>;
+    preloadClientComponent?: (id: string) => Promise<void>;
+    streaming?: {
+      enabled?: boolean;
+      complete?: boolean;
+      bufferedRows: string[];
+      streamingBridgeInstalled?: boolean;
+    };
+    serverComponents?: Set<string>;
+    routeInfoCache?: {
+      clear: () => void;
+      invalidate?: (path: string) => void;
+    };
+    cookies?: () => CookieStore;
+    headers?: () => ReadonlyHeaders;
+    useCacheDynamicDepth?: number;
+    useCacheBuildId?: string;
+    useCachePrivateKey?: string;
+    pageCacheTags?: Set<string>;
+    invalidateUseCache?: (input: Readonly<{
+      tag?: string;
+      path?: string;
+    }>) => Promise<void>;
+    markUseCacheDynamic?: () => void;
+  };
+  '~clientComponents'?: Record<string, ComponentInfo>;
+  '~clientComponentPaths'?: Record<string, string>;
+  '~clientComponentNames'?: Record<string, string>;
+}
+declare global {
+  interface GlobalThis {
+    '~rari'?: GlobalWithRari['~rari'];
+    '~clientComponents'?: GlobalWithRari['~clientComponents'];
+    '~clientComponentPaths'?: GlobalWithRari['~clientComponentPaths'];
+    '~clientComponentNames'?: GlobalWithRari['~clientComponentNames'];
+    '~rariExecuteProxy'?: (request: Readonly<{
+      readonly url: string;
+      readonly method: string;
+      readonly headers: {
+        readonly [key: string]: string;
+      };
+    }>) => Promise<{
+      continue: boolean;
+      redirect?: {
+        destination: string;
+        permanent: boolean;
+      };
+      rewrite?: string;
+      requestHeaders?: Record<string, string | string[]>;
+      responseHeaders?: Record<string, string | string[]>;
+      response?: {
+        status: number;
+        headers: Record<string, string | string[]>;
+        body?: string;
+      };
+    }>;
+    'registerClientComponent'?: (key: string, id: string, reference: unknown) => void;
+    '__rari_rsc_require__'?: (id: string) => unknown;
+    '__rari_client_ready'?: boolean;
+    '__rari_f'?: ReadonlyArray<0 | string | readonly [2, string]>;
+    '__rari_chunk_load__'?: (chunkId: string) => Promise<unknown>;
+  }
+  interface Window {
+    '~rari'?: GlobalWithRari['~rari'];
+    '~clientComponents'?: GlobalWithRari['~clientComponents'];
+    '~clientComponentPaths'?: GlobalWithRari['~clientComponentPaths'];
+    '~clientComponentNames'?: GlobalWithRari['~clientComponentNames'];
+  }
+}
+//#endregion
+export { ReadonlyHeaders as i, CookieStore as n, ReadonlyCookie as r, CookieOptions as t };

package/dist/utils-C-LVG9QI-D-IHIad5.mjs

@@ -0,0 +1,37 @@
+import{existsSync as e,readFileSync as t,writeFileSync as n}from"node:fs";import{join as r}from"node:path";import i from"node:process";import{styleText as a}from"node:util";function o(e){console.warn(`${a(`blue`,`info`)} ${e}`)}function s(e){console.warn(`${a(`green`,`✓`)} ${e}`)}function c(e){console.error(`${a(`red`,`✗`)} ${e}`)}function l(e){console.warn(`${a(`yellow`,`⚠`)} ${e}`)}const u=/\s+(?:&&\s+)?/,d=/^>=?\s*(\d+)/,f=/^>=?\s*(\d+)\.(\d+)\.(\d+)/,p=/^=?\s*(\d+)\.(\d+)\.(\d+)/,m=/^\^\s*(\d+)\.(\d+)\.(\d+)/,h=/^~\s*(\d+)\.(\d+)\.(\d+)/,g=/^(?:>=?|<=?|[=~^])?\s*(\d+)\.(\d+)/,_=/^(\d+)\.(?:x|\*)/i,v=/^(?:>=?|[=~^])\s*(\d+)(?:\s|$)/,y=/^(\d+)$/;function b(e){return typeof e==`object`&&!!e}function x(e){let t=JSON.parse(e);if(!b(t))throw Error(`Invalid package.json`);return t}function S(e,t=`>=22.18.0`){if(e.engines=e.engines??{},e.engines.node){if(!C(e.engines.node,t))return l(`Current engines.node value "${e.engines.node}" may not meet the required minimum of ${t}`),l(`Updating to ${t} for deployment compatibility`),e.engines.node=t,!0}else return e.engines.node=t,!0;return!1}function C(e,t){let n=w(e),r=w(t);return!n||!r?!1:T(n,r)>=0}function w(e){let t=e.trim(),n=e=>e!==null;if(t.includes(`||`)){let e=t.split(`||`).map(e=>e.trim()).map(e=>w(e)).filter(n);return e.length===0?null:e.reduce((e,t)=>T(t,e)<0?t:e)}let r=t.split(u).filter(e=>e!==``&&e!==`&&`);if(r.length>1){let e=r.filter(e=>d.test(e)).map(e=>w(e)).filter(n);return e.length===0?null:e.reduce((e,t)=>T(t,e)>0?t:e)}let i=null;return i=f.exec(t),i||(i=p.exec(t),i)||(i=m.exec(t),i)||(i=h.exec(t),i)?{major:Number.parseInt(i[1],10),minor:Number.parseInt(i[2],10),patch:Number.parseInt(i[3],10)}:(i=g.exec(t),i?{major:Number.parseInt(i[1],10),minor:Number.parseInt(i[2],10),patch:0}:(i=_.exec(t),i||(i=v.exec(t),i)||(i=y.exec(t),i)?{major:Number.parseInt(i[1],10),minor:0,patch:0}:null))}function T(e,t){return e.major===t.major?e.minor===t.minor?e.patch-t.patch:e.minor-t.minor:e.major-t.major}function E(n=i.cwd()){let a=r(n,`node_modules/rari/package.json`);if(!e(a))return c(`rari is not installed. Please run "npm install rari" first.`),i.exit(1),``;try{let e=x(t(a,`utf-8`));return e.version!=null&&e.version!==``?`^${e.version}`:(c(`Could not determine rari version from package.json`),i.exit(1),``)}catch(e){return c(`Failed to read rari package.json: ${e instanceof Error?e.message:`Unknown error`}`),i.exit(1),``}}function D(a,u){let d=r(a,`package.json`);e(d)||(c(`No package.json found. Please run this command from your project root.`),i.exit(1));try{let e=x(t(d,`utf-8`));e.scripts=e.scripts??{};let r=u.startScript??`rari start`;e.scripts.start&&e.scripts.start!==r&&!e.scripts[`start:original`]&&(l(`Existing start script found: "${e.scripts.start}"`),l(`Backing up to start:original and replacing with "${r}"`),e.scripts[`start:original`]=e.scripts.start),e.scripts.start=r,e.scripts[`start:local`]=`rari start`,e.scripts[`deploy:${u.providerName.toLowerCase()}`]=u.deployScript,S(e),(e.dependencies?.rari==null||e.dependencies.rari===``)&&(o(`Adding rari dependency...`),e.dependencies=e.dependencies??{},e.dependencies.rari=u.dependency??E(a)),n(d,`${JSON.stringify(e,null,2)}\n`),s(`Updated package.json for ${u.providerName} deployment`)}catch(e){c(`Failed to update package.json: ${e instanceof Error?e.message:`Unknown error`}`),i.exit(1)}}function O(i,a,o){let c=r(i,`.gitignore`),l=[``,`# ${a}`,`${o}/`,``].join(`
+`);if(e(c)){let e=t(c,`utf-8`),r=e.split(`
+`).map(e=>e.trim());r.includes(`${o}/`)||r.includes(o)||(n(c,e+l),s(`Updated .gitignore with ${a} entries`))}else n(c,`# Dependencies
+node_modules
+.pnpm-store
+
+# Build outputs
+dist
+
+# Environment variables
+.env
+.env.local
+.env.production
+
+# ${a}
+${o}
+
+# Logs
+*.log
+npm-debug.log*
+pnpm-debug.log*
+
+# OS files
+.DS_Store
+Thumbs.db
+
+# IDE files
+.vscode
+.idea
+*.swp
+*.swo
+*~
+
+# Temporary files
+.tmp
+tmp
+`),s(`Created .gitignore with ${a} entries`)}function k(a,o,u){let d=r(a,o);try{if(e(d)){let i=t(d,`utf-8`),s=`${o}.backup`,c=r(a,s);e(c)&&(s=`${o}.backup.${Date.now()}`,c=r(a,s)),l(`${o} already exists, backing up to ${s}`),n(c,i,{flag:`wx`})}n(d,u),s(`Created ${o} configuration`)}catch(e){c(`Failed to create or backup ${o}: ${e instanceof Error?e.message:`Unknown error`}`),i.exit(1)}}export{o as a,O as i,E as n,s as o,D as r,k as t};