Index

Modules: happyx, happyx/bindings/python_types, happyx/core/constants, happyx/core/exceptions, happyx/core/queries, happyx/core/secure, happyx/private/macro_utils, happyx/routing/decorators, happyx/routing/mounting, happyx/routing/routing, happyx/spa/components, happyx/spa/renderer, happyx/spa/state, happyx/spa/tag, happyx/spa/translatable, happyx/ssr/cors, happyx/ssr/docs/api_doc_template, happyx/ssr/docs/autodocs, happyx/ssr/docs/open_api, happyx/ssr/form_data, happyx/ssr/handlers, happyx/ssr/request_models, happyx/ssr/server, happyx/ssr/session, happyx/ssr/utils, happyx/sugar/js, happyx/sugar/sgr, happyx/sugar/style, happyx/sugar/use, happyx/tmpl_engine/engine.

API symbols

`!=`:

• state: proc `!=`[T](self`gensym1, other`gensym1: State[T]): bool
• state: proc `!=`[T](self`gensym1: State[T]; other`gensym1: T): bool

`!`:

• state: proc `!`[T](self`gensym10, other`gensym10: State[T]): T
• state: proc `!`[T](self`gensym10: State[T]; other`gensym10: T): T
• state: proc `!`[T](other`gensym10: T; self`gensym10: State[T]): T

`$=`:

• state: proc `$=`[T](self`gensym23: State[T]; other`gensym23: State[T])
• state: proc `$=`[T](self`gensym23: State[T]; other`gensym23: T)
• state: proc `$=`[T](other`gensym23: T; self`gensym23: State[T])

`$`:

• state: proc `$`[T](self: State[T]): string
• tag: proc `$`(self: TagRef): string

`%=`:

• state: proc `%=`[T](self`gensym22: State[T]; other`gensym22: State[T])
• state: proc `%=`[T](self`gensym22: State[T]; other`gensym22: T)
• state: proc `%=`[T](other`gensym22: T; self`gensym22: State[T])

`%`:

• state: proc `%`[T](self`gensym12, other`gensym12: State[T]): T
• state: proc `%`[T](self`gensym12: State[T]; other`gensym12: T): T
• state: proc `%`[T](other`gensym12: T; self`gensym12: State[T]): T

`&=`:

• state: proc `&=`[T](self`gensym21: State[T]; other`gensym21: State[T])
• state: proc `&=`[T](self`gensym21: State[T]; other`gensym21: T)
• state: proc `&=`[T](other`gensym21: T; self`gensym21: State[T])

`&`:

• state: proc `&`[T](self`gensym5, other`gensym5: State[T]): T
• state: proc `&`[T](self`gensym5: State[T]; other`gensym5: T): T
• state: proc `&`[T](other`gensym5: T; self`gensym5: State[T]): T

`*=`:

• state: proc `*=`[T](self`gensym16: State[T]; other`gensym16: State[T])
• state: proc `*=`[T](self`gensym16: State[T]; other`gensym16: T)
• state: proc `*=`[T](other`gensym16: T; self`gensym16: State[T])

`*`:

• state: proc `*`[T](self`gensym8, other`gensym8: State[T]): T
• state: proc `*`[T](self`gensym8: State[T]; other`gensym8: T): T
• state: proc `*`[T](other`gensym8: T; self`gensym8: State[T]): T

`+=`:

• state: proc `+=`[T](self`gensym17: State[T]; other`gensym17: State[T])
• state: proc `+=`[T](self`gensym17: State[T]; other`gensym17: T)
• state: proc `+=`[T](other`gensym17: T; self`gensym17: State[T])

`+`:

• state: proc `+`[T](self`gensym6, other`gensym6: State[T]): T
• state: proc `+`[T](self`gensym6: State[T]; other`gensym6: T): T
• state: proc `+`[T](other`gensym6: T; self`gensym6: State[T]): T

`-=`:

• state: proc `-=`[T](self`gensym18: State[T]; other`gensym18: State[T])
• state: proc `-=`[T](self`gensym18: State[T]; other`gensym18: T)
• state: proc `-=`[T](other`gensym18: T; self`gensym18: State[T])

`->`:

• state: macro `->`(self: State; field: untyped): untyped
• sgr: macro `->`(route, at, body: untyped): untyped

`-`:

