Index

Modules: happyx, happyx/bindings/python_types, happyx/core/constants, happyx/core/exceptions, happyx/core/queries, happyx/core/secure, happyx/private/macro_utils, happyx/private/scanutils, happyx/routing/decorators, happyx/routing/decorators/base, happyx/routing/decorators/builtin/auth, happyx/routing/decorators/builtin/cached, happyx/routing/decorators/builtin/rate_limit, happyx/routing/decorators/builtin/user_agent, happyx/routing/mounting, happyx/routing/routing, happyx/routing/routing/base, happyx/routing/routing/scanfuncs, happyx/routing/routing/types, happyx/spa/components, happyx/spa/renderer, happyx/spa/state, happyx/spa/tag, happyx/spa/translatable, happyx/ssr/core, 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/liveviews/liveviews, happyx/ssr/liveviews/utils, happyx/ssr/request_models, happyx/ssr/server, happyx/ssr/session, happyx/ssr/types, happyx/ssr/utils, happyx/ssr/websockets, happyx/sugar/js, happyx/sugar/sgr, happyx/sugar/style, happyx/sugar/use, happyx/tmpl_engine/engine.

API symbols

`!=`:

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

`!`:

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

`$=`:

• state: template `$=`[T](a`gensym23: State[T]; b`gensym23: State[T])
• state: template `$=`[T](a`gensym23: State[T]; b`gensym23: T)
• state: template `$=`[T](b`gensym23: T; a`gensym23: State[T])

`$`:

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

`%=`:

• state: template `%=`[T](a`gensym22: State[T]; b`gensym22: State[T])
• state: template `%=`[T](a`gensym22: State[T]; b`gensym22: T)
• state: template `%=`[T](b`gensym22: T; a`gensym22: State[T])

`%`:

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

`&=`:

• state: template `&=`[T](a`gensym21: State[T]; b`gensym21: State[T])
• state: template `&=`[T](a`gensym21: State[T]; b`gensym21: T)
• state: template `&=`[T](b`gensym21: T; a`gensym21: State[T])

`&`:

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

`*=`:

• state: template `*=`[T](a`gensym16: State[T]; b`gensym16: State[T])
• state: template `*=`[T](a`gensym16: State[T]; b`gensym16: T)
• state: template `*=`[T](b`gensym16: T; a`gensym16: State[T])

`*`:

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

`+=`:

• state: template `+=`[T](a`gensym17: State[T]; b`gensym17: State[T])
• state: template `+=`[T](a`gensym17: State[T]; b`gensym17: T)
• state: template `+=`[T](b`gensym17: T; a`gensym17: State[T])

`+`:

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

`-=`:

• state: template `-=`[T](a`gensym18: State[T]; b`gensym18: State[T])
• state: template `-=`[T](a`gensym18: State[T]; b`gensym18: T)
• state: template `-=`[T](b`gensym18: T; a`gensym18: State[T])

`->`:

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

`-`:

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

`.`:

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

`/=`:

• state: template `/=`[T](a`gensym19: State[T]; b`gensym19: State[T])
• state: template `/=`[T](a`gensym19: State[T]; b`gensym19: T)
• state: template `/=`[T](b`gensym19: T; a`gensym19: State[T])

`/`:

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

`:=`:

• state: template `:=`[T](a`gensym25: State[T]; b`gensym25: State[T])
• state: template `:=`[T](a`gensym25: State[T]; b`gensym25: T)
• state: template `:=`[T](b`gensym25: T; a`gensym25: State[T])
• sgr: template `:=`(name, value: untyped): untyped

`<=`:

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

`<`:

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

`==`:

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

`>=`:

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

`>`:

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

`?`:

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

`@=`:

• state: template `@=`[T](a`gensym24: State[T]; b`gensym24: State[T])
• state: template `@=`[T](a`gensym24: State[T]; b`gensym24: T)
• state: template `@=`[T](b`gensym24: T; a`gensym24: State[T])

`@`:

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

`[]=`:

