@netrojs/fnetro 0.1.5 → 0.2.0

package/dist/core.d.ts

@@ -1,200 +1,113 @@
 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 getCurrentScope(): EffectScope | undefined;
-declare function onScopeDispose(fn: () => void): void;
-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;
-}
-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;
-interface FNetroHooks {
-    useValue<T>(r: Ref<T> | (() => T)): T;
-    useLocalRef<T>(init: T): Ref<T>;
-    useLocalReactive<T extends object>(init: T): T;
+interface LayoutProps {
+    children: JSX.Element;
+    url: string;
+    params: Record<string, string>;
 }
-declare const __hooks: FNetroHooks;
-/**
- * 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: FNetroMiddleware[];
+    middleware: HonoMiddleware[];
 }
-declare function resolveRoutes(routes: (PageDef<any> | GroupDef | ApiRouteDef)[], options?: {
+declare function resolveRoutes(routes: Route[], options?: {
     prefix?: string;
-    middleware?: FNetroMiddleware[];
+    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__";
 
-export { type AnyJSX, type ApiRouteDef, type AppConfig, type ComputedRef, type EffectFn, EffectScope, type FNetroMiddleware, type GroupDef, type LayoutDef, type LoaderCtx, type MiddlewareDef, type MultiSource, PARAMS_KEY, type PageDef, ReactiveEffect, type Ref, type ResolvedRoute, SPA_HEADER, STATE_KEY, type WatchEffectOptions, type WatchOptions, type WatchSource, type WritableComputedRef, __hooks, computed, defineApiRoute, defineGroup, defineLayout, defineMiddleware, definePage, effect, effectScope, getCurrentScope, isReactive, isReadonly, isRef, markRaw, onScopeDispose, reactive, readonly, ref, resolveRoutes, shallowReactive, shallowRef, toRaw, toRef, toRefs, triggerRef, unref, use, useLocalReactive, useLocalRef, watch, watchEffect };
+export { type ApiRouteDef, type AppConfig, type ClientMiddleware, type CompiledPath, type GroupDef, type HonoMiddleware, type LayoutDef, type LayoutProps, type LoaderCtx, PARAMS_KEY, type PageDef, type PageProps, type ResolvedRoute, type Route, type SEOMeta, SEO_KEY, SPA_HEADER, STATE_KEY, compilePath, defineApiRoute, defineGroup, defineLayout, definePage, matchPath, resolveRoutes };