@teyik0/furin 0.1.0-alpha.3

package/dist/client.d.ts

@@ -0,0 +1,158 @@
+import type { Cookie, StatusMap } from "elysia";
+import type { AnySchema, HTTPHeaders, UnwrapSchema } from "elysia/types";
+declare const UNSET: unique symbol;
+type Unset = typeof UNSET;
+type ResolvedSchema<T> = [T] extends [Unset] ? Unset : T extends AnySchema ? UnwrapSchema<T> : Unset;
+type MergeSchema<TParent, TOwn> = [TParent] extends [Unset] ? TOwn : [TOwn] extends [Unset] ? TParent : TParent & TOwn;
+type NormalizeUnset<T> = [T] extends [Unset] ? {} : T;
+export interface RouteContext<TParams = {}, TQuery = {}> {
+    cookie: Record<string, Cookie<unknown>>;
+    headers: Record<string, string | undefined>;
+    params: NormalizeUnset<TParams>;
+    path: string;
+    query: NormalizeUnset<TQuery>;
+    redirect: (url: string, status?: 301 | 302 | 303 | 307 | 308) => Response;
+    request: Request;
+    set: {
+        headers: HTTPHeaders;
+        status?: number | keyof StatusMap;
+    };
+}
+export interface ComponentProps<TParams = {}, TQuery = {}> {
+    params: NormalizeUnset<TParams>;
+    path: string;
+    query: NormalizeUnset<TQuery>;
+}
+type ResolveParent<T> = T extends RouteRef<infer D, infer P, infer Q> ? {
+    data: D;
+    params: P;
+    query: Q;
+} : {
+    data: {};
+    params: Unset;
+    query: Unset;
+};
+interface Resolved<TParentRef, TLoaderData, TParamsSchema = Unset, TQuerySchema = Unset> {
+    data: ResolveParent<TParentRef>["data"] & TLoaderData;
+    params: MergeSchema<ResolveParent<TParentRef>["params"], ResolvedSchema<TParamsSchema>>;
+    query: MergeSchema<ResolveParent<TParentRef>["query"], ResolvedSchema<TQuerySchema>>;
+}
+export type MetaDescriptor = {
+    charSet: "utf-8";
+} | {
+    title: string;
+} | {
+    name: string;
+    content: string;
+} | {
+    property: string;
+    content: string;
+} | {
+    httpEquiv: string;
+    content: string;
+} | {
+    "script:ld+json": object;
+} | {
+    tagName: "meta" | "link";
+    [name: string]: string | undefined;
+};
+export interface HeadOptions {
+    links?: Array<{
+        rel: string;
+        href: string;
+        [key: string]: string;
+    }>;
+    meta?: MetaDescriptor[];
+    scripts?: Array<{
+        src?: string;
+        type?: string;
+        children?: string;
+        [key: string]: string | undefined;
+    }>;
+    styles?: Array<{
+        type?: string;
+        children: string;
+    }>;
+}
+export type LoaderDeps = (route: {
+    __type: string;
+}) => Promise<Record<string, unknown>>;
+export interface PageConfig<TParentData extends Record<string, unknown>, TParams, TQuery, TPageLoaderData extends Record<string, unknown> = {}> {
+    component: React.FC<TParentData & TPageLoaderData & ComponentProps<TParams, TQuery>>;
+    head?: (ctx: ComponentProps<TParams, TQuery> & TParentData & TPageLoaderData) => HeadOptions;
+    loader?: (ctx: RouteContext<TParams, TQuery> & TParentData, deps: TypedDeps) => Promise<TPageLoaderData> | TPageLoaderData;
+    staticParams?: () => Promise<NormalizeUnset<TParams>[]> | NormalizeUnset<TParams>[];
+}
+export interface RuntimeRoute {
+    __type: "FURIN_ROUTE";
+    layout?: React.FC<Record<string, unknown> & {
+        children: React.ReactNode;
+    }>;
+    loader?(ctx: Record<string, unknown>, deps: LoaderDeps): Promise<Record<string, unknown>> | Record<string, unknown>;
+    mode?: "ssr" | "ssg" | "isr";
+    params?: unknown;
+    parent?: RuntimeRoute;
+    query?: unknown;
+    revalidate?: number;
+}
+export interface RuntimePage {
+    __type: "FURIN_PAGE";
+    _route: RuntimeRoute;
+    component: React.FC<Record<string, unknown>>;
+    head?(ctx: Record<string, unknown>): HeadOptions;
+    loader?(ctx: Record<string, unknown>, deps: LoaderDeps): Promise<Record<string, unknown>> | Record<string, unknown>;
+    staticParams?(): Promise<Record<string, string>[]> | Record<string, string>[];
+}
+export interface RouteRef<TData extends Record<string, unknown> = Record<string, unknown>, TParams = unknown, TQuery = unknown> {
+    readonly __brand: "FURIN_ROUTE_REF";
+    readonly __phantom: {
+        data: TData;
+        params: TParams;
+        query: TQuery;
+    };
+}
+interface PageResult<TData extends Record<string, unknown>, TParams, TQuery, TPageLoaderData extends Record<string, unknown>> {
+    __type: "FURIN_PAGE";
+    _route: Route<TData, TParams, TQuery>;
+    component: React.FC<TData & TPageLoaderData & ComponentProps<TParams, TQuery>>;
+    head?: (ctx: ComponentProps<TParams, TQuery> & TData & TPageLoaderData) => HeadOptions;
+    loader?: (ctx: RouteContext<TParams, TQuery> & TData, deps: TypedDeps) => Promise<TPageLoaderData> | TPageLoaderData;
+}
+export interface Route<TParentData extends Record<string, unknown>, TParams, TQuery> {
+    __type: "FURIN_ROUTE";
+    layout?: React.FC<TParentData & {
+        children: React.ReactNode;
+    } & ComponentProps<TParams, TQuery>>;
+    loader?(ctx: RouteContext<TParams, TQuery> & TParentData, deps: TypedDeps): Promise<TParentData> | TParentData;
+    mode?: "ssr" | "ssg" | "isr";
+    page<TPageLoaderData extends Record<string, unknown> = {}>(config: PageConfig<TParentData, TParams, TQuery, TPageLoaderData>): PageResult<TParentData, TParams, TQuery, TPageLoaderData>;
+    params?: unknown;
+    parent?: RuntimeRoute;
+    query?: unknown;
+    /** Branded ref for type inference when used as a parent. */
+    ref: RouteRef<TParentData, TParams, TQuery>;
+    revalidate?: number;
+}
+type TypedDeps = <TData extends Record<string, unknown>>(route: Route<TData, any, any>) => Promise<TData>;
+export declare function createRoute<TParentRef extends RouteRef | undefined = undefined, TParamsSchema extends AnySchema | Unset = Unset, TQuerySchema extends AnySchema | Unset = Unset, TLoaderData extends Record<string, unknown> = {}>(config?: {
+    parent?: {
+        ref: TParentRef;
+    } & {
+        __type: "FURIN_ROUTE";
+    };
+    mode?: "ssr" | "ssg" | "isr";
+    revalidate?: number;
+    params?: TParamsSchema;
+    query?: TQuerySchema;
+    loader?: (ctx: RouteContext<Resolved<TParentRef, TLoaderData, TParamsSchema, TQuerySchema>["params"], Resolved<TParentRef, TLoaderData, TParamsSchema, TQuerySchema>["query"]> & ResolveParent<TParentRef>["data"], deps: TypedDeps) => Promise<TLoaderData> | TLoaderData;
+    layout?: React.FC<Resolved<TParentRef, TLoaderData, TParamsSchema, TQuerySchema>["data"] & {
+        children: React.ReactNode;
+    } & ComponentProps<Resolved<TParentRef, TLoaderData, TParamsSchema, TQuerySchema>["params"], Resolved<TParentRef, TLoaderData, TParamsSchema, TQuerySchema>["query"]>>;
+}): Route<Resolved<TParentRef, TLoaderData, TParamsSchema, TQuerySchema>["data"], Resolved<TParentRef, TLoaderData, TParamsSchema, TQuerySchema>["params"], Resolved<TParentRef, TLoaderData, TParamsSchema, TQuerySchema>["query"]>;
+export type InferProps<T> = T extends {
+    __type: "ELYRA_PAGE";
+    component: React.FC<infer P>;
+} ? P : T extends Route<infer D, infer P, infer Q> ? D & {
+    children: React.ReactNode;
+} & ComponentProps<P, Q> : never;
+export {};

