@devlusoft/devix 0.4.1-beta.4 → 0.4.1-beta.6

package/dist/server/api-router.d.ts

@@ -0,0 +1,22 @@
+export interface ApiRoute {
+    path: string;
+    key: string;
+    params: string[];
+    regex: RegExp;
+}
+export interface ApiMiddleware {
+    dir: string;
+    key: string;
+}
+export interface ApiResult {
+    routes: ApiRoute[];
+    middlewares: ApiMiddleware[];
+}
+export declare function keyToRoutePattern(key: string, apiDir: string): string;
+export declare function invalidateApiCache(): void;
+export declare function buildRoutes(routeKeys: string[], middlewareKeys: string[], apiDir: string): ApiResult;
+export declare function collectMiddlewareChain(routeKey: string, middlewares: ApiMiddleware[]): ApiMiddleware[];
+export declare function matchRoute(pathname: string, routes: ApiRoute[]): {
+    route: ApiRoute;
+    params: Record<string, string>;
+} | null;

package/dist/server/api.d.ts

@@ -0,0 +1,2 @@
+import type { ApiGlob } from './types';
+export declare function handleApiRequest(url: string, request: Request, glob: ApiGlob): Promise<Response>;

package/dist/server/collect-css.d.ts

@@ -0,0 +1,2 @@
+import type { ViteDevServer } from 'vite';
+export declare function collectCss(vite: ViteDevServer): Promise<string[]>;

package/dist/server/handler-store.d.ts

@@ -0,0 +1,10 @@
+import type { RouteContext } from '../runtime/api-context';
+interface HandlerStore {
+    request: Request;
+    ctx: RouteContext;
+}
+export declare function withHandlerStore<T>(store: HandlerStore, fn: () => T): T;
+export declare function useRequest(): Request;
+export declare function useCtx(): RouteContext;
+export declare function useParams(): Record<string, string>;
+export {};

package/dist/server/index.d.ts

@@ -0,0 +1,6 @@
+export { buildPages, collectLayoutChain, matchPage } from './pages-router';
+export { buildRoutes, collectMiddlewareChain, matchRoute } from './api-router';
+export { resolveMetadata, mergeMetadata } from '../runtime/metadata';
+export type { Page, Layout, PagesResult } from './pages-router';
+export type { ApiRoute, ApiMiddleware, ApiResult } from './api-router';
+export type { PageModule, LayoutModule } from './types';

package/dist/server/pages-router.d.ts

@@ -0,0 +1,21 @@
+export interface Page {
+    path: string;
+    key: string;
+    params: string[];
+    regex: RegExp;
+}
+export interface Layout {
+    dir: string;
+    key: string;
+}
+export interface PagesResult {
+    pages: Page[];
+    layouts: Layout[];
+}
+export declare function invalidatePagesCache(): void;
+export declare function buildPages(pageKeys: string[], layoutKeys: string[], pagesDir: string): PagesResult;
+export declare function collectLayoutChain(pageKey: string, layouts: Layout[]): Layout[];
+export declare function matchPage(pathname: string, pages: Page[]): {
+    page: Page;
+    params: Record<string, string>;
+} | null;

package/dist/server/public-index.d.ts

@@ -0,0 +1 @@
+export { useRequest, useCtx, useParams } from './handler-store';

package/dist/server/render.d.ts

@@ -0,0 +1,62 @@
+import type { PageGlob } from './types';
+import type { Manifest } from "vite";
+export declare function runLoader(url: string, request: Request, glob: PageGlob, options?: {
+    loaderTimeout?: number;
+}): Promise<{
+    error: true;
+    loaderData: null;
+    params: {};
+    layouts: never[];
+    metadata: null;
+    viewport: undefined;
+    redirect?: undefined;
+    redirectStatus?: undefined;
+    redirectReplace?: undefined;
+} | {
+    loaderData: null;
+    params: {};
+    layouts: never[];
+    metadata: null;
+    viewport: undefined;
+    error?: undefined;
+    redirect?: undefined;
+    redirectStatus?: undefined;
+    redirectReplace?: undefined;
+} | {
+    redirect: string | undefined;
+    redirectStatus: number | undefined;
+    redirectReplace: boolean | undefined;
+    error?: undefined;
+    loaderData?: undefined;
+    params?: undefined;
+    layouts?: undefined;
+    metadata?: undefined;
+    viewport?: undefined;
+} | {
+    loaderData: unknown;
+    params: Record<string, string>;
+    layouts: {
+        loaderData: unknown;
+    }[];
+    metadata: import("../types").Metadata;
+    viewport: import("../types").Viewport | undefined;
+    error?: undefined;
+    redirect?: undefined;
+    redirectStatus?: undefined;
+    redirectReplace?: undefined;
+}>;
+export declare function render(url: string, request: Request, glob: PageGlob, options?: {
+    manifest?: Manifest;
+    loaderTimeout?: number;
+}): Promise<{
+    html: string;
+    statusCode: number | undefined;
+    headers: {
+        Location: string | undefined;
+    };
+} | {
+    html: string;
+    statusCode: number;
+    headers: Record<string, string>;
+}>;
+export declare function getStaticRoutes(glob: PageGlob): Promise<string[]>;

