@netrojs/fnetro 0.1.2

package/dist/client.d.ts

@@ -0,0 +1,196 @@
+import { Hono, MiddlewareHandler, Context } from 'hono';
+
+type EffectFn = () => void | (() => void);
+declare const IS_REF: unique symbol;
+declare class ReactiveEffect {
+    fn: () => any;
+    scheduler?: (() => void) | undefined;
+    scope?: EffectScope | undefined;
+    deps: Set<ReactiveEffect>[];
+    active: boolean;
+    cleanup?: () => void;
+    computed: boolean;
+    constructor(fn: () => any, scheduler?: (() => void) | undefined, scope?: EffectScope | undefined);
+    run(): any;
+    stop(): void;
+}
+declare class EffectScope {
+    effects: ReactiveEffect[];
+    cleanups: (() => void)[];
+    active: boolean;
+    run<T>(fn: () => T): T;
+    stop(): void;
+    onCleanup(fn: () => void): void;
+}
+declare function effectScope(): EffectScope;
+declare function effect(fn: EffectFn): () => void;
+interface WatchEffectOptions {
+    flush?: 'sync' | 'post';
+    onTrack?: (e: any) => void;
+    onTrigger?: (e: any) => void;
+}
+declare function watchEffect(fn: EffectFn, opts?: WatchEffectOptions): () => void;
+interface Ref<T = unknown> {
+    value: T;
+    readonly [IS_REF]: true;
+}
+declare function ref<T>(value: T): Ref<T>;
+declare function shallowRef<T>(value: T): Ref<T>;
+declare function triggerRef(r: Ref): void;
+declare function isRef<T = unknown>(r: unknown): r is Ref<T>;
+declare function unref<T>(r: T | Ref<T>): T;
+declare function toRef<T extends object, K extends keyof T>(obj: T, key: K): Ref<T[K]>;
+declare function toRefs<T extends object>(obj: T): {
+    [K in keyof T]: Ref<T[K]>;
+};
+interface WritableComputedRef<T> extends Ref<T> {
+    readonly effect: ReactiveEffect;
+}
+interface ComputedRef<T> extends WritableComputedRef<T> {
+    readonly value: T;
+}
+declare function computed<T>(getter: () => T): ComputedRef<T>;
+declare function computed<T>(opts: {
+    get: () => T;
+    set: (v: T) => void;
+}): WritableComputedRef<T>;
+declare function reactive<T extends object>(target: T): T;
+declare function shallowReactive<T extends object>(target: T): T;
+declare function readonly<T extends object>(target: T): Readonly<T>;
+declare function markRaw<T extends object>(value: T): T;
+declare function toRaw<T>(observed: T): T;
+declare function isReactive(value: unknown): boolean;
+declare function isReadonly(value: unknown): boolean;
+type WatchSource<T = unknown> = Ref<T> | ComputedRef<T> | (() => T);
+type MultiSource = WatchSource[] | readonly WatchSource[];
+type MapSources<T, Immediate = false> = {
+    [K in keyof T]: T[K] extends WatchSource<infer V> ? Immediate extends true ? V | undefined : V : T[K] extends object ? T[K] : never;
+};
+interface WatchOptions<Immediate = boolean> {
+    immediate?: Immediate;
+    deep?: boolean;
+    once?: boolean;
+}
+type StopHandle = () => void;
+type CleanupFn = (fn: () => void) => void;
+declare function watch<T>(source: WatchSource<T>, cb: (val: T, old: T | undefined, cleanup: CleanupFn) => void, opts?: WatchOptions): StopHandle;
+declare function watch<T extends MultiSource>(source: T, cb: (val: MapSources<T>, old: MapSources<T, true>, cleanup: CleanupFn) => void, opts?: WatchOptions): StopHandle;
+/**
+ * Subscribe to a Ref or computed getter inside a JSX component.
+ * On the server, returns the current value (no reactivity needed).
+ * On the client, re-renders the component whenever the value changes.
+ *
+ * @example
+ * const count = ref(0)
+ * function Counter() {
+ *   const n = use(count)
+ *   return <button onClick={() => count.value++}>{n}</button>
+ * }
+ */
+declare function use<T>(source: Ref<T> | (() => T)): T;
+/**
+ * Create a component-local reactive Ref.
+ * Unlike module-level `ref()`, this is scoped to the component lifecycle.
+ *
+ * @example
+ * function Input() {
+ *   const text = useLocalRef('')
+ *   return <input value={use(text)} onInput={e => text.value = e.target.value} />
+ * }
+ */
+declare function useLocalRef<T>(init: T): Ref<T>;
+/**
+ * Create a component-local reactive object.
+ * @example
+ * function Form() {
+ *   const form = useLocalReactive({ name: '', email: '' })
+ *   return <input value={form.name} onInput={e => form.name = e.target.value} />
+ * }
+ */
+declare function useLocalReactive<T extends object>(init: T): T;
+type LoaderCtx = Context;
+type FNetroMiddleware = MiddlewareHandler;
+type AnyJSX = any;
+interface PageDef<TData extends object = {}> {
+    readonly __type: 'page';
+    path: string;
+    /** Middleware applied only to this route */
+    middleware?: FNetroMiddleware[];
+    /** Server-side data loader. Return value becomes Page props. */
+    loader?: (c: LoaderCtx) => TData | Promise<TData>;
+    /** Override the group/app layout for this page. Pass `false` to use no layout. */
+    layout?: LayoutDef | false;
+    /** The JSX page component */
+    Page: (props: TData & {
+        url: string;
+        params: Record<string, string>;
+    }) => AnyJSX;
+}
+interface GroupDef {
+    readonly __type: 'group';
+    /** URL prefix — e.g. '/admin' */
+    prefix: string;
+    /** Layout override for all pages in this group */
+    layout?: LayoutDef | false;
+    /** Middleware applied to every route in the group */
+    middleware?: FNetroMiddleware[];
+    /** Pages and nested groups */
+    routes: (PageDef<any> | GroupDef | ApiRouteDef)[];
+}
+interface LayoutDef {
+    readonly __type: 'layout';
+    Component: (props: {
+        children: AnyJSX;
+        url: string;
+        params: Record<string, string>;
+    }) => AnyJSX;
+}
+interface ApiRouteDef {
+    readonly __type: 'api';
+    /** Mount path — e.g. '/api' or '/api/admin' */
+    path: string;
+    /** Register raw Hono routes on the provided sub-app */
+    register: (app: Hono, middleware: FNetroMiddleware[]) => void;
+}
+interface MiddlewareDef {
+    readonly __type: 'middleware';
+    handler: FNetroMiddleware;
+}
+interface AppConfig {
+    /** Default layout for all pages */
+    layout?: LayoutDef;
+    /** Global middleware applied before every route */
+    middleware?: FNetroMiddleware[];
+    /** Top-level routes, groups, and API routes */
+    routes: (PageDef<any> | GroupDef | ApiRouteDef)[];
+    /** 404 page */
+    notFound?: () => AnyJSX;
+}
+declare function definePage<TData extends object = {}>(def: Omit<PageDef<TData>, '__type'>): PageDef<TData>;
+declare function defineGroup(def: Omit<GroupDef, '__type'>): GroupDef;
+declare function defineLayout(Component: LayoutDef['Component']): LayoutDef;
+declare function defineMiddleware(handler: FNetroMiddleware): MiddlewareDef;
+declare function defineApiRoute(path: string, register: ApiRouteDef['register']): ApiRouteDef;
+
+type NavListener = (url: string) => void | Promise<void>;
+/** Called before each SPA navigation. Returning false cancels. */
+declare function onBeforeNavigate(fn: NavListener): () => void;
+/** Called after each SPA navigation (including initial boot). */
+declare function onAfterNavigate(fn: NavListener): () => void;
+interface NavigateOptions {
+    replace?: boolean;
+    scroll?: boolean;
+}
+declare function navigate(to: string, opts?: NavigateOptions): Promise<void>;
+/** Warm the prefetch cache for a URL (call on hover / mousedown). */
+declare function prefetch(url: string): void;
+interface BootOptions extends AppConfig {
+    /**
+     * Enable hover-based prefetching (default: true).
+     * Fires a SPA fetch when the user hovers any <a> that matches a route.
+     */
+    prefetchOnHover?: boolean;
+}
+declare function boot(options: BootOptions): Promise<void>;
+
+export { type ApiRouteDef, type AppConfig, type BootOptions, type ComputedRef, type GroupDef, type LayoutDef, type NavigateOptions, type PageDef, type Ref, type WatchOptions, type WatchSource, type WritableComputedRef, boot, computed, defineApiRoute, defineGroup, defineLayout, defineMiddleware, definePage, effect, effectScope, isReactive, isReadonly, isRef, markRaw, navigate, onAfterNavigate, onBeforeNavigate, prefetch, reactive, readonly, ref, shallowReactive, shallowRef, toRaw, toRef, toRefs, triggerRef, unref, use, useLocalReactive, useLocalRef, watch, watchEffect };