package/dist/client.js

@@ -0,0 +1,20 @@
+// @bun
+// src/client.ts
+function createRoute(config) {
+  const route = {
+    ...config,
+    __type: "FURIN_ROUTE",
+    ref: {},
+    page(pageConfig) {
+      return {
+        ...pageConfig,
+        __type: "FURIN_PAGE",
+        _route: route
+      };
+    }
+  };
+  return route;
+}
+export {
+  createRoute
+};

package/dist/config.d.ts

@@ -0,0 +1,16 @@
+export type { BunPlugin } from "bun";
+export declare const BUILD_TARGETS: readonly ["bun", "node", "vercel", "cloudflare"];
+export type BuildTarget = (typeof BUILD_TARGETS)[number];
+export declare const configSchema: import("@sinclair/typebox").TObject<{
+    rootDir: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    pagesDir: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    serverEntry: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    targets: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TArray<import("@sinclair/typebox").TUnion<import("@sinclair/typebox").TLiteral<"bun" | "node" | "vercel" | "cloudflare">[]>>>;
+    bun: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TObject<{
+        compile: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TLiteral<"server">, import("@sinclair/typebox").TLiteral<"embed">]>>;
+    }>>;
+}>;
+export type FurinConfig = (typeof configSchema)["static"] & {
+    plugins?: Bun.BunPlugin[];
+};
+export declare function defineConfig(config: FurinConfig): FurinConfig;

