@netrojs/fnetro 0.1.6 → 0.2.0

package/dist/server.d.ts

@@ -1,231 +1,172 @@
 import { Hono, MiddlewareHandler, Context } from 'hono';
+import { Component, JSX } from 'solid-js';
 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;
+type HonoMiddleware = MiddlewareHandler;
+type LoaderCtx = Context;
+interface SEOMeta {
+    title?: string;
+    description?: string;
+    keywords?: string;
+    author?: string;
+    robots?: string;
+    canonical?: string;
+    themeColor?: string;
+    ogTitle?: string;
+    ogDescription?: string;
+    ogImage?: string;
+    ogImageAlt?: string;
+    ogImageWidth?: string;
+    ogImageHeight?: string;
+    ogUrl?: string;
+    ogType?: string;
+    ogSiteName?: string;
+    ogLocale?: string;
+    twitterCard?: 'summary' | 'summary_large_image' | 'app' | 'player';
+    twitterSite?: string;
+    twitterCreator?: string;
+    twitterTitle?: string;
+    twitterDescription?: string;
+    twitterImage?: string;
+    twitterImageAlt?: string;
+    jsonLd?: Record<string, unknown> | Record<string, unknown>[];
+    extra?: Array<{
+        name?: string;
+        property?: string;
+        httpEquiv?: string;
+        content: string;
+    }>;
+}
+type PageProps<TData extends object = {}> = TData & {
+    url: string;
+    params: Record<string, string>;
 };
-interface WatchOptions<Immediate = boolean> {
-    immediate?: Immediate;
-    deep?: boolean;
-    once?: boolean;
+interface LayoutProps {
+    children: JSX.Element;
+    url: string;
+    params: Record<string, string>;
 }
-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. */
+    middleware?: HonoMiddleware[];
     loader?: (c: LoaderCtx) => TData | Promise<TData>;
-    /** Override the group/app layout for this page. Pass `false` to use no layout. */
+    seo?: SEOMeta | ((data: TData, params: Record<string, string>) => SEOMeta);
     layout?: LayoutDef | false;
-    /** The JSX page component */
-    Page: (props: TData & {
-        url: string;
-        params: Record<string, string>;
-    }) => AnyJSX;
+    Page: Component<PageProps<TData>>;
 }
 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)[];
+    middleware?: HonoMiddleware[];
+    routes: Route[];
 }
 interface LayoutDef {
     readonly __type: 'layout';
-    Component: (props: {
-        children: AnyJSX;
-        url: string;
-        params: Record<string, string>;
-    }) => AnyJSX;
+    Component: Component<LayoutProps>;
 }
 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;
+    register: (app: Hono, globalMiddleware: HonoMiddleware[]) => void;
 }
+type Route = PageDef<any> | GroupDef | ApiRouteDef;
 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;
-}
+    seo?: SEOMeta;
+    middleware?: HonoMiddleware[];
+    routes: Route[];
+    notFound?: Component;
+    htmlAttrs?: Record<string, string>;
+    head?: string;
+}
+type ClientMiddleware = (url: string, next: () => Promise<void>) => Promise<void>;
 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 defineLayout(Component: Component<LayoutProps>): LayoutDef;
 declare function defineApiRoute(path: string, register: ApiRouteDef['register']): ApiRouteDef;
+interface ResolvedRoute {
+    fullPath: string;
+    page: PageDef<any>;
+    layout: LayoutDef | false | undefined;
+    middleware: HonoMiddleware[];
+}
+declare function resolveRoutes(routes: Route[], options?: {
+    prefix?: string;
+    middleware?: HonoMiddleware[];
+    layout?: LayoutDef | false;
+}): {
+    pages: ResolvedRoute[];
+    apis: ApiRouteDef[];
+};
+interface CompiledPath {
+    re: RegExp;
+    keys: string[];
+}
+declare function compilePath(path: string): CompiledPath;
+declare function matchPath(compiled: CompiledPath, pathname: string): Record<string, string> | null;
 declare const SPA_HEADER = "x-fnetro-spa";
 declare const STATE_KEY = "__FNETRO_STATE__";
+declare const PARAMS_KEY = "__FNETRO_PARAMS__";
+declare const SEO_KEY = "__FNETRO_SEO__";
 
+interface AssetConfig {
+    /** Explicit script URLs injected into every HTML page. */
+    scripts?: string[];
+    /** Explicit stylesheet URLs injected into every HTML page. */
+    styles?: string[];
+    /**
+     * Directory that contains the Vite-generated `manifest.json`.
+     * When provided, asset URLs are resolved from the manifest so hashed
+     * filenames work correctly.  Typically equals `clientOutDir`.
+     */
+    manifestDir?: string;
+    /**
+     * Key in the manifest corresponding to the client entry file.
+     * @default `'client.ts'`
+     */
+    manifestEntry?: string;
+}
+interface FNetroOptions extends AppConfig {
+    /**
+     * Production asset configuration.
+     * In dev mode `@hono/vite-dev-server` injects assets automatically — ignored.
+     */
+    assets?: AssetConfig;
+}
 interface FNetroApp {
-    /** The underlying Hono instance — add raw routes, custom error handlers, etc. */
+    /** The underlying Hono instance — attach custom routes, error handlers, etc. */
     app: Hono;
-    /** Hono fetch handler — export this as default for edge runtimes */
-    handler: Hono['fetch'];
+    /** Fetch handler for edge runtimes */
+    handler: typeof Hono.prototype.fetch;
 }
-declare function createFNetro(config: AppConfig): FNetroApp;
-type Runtime = 'node' | 'bun' | 'deno' | 'edge' | 'unknown';
+declare function createFNetro(config: FNetroOptions): FNetroApp;
+type Runtime = 'node' | 'bun' | 'deno' | 'edge';
 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' */
+    /** Root directory for static file serving.  @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'
-     */
+    /** Server entry file.   @default `'server.ts'` */
     serverEntry?: string;
-    /**
-     * Client entry file (calls boot()).
-     * @default 'app/client.ts'
-     */
+    /** Client entry file.   @default `'client.ts'` */
     clientEntry?: string;
-    /**
-     * Output directory for the server bundle.
-     * @default 'dist/server'
-     */
+    /** Server bundle output directory.   @default `'dist/server'` */
     serverOutDir?: string;
-    /**
-     * Output directory for client assets (JS, CSS).
-     * @default 'dist/assets'
-     */
+    /** Client assets output directory.   @default `'dist/assets'` */
     clientOutDir?: string;
-    /**
-     * External packages for the server bundle.
-     * Node built-ins are always external.
-     */
+    /** Extra packages to mark external in the server bundle. */
     serverExternal?: string[];
-    /**
-     * Emit type declarations for framework types.
-     * @default false
-     */
-    dts?: boolean;
+    /** Extra options forwarded to `vite-plugin-solid`. */
+    solidOptions?: Record<string, unknown>;
 }
 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 };
+export { type ApiRouteDef, type AppConfig, type AssetConfig, type ClientMiddleware, type CompiledPath, type FNetroApp, type FNetroOptions, type FNetroPluginOptions, type GroupDef, type HonoMiddleware, type LayoutDef, type LayoutProps, type LoaderCtx, PARAMS_KEY, type PageDef, type PageProps, type ResolvedRoute, type Route, type Runtime, type SEOMeta, SEO_KEY, SPA_HEADER, STATE_KEY, type ServeOptions, compilePath, createFNetro, defineApiRoute, defineGroup, defineLayout, definePage, detectRuntime, fnetroVitePlugin, matchPath, resolveRoutes, serve };