package/dist/server/routes.d.ts

@@ -0,0 +1,11 @@
+import type { Hono } from 'hono';
+import type { Manifest } from 'vite';
+interface ServerOptions {
+    renderModule: any;
+    apiModule: any;
+    manifest?: Manifest;
+    loaderTimeout?: number;
+}
+export declare function registerApiRoutes(app: Hono, { apiModule, renderModule, loaderTimeout }: ServerOptions): void;
+export declare function registerSsrRoute(app: Hono, { renderModule, manifest, loaderTimeout }: ServerOptions): void;
+export {};

package/dist/server/types.d.ts

@@ -0,0 +1,52 @@
+import type React from "react";
+import { LoaderContext, Metadata, Viewport } from "../types";
+import type { Redirect } from "../utils/response";
+type InferLoaderData<T> = T extends (...args: any[]) => infer R ? [Awaited<R>] extends [void | undefined | Redirect] ? undefined : Exclude<Awaited<R>, Redirect> : T;
+type IsParams<T> = [T] extends [Record<string, string>] ? true : false;
+export interface PageProps<TDataOrParams = unknown, TParams = Record<string, string>> {
+    data: IsParams<TDataOrParams> extends true ? unknown : InferLoaderData<TDataOrParams>;
+    params: IsParams<TDataOrParams> extends true ? TDataOrParams extends Record<string, string> ? TDataOrParams : Record<string, string> : TParams;
+    url: string;
+}
+export interface LayoutProps<TDataOrParams = unknown, TParams = Record<string, string>> {
+    children: React.ReactNode;
+    data: IsParams<TDataOrParams> extends true ? unknown : InferLoaderData<TDataOrParams>;
+    params: IsParams<TDataOrParams> extends true ? TDataOrParams extends Record<string, string> ? TDataOrParams : Record<string, string> : TParams;
+}
+export interface ErrorProps {
+    statusCode: number;
+    message?: string;
+}
+export interface PageGlob {
+    pages: Record<string, () => Promise<unknown>>;
+    layouts: Record<string, () => Promise<unknown>>;
+    pagesDir: string;
+}
+export interface ApiGlob {
+    routes: Record<string, () => Promise<unknown>>;
+    middlewares: Record<string, () => Promise<unknown>>;
+    apiDir: string;
+}
+interface BaseModule<TData, TParams> {
+    loader?: (ctx: LoaderContext<TParams>) => Promise<TData | Redirect | void> | TData | Redirect | void;
+    guard?: (ctx: LoaderContext<TParams>) => Promise<string | Redirect | Record<string, unknown> | null> | string | Redirect | Record<string, unknown> | null;
+    metadata?: Metadata;
+    generateMetadata?: (ctx: LoaderContext<TParams> & {
+        loaderData: TData;
+    }) => Promise<Metadata> | Metadata;
+    viewport?: Viewport;
+    generateViewport?: (ctx: LoaderContext<TParams>) => Promise<Viewport> | Viewport;
+    headers?: Record<string, string>;
+}
+export interface PageModule<TData = unknown, TParams = Record<string, string>> extends BaseModule<TData, TParams> {
+    default: React.ComponentType<PageProps<TData, TParams>>;
+    generateStaticParams?: () => Promise<Record<string, string>[]> | Record<string, string>[];
+}
+export interface LayoutModule<TData = unknown, TParams = Record<string, string>> extends BaseModule<TData, TParams> {
+    default: React.ComponentType<LayoutProps<TData, TParams>>;
+    lang?: string;
+    generateLang?: (ctx: LoaderContext<TParams> & {
+        loaderData: TData;
+    }) => Promise<string> | string;
+}
+export {};

package/dist/types.d.ts