• state: proc `-`[T](self`gensym7, other`gensym7: State[T]): T
• state: proc `-`[T](self`gensym7: State[T]; other`gensym7: T): T
• state: proc `-`[T](other`gensym7: T; self`gensym7: State[T]): T

`.`:

• server: macro `.`(obj: JsonNode; field: untyped): JsonNode

`/=`:

• state: proc `/=`[T](self`gensym19: State[T]; other`gensym19: State[T])
• state: proc `/=`[T](self`gensym19: State[T]; other`gensym19: T)
• state: proc `/=`[T](other`gensym19: T; self`gensym19: State[T])

`/`:

• state: proc `/`[T](self`gensym9, other`gensym9: State[T]): T
• state: proc `/`[T](self`gensym9: State[T]; other`gensym9: T): T
• state: proc `/`[T](other`gensym9: T; self`gensym9: State[T]): T

`:=`:

• state: proc `:=`[T](self`gensym25: State[T]; other`gensym25: State[T])
• state: proc `:=`[T](self`gensym25: State[T]; other`gensym25: T)
• state: proc `:=`[T](other`gensym25: T; self`gensym25: State[T])
• sgr: template `:=`(name, value: untyped): untyped

`<=`:

• state: proc `<=`[T](self`gensym3, other`gensym3: State[T]): bool
• state: proc `<=`[T](self`gensym3: State[T]; other`gensym3: T): bool

`<`:

• state: proc `<`[T](self`gensym15, other`gensym15: State[T]): T
• state: proc `<`[T](self`gensym15: State[T]; other`gensym15: T): T
• state: proc `<`[T](other`gensym15: T; self`gensym15: State[T]): T

`==`:

• state: proc `==`[T](self`gensym0, other`gensym0: State[T]): bool
• state: proc `==`[T](self`gensym0: State[T]; other`gensym0: T): bool

`>=`:

• state: proc `>=`[T](self`gensym2, other`gensym2: State[T]): bool
• state: proc `>=`[T](self`gensym2: State[T]; other`gensym2: T): bool

`>`:

• state: proc `>`[T](self`gensym14, other`gensym14: State[T]): T
• state: proc `>`[T](self`gensym14: State[T]; other`gensym14: T): T
• state: proc `>`[T](other`gensym14: T; self`gensym14: State[T]): T

`?`:

• queries: macro `?`(strTable: StringTableRef | TableRef[string, seq[string]]; key: untyped): untyped

`@=`:

• state: proc `@=`[T](self`gensym24: State[T]; other`gensym24: State[T])
• state: proc `@=`[T](self`gensym24: State[T]; other`gensym24: T)
• state: proc `@=`[T](other`gensym24: T; self`gensym24: State[T])

`@`:

• state: proc `@`[T](self`gensym13, other`gensym13: State[T]): T
• state: proc `@`[T](self`gensym13: State[T]; other`gensym13: T): T
• state: proc `@`[T](other`gensym13: T; self`gensym13: State[T]): T

`[]=`:

• state: proc `[]=`[T, U](self: State[array[T, U]]; idx: int; value: T)
• state: proc `[]=`[T](self: State[seq[T]]; idx: int; value: T)
• state: proc `[]=`(self: State[StringTableRef]; idx: string; value: string)
• state: proc `[]=`[T, U](self: State[TableRef[T, U]]; idx: T; value: U)
• tag: proc `[]=`(self: TagRef; attrName: string; attrValue: string)
• server: proc `[]=`[T](self: CustomHeaders; key: string; value: T)

`[]`:

• python_types: proc `[]`(self: RequestModels; name: string): RequestModelData
• python_types: proc `[]`(params: seq[HandlerParam]; key: string): string
• state: proc `[]`[T](self: State[openArray[T]]; idx: int): T
• state: proc `[]`[T](self: State[openArray[T]]; idx: State[int]): T
• state: proc `[]`(self: State[StringTableRef]; idx: string): string
• state: proc `[]`[T, U](self: State[TableRef[T, U]]; idx: T): U
• tag: proc `[]`(self: TagRef; index: int): TagRef
• tag: proc `[]`(self: TagRef; attrName: string): string

`^=`:

• state: proc `^=`[T](self`gensym20: State[T]; other`gensym20: State[T])
• state: proc `^=`[T](self`gensym20: State[T]; other`gensym20: T)
• state: proc `^=`[T](other`gensym20: T; self`gensym20: State[T])

`^`:

