@foxpage/foxpage-types/lib/context/render.d.ts

foxpage sdk types

/// <reference types="node" />
import * as url from 'url';
import { AppConfig, FoxRoute } from '../application';
import { BrowserInitialStateOption, BrowserResource } from '../browser';
import { FoxpageComponent } from '../component';
import { ContentDetail } from '../content';
import { FoxpageHooks } from '../hook';
import { Logger } from '../logger';
import { Block, Condition, FPFile, FPFunction, Material, Mock, Package, Page, PrePackage, RelationInfo, Tag, Template, Variable } from '../manager';
import { PerformanceLogger, RenderPerformance } from '../performance';
import { FoxpageDelegatedCookie, FoxpageDelegatedRequest, FoxpageDelegatedResponse, RequestMode } from '../request';
import { StructureNode } from '../structure';
type ContentType = Template | Variable | Condition | FPFunction | Block;
export interface FrameworkResource extends BrowserResource {
}
export interface RenderOption extends BrowserInitialStateOption {
}
export type ContextPage = ContentDetail<StructureNode>;
export interface ParsedContent<T = ContentType | Package | PrePackage, P = any> {
    content: T;
    parseStatus?: boolean;
    parseMessages?: string[];
    parsed: P;
}
export interface RenderContent<T = ContentType | Package | PrePackage> extends ParsedContent<T> {
    renderMessage?: string[];
}
export interface ContextResource {
    templates?: Record<string, RenderContent<Template>>;
    variables?: Record<string, RenderContent<Variable>>;
    materials?: Record<string, RenderContent<Material>>;
    conditions?: Record<string, RenderContent<Condition>>;
    functions?: Record<string, RenderContent<FPFunction>>;
    blocks?: Record<string, RenderContent<Block>>;
    libraries?: Record<string, PrePackage>;
    plugins?: Record<string, PrePackage>;
}
export interface ContextOrigin {
    /**
     * T：contain page,block content
     */
    page?: ContextPage;
    extendPage?: Page;
    templates?: Template[];
    packages?: Package[];
    variables?: Variable[];
    sysVariables?: Variable[];
    materials?: Material[];
    conditions?: Condition[];
    functions?: FPFunction[];
    mocks?: Mock[];
    blocks?: Block[];
    libraries?: PrePackage[];
    plugins?: PrePackage[];
}
/**
 * render context
 *
 * @export
 * @interface Context
 */
export interface Context extends RequestMode {
    URL?: url.URL;
    url: string;
    host: string;
    locale?: string;
    /**
     * @deprecated
     */
    _foxpage_preview_time?: string;
    _foxpage_preview_locale?: string;
    readonly appId: string;
    readonly appSlug: string;
    readonly appConfigs?: AppConfig;
    matchedRoute?: FoxRoute;
    pathname?: string;
    /**
     * T：contain page,block content
     */
    page: ContextPage;
    file?: FPFile;
    tags?: Tag[];
    packages?: Package[];
    libraries?: Record<string, PrePackage>;
    csrPlugins?: Record<string, PrePackage>;
    /**
     * key - string - structure id
     * value - FoxpageComponent - component
     */
    componentMap?: Map<string, FoxpageComponent>;
    /**
     * key - string - structure id
     * value - FoxpageComponent - component
     */
    dependencies?: Map<string, FoxpageComponent>;
    structureMap?: Map<string, StructureNode & {
        childrenIds: string[];
    } & {
        ssrEnable?: boolean;
        ssrHookEnable?: boolean;
    }>;
    templates: Record<string, Template>;
    variables: Record<'__templates' | '__conditions' | '__functions' | '__blocks' | string, unknown> & {
        has?: (key: string) => boolean;
    };
    conditions: Record<string, boolean>;
    functions: Record<string, unknown>;
    blocks: Record<string, Block>;
    plugins?: string[];
    hooks?: FoxpageHooks;
    moduleIds?: string[];
    runtime?: {
        isServer?: boolean;
        isBrowser?: boolean;
        clientType?: 'server' | 'browser';
    };
    sessionId?: string;
    env?: string;
    readonly origin: ContextOrigin;
    frameworkResource?: FrameworkResource;
    options?: RenderOption;
    disableConditionRender?: boolean;
    logger?: Logger;
    performance: RenderPerformance;
    request?: FoxpageDelegatedRequest;
    response?: FoxpageDelegatedResponse;
    cookies?: FoxpageDelegatedCookie;
    renderConfig?: {
        errorThrow?: boolean;
    };
    mockConditions?: string[];
    updateOrigin(relation: RelationInfo): void;
    updateOriginByKey<K extends keyof ContextOrigin>(key: K, value: ContextOrigin[K]): void;
    updateOriginPage(content: ContextPage): void;
    getOrigin<K extends keyof ContextOrigin>(key: K): ContextOrigin[K];
    updatePage(content: ContextPage): void;
    updateResource<K extends keyof ContextResource, T extends RenderContent>(target: K, key: string, value: T): void;
    render?: (dsl: Page['schemas'], ctx: Context) => Promise<string>;
    performanceLogger: PerformanceLogger;
}
export {};