@netrojs/fnetro 0.1.6 → 0.2.1

package/dist/client.d.ts

@@ -1,196 +1,140 @@
 import { Hono, MiddlewareHandler, Context } from 'hono';
+import { Component, JSX } from 'solid-js';
 
-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;
+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;
+    }>;
 }
-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 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__";
 
-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;
+/**
+ * Register a client-side navigation middleware.
+ * Must be called **before** `boot()`.
+ *
+ * @example
+ * useClientMiddleware(async (url, next) => {
+ *   if (!isLoggedIn() && url.startsWith('/dashboard')) {
+ *     await navigate('/login')
+ *     return                   // cancel original navigation
+ *   }
+ *   await next()
+ * })
+ */
+declare function useClientMiddleware(mw: ClientMiddleware): 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). */
+/** Warm the prefetch cache for a URL on hover/focus/etc. */
 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.
-     */
+    /** Enable hover-based prefetching.  @default true */
     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 };
+export { type ApiRouteDef, type AppConfig, type BootOptions, type ClientMiddleware, type CompiledPath, type GroupDef, type HonoMiddleware, type LayoutDef, type LayoutProps, type LoaderCtx, type NavigateOptions, PARAMS_KEY, type PageDef, type PageProps, type ResolvedRoute, type Route, type SEOMeta, SEO_KEY, SPA_HEADER, STATE_KEY, boot, compilePath, defineApiRoute, defineGroup, defineLayout, definePage, matchPath, navigate, prefetch, resolveRoutes, useClientMiddleware };