• state: proc `^`[T](self`gensym11, other`gensym11: State[T]): T
• state: proc `^`[T](self`gensym11: State[T]; other`gensym11: T): T
• state: proc `^`[T](other`gensym11: T; self`gensym11: State[T]): T

`not`:

• state: proc `not`[T](self`gensym4: State[T]): bool

`|=`:

• state: proc `|=`[T](self`gensym26: State[T]; other`gensym26: State[T])
• state: proc `|=`[T](self`gensym26: State[T]; other`gensym26: T)
• state: proc `|=`[T](other`gensym26: T; self`gensym26: State[T])

`~=`:

• state: proc `~=`[T](self`gensym27: State[T]; other`gensym27: State[T])
• state: proc `~=`[T](self`gensym27: State[T]; other`gensym27: T)
• state: proc `~=`[T](other`gensym27: T; self`gensym27: State[T])

add:

• tag: proc add(self: TagRef; tags: varargs[TagRef])

addArg:

• tag: proc addArg(self: TagRef; arg: string)

addArgIter:

• tag: proc addArgIter(self: TagRef; arg: string)

addAttribute:

• macro_utils: proc addAttribute(node, key, value: NimNode; inComponent: bool = false)

addCORSHeaders:

• cors: macro addCORSHeaders(headers: HttpHeaders)

answer:

• server: template answer(req: Request; message: string | int | float | bool | char; code: HttpCode = Http200; headers: HttpHeaders = newHttpHeaders( [("Content-Type", "text/plain; charset=utf-8")]); contentLength: Option[int] = int.none)

answerFile:

• server: proc answerFile(req: Request; filename: string; code: HttpCode = Http200; asAttachment = false; bufSize: int = 40960; forceResponse: bool = false; headers: CustomHeaders = newCustomHeaders()): owned(Future[void])

answerHtml:

• server: template answerHtml(req: Request; data: string | TagRef; code: HttpCode = Http200; headers: HttpHeaders = newHttpHeaders( [("Content-Type", "text/html; charset=utf-8")])): untyped

answerJson:

• server: template answerJson(req: Request; data: untyped; code: HttpCode = Http200; headers: HttpHeaders = newHttpHeaders( [("Content-Type", "application/json; charset=utf-8")])): untyped

ApiDocObject:

• server: object ApiDocObject

apiDocsPath:

• constants: const apiDocsPath

App:

• renderer: type App

AppEventHandler:

• renderer: type AppEventHandler

application:

• renderer: var application

appName:

• constants: const appName

appRoutes:

• renderer: macro appRoutes(name: string; body: untyped): untyped

attribute:

• macro_utils: proc attribute(attr: NimNode; inComponent: bool = false): NimNode

BaseComponent:

• renderer: type BaseComponent

BaseComponentObj:

• renderer: object BaseComponentObj

bracket:

• macro_utils: proc bracket(node: seq[NimNode] | seq[string]): NimNode
• macro_utils: proc bracket(node: varargs[NimNode]): NimNode

buildComponentHtml:

• renderer: macro buildComponentHtml(componentName, html: untyped): untyped

buildHtml:

• renderer: macro buildHtml(html: untyped): untyped
• renderer: macro buildHtml(root, html: untyped): untyped

buildHtmlProcedure:

• macro_utils: proc buildHtmlProcedure(root, body: NimNode; inComponent: bool = false; componentName: NimNode = newEmptyNode(); inCycle: bool = false; cycleTmpVar: string = ""; compTmpVar: NimNode = newEmptyNode(); cycleVars: var seq[NimNode]; parent: NimNode = newEmptyNode()): NimNode

buildHtmlSlot:

• renderer: macro buildHtmlSlot(html: untyped; inCycle, inComponent: static[bool]): untyped

buildJs:

• js: macro buildJs(body: untyped): untyped

buildStyle:

• style: macro buildStyle(body: untyped): untyped

check_password:

• secure: proc check_password(source, hash): bool

closeSession:

• session: template closeSession(session: Session)
• session: template closeSession(sessionId: string)

compDefArg:

• components: proc compDefArg[T](value: typedesc[T]): T

component:

• components: macro component(name, body: untyped): untyped

componentDebugTarget:

• constants: const componentDebugTarget

ComponentEventHandler:

• renderer: type ComponentEventHandler

componentEventHandlers:

• renderer: var componentEventHandlers

components:

• renderer: var components

componentsResult:

• renderer: var componentsResult

contains:

• python_types: proc contains(self: RequestModels; name: string): bool
• python_types: proc contains(params: seq[HandlerParam]; key: string): bool

convertJson:

• routing: proc convertJson(self: RequestModelData; body: string): JsonNode

CORSObj:

• cors: object CORSObj

createdComponentsList:

• renderer: var createdComponentsList

cryptoMethod:

• constants: const cryptoMethod

currentComponent:

• renderer: var currentComponent

currentComponentsList:

• renderer: var currentComponentsList

currentRoute:

• renderer: var currentRoute

CustomHeaders:

• server: type CustomHeaders

decorator:

• decorators: macro decorator(name, body: untyped): untyped

DecoratorImpl:

• decorators: type DecoratorImpl

decorators:

• decorators: var decorators

discardStmt:

• macro_utils: proc discardStmt(): NimNode

elem:

• renderer: macro elem(name: untyped): untyped

enableApiDoc:

• constants: const enableApiDoc

enableAppRouting:

• constants: const enableAppRouting

enableAutoTranslate:

• constants: const enableAutoTranslate

enableDebug:

• constants: const enableDebug

enableDebugComponentMacro:

• constants: const enableDebugComponentMacro

enableDebugSpaMacro:

• constants: const enableDebugSpaMacro

enableDebugSsrMacro:

• constants: const enableDebugSsrMacro

enableDebugTreeComponentMacro:

• constants: const enableDebugTreeComponentMacro

enableDefaultComponents:

• constants: const enableDefaultComponents

enableDefaultDecorators:

• constants: const enableDefaultDecorators

enableHistoryApi:

• constants: const enableHistoryApi

enableHttpBeast:

• constants: const enableHttpBeast

enableHttpx:

• constants: const enableHttpx

enableLiveViews:

• constants: const enableLiveViews

enableMicro:

• constants: const enableMicro

enableRequestModelDebugMacro:

• constants: const enableRequestModelDebugMacro

enableRouting:

• state: var enableRouting

enableRoutingDebugMacro:

• constants: const enableRoutingDebugMacro

enableSafeRequests:

• constants: const enableSafeRequests

enableTemplateEngine:

• constants: const enableTemplateEngine

enableUseCompDebugMacro:

• constants: const enableUseCompDebugMacro

endsWithBuildHtml:

• macro_utils: proc endsWithBuildHtml(statement: NimNode): bool

eventHandlers:

• renderer: var eventHandlers

exportJvm:

• constants: const exportJvm

exportPython:

• constants: const exportPython

exportRouteArgs:

• routing: proc exportRouteArgs(urlPath, routePath, body: NimNode): NimNode

fetchModelFields:

• autodocs: proc fetchModelFields(): NimNode

fetchPathParams:

• autodocs: proc fetchPathParams(route: var string): tuple[pathParams, models: NimNode]

fgColored:

• server: proc fgColored(text: string; clr: ForegroundColor): string

FileResponseObj:

• python_types: type FileResponseObj

findAndReplaceMount:

• mounting: proc findAndReplaceMount(body: NimNode)

findByTag:

• tag: proc findByTag(self: TagRef; tag: string): seq[TagRef]

formatNode:

• macro_utils: proc formatNode(node: NimNode): NimNode

FormDataItem:

• form_data: object FormDataItem

genApiDoc:

• autodocs: proc genApiDoc(body: var NimNode): NimNode

generate_password:

• secure: proc generate_password(source: string): MDigest[512]

genSessionId:

• session: proc genSessionId(): string

get:

• state: proc get[T](self: State[T]): T
• tag: proc get(self: TagRef; tag: string): TagRef

getAttribute:

• tag: proc getAttribute(self: TagRef; attrName: string; default: string = ""): string

getParamName:

• python_types: proc getParamName(params: seq[HandlerParam]; paramType: string): string

getParamType:

• python_types: proc getParamType(params: seq[HandlerParam]; key: string): string

getRouteParams:

• routing: proc getRouteParams(routeData: RouteDataObj; found_regexp_matches: seq[RegexMatch2]; urlPath: string = ""; handlerParams: seq[HandlerParam] = @[]; body: string = ""; force: bool = false): RouteObject

getSession:

• session: proc getSession(req: Request; host: string; cookies: var seq[string]; timeout: int64 = 0): Session

getTagName:

• macro_utils: proc getTagName(name: string): string

handleRoute:

• routing: proc handleRoute(route: string): RouteDataObj

HandlerParam:

• python_types: object HandlerParam

happyxDocs:

• autodocs: proc happyxDocs(docsData: NimNode): NimNode

has:

• sgr: proc has[T: HoleyEnum; U](e: typedesc[T]; val: U): bool
• sgr: proc has[T: OrdinalEnum; U](e: typedesc[T]; val: U): bool

hasHttpMethod:

• python_types: proc hasHttpMethod(self: Route; httpMethod: string | seq[string] | openArray[string]): bool

hasHttpRequest:

• python_types: proc hasHttpRequest(params: seq[HandlerParam]): bool

hasParamType:

• python_types: proc hasParamType(params: seq[HandlerParam]; key: string): bool

HpxAppRouteDefect:

• exceptions: object HpxAppRouteDefect

HpxBuildHtmlDefect:

• exceptions: object HpxBuildHtmlDefect

HpxBuildJsDefect:

• exceptions: object HpxBuildJsDefect

HpxBuildStyleDefect:

• exceptions: object HpxBuildStyleDefect

HpxComponentDefect:

• exceptions: object HpxComponentDefect

HpxCorsDefect:

• exceptions: object HpxCorsDefect

HpxMajor:

• constants: const HpxMajor

HpxMinor:

• constants: const HpxMinor

HpxModelSyntaxDefect:

• exceptions: object HpxModelSyntaxDefect

HpxMountDefect:

• exceptions: object HpxMountDefect

HpxPatch:

• constants: const HpxPatch

HpxPathParamDefect:

• exceptions: object HpxPathParamDefect

HpxServeRouteDefect:

• exceptions: object HpxServeRouteDefect

HpxSyntaxSugarDefect:

• exceptions: object HpxSyntaxSugarDefect

HpxTranslatableDefect:

• exceptions: object HpxTranslatableDefect

HpxUseDefect:

• exceptions: object HpxUseDefect

HpxVersion:

• constants: const HpxVersion

html:

• renderer: proc html(comp: BaseComponent; data: string)
• renderer: proc html(host, data: string)

HtmlResponseObj:

• python_types: type HtmlResponseObj

htmlTagsList:

• constants: const htmlTagsList

httpMethods:

• constants: const httpMethods

HttpRequest:

• python_types: type HttpRequest

importComponent:

• components: macro importComponent(body: untyped): untyped

IndexApiDocPageTemplate:

• api_doc_template: const IndexApiDocPageTemplate

initHttpRequest:

• python_types: proc initHttpRequest(path, httpMethod: string; headers: HttpHeaders; body: string = ""): HttpRequest

initRoute:

• python_types: proc initRoute(path, purePath: string; httpMethod: seq[string]; pattern: Regex2; handler: PyObject): Route

initServer:

• server: macro initServer(body: untyped): untyped

initTag:

• tag: proc initTag(name: string; isText: bool; children: seq[TagRef] = @[]; onlyChildren: bool = false): TagRef
• tag: proc initTag(name: string; isText: bool; attrs: StringTableRef; children: seq[TagRef] = @[]; onlyChildren: bool = false): TagRef
• tag: proc initTag(name: string; children: seq[TagRef] = @[]; onlyChildren: bool = false): TagRef
• tag: proc initTag(name: string; attrs: StringTableRef; children: seq[TagRef] = @[]; onlyChildren: bool = false): TagRef

injectJs:

• renderer: proc injectJs(host, script: string)

isExpr:

• macro_utils: proc isExpr(node: NimNode): bool

isIdentUsed:

• macro_utils: proc isIdentUsed(body, name: NimNode): bool

items:

• state: iterator items[T](self: State[openArray[T]]): T

js:

• renderer: proc js(comp: BaseComponent; script: string)

JsonResponseObj:

• python_types: type JsonResponseObj

LanguageSettings:

• translatable: object LanguageSettings

len:

• state: proc len[T](self: State[T]): int

liveview:

• server: macro liveview(body: untyped): untyped

lvl:

• tag: proc lvl(self: TagRef): int

model:

• request_models: macro model(modelName, body: untyped): untyped

ModelBase:

• server: type ModelBase

modelFields:

• request_models: const modelFields

modelFieldsGenerics:

• request_models: const modelFieldsGenerics

mount:

• mounting: macro mount(mountName, body: untyped): untyped

newAnnotations:

• python_types: proc newAnnotations(data: PyObject): JsonNode

newApiDocObject:

• server: proc newApiDocObject(httpMethod: seq[string]; description, path: string; pathParams: seq[PathParamObj]; models: seq[RequestModelObj]): ApiDocObject

newCast:

• macro_utils: proc newCast(fromType, toType: NimNode): NimNode

newCustomHeaders:

• server: proc newCustomHeaders(): CustomHeaders

newHandlerParams:

• python_types: proc newHandlerParams(args: openArray[string]; annotations: JsonNode): seq[ HandlerParam]

newLambda:

• macro_utils: proc newLambda(body: NimNode; params: seq[NimNode] | NimNode = @[newEmptyNode()]; pragmas: seq[NimNode] | seq[string] = @[newEmptyNode()]): NimNode

newMultiVarStmt:

• macro_utils: proc newMultiVarStmt(extractNames: openArray[NimNode]; val: NimNode; isLet: bool = false): NimNode

newPathParamObj:

• routing: proc newPathParamObj(name, paramType, defaultValue: string; optional, mutable: bool): PathParamObj

newRequestModelObj:

• routing: proc newRequestModelObj(name, typeName, target: string; mutable: bool): RequestModelObj

newServer:

• server: proc newServer(address: string = "127.0.0.1"; port: int = 5000): Server

newWebSocketObj:

• python_types: proc newWebSocketObj(ws: websocketx.WebSocket; data: string = ""): python_types.WebSocket

nim_1_6_14:

• constants: const nim_1_6_14

nim_2_0_0:

• constants: const nim_2_0_0

NimKeywords:

• tag: const NimKeywords

nnkNumbers:

• style: const nnkNumbers

numThreads:

• constants: const numThreads

onException:

• routing: const onException

openApiDocs:

• autodocs: proc openApiDocs(docsData: NimNode): NimNode

pairs:

• state: iterator pairs[T, U](self: State[TableRef[T, U]]): (T, U)

parseBoolOrJString:

• routing: proc parseBoolOrJString(str: string): JsonNode

parseFloatOrJString:

• routing: proc parseFloatOrJString(str: string): JsonNode

parseFormData:

• form_data: proc parseFormData(formData: string): (StringTableRef, TableRef[string, FormDataItem])

parseIntOrJString:

• routing: proc parseIntOrJString(str: string): JsonNode

parseQuery:

• queries: proc parseQuery(q: string): owned(StringTableRef)

parseQueryArrays:

• queries: proc parseQueryArrays(query: string): TableRef[string, seq[string]]

parseXmlBody:

• form_data: proc parseXmlBody(data: string): JsonNode

parseXWwwFormUrlencoded:

• form_data: proc parseXWwwFormUrlencoded(data: string): StringTableRef

PathParamObj:

• routing: object PathParamObj

pathParams:

• routing: macro pathParams(body: untyped): untyped

pragmaBlock:

• macro_utils: proc pragmaBlock(pragmas: openArray[NimNode]; statementList: NimNode): NimNode

procApiDocs:

• autodocs: proc procApiDocs(docsData: NimNode): NimNode

processWebSocket:

• python_types: proc processWebSocket(py, locals: PyObject)

regCORS:

• cors: macro regCORS(body: untyped): untyped

regDecorator:

• decorators: proc regDecorator(decoratorName: string; decorator: DecoratorImpl)

registerApp:

• renderer: proc registerApp(appId: cstring = "app"): App

registerComponent:

• renderer: proc registerComponent(name: string; component: BaseComponent): BaseComponent

registeredMounts:

• mounting: const registeredMounts

registerRouteParamType:

• routing: macro registerRouteParamType(name, pattern: string; creator: untyped)

remember:

• state: proc remember[T](val: T): State[T]

render:

• renderer: method render(self: BaseComponent): TagRef
• engine: proc render(model: auto; htmlTemplate: static[string]): string

rendererHandlers:

• renderer: var rendererHandlers

renderTemplate:

• engine: macro renderTemplate(name: static[string]): untyped

renderVdom:

• renderer: proc renderVdom(app: App; tag: TagRef; force: bool = false)

replaceIter:

• macro_utils: proc replaceIter(root: NimNode; search: proc (x: NimNode): bool; replace: proc (x: NimNode): NimNode): bool

replaceSelfComponent:

• macro_utils: proc replaceSelfComponent(statement, componentName: NimNode; parent: NimNode = nil; convert: bool = false; is_constructor: bool = false; is_field: bool = true): NimNode

replaceUseInComponent:

• macro_utils: proc replaceUseInComponent(body: NimNode)

reqModelDebugTarget:

• constants: const reqModelDebugTarget

RequestModelData:

• python_types: object RequestModelData

RequestModelObj:

• routing: object RequestModelObj

RequestModels:

• python_types: type RequestModels

requestModelsHidden:

• python_types: var requestModelsHidden

requestResult:

• renderer: var requestResult

reRender:

• renderer: method reRender(self: BaseComponent)

reRenderTmpl:

• components: template reRenderTmpl()

ResponseObj:

• python_types: type ResponseObj

Route:

• python_types: type Route

route:

• renderer: proc route(comp: BaseComponent; path: string)
• renderer: proc route(host, path: string)

RouteDataObj:

• routing: object RouteDataObj

RouteObject:

• routing: type RouteObject

routes:

• renderer: macro routes(app: App; body: untyped): untyped
• server: macro routes(server: Server; body: untyped = newStmtList()): untyped

serve:

• server: macro serve(address: string; port: int; body: untyped): untyped

Server:

• server: type Server

Session:

• session: object Session

sessionIdLength:

• constants: const sessionIdLength

set:

• state: proc set(settings: var LanguageSettings; lang: string)
• state: proc set[T](self: State[T]; value: T)

slots:

• macro_utils: const slots

start:

• renderer: template start(app: App)
• server: template start(server: Server): untyped

startSession:

• session: template startSession(): Session
• session: template startSession(timeout: int64): Session

State:

• state: type State

sugarRoutes:

• sgr: const sugarRoutes

tag:

• tag: proc tag(name: string): TagRef
• tag: proc tag(tag: TagRef): TagRef

tagFromString:

• tag: proc tagFromString(source: string): TagRef

TagRef:

• tag: type TagRef

templateFolder:

• engine: macro templateFolder(f: string)

textTag:

• tag: proc textTag(text: string): TagRef

throwDefect:

• exceptions: proc throwDefect(defect: typedesc; msg: string; lineInfo: LineInfo)

toBool:

• state: converter toBool(self: State[bool]): bool

toChar:

• state: converter toChar(self: State[char]): char

toCString:

• state: converter toCString(self: State[cstring]): cstring

toFloat:

• state: converter toFloat(self: State[float]): float

toFloat32:

• state: converter toFloat32(self: State[float32]): float32

toFloat64:

• state: converter toFloat64(self: State[float64]): float64

toHttpHeaders:

• python_types: proc toHttpHeaders(headers: PyObject): HttpHeaders
• utils: proc toHttpHeaders(json: JsonNode): HttpHeaders

toInt:

• state: converter toInt(self: State[int]): int

toInt16:

• state: converter toInt16(self: State[int16]): int16

toInt32:

• state: converter toInt32(self: State[int32]): int32

toInt64:

• state: converter toInt64(self: State[int64]): int64

toInt8:

• state: converter toInt8(self: State[int8]): int8

toJsonNode:

• utils: proc toJsonNode(headers: HttpHeaders | Option[HttpHeaders]): JsonNode

toPPyObject:

• python_types: proc toPPyObject(headers: HttpHeaders): PPyObject

toSeq:

• state: converter toSeq[T](self: State[seq[T]]): seq[T]

toSeqIter:

• tag: proc toSeqIter(self: TagRef): seq[TagRef]

toString:

• state: converter toString(self: State[string]): string

translatable:

• translatable: macro translatable(body: untyped): untyped

translate:

• translatable: macro translate(self: string): string

UnclosedTags:

• tag: const UnclosedTags

UniqueComponentId:

• macro_utils: const UniqueComponentId

uniqueId:

• macro_utils: const uniqueId

uniqueWebSocketId:

• python_types: var uniqueWebSocketId

use:

• use: macro use(expr: untyped; inComp: static[bool] = false; compTmpVar: string = ""): untyped

useComponent:

• macro_utils: proc useComponent(statement: NimNode; inCycle, inComponent: bool; cycleTmpVar: string; compTmpVar: NimNode; cycleVars: var seq[NimNode]; returnTagRef: bool = true; constructor: bool = false; nameIsIdent: bool = false): NimNode

val=:

• state: proc val=[T](self: State[T]; value: T)

WebSocket:

• python_types: type WebSocket

WebSocketState:

• python_types: enum WebSocketState