package/dist/config.js

@@ -0,0 +1,23 @@
+// @bun
+// src/config.ts
+import { t } from "elysia";
+var BUILD_TARGETS = ["bun", "node", "vercel", "cloudflare"];
+var buildTargetSchema = t.Union(BUILD_TARGETS.map((v) => t.Literal(v)));
+var compileTargetSchema = t.Union([t.Literal("server"), t.Literal("embed")]);
+var configSchema = t.Object({
+  rootDir: t.Optional(t.String()),
+  pagesDir: t.Optional(t.String()),
+  serverEntry: t.Optional(t.String()),
+  targets: t.Optional(t.Array(buildTargetSchema)),
+  bun: t.Optional(t.Object({
+    compile: t.Optional(compileTargetSchema)
+  }))
+});
+function defineConfig(config) {
+  return config;
+}
+export {
+  defineConfig,
+  configSchema,
+  BUILD_TARGETS
+};

package/dist/furin.d.ts

@@ -0,0 +1,45 @@
+import { Elysia } from "elysia";
+/**
+ * Main Furin plugin.
+ *
+ * Returns a standalone Elysia instance (async function) so that routes are
+ * properly registered in Elysia's router for SPA navigation to work.
+ *
+ * ## Usage
+ *
+ * ```ts
+ * new Elysia()
+ *   .use(await furin({ ... }))
+ *   .listen(3000)
+ * ```
+ */
+export declare function furin({ pagesDir }: {
+    pagesDir?: string;
+}): Promise<Elysia<"", {
+    decorator: {};
+    store: {};
+    derive: {};
+    resolve: {};
+}, {
+    typebox: {};
+    error: {};
+}, {
+    schema: {};
+    standaloneSchema: {};
+    macro: {};
+    macroFn: {};
+    parser: {};
+    response: {};
+}, {}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}>>;