@netrojs/fnetro 0.1.2

package/dist/server.d.ts

@@ -0,0 +1,231 @@
+import { Hono, MiddlewareHandler, Context } from 'hono';
+import { Plugin } from 'vite';
+
+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;
+declare const SPA_HEADER = "x-fnetro-spa";
+declare const STATE_KEY = "__FNETRO_STATE__";
+
+interface FNetroApp {
+    /** The underlying Hono instance — add raw routes, custom error handlers, etc. */
+    app: Hono;
+    /** Hono fetch handler — export this as default for edge runtimes */
+    handler: Hono['fetch'];
+}
+declare function createFNetro(config: AppConfig): FNetroApp;
+type Runtime = 'node' | 'bun' | 'deno' | 'edge' | 'unknown';
+declare function detectRuntime(): Runtime;
+interface ServeOptions {
+    app: FNetroApp;
+    port?: number;
+    hostname?: string;
+    /** Override auto-detected runtime. */
+    runtime?: Runtime;
+    /** Static assets root directory (served at /assets/*). @default './dist' */
+    staticDir?: string;
+}
+declare function serve(opts: ServeOptions): Promise<void>;
+interface FNetroPluginOptions {
+    /**
+     * Server entry file (exports the Hono app / calls serve()).
+     * @default 'app/server.ts'
+     */
+    serverEntry?: string;
+    /**
+     * Client entry file (calls boot()).
+     * @default 'app/client.ts'
+     */
+    clientEntry?: string;
+    /**
+     * Output directory for the server bundle.
+     * @default 'dist/server'
+     */
+    serverOutDir?: string;
+    /**
+     * Output directory for client assets (JS, CSS).
+     * @default 'dist/assets'
+     */
+    clientOutDir?: string;
+    /**
+     * External packages for the server bundle.
+     * Node built-ins are always external.
+     */
+    serverExternal?: string[];
+    /**
+     * Emit type declarations for framework types.
+     * @default false
+     */
+    dts?: boolean;
+}
+declare function fnetroVitePlugin(opts?: FNetroPluginOptions): Plugin[];
+
+export { type AnyJSX, type ApiRouteDef, type AppConfig, type ComputedRef, type FNetroApp, type FNetroMiddleware, type FNetroPluginOptions, type GroupDef, type LayoutDef, type LoaderCtx, type MiddlewareDef, type PageDef, type Ref, type Runtime, SPA_HEADER, STATE_KEY, type ServeOptions, type WatchOptions, type WatchSource, type WritableComputedRef, computed, createFNetro, defineApiRoute, defineGroup, defineLayout, defineMiddleware, definePage, detectRuntime, effect, effectScope, fnetroVitePlugin, isReactive, isReadonly, isRef, markRaw, reactive, readonly, ref, serve, shallowReactive, shallowRef, toRaw, toRef, toRefs, triggerRef, unref, use, useLocalReactive, useLocalRef, watch, watchEffect };