@@ -0,0 +1,42 @@
+export interface Metadata {
+    title?: string;
+    description?: string;
+    keywords?: string[];
+    og?: {
+        title?: string;
+        description?: string;
+        image?: string;
+        type?: 'website' | 'article' | 'product';
+        url?: string;
+    };
+    twitter?: {
+        card?: 'summary' | 'summary_large_image';
+        title?: string;
+        description?: string;
+        image?: string;
+        creator?: string;
+    };
+    canonical?: string;
+    robots?: string;
+    alternates?: Record<string, string>;
+}
+export interface Viewport {
+    width?: string | number;
+    initialScale?: number;
+    maximumScale?: number;
+    userScalable?: boolean;
+    themeColor?: string;
+}
+export interface LoaderContext<TParams = Record<string, string>> {
+    params: TParams;
+    request: Request;
+    guardData: unknown;
+}
+import type { Redirect } from './utils/response';
+export type LoaderFunction<TData = unknown, TParams = Record<string, string>> = (ctx: LoaderContext<TParams>) => Promise<TData | Redirect | void> | TData | Redirect | void;
+export type GuardFunction<TParams = Record<string, string>> = (ctx: LoaderContext<TParams>) => Promise<string | Redirect | Record<string, unknown> | null> | string | Redirect | Record<string, unknown> | null;
+type GuardData<TGuard> = TGuard extends (...args: any[]) => infer R ? Exclude<Awaited<R>, string | Redirect | null | undefined> : unknown;
+export type LoaderContextWithGuard<TGuard extends GuardFunction | undefined = undefined, TParams = Record<string, string>> = LoaderContext<TParams> & {
+    guardData: GuardData<TGuard>;
+};
+export {};

package/dist/utils/async.d.ts

@@ -0,0 +1 @@
+export declare function withTimeout<T>(promise: Promise<T>, ms: number): Promise<T>;

package/dist/utils/banner.d.ts

@@ -0,0 +1 @@
+export declare function printDevBanner(port: number): void;

package/dist/utils/banner.js