• state: template `[]=`[T, U](a: State[array[T, U]]; idx: int; value: T)
• state: template `[]=`[T](a: State[seq[T]]; idx: int; value: T)
• state: template `[]=`(a: State[StringTableRef]; idx: string; value: string)
• state: template `[]=`[T, U](a: State[TableRef[T, U]]; idx: T; value: U)
• tag: proc `[]=`(self: TagRef; attrName: string; attrValue: string)
• utils: 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, U](self: State[array[T, U]]; idx: int): T
• state: proc `[]`[T, U](self: State[array[T, U]]; idx: State[int]): T
• state: proc `[]`[T](self: State[seq[T]]; idx: int): T
• state: proc `[]`[T](self: State[seq[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: template `^=`[T](a`gensym20: State[T]; b`gensym20: State[T])
• state: template `^=`[T](a`gensym20: State[T]; b`gensym20: T)
• state: template `^=`[T](b`gensym20: T; a`gensym20: State[T])

`^`:

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

`not`:

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

`|=`:

• state: template `|=`[T](a`gensym26: State[T]; b`gensym26: State[T])
• state: template `|=`[T](a`gensym26: State[T]; b`gensym26: T)
• state: template `|=`[T](b`gensym26: T; a`gensym26: State[T])

`~=`:

• state: template `~=`[T](a`gensym27: State[T]; b`gensym27: State[T])
• state: template `~=`[T](a`gensym27: State[T]; b`gensym27: T)
• state: template `~=`[T](b`gensym27: T; a`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)
• server: template answer(req: Request; message: string | int | float | bool | char; code: HttpCode = Http200; headers: HttpHeaders; contentLength: Option[int] | Option[string] = 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:

• autodocs: 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

bck:

• renderer: proc bck(hostname, urlPath: string)

body:

• core: proc body(req: Request): Option[string]

boolean:

• scanfuncs: proc boolean(input: string; boolVal: var bool; start: int; opt: bool = false): int

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

buildHtmls:

• renderer: template buildHtmls(body: untyped): seq[TagRef]

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

builtinTypes:

• request_models: const builtinTypes

CachedResult:

• cached: object CachedResult

CachedRoute:

• cached: object CachedRoute

cachedRoutes:

• cached: var cachedRoutes

check_password:

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

closed:

• core: proc closed(req: Request): 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

corsRegistered:

• cors: const corsRegistered

createdComponentsList:

• renderer: var createdComponentsList

cryptoMethod:

• constants: const cryptoMethod

currentComponent:

• renderer: var currentComponent

currentComponentsList:

• renderer: var currentComponentsList

currentRoute:

• renderer: var currentRoute

CustomHeaders:

• utils: type CustomHeaders

declaredPathParams:

• base: const declaredPathParams

decorator:

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

DecoratorImpl:

• base: type DecoratorImpl

decorators:

• base: var decorators

default:

• scanfuncs: proc default(input: string; strVal: var string; start: int): int

discardStmt:

• macro_utils: proc discardStmt(): NimNode

enableApiDoc:

• constants: const enableApiDoc

enableAppRouting:

• constants: const enableAppRouting

enableAutoTranslate:

• constants: const enableAutoTranslate

enableBuiltin:

• constants: const enableBuiltin

enableCachedRoutes:

• constants: const enableCachedRoutes

enableColors:

• constants: const enableColors

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

enableStd:

• constants: const enableStd

enableTemplateEngine:

• constants: const enableTemplateEngine

enableUseCompDebugMacro:

• constants: const enableUseCompDebugMacro

enableWarning:

• macro_utils: proc enableWarning(warnName: static[string]; enable: static[bool]): NimNode

endsWithBuildHtml:

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

enumerate:

• scanfuncs: proc enumerate[T: enum](input: string; e: var T; start: int; opt: bool = false): int

eventHandlers:

• renderer: var eventHandlers

exportJvm:

• constants: const exportJvm

exportPython:

• constants: const exportPython

exportRouteArgs:

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

fetchModelFields:

• autodocs: proc fetchModelFields(): NimNode

fetchPathParams:

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

fgColored:

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

FileResponseObj:

• python_types: type FileResponseObj

findAllUses:

• macro_utils: proc findAllUses(body, name: NimNode; uses: var seq[NimNode])

findAndReplaceMount:

• mounting: proc findAndReplaceMount(body: NimNode)

findByTag:

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

findModels:

• scanfuncs: proc findModels(route: string): seq[tuple[name, kind, mode: string]]

findParams:

• scanfuncs: proc findParams(route: string; purePath: var string): seq[ tuple[name, kind: string, opt: bool, def: string]]

findTagsAtTop:

• tag: proc findTagsAtTop(tree: XmlNode; tag: string): seq[XmlNode]

forget:

• core: proc forget(req: Request)

formatNode:

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

FormDataItem:

• form_data: object FormDataItem

frwrd:

• renderer: proc frwrd(hostname, urlPath: string)

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

getIdentUses:

• macro_utils: proc getIdentUses(body, name: NimNode): seq[NimNode]

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

handleLiveViews:

• liveviews: proc handleLiveViews(body: NimNode)

handleRoute:

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

HandlerParam:

• python_types: object HandlerParam

handleWebsockets:

• websockets: proc handleWebsockets(wsClosedConnection: NimNode): tuple[ wsStmtList, insertWsList: NimNode]

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

headers:

• core: proc headers(req: Request): Option[HttpHeaders]

high:

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

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

htmlNonBoolAttrs:

• constants: const htmlNonBoolAttrs

HtmlResponseObj:

• python_types: type HtmlResponseObj

htmlTagsList:

• constants: const htmlTagsList

httpMethod:

• core: proc httpMethod(req: Request): Option[HttpMethod]

httpMethods:

• constants: const httpMethods

HttpRequest:

• python_types: type HttpRequest

httpxClientBufDefaultSize:

• core: const httpxClientBufDefaultSize

httpxClientBufSize:

• core: const httpxClientBufSize

HttpxDefect:

• core: type HttpxDefect

i18n:

• translatable: template i18n(body: untyped): untyped

importComponent:

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

importFuncComponent:

• components: macro importFuncComponent(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

initSettings:

• core: proc initSettings(port = Port(8080); bindAddr = ""; numThreads = 0; startup: Startup = doNothing(); listener: Socket = nil): Settings

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)

integer:

• scanfuncs: proc integer(input: string; intVal: var int; start: int; opt: bool = false): int

ip:

• core: proc ip(req: Request): 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)
• renderer: proc js(host, script: string)

JsonResponseObj:

• python_types: type JsonResponseObj

kind:

• scanfuncs: proc kind(input: string; strVal: var string; start: int): int

kind2scanable:

• scanfuncs: proc kind2scanable(kind: string; opt: bool): string

kind2tp:

• scanfuncs: proc kind2tp(kind: string): string

LanguageSettings:

• translatable: object LanguageSettings

lazyHtml:

• renderer: template lazyHtml(body: untyped): proc (): TagRef

lazyHtmls:

• renderer: template lazyHtmls(body: untyped): seq[proc (): TagRef]

lazyTag:

• tag: proc lazyTag(lazy: proc (): TagRef): TagRef

len:

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

liveview:

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

liveviewParam:

• macro_utils: proc liveviewParam(name: string): NimNode

liveviewRoutes:

• renderer: var liveviewRoutes

liveViewsCache:

• liveviews: const liveViewsCache

liveViewScript:

• utils: proc liveViewScript(): NimNode

liveviewWsHost:

• liveviews: const liveviewWsHost

low:

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

lvl:

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

model:

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

ModelBase:

• types: type ModelBase

modelFields:

• request_models: const modelFields

modelFieldsGenerics:

• request_models: const modelFieldsGenerics

modelImplementation:

• request_models: macro modelImplementation(modelName: untyped; enableOptions: static[bool]; options: static[seq[string]]; generics, genericsBracket: untyped; body: typed): untyped

modelImplementationUntyped:

• request_models: macro modelImplementationUntyped(modelName: untyped; enableOptions: static[bool]; options: static[seq[string]]; generics, genericsBracket: untyped; body: untyped): untyped

mount:

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

newAnnotations:

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

newApiDocObject:

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

newCast:

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

newCustomHeaders:

• utils: 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:

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

newRequestModelObj:

• types: proc newRequestModelObj(name, typeName, target: string): RequestModelObj

newServer:

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

newWebSocket:

• core: proc newWebSocket(req: Request): Future[WebSocket]

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:

• base: const onException

OnRequest:

• core: type OnRequest

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

parseContentLength:

• core: proc parseContentLength(data: string): int

parseFloatOrJString:

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

parseFormData:

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

parseHeaders:

• core: proc parseHeaders(data: string): Option[HttpHeaders]

parseHttpMethod:

• core: proc parseHttpMethod(data: string): Option[HttpMethod]

parseIntOrJString:

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

parsePath:

• core: proc parsePath(data: string): Option[string]

parsePathWithQueries:

• core: proc parsePathWithQueries(data: string): Option[(string, string)]

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

path:

• scanfuncs: proc path(input: string; strVal: var string; start: int): int
• core: proc path(req: Request): Option[string]

PathParamObj:

• types: object PathParamObj

pathParams:

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

pathWithQueries:

• core: proc pathWithQueries(req: Request): Option[(string, string)]

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)

RateLimitInfo:

• rate_limit: object RateLimitInfo

rateLimits:

• rate_limit: var rateLimits

realnum:

• scanfuncs: proc realnum(input: string; floatVal: var float; start: int; opt: bool = false): int

regCORS:

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

regDecorator:

• base: 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

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

Request:

• core: object Request

RequestModelData:

• python_types: object RequestModelData

RequestModelObj:

• types: object RequestModelObj

RequestModels:

• python_types: type RequestModels

requestModelsHidden:

• python_types: var requestModelsHidden

requestResult:

• renderer: var requestResult

rerender:

• renderer: proc rerender(query, queryArr, reqMethod, inCookies, headers: auto; hostname, urlPath: string)

reRender:

• renderer: method reRender(self: BaseComponent)

reRenderTmpl:

• components: template reRenderTmpl()

rerenderWithComponent:

• renderer: proc rerenderWithComponent(comp: BaseComponent)

ResponseObj:

• python_types: type ResponseObj

rf:

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

Route:

• python_types: type Route

route:

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

RouteDataObj:

• types: object RouteDataObj

RouteObject:

• types: type RouteObject

routes:

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

run:

• core: proc run(onRequest: OnRequest)
• core: proc run(onRequest: OnRequest; settings: Settings)

runAsync:

• core: proc runAsync(onRequest: OnRequest): owned(Future[void])
• core: proc runAsync(onRequest: OnRequest; settings: Settings): owned(Future[void])

scanf:

• scanutils: macro scanf(input: string; pattern: static[string]; results: varargs[typed]): bool
• scanutils: Module scanutils

scopeCss:

• components: proc scopeCss(source, uniqCompId: string): string

scopedCycleCounter:

• renderer: var scopedCycleCounter

send:

• core: proc send(req: Request; code: HttpCode)
• core: proc send(req: Request; code: HttpCode; body: string; contentLength: Option[int]; headers = "")
• core: proc send(req: Request; code: HttpCode; body: string; contentLength: Option[string]; headers = "")
• core: proc send(req: Request; body: string; code = Http200)
• core: template send(req: Request; code: HttpCode; body: string; headers = "")
• server: proc send(request: Request; content: string): Future[void]

serve:

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

Server:

• types: type Server

Session:

• session: object Session

sessionIdLength:

• constants: const sessionIdLength

set:

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

Settings:

• core: object Settings

slots:

• macro_utils: const slots

sseSend:

• server: proc sseSend[T](request: Request; eventName: string; content: T): Future[void]

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

StateChangeHandler:

• state: type StateChangeHandler

str:

• scanfuncs: proc str(input: string; strVal: var string; start: int; opt: bool = false): int

sugarRoutes:

• sgr: const sugarRoutes

SvgElements:

• tag: const SvgElements

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(customHeaders: CustomHeaders): 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; variables: varargs[string]): string

ugly:

• tag: proc ugly(self: TagRef): string

UnclosedTags:

• tag: const UnclosedTags

UniqueComponentId:

• macro_utils: const UniqueComponentId

uniqueId:

• macro_utils: const uniqueId

uniqueWebSocketId:

• python_types: var uniqueWebSocketId

unsafeSend:

• core: proc unsafeSend(req: Request; data: string)

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

useWss:

• liveviews: const useWss

val=:

• state: template val=[T](a: State[T]; value: T)

watch:

• state: macro watch(state, newVal, oldVal, body: untyped): untyped

watchImpl:

• state: proc watchImpl[T](state: State[T]; o, n: T)

WebSocket:

• python_types: type WebSocket

WebSocketState:

• python_types: enum WebSocketState

word:

• scanfuncs: proc word(input: string; strVal: var string; start: int; opt: bool = false): int

xml2Tag:

• tag: proc xml2Tag(xml: XmlNode): TagRef

xmlTree2Tag:

• tag: proc xmlTree2Tag(current, parent: TagRef; tree: XmlNode)