alepha 0.6.7 → 0.6.9

package/react.d.ts

@@ -1 +1,617 @@
-export * from '@alepha/react';
+import * as _alepha_core from '@alepha/core';
+import { Alepha, Static as Static$1, TSchema as TSchema$1, KIND, OPTIONS, Async, Class, TObject as TObject$1 } from '@alepha/core';
+import * as _alepha_server from '@alepha/server';
+import { HttpClientLink, HttpClient, ServerRouterProvider, ServerHandler, ServerRequest } from '@alepha/server';
+import * as react from 'react';
+import react__default, { ReactNode, FC, AnchorHTMLAttributes } from 'react';
+import { Root } from 'react-dom/client';
+import { RouterProvider, Route } from '@alepha/router';
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import { ServerStaticProvider } from '@alepha/server-static';
+
+/** Symbol key applied to readonly types */
+declare const ReadonlyKind: unique symbol;
+/** Symbol key applied to optional types */
+declare const OptionalKind: unique symbol;
+/** Symbol key applied to types */
+declare const Hint: unique symbol;
+/** Symbol key applied to types */
+declare const Kind: unique symbol;
+
+type TReadonly<T extends TSchema> = T & {
+    [ReadonlyKind]: 'Readonly';
+};
+
+type StringFormatOption = 'date-time' | 'time' | 'date' | 'email' | 'idn-email' | 'hostname' | 'idn-hostname' | 'ipv4' | 'ipv6' | 'uri' | 'uri-reference' | 'iri' | 'uuid' | 'iri-reference' | 'uri-template' | 'json-pointer' | 'relative-json-pointer' | 'regex' | ({} & string);
+type StringContentEncodingOption = '7bit' | '8bit' | 'binary' | 'quoted-printable' | 'base64' | ({} & string);
+interface StringOptions extends SchemaOptions {
+    /** The maximum string length */
+    maxLength?: number;
+    /** The minimum string length */
+    minLength?: number;
+    /** A regular expression pattern this string should match */
+    pattern?: string;
+    /** A format this string should match */
+    format?: StringFormatOption;
+    /** The content encoding for this string */
+    contentEncoding?: StringContentEncodingOption;
+    /** The content media type for this string */
+    contentMediaType?: string;
+}
+interface TString extends TSchema, StringOptions {
+    [Kind]: 'String';
+    static: string;
+    type: 'string';
+}
+
+interface TBoolean extends TSchema {
+    [Kind]: 'Boolean';
+    static: boolean;
+    type: 'boolean';
+}
+
+type TOptional<T extends TSchema> = T & {
+    [OptionalKind]: 'Optional';
+};
+
+/** Creates a static type from a TypeBox type */
+type Static<Type extends TSchema, Params extends unknown[] = [], Result = (Type & {
+    params: Params;
+})['static']> = Result;
+
+type ReadonlyOptionalPropertyKeys<T extends TProperties> = {
+    [K in keyof T]: T[K] extends TReadonly<TSchema> ? (T[K] extends TOptional<T[K]> ? K : never) : never;
+}[keyof T];
+type ReadonlyPropertyKeys<T extends TProperties> = {
+    [K in keyof T]: T[K] extends TReadonly<TSchema> ? (T[K] extends TOptional<T[K]> ? never : K) : never;
+}[keyof T];
+type OptionalPropertyKeys<T extends TProperties> = {
+    [K in keyof T]: T[K] extends TOptional<TSchema> ? (T[K] extends TReadonly<T[K]> ? never : K) : never;
+}[keyof T];
+type RequiredPropertyKeys<T extends TProperties> = keyof Omit<T, ReadonlyOptionalPropertyKeys<T> | ReadonlyPropertyKeys<T> | OptionalPropertyKeys<T>>;
+type ObjectStaticProperties<T extends TProperties, R extends Record<keyof any, unknown>> = Evaluate<(Readonly<Partial<Pick<R, ReadonlyOptionalPropertyKeys<T>>>> & Readonly<Pick<R, ReadonlyPropertyKeys<T>>> & Partial<Pick<R, OptionalPropertyKeys<T>>> & Required<Pick<R, RequiredPropertyKeys<T>>>)>;
+type ObjectStatic<T extends TProperties, P extends unknown[]> = ObjectStaticProperties<T, {
+    [K in keyof T]: Static<T[K], P>;
+}>;
+type TPropertyKey = string | number;
+type TProperties = Record<TPropertyKey, TSchema>;
+type TAdditionalProperties = undefined | TSchema | boolean;
+interface ObjectOptions extends SchemaOptions {
+    /** Additional property constraints for this object */
+    additionalProperties?: TAdditionalProperties;
+    /** The minimum number of properties allowed on this object */
+    minProperties?: number;
+    /** The maximum number of properties allowed on this object */
+    maxProperties?: number;
+}
+interface TObject<T extends TProperties = TProperties> extends TSchema, ObjectOptions {
+    [Kind]: 'Object';
+    static: ObjectStatic<T, this['params']>;
+    additionalProperties?: TAdditionalProperties;
+    type: 'object';
+    properties: T;
+    required?: string[];
+}
+
+type Evaluate<T> = T extends infer O ? {
+    [K in keyof O]: O[K];
+} : never;
+
+interface SchemaOptions {
+    $schema?: string;
+    /** Id for this schema */
+    $id?: string;
+    /** Title of this schema */
+    title?: string;
+    /** Description of this schema */
+    description?: string;
+    /** Default value for this schema */
+    default?: any;
+    /** Example values matching this schema */
+    examples?: any;
+    /** Optional annotation for readOnly */
+    readOnly?: boolean;
+    /** Optional annotation for writeOnly */
+    writeOnly?: boolean;
+    [prop: string]: any;
+}
+interface TKind {
+    [Kind]: string;
+}
+interface TSchema extends TKind, SchemaOptions {
+    [ReadonlyKind]?: string;
+    [OptionalKind]?: string;
+    [Hint]?: string;
+    params: unknown[];
+    static: unknown;
+}
+
+interface Head$1 {
+    title?: string;
+    htmlAttributes?: Record<string, string>;
+    bodyAttributes?: Record<string, string>;
+    meta?: Array<{
+        name: string;
+        content: string;
+    }>;
+}
+declare class ServerHeadProvider {
+    renderHead(template: string, head: Head$1): string;
+    mergeAttributes(existing: string, attrs: Record<string, string>): string;
+    parseAttributes(attrStr: string): Record<string, string>;
+    escapeHtml(str: string): string;
+}
+
+declare class BrowserHeadProvider {
+    renderHead(document: Document, head: Head$1): void;
+}
+
+interface BrowserRoute extends Route {
+    page: PageRoute;
+}
+declare class BrowserRouterProvider extends RouterProvider<BrowserRoute> {
+    protected readonly log: _alepha_core.Logger;
+    protected readonly alepha: Alepha;
+    protected readonly pageDescriptorProvider: PageDescriptorProvider;
+    add(entry: PageRouteEntry): void;
+    protected readonly configure: _alepha_core.HookDescriptor<"configure">;
+    transition(url: URL, options?: TransitionOptions): Promise<RouterRenderResult>;
+    root(state: RouterState, context?: PageReactContext): ReactNode;
+}
+
+declare const envSchema$1: _alepha_core.TObject<{
+    REACT_ROOT_ID: TString;
+}>;
+declare module "alepha" {
+    interface Env extends Partial<Static$1<typeof envSchema$1>> {
+    }
+}
+declare class ReactBrowserProvider {
+    protected readonly log: _alepha_core.Logger;
+    protected readonly client: HttpClient;
+    protected readonly alepha: Alepha;
+    protected readonly router: BrowserRouterProvider;
+    protected readonly headProvider: BrowserHeadProvider;
+    protected readonly env: {
+        REACT_ROOT_ID: string;
+    };
+    protected root: Root;
+    transitioning?: {
+        to: string;
+    };
+    state: RouterState;
+    get document(): Document;
+    get history(): History;
+    get url(): string;
+    invalidate(props?: Record<string, any>): Promise<void>;
+    /**
+     *
+     * @param url
+     * @param options
+     */
+    go(url: string, options?: RouterGoOptions): Promise<void>;
+    protected render(options?: {
+        url?: string;
+        previous?: PreviousLayerData[];
+    }): Promise<{
+        url: string;
+        head: Head;
+    }>;
+    /**
+     * Get embedded layers from the server.
+     *
+     * @protected
+     */
+    protected getHydrationState(): ReactHydrationState | undefined;
+    /**
+     *
+     * @protected
+     */
+    protected getRootElement(): HTMLElement;
+    /**
+     *
+     * @protected
+     */
+    readonly ready: _alepha_core.HookDescriptor<"ready">;
+    readonly onTransitionEnd: _alepha_core.HookDescriptor<"react:transition:end">;
+}
+interface RouterGoOptions {
+    replace?: boolean;
+    match?: TransitionOptions;
+}
+interface ReactHydrationState {
+    layers?: PreviousLayerData[];
+    links?: HttpClientLink[];
+}
+
+declare class RouterHookApi {
+    private readonly state;
+    private readonly layer;
+    private readonly browser?;
+    constructor(state: RouterState, layer: {
+        path: string;
+    }, browser?: ReactBrowserProvider | undefined);
+    /**
+     *
+     */
+    get current(): RouterState;
+    /**
+     *
+     */
+    get pathname(): string;
+    /**
+     *
+     */
+    get query(): Record<string, string>;
+    /**
+     *
+     */
+    back(): Promise<void>;
+    /**
+     *
+     */
+    forward(): Promise<void>;
+    /**
+     *
+     * @param props
+     */
+    invalidate(props?: Record<string, any>): Promise<void>;
+    /**
+     * Create a valid href for the given pathname.
+     *
+     * @param pathname
+     * @param layer
+     */
+    createHref(pathname: HrefLike, layer?: {
+        path: string;
+    }): string;
+    /**
+     *
+     * @param path
+     * @param options
+     */
+    go(path: HrefLike, options?: RouterGoOptions): Promise<void>;
+    /**
+     *
+     * @param path
+     */
+    createAnchorProps(path: string): AnchorProps;
+    /**
+     * Set query params.
+     *
+     * @param record
+     * @param options
+     */
+    setQueryParams(record: Record<string, any>, options?: {
+        /**
+         * If true, this will merge current query params with the new ones.
+         */
+        merge?: boolean;
+        /**
+         * If true, this will add a new entry to the history stack.
+         */
+        push?: boolean;
+    }): void;
+}
+type HrefLike = string | {
+    options: {
+        path?: string;
+        name?: string;
+    };
+};
+
+declare const KEY = "PAGE";
+interface PageConfigSchema {
+    query?: TSchema$1;
+    params?: TSchema$1;
+}
+type TPropsDefault = any;
+type TPropsParentDefault = object;
+interface PageDescriptorOptions<TConfig extends PageConfigSchema = PageConfigSchema, TProps extends object = TPropsDefault, TPropsParent extends object = TPropsParentDefault> {
+    name?: string;
+    path?: string;
+    schema?: TConfig;
+    resolve?: (config: PageResolve<TConfig, TPropsParent>) => Async<TProps>;
+    component?: FC<TProps & TPropsParent>;
+    lazy?: () => Promise<{
+        default: FC<TProps & TPropsParent>;
+    }>;
+    children?: Array<{
+        [OPTIONS]: PageDescriptorOptions;
+    }>;
+    parent?: {
+        [OPTIONS]: PageDescriptorOptions<any, TPropsParent>;
+    };
+    can?: () => boolean;
+    head?: Head | ((props: TProps, previous?: Head) => Head);
+    errorHandler?: FC<{
+        error: Error;
+        url: string;
+    }>;
+}
+interface PageDescriptor<TConfig extends PageConfigSchema = PageConfigSchema, TProps extends object = TPropsDefault, TPropsParent extends object = TPropsParentDefault> {
+    [KIND]: typeof KEY;
+    [OPTIONS]: PageDescriptorOptions<TConfig, TProps, TPropsParent>;
+    render: (options?: {
+        params?: Record<string, string>;
+        query?: Record<string, string>;
+    }) => Promise<string>;
+    go: () => void;
+    createAnchorProps: (routerHook: RouterHookApi) => {
+        href: string;
+        onClick: () => void;
+    };
+    can: () => boolean;
+}
+declare const $page: {
+    <TConfig extends PageConfigSchema = PageConfigSchema, TProps extends object = any, TPropsParent extends object = object>(options: PageDescriptorOptions<TConfig, TProps, TPropsParent>): PageDescriptor<TConfig, TProps, TPropsParent>;
+    [KIND]: string;
+};
+interface Head {
+    title?: string;
+    titleSeparator?: string;
+    htmlAttributes?: Record<string, string>;
+    bodyAttributes?: Record<string, string>;
+    meta?: Array<{
+        name: string;
+        content: string;
+    }>;
+}
+interface PageRequestConfig<TConfig extends PageConfigSchema = PageConfigSchema> {
+    params: TConfig["params"] extends TSchema$1 ? Static$1<TConfig["params"]> : Record<string, string>;
+    query: TConfig["query"] extends TSchema$1 ? Static$1<TConfig["query"]> : Record<string, string>;
+}
+type PageResolve<TConfig extends PageConfigSchema = PageConfigSchema, TPropsParent extends object = TPropsParentDefault> = PageRequestConfig<TConfig> & TPropsParent & PageResolveContext;
+interface PageResolveContext {
+    url: URL;
+    head: Head;
+}
+
+declare class PageDescriptorProvider {
+    protected readonly log: _alepha_core.Logger;
+    protected readonly alepha: Alepha;
+    protected readonly pages: PageRoute[];
+    getPages(): PageRoute[];
+    page(name: string): PageRoute;
+    root(state: RouterState, context?: PageReactContext): ReactNode;
+    createLayers(route: PageRoute, request: PageRequest): Promise<CreateLayersResult>;
+    protected getErrorHandler(route: PageRoute): react.FC<{
+        error: Error;
+        url: string;
+    }> | undefined;
+    protected createElement(page: PageRoute, props: Record<string, any>): Promise<ReactNode>;
+    protected fillHead(page: PageRoute, ctx: PageRequest, props: Record<string, any>): void;
+    renderError(e: Error): ReactNode;
+    renderEmptyView(): ReactNode;
+    href(page: {
+        options: {
+            name?: string;
+        };
+    }, params?: Record<string, any>): string;
+    compile(path: string, params?: Record<string, string>): string;
+    protected renderView(index: number, path: string, view?: ReactNode): ReactNode;
+    protected readonly configure: _alepha_core.HookDescriptor<"configure">;
+    protected map(pages: Array<{
+        value: {
+            [OPTIONS]: PageDescriptorOptions;
+        };
+    }>, target: {
+        [OPTIONS]: PageDescriptorOptions;
+    }): PageRouteEntry;
+    add(entry: PageRouteEntry): void;
+    protected createMatch(page: PageRoute): string;
+    protected _next: number;
+    protected nextId(): string;
+}
+declare const isPageRoute: (it: any) => it is PageRoute;
+interface PageRouteEntry extends Omit<PageDescriptorOptions, "children" | "parent"> {
+    children?: PageRouteEntry[];
+}
+interface PageRoute extends PageRouteEntry {
+    type: "page";
+    name: string;
+    parent?: PageRoute;
+    match: string;
+}
+interface Layer {
+    config?: {
+        query?: Record<string, any>;
+        params?: Record<string, any>;
+        context?: Record<string, any>;
+    };
+    name: string;
+    props?: Record<string, any>;
+    error?: Error;
+    part?: string;
+    element: ReactNode;
+    index: number;
+    path: string;
+}
+type PreviousLayerData = Omit<Layer, "element">;
+interface AnchorProps {
+    href?: string;
+    onClick?: (ev: any) => any;
+}
+interface RouterState {
+    pathname: string;
+    search: string;
+    layers: Array<Layer>;
+    head: Head;
+}
+interface TransitionOptions {
+    state?: RouterState;
+    previous?: PreviousLayerData[];
+    context?: PageReactContext;
+}
+interface RouterStackItem {
+    route: PageRoute;
+    config?: Record<string, any>;
+    props?: Record<string, any>;
+    error?: Error;
+}
+interface RouterRenderResult {
+    redirect?: string;
+    layers: Layer[];
+    head: Head;
+    element: ReactNode;
+}
+interface PageRequest extends PageReactContext {
+    url: URL;
+    params: Record<string, any>;
+    query: Record<string, string>;
+    head: Head;
+    previous?: PreviousLayerData[];
+}
+interface CreateLayersResult extends RouterState {
+    redirect?: string;
+}
+interface PageReactContext {
+    links?: HttpClientLink[];
+}
+
+interface NestedViewProps {
+    children?: ReactNode;
+}
+/**
+ * Nested view component
+ *
+ * @param props
+ * @constructor
+ */
+declare const NestedView: (props: NestedViewProps) => string | number | bigint | boolean | react.ReactElement<unknown, string | react.JSXElementConstructor<any>> | Iterable<ReactNode> | Promise<string | number | bigint | boolean | react.ReactPortal | react.ReactElement<unknown, string | react.JSXElementConstructor<any>> | Iterable<ReactNode> | null | undefined> | null;
+
+interface LinkProps extends AnchorHTMLAttributes<HTMLAnchorElement> {
+    to: string | PageDescriptor;
+    children?: react__default.ReactNode;
+}
+declare const Link: (props: LinkProps) => react_jsx_runtime.JSX.Element | null;
+
+interface RouterContextValue {
+    alepha: Alepha;
+    state: RouterState;
+    context: PageReactContext;
+}
+declare const RouterContext: react.Context<RouterContextValue | undefined>;
+
+interface RouterLayerContextValue {
+    index: number;
+    path: string;
+}
+declare const RouterLayerContext: react.Context<RouterLayerContextValue | undefined>;
+
+declare const useInject: <T extends object>(clazz: Class<T>) => T;
+
+declare const useClient: () => HttpClient;
+declare const useApi: <T extends object>() => _alepha_server.HttpVirtualClient<T>;
+
+interface UseQueryParamsHookOptions {
+    format?: "base64" | "querystring";
+    key?: string;
+    push?: boolean;
+}
+declare const useQueryParams: <T extends TObject$1>(schema: T, options?: UseQueryParamsHookOptions) => [Static$1<T>, (data: Static$1<T>) => void];
+
+declare const useRouter: () => RouterHookApi;
+
+declare const useRouterEvents: (opts?: {
+    onBegin?: (ev: {
+        state: RouterState;
+    }) => void;
+    onEnd?: (ev: {
+        state: RouterState;
+    }) => void;
+    onError?: (ev: {
+        state: RouterState;
+        error: Error;
+    }) => void;
+}, deps?: any[]) => void;
+
+declare const useRouterState: () => RouterState;
+
+declare const useActive: (path: HrefLike) => UseActiveHook;
+interface UseActiveHook {
+    isActive: boolean;
+    anchorProps: AnchorProps;
+    isPending: boolean;
+    name?: string;
+}
+
+declare class RedirectionError extends Error {
+    readonly page: HrefLike;
+    constructor(page: HrefLike);
+}
+
+declare const envSchema: TObject<{
+    REACT_SERVER_DIST: TString;
+    REACT_SERVER_PREFIX: TString;
+    REACT_SSR_ENABLED: TBoolean;
+    REACT_ROOT_ID: TString;
+}>;
+declare module "alepha/core" {
+    interface Env extends Partial<Static$1<typeof envSchema>> {
+    }
+    interface State {
+        "ReactServerProvider.template"?: string;
+        "ReactServerProvider.ssr"?: boolean;
+    }
+}
+declare class ReactServerProvider {
+    protected readonly log: _alepha_core.Logger;
+    protected readonly alepha: Alepha;
+    protected readonly pageDescriptorProvider: PageDescriptorProvider;
+    protected readonly serverStaticProvider: ServerStaticProvider;
+    protected readonly serverRouterProvider: ServerRouterProvider;
+    protected readonly headProvider: ServerHeadProvider;
+    protected readonly env: {
+        REACT_ROOT_ID: string;
+        REACT_SERVER_DIST: string;
+        REACT_SERVER_PREFIX: string;
+        REACT_SSR_ENABLED: boolean;
+    };
+    protected readonly ROOT_DIV_REGEX: RegExp;
+    protected readonly configure: _alepha_core.HookDescriptor<"configure">;
+    protected registerPages(templateLoader: () => Promise<string | undefined>): Promise<void>;
+    protected getPublicDirectory(): string;
+    protected configureStaticServer(root: string): Promise<void>;
+    protected configureVite(): Promise<void>;
+    protected createRenderFunction(name: string): (options?: {
+        params?: Record<string, string>;
+        query?: Record<string, string>;
+    }) => Promise<string>;
+    protected createHandler(page: PageRoute, templateLoader: () => Promise<string | undefined>): ServerHandler;
+    fillTemplate(response: {
+        html: string;
+    }, app: string, script: string): void;
+}
+
+declare module "@alepha/core" {
+    interface Hooks {
+        "react:browser:render": {
+            context: PageReactContext;
+            hydration?: ReactHydrationState;
+        };
+        "react:server:render": {
+            request: ServerRequest;
+            pageRequest: PageRequest;
+        };
+        "react:transition:begin": {
+            state: RouterState;
+        };
+        "react:transition:success": {
+            state: RouterState;
+        };
+        "react:transition:error": {
+            error: Error;
+            state: RouterState;
+        };
+        "react:transition:end": {
+            state: RouterState;
+        };
+    }
+}
+declare class ReactModule {
+    protected readonly alepha: Alepha;
+    constructor();
+}
+
+export { $page, type AnchorProps, type CreateLayersResult, type Head, type HrefLike, type Layer, Link, NestedView, type PageConfigSchema, type PageDescriptor, type PageDescriptorOptions, PageDescriptorProvider, type PageReactContext, type PageRequest, type PageRequestConfig, type PageResolve, type PageResolveContext, type PageRoute, type PageRouteEntry, type PreviousLayerData, ReactBrowserProvider, type ReactHydrationState, ReactModule, ReactServerProvider, RedirectionError, RouterContext, type RouterContextValue, type RouterGoOptions, RouterHookApi, RouterLayerContext, type RouterLayerContextValue, type RouterRenderResult, type RouterStackItem, type RouterState, type TPropsDefault, type TPropsParentDefault, type TransitionOptions, type UseActiveHook, type UseQueryParamsHookOptions, envSchema, isPageRoute, useActive, useApi, useClient, useInject, useQueryParams, useRouter, useRouterEvents, useRouterState };