@@ -1,2 +1,2 @@
-import o from"picocolors";import{networkInterfaces as r}from"node:os";function s(e){let l=r();for(let n of Object.values(l))for(let t of n??[])if(t.family==="IPv4"&&!t.internal)return`http://${t.address}:${e}/`;return null}function $(e){let l="0.4.1-beta.4",n=s(e);console.log(),console.log(`  ${o.bold(o.yellow("devix"))} ${o.dim(`v${l}`)}`),console.log(),console.log(`  ${o.green("\u279C")}  ${o.bold("Local:")}   ${o.cyan(`http://localhost:${e}/`)}`),console.log(n?`  ${o.green("\u279C")}  ${o.bold("Network:")} ${o.cyan(n)}`:`  ${o.green("\u279C")}  ${o.bold("Network:")} ${o.dim("use --host to expose")}`),console.log()}export{$ as printDevBanner};
+import o from"picocolors";import{networkInterfaces as r}from"node:os";function s(e){let l=r();for(let n of Object.values(l))for(let t of n??[])if(t.family==="IPv4"&&!t.internal)return`http://${t.address}:${e}/`;return null}function $(e){let l="0.4.1-beta.6",n=s(e);console.log(),console.log(`  ${o.bold(o.yellow("devix"))} ${o.dim(`v${l}`)}`),console.log(),console.log(`  ${o.green("\u279C")}  ${o.bold("Local:")}   ${o.cyan(`http://localhost:${e}/`)}`),console.log(n?`  ${o.green("\u279C")}  ${o.bold("Network:")} ${o.cyan(n)}`:`  ${o.green("\u279C")}  ${o.bold("Network:")} ${o.dim("use --host to expose")}`),console.log()}export{$ as printDevBanner};
 //# sourceMappingURL=banner.js.map

package/dist/utils/cookies.d.ts

@@ -0,0 +1,12 @@
+export interface CookieOptions {
+    httpOnly?: boolean;
+    secure?: boolean;
+    sameSite?: 'Strict' | 'Lax' | 'None';
+    maxAge?: number;
+    expires?: Date;
+    path?: string;
+    domain?: string;
+}
+export declare function getCookie(req: Request, name: string): string | undefined;
+export declare function setCookie(headers: Headers, name: string, value: string, options?: CookieOptions): void;
+export declare function deleteCookie(headers: Headers, name: string, options?: Pick<CookieOptions, 'path' | 'domain'>): void;

package/dist/utils/duration.d.ts

@@ -0,0 +1 @@
+export declare function parseDuration(value: number | string): number;

package/dist/utils/env.d.ts

@@ -0,0 +1 @@
+export declare function loadDotenv(mode: string): void;

package/dist/utils/html.d.ts

@@ -0,0 +1,2 @@
+export declare function safeJsonStringify(value: unknown): string;
+export declare function escapeAttr(value: string): string;

package/dist/utils/patterns.d.ts

@@ -0,0 +1 @@
+export declare function routePattern(rel: string): string;

package/dist/utils/response.d.ts

@@ -0,0 +1,19 @@
+export type JsonResponse<T = unknown> = Response & {
+    readonly __body: T;
+};
+export declare const json: <const T>(data: T, status?: number) => JsonResponse<T>;
+export declare const text: (body: string, status?: number) => Response;
+declare const REDIRECT_BRAND: unique symbol;
+export interface RedirectOptions {
+    status?: number;
+    replace?: boolean;
+}
+export interface Redirect {
+    readonly [REDIRECT_BRAND]: true;
+    readonly url: string;
+    readonly status: number;
+    readonly replace: boolean;
+}
+export declare function redirect(url: string, statusOrOptions?: number | RedirectOptions): Redirect;
+export declare function isRedirect(value: unknown): value is Redirect;
+export {};

package/dist/vite/codegen/api.d.ts

@@ -0,0 +1,6 @@
+interface ApiOptions {
+    apiPath: string;
+    appDir: string;
+}
+export declare function generateApi({ apiPath, appDir }: ApiOptions): string;
+export {};

package/dist/vite/codegen/client-routes.d.ts

@@ -0,0 +1,6 @@
+interface ClientRoutesOptions {
+    pagesDir: string;
+    matcherPath: string;
+}
+export declare function generateClientRoutes({ pagesDir, matcherPath }: ClientRoutesOptions): string;
+export {};

package/dist/vite/codegen/context.d.ts

@@ -0,0 +1 @@
+export declare function generateContext(): string;

package/dist/vite/codegen/entry-client.d.ts

@@ -0,0 +1,5 @@
+interface EntryClientOptions {
+    cssUrls: string[];
+}
+export declare function generateEntryClient({ cssUrls }: EntryClientOptions): string;
+export {};

package/dist/vite/codegen/extract-methods.d.ts

@@ -0,0 +1,4 @@
+declare const HTTP_METHODS: readonly ["GET", "POST", "PUT", "PATCH", "DELETE", "HEAD", "OPTIONS"];
+export type HttpMethod = (typeof HTTP_METHODS)[number];
+export declare function extractHttpMethods(content: string): HttpMethod[];
+export {};

package/dist/vite/codegen/render.d.ts

@@ -0,0 +1,6 @@
+interface RenderOptions {
+    pagesDir: string;
+    renderPath: string;
+}
+export declare function generateRender({ pagesDir, renderPath }: RenderOptions): string;
+export {};

package/dist/vite/codegen/routes-dts.d.ts

@@ -0,0 +1,10 @@
+import type { HttpMethod } from './extract-methods';
+export interface RouteEntry {
+    filePath: string;
+    urlPattern: string;
+    identifier: string;
+    methods: HttpMethod[];
+}
+export declare function filePathToIdentifier(filePath: string, apiDir: string): string;
+export declare function buildRouteEntry(filePath: string, apiDir: string, methods: HttpMethod[]): RouteEntry;
+export declare function generateRoutesDts(entries: RouteEntry[], apiDir: string): string;

package/dist/vite/codegen/scan-api.d.ts

@@ -0,0 +1,2 @@
+import type { RouteEntry } from './routes-dts';
+export declare function scanApiFiles(appDir: string, projectRoot: string): RouteEntry[];

package/dist/vite/codegen/write-routes-dts.d.ts

@@ -0,0 +1 @@
+export declare function writeRoutesDts(content: string, projectRoot: string): boolean;

package/dist/vite/index.d.ts

@@ -0,0 +1,3 @@
+import { UserConfig } from 'vite';
+import type { DevixConfig } from '../config';
+export declare function devix(config: DevixConfig): UserConfig;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@devlusoft/devix",
-  "version": "0.4.1-beta.4",
+  "version": "0.4.1-beta.6",
   "type": "module",
   "description": "A lightweight React SSR meta-framework — devix",
   "author": "devlusoft",