handlebars

handlebars

Version 4.7.8
Published 1 year ago
2.78 MB
5 dependencies
MIT license

Install

npm i handlebars

yarn add handlebars

pnpm add handlebars

Overview

Handlebars provides the power necessary to let you build semantic templates effectively with no frustration

Index

Namespaces

handlebars
Handlebars
handlebars.AST
- helpers
Handlebars.AST
- helpers
handlebars.Utils
Handlebars.Utils
handlebars.VM
- resolvePartial()
Handlebars.VM
- resolvePartial()
handlebars/runtime
handlebars/runtime.AST
- helpers
handlebars/runtime.Utils
handlebars/runtime.VM
- resolvePartial()
hbs
- SafeString
- Utils
hbs.AST

Namespaces

namespace handlebars

module 'handlebars' {}

variable decorators

const decorators: { [name: string]: Function };

variable escapeExpression

const escapeExpression: (str: string) => string;

variable helpers

const helpers: { [name: string]: HelperDelegate };

variable logger

const logger: Logger;

variable partials

const partials: { [name: string]: any };

variable templates

const templates: HandlebarsTemplates;

variable VERSION

const VERSION: string;

function blockParams

blockParams: (obj: any[], ids: any[]) => any[];

function compile

compile: <T = any>(
    input: any,
    options?: CompileOptions
) => HandlebarsTemplateDelegate<T>;

function create

create: () => typeof Handlebars;

function createFrame

createFrame: (object: any) => any;

function K

K: () => void;

function log

log: (level: number, obj: any) => void;

function noConflict

noConflict: () => typeof Handlebars;

function parse

parse: (input: string, options?: ParseOptions) => hbs.AST.Program;

function parseWithoutProcessing

parseWithoutProcessing: (
    input: string,
    options?: ParseOptions
) => hbs.AST.Program;

function precompile

precompile: (input: any, options?: PrecompileOptions) => TemplateSpecification;

function registerDecorator

registerDecorator: (name: string, fn: Function) => void;

function registerHelper

registerHelper: {
    (name: string, fn: HelperDelegate): void;
    (name: HelperDeclareSpec): void;
};

function registerPartial

registerPartial: {
    (name: string, fn: Template): void;
    (spec: { [name: string]: HandlebarsTemplateDelegate<any> }): void;
};

function template

template: <T = any>(
    precompilation: TemplateSpecification
) => HandlebarsTemplateDelegate<T>;

function unregisterDecorator

unregisterDecorator: (name: string) => void;

function unregisterHelper

unregisterHelper: (name: string) => void;

function unregisterPartial

unregisterPartial: (name: string) => void;

class Exception

class Exception {}

constructor

constructor(message: string, node?: hbs.AST.Node);

property column

column?: any;

property description

description: string;

property endColumn

endColumn?: any;

property endLineNumber

endLineNumber?: any;

property fileName

fileName: string;

property lineNumber

lineNumber?: any;

property message

message: string;

property name

name: string;

property number

number: number;

property stack

stack?: string;

class SafeString

class SafeString {}

constructor

constructor(str: string);

method toHTML

toHTML: () => string;

method toString

toString: () => string;

class Visitor

class Visitor implements ICompiler {}

method accept

accept: (node: hbs.AST.Node) => void;

method acceptArray

acceptArray: (arr: hbs.AST.Expression[]) => void;

method acceptKey

acceptKey: (node: hbs.AST.Node, name: string) => void;

method BlockStatement

BlockStatement: (block: hbs.AST.BlockStatement) => void;

method BooleanLiteral

BooleanLiteral: (bool: hbs.AST.BooleanLiteral) => void;

method CommentStatement

CommentStatement: (comment?: hbs.AST.CommentStatement) => void;

method ContentStatement

ContentStatement: (content: hbs.AST.ContentStatement) => void;

method Decorator

Decorator: (decorator: hbs.AST.Decorator) => void;

method DecoratorBlock

DecoratorBlock: (decorator: hbs.AST.DecoratorBlock) => void;

method Hash

Hash: (hash: hbs.AST.Hash) => void;

method MustacheStatement

MustacheStatement: (mustache: hbs.AST.MustacheStatement) => void;

method NullLiteral

NullLiteral: () => void;

method NumberLiteral

NumberLiteral: (num: hbs.AST.NumberLiteral) => void;

method PartialBlockStatement

PartialBlockStatement: (partial: hbs.AST.PartialBlockStatement) => void;

method PartialStatement

PartialStatement: (partial: hbs.AST.PartialStatement) => void;

method PathExpression

PathExpression: (path: hbs.AST.PathExpression) => void;

method Program

Program: (program: hbs.AST.Program) => void;

method StringLiteral

StringLiteral: (str: hbs.AST.StringLiteral) => void;

method SubExpression

SubExpression: (sexpr: hbs.AST.SubExpression) => void;

method UndefinedLiteral

UndefinedLiteral: () => void;

interface HelperDeclareSpec

interface HelperDeclareSpec {}

index signature

[key: string]: HelperDelegate;

interface HelperDelegate

interface HelperDelegate {}

call signature

(
    context?: any,
    arg1?: any,
    arg2?: any,
    arg3?: any,
    arg4?: any,
    arg5?: any,
    options?: HelperOptions
): any;

interface HelperOptions

interface HelperOptions {}

property data

data?: any;

property fn

fn: TemplateDelegate;

property hash

hash: any;

property inverse

inverse: TemplateDelegate;

interface ICompiler

interface ICompiler {}

method accept

accept: (node: hbs.AST.Node) => void;

method BlockStatement

BlockStatement: (block: hbs.AST.BlockStatement) => void;

method BooleanLiteral

BooleanLiteral: (bool: hbs.AST.BooleanLiteral) => void;

method CommentStatement

CommentStatement: (comment?: hbs.AST.CommentStatement) => void;

method ContentStatement

ContentStatement: (content: hbs.AST.ContentStatement) => void;

method Decorator

Decorator: (decorator: hbs.AST.Decorator) => void;

method DecoratorBlock

DecoratorBlock: (decorator: hbs.AST.DecoratorBlock) => void;

method Hash

Hash: (hash: hbs.AST.Hash) => void;

method MustacheStatement

MustacheStatement: (mustache: hbs.AST.MustacheStatement) => void;

method NullLiteral

NullLiteral: () => void;

method NumberLiteral

NumberLiteral: (num: hbs.AST.NumberLiteral) => void;

method PartialBlockStatement

PartialBlockStatement: (partial: hbs.AST.PartialBlockStatement) => void;

method PartialStatement

PartialStatement: (partial: hbs.AST.PartialStatement) => void;

method PathExpression

PathExpression: (path: hbs.AST.PathExpression) => void;

method Program

Program: (program: hbs.AST.Program) => void;

method StringLiteral

StringLiteral: (str: hbs.AST.StringLiteral) => void;

method SubExpression

SubExpression: (sexpr: hbs.AST.SubExpression) => void;

method UndefinedLiteral

UndefinedLiteral: () => void;

interface ParseOptions

interface ParseOptions {}

property ignoreStandalone

ignoreStandalone?: boolean;

property srcName

srcName?: string;

interface ResolvePartialOptions

interface ResolvePartialOptions {}

property data

data?: any;

property decorators

decorators?: { [name: string]: Function };

property helpers

helpers?: { [name: string]: Function };

property name

name: string;

property partials

partials?: { [name: string]: HandlebarsTemplateDelegate };

interface RuntimeOptions

interface RuntimeOptions {}

property allowCallsToHelperMissing

allowCallsToHelperMissing?: boolean;

property allowedProtoMethods

allowedProtoMethods?: { [name: string]: boolean };

property allowedProtoProperties

allowedProtoProperties?: { [name: string]: boolean };

property allowProtoMethodsByDefault

allowProtoMethodsByDefault?: boolean;

property allowProtoPropertiesByDefault

allowProtoPropertiesByDefault?: boolean;

property blockParams

blockParams?: any[];

property data

data?: any;

property decorators

decorators?: { [name: string]: Function };

property depths

depths?: any[];

property helpers

helpers?: { [name: string]: Function };

property partial

partial?: boolean;

property partials

partials?: { [name: string]: HandlebarsTemplateDelegate };

interface TemplateDelegate

interface TemplateDelegate<T = any> {}

call signature

(context: T, options?: RuntimeOptions): string;

type Template

type Template<T = any> = TemplateDelegate<T> | string;

namespace Handlebars

namespace Handlebars {}

variable decorators

const decorators: { [name: string]: Function };

variable escapeExpression

const escapeExpression: (str: string) => string;

variable helpers

const helpers: { [name: string]: HelperDelegate };

variable logger

const logger: Logger;

variable partials

const partials: { [name: string]: any };

variable templates

const templates: HandlebarsTemplates;

variable VERSION

const VERSION: string;

function blockParams

blockParams: (obj: any[], ids: any[]) => any[];

function compile

compile: <T = any>(
    input: any,
    options?: CompileOptions
) => HandlebarsTemplateDelegate<T>;

function create

create: () => typeof Handlebars;

function createFrame

createFrame: (object: any) => any;

function K

K: () => void;

function log

log: (level: number, obj: any) => void;

function noConflict

noConflict: () => typeof Handlebars;

function parse

parse: (input: string, options?: ParseOptions) => hbs.AST.Program;

function parseWithoutProcessing

parseWithoutProcessing: (
    input: string,
    options?: ParseOptions
) => hbs.AST.Program;

function precompile

precompile: (input: any, options?: PrecompileOptions) => TemplateSpecification;

function registerDecorator

registerDecorator: (name: string, fn: Function) => void;

function registerHelper

registerHelper: {
    (name: string, fn: HelperDelegate): void;
    (name: HelperDeclareSpec): void;
};

function registerPartial

registerPartial: {
    (name: string, fn: Template): void;
    (spec: { [name: string]: HandlebarsTemplateDelegate<any> }): void;
};

function template

template: <T = any>(
    precompilation: TemplateSpecification
) => HandlebarsTemplateDelegate<T>;

function unregisterDecorator

unregisterDecorator: (name: string) => void;

function unregisterHelper

unregisterHelper: (name: string) => void;

function unregisterPartial

unregisterPartial: (name: string) => void;

class Exception

class Exception {}

constructor

constructor(message: string, node?: hbs.AST.Node);

property column

column?: any;

property description

description: string;

property endColumn

endColumn?: any;

property endLineNumber

endLineNumber?: any;

property fileName

fileName: string;

property lineNumber

lineNumber?: any;

property message

message: string;

property name

name: string;

property number

number: number;

property stack

stack?: string;

class SafeString

class SafeString {}

constructor

constructor(str: string);

method toHTML

toHTML: () => string;

method toString

toString: () => string;

class Visitor

class Visitor implements ICompiler {}

method accept

accept: (node: hbs.AST.Node) => void;

method acceptArray

acceptArray: (arr: hbs.AST.Expression[]) => void;

method acceptKey

acceptKey: (node: hbs.AST.Node, name: string) => void;

method BlockStatement

BlockStatement: (block: hbs.AST.BlockStatement) => void;

method BooleanLiteral

BooleanLiteral: (bool: hbs.AST.BooleanLiteral) => void;

method CommentStatement

CommentStatement: (comment?: hbs.AST.CommentStatement) => void;

method ContentStatement

ContentStatement: (content: hbs.AST.ContentStatement) => void;

method Decorator

Decorator: (decorator: hbs.AST.Decorator) => void;

method DecoratorBlock

DecoratorBlock: (decorator: hbs.AST.DecoratorBlock) => void;

method Hash

Hash: (hash: hbs.AST.Hash) => void;

method MustacheStatement

MustacheStatement: (mustache: hbs.AST.MustacheStatement) => void;

method NullLiteral

NullLiteral: () => void;

method NumberLiteral

NumberLiteral: (num: hbs.AST.NumberLiteral) => void;

method PartialBlockStatement

PartialBlockStatement: (partial: hbs.AST.PartialBlockStatement) => void;

method PartialStatement

PartialStatement: (partial: hbs.AST.PartialStatement) => void;

method PathExpression

PathExpression: (path: hbs.AST.PathExpression) => void;

method Program

Program: (program: hbs.AST.Program) => void;

method StringLiteral

StringLiteral: (str: hbs.AST.StringLiteral) => void;

method SubExpression

SubExpression: (sexpr: hbs.AST.SubExpression) => void;

method UndefinedLiteral

UndefinedLiteral: () => void;

interface HelperDeclareSpec

interface HelperDeclareSpec {}

index signature

[key: string]: HelperDelegate;

interface HelperDelegate

interface HelperDelegate {}

call signature

(
    context?: any,
    arg1?: any,
    arg2?: any,
    arg3?: any,
    arg4?: any,
    arg5?: any,
    options?: HelperOptions
): any;

interface HelperOptions

interface HelperOptions {}

property data

data?: any;

property fn

fn: TemplateDelegate;

property hash

hash: any;

property inverse

inverse: TemplateDelegate;

interface ICompiler

interface ICompiler {}

method accept

accept: (node: hbs.AST.Node) => void;

method BlockStatement

BlockStatement: (block: hbs.AST.BlockStatement) => void;

method BooleanLiteral

BooleanLiteral: (bool: hbs.AST.BooleanLiteral) => void;

method CommentStatement

CommentStatement: (comment?: hbs.AST.CommentStatement) => void;

method ContentStatement

ContentStatement: (content: hbs.AST.ContentStatement) => void;

method Decorator

Decorator: (decorator: hbs.AST.Decorator) => void;

method DecoratorBlock

DecoratorBlock: (decorator: hbs.AST.DecoratorBlock) => void;

method Hash

Hash: (hash: hbs.AST.Hash) => void;

method MustacheStatement

MustacheStatement: (mustache: hbs.AST.MustacheStatement) => void;

method NullLiteral

NullLiteral: () => void;

method NumberLiteral

NumberLiteral: (num: hbs.AST.NumberLiteral) => void;

method PartialBlockStatement

PartialBlockStatement: (partial: hbs.AST.PartialBlockStatement) => void;

method PartialStatement

PartialStatement: (partial: hbs.AST.PartialStatement) => void;

method PathExpression

PathExpression: (path: hbs.AST.PathExpression) => void;

method Program

Program: (program: hbs.AST.Program) => void;

method StringLiteral

StringLiteral: (str: hbs.AST.StringLiteral) => void;

method SubExpression

SubExpression: (sexpr: hbs.AST.SubExpression) => void;

method UndefinedLiteral

UndefinedLiteral: () => void;

interface ParseOptions

interface ParseOptions {}

property ignoreStandalone

ignoreStandalone?: boolean;

property srcName

srcName?: string;

interface ResolvePartialOptions

interface ResolvePartialOptions {}

property data

data?: any;

property decorators

decorators?: { [name: string]: Function };

property helpers

helpers?: { [name: string]: Function };

property name

name: string;

property partials

partials?: { [name: string]: HandlebarsTemplateDelegate };

interface RuntimeOptions

interface RuntimeOptions {}

property allowCallsToHelperMissing

allowCallsToHelperMissing?: boolean;

property allowedProtoMethods

allowedProtoMethods?: { [name: string]: boolean };

property allowedProtoProperties

allowedProtoProperties?: { [name: string]: boolean };

property allowProtoMethodsByDefault

allowProtoMethodsByDefault?: boolean;

property allowProtoPropertiesByDefault

allowProtoPropertiesByDefault?: boolean;

property blockParams

blockParams?: any[];

property data

data?: any;

property decorators

decorators?: { [name: string]: Function };

property depths

depths?: any[];

property helpers

helpers?: { [name: string]: Function };

property partial

partial?: boolean;

property partials

partials?: { [name: string]: HandlebarsTemplateDelegate };

interface TemplateDelegate

interface TemplateDelegate<T = any> {}

call signature

(context: T, options?: RuntimeOptions): string;

type Template

type Template<T = any> = TemplateDelegate<T> | string;

namespace handlebars.AST

namespace handlebars.AST {}

variable helpers

const helpers: hbs.AST.helpers;

namespace Handlebars.AST

namespace Handlebars.AST {}

variable helpers

const helpers: hbs.AST.helpers;

namespace handlebars.Utils

namespace handlebars.Utils {}

function blockParams

blockParams: (obj: any[], ids: any[]) => any[];

function createFrame

createFrame: (object: any) => any;

function escapeExpression

escapeExpression: (str: string) => string;

function extend

extend: (obj: any, ...source: any[]) => any;

function isArray

isArray: (obj: any) => boolean;

function isEmpty

isEmpty: (obj: any) => boolean;

function isFunction

isFunction: (obj: any) => boolean;

function toString

toString: (obj: any) => string;

namespace Handlebars.Utils

namespace Handlebars.Utils {}

function blockParams

blockParams: (obj: any[], ids: any[]) => any[];

function createFrame

createFrame: (object: any) => any;

function escapeExpression

escapeExpression: (str: string) => string;

function extend

extend: (obj: any, ...source: any[]) => any;

function isArray

isArray: (obj: any) => boolean;

function isEmpty

isEmpty: (obj: any) => boolean;

function isFunction

isFunction: (obj: any) => boolean;

function toString

toString: (obj: any) => string;

namespace handlebars.VM

namespace handlebars.VM {}

function resolvePartial

resolvePartial: <T = any>(
    partial: HandlebarsTemplateDelegate<T> | undefined,
    context: any,
    options: ResolvePartialOptions
) => HandlebarsTemplateDelegate<T>;

Deprecated

namespace Handlebars.VM

namespace Handlebars.VM {}

function resolvePartial

resolvePartial: <T = any>(
    partial: HandlebarsTemplateDelegate<T> | undefined,
    context: any,
    options: ResolvePartialOptions
) => HandlebarsTemplateDelegate<T>;

Deprecated

namespace handlebars/runtime

module 'handlebars/runtime' {}

variable decorators

const decorators: { [name: string]: Function };

variable escapeExpression

const escapeExpression: (str: string) => string;

variable helpers

const helpers: { [name: string]: HelperDelegate };

variable logger

const logger: Logger;

variable partials

const partials: { [name: string]: any };

variable templates

const templates: HandlebarsTemplates;

variable VERSION

const VERSION: string;

function blockParams

blockParams: (obj: any[], ids: any[]) => any[];

function compile

compile: <T = any>(
    input: any,
    options?: CompileOptions
) => HandlebarsTemplateDelegate<T>;

function create

create: () => typeof Handlebars;

function createFrame

createFrame: (object: any) => any;

function K

K: () => void;

function log

log: (level: number, obj: any) => void;

function noConflict

noConflict: () => typeof Handlebars;

function parse

parse: (input: string, options?: ParseOptions) => hbs.AST.Program;

function parseWithoutProcessing

parseWithoutProcessing: (
    input: string,
    options?: ParseOptions
) => hbs.AST.Program;

function precompile

precompile: (input: any, options?: PrecompileOptions) => TemplateSpecification;

function registerDecorator

registerDecorator: (name: string, fn: Function) => void;

function registerHelper

registerHelper: {
    (name: string, fn: HelperDelegate): void;
    (name: HelperDeclareSpec): void;
};

function registerPartial

registerPartial: {
    (name: string, fn: Template): void;
    (spec: { [name: string]: HandlebarsTemplateDelegate<any> }): void;
};

function template

template: <T = any>(
    precompilation: TemplateSpecification
) => HandlebarsTemplateDelegate<T>;

function unregisterDecorator

unregisterDecorator: (name: string) => void;

function unregisterHelper

unregisterHelper: (name: string) => void;

function unregisterPartial

unregisterPartial: (name: string) => void;

class Exception

class Exception {}

constructor

constructor(message: string, node?: hbs.AST.Node);

property column

column?: any;

property description

description: string;

property endColumn

endColumn?: any;

property endLineNumber

endLineNumber?: any;

property fileName

fileName: string;

property lineNumber

lineNumber?: any;

property message

message: string;

property name

name: string;

property number

number: number;

property stack

stack?: string;

class SafeString

class SafeString {}

constructor

constructor(str: string);

method toHTML

toHTML: () => string;

method toString

toString: () => string;

class Visitor

class Visitor implements ICompiler {}

method accept

accept: (node: hbs.AST.Node) => void;

method acceptArray

acceptArray: (arr: hbs.AST.Expression[]) => void;

method acceptKey

acceptKey: (node: hbs.AST.Node, name: string) => void;

method BlockStatement

BlockStatement: (block: hbs.AST.BlockStatement) => void;

method BooleanLiteral

BooleanLiteral: (bool: hbs.AST.BooleanLiteral) => void;

method CommentStatement

CommentStatement: (comment?: hbs.AST.CommentStatement) => void;

method ContentStatement

ContentStatement: (content: hbs.AST.ContentStatement) => void;

method Decorator

Decorator: (decorator: hbs.AST.Decorator) => void;

method DecoratorBlock

DecoratorBlock: (decorator: hbs.AST.DecoratorBlock) => void;

method Hash

Hash: (hash: hbs.AST.Hash) => void;

method MustacheStatement

MustacheStatement: (mustache: hbs.AST.MustacheStatement) => void;

method NullLiteral

NullLiteral: () => void;

method NumberLiteral

NumberLiteral: (num: hbs.AST.NumberLiteral) => void;

method PartialBlockStatement

PartialBlockStatement: (partial: hbs.AST.PartialBlockStatement) => void;

method PartialStatement

PartialStatement: (partial: hbs.AST.PartialStatement) => void;

method PathExpression

PathExpression: (path: hbs.AST.PathExpression) => void;

method Program

Program: (program: hbs.AST.Program) => void;

method StringLiteral

StringLiteral: (str: hbs.AST.StringLiteral) => void;

method SubExpression

SubExpression: (sexpr: hbs.AST.SubExpression) => void;

method UndefinedLiteral

UndefinedLiteral: () => void;

interface HelperDeclareSpec

interface HelperDeclareSpec {}

index signature

[key: string]: HelperDelegate;

interface HelperDelegate

interface HelperDelegate {}

call signature

(
    context?: any,
    arg1?: any,
    arg2?: any,
    arg3?: any,
    arg4?: any,
    arg5?: any,
    options?: HelperOptions
): any;

interface HelperOptions

interface HelperOptions {}

property data

data?: any;

property fn

fn: TemplateDelegate;

property hash

hash: any;

property inverse

inverse: TemplateDelegate;

interface ICompiler

interface ICompiler {}

method accept

accept: (node: hbs.AST.Node) => void;

method BlockStatement

BlockStatement: (block: hbs.AST.BlockStatement) => void;

method BooleanLiteral

BooleanLiteral: (bool: hbs.AST.BooleanLiteral) => void;

method CommentStatement

CommentStatement: (comment?: hbs.AST.CommentStatement) => void;

method ContentStatement

ContentStatement: (content: hbs.AST.ContentStatement) => void;

method Decorator

Decorator: (decorator: hbs.AST.Decorator) => void;

method DecoratorBlock

DecoratorBlock: (decorator: hbs.AST.DecoratorBlock) => void;

method Hash

Hash: (hash: hbs.AST.Hash) => void;

method MustacheStatement

MustacheStatement: (mustache: hbs.AST.MustacheStatement) => void;

method NullLiteral

NullLiteral: () => void;

method NumberLiteral

NumberLiteral: (num: hbs.AST.NumberLiteral) => void;

method PartialBlockStatement

PartialBlockStatement: (partial: hbs.AST.PartialBlockStatement) => void;

method PartialStatement

PartialStatement: (partial: hbs.AST.PartialStatement) => void;

method PathExpression

PathExpression: (path: hbs.AST.PathExpression) => void;

method Program

Program: (program: hbs.AST.Program) => void;

method StringLiteral

StringLiteral: (str: hbs.AST.StringLiteral) => void;

method SubExpression

SubExpression: (sexpr: hbs.AST.SubExpression) => void;

method UndefinedLiteral

UndefinedLiteral: () => void;

interface ParseOptions

interface ParseOptions {}

property ignoreStandalone

ignoreStandalone?: boolean;

property srcName

srcName?: string;

interface ResolvePartialOptions

interface ResolvePartialOptions {}

property data

data?: any;

property decorators

decorators?: { [name: string]: Function };

property helpers

helpers?: { [name: string]: Function };

property name

name: string;

property partials

partials?: { [name: string]: HandlebarsTemplateDelegate };

interface RuntimeOptions

interface RuntimeOptions {}

property allowCallsToHelperMissing

allowCallsToHelperMissing?: boolean;

property allowedProtoMethods

allowedProtoMethods?: { [name: string]: boolean };

property allowedProtoProperties

allowedProtoProperties?: { [name: string]: boolean };

property allowProtoMethodsByDefault

allowProtoMethodsByDefault?: boolean;

property allowProtoPropertiesByDefault

allowProtoPropertiesByDefault?: boolean;

property blockParams

blockParams?: any[];

property data

data?: any;

property decorators

decorators?: { [name: string]: Function };

property depths

depths?: any[];

property helpers

helpers?: { [name: string]: Function };

property partial

partial?: boolean;

property partials

partials?: { [name: string]: HandlebarsTemplateDelegate };

interface TemplateDelegate

interface TemplateDelegate<T = any> {}

call signature

(context: T, options?: RuntimeOptions): string;

type Template

type Template<T = any> = TemplateDelegate<T> | string;

namespace handlebars/runtime.AST

namespace handlebars/runtime.AST {}

variable helpers

const helpers: hbs.AST.helpers;

namespace handlebars/runtime.Utils

namespace handlebars/runtime.Utils {}

function blockParams

blockParams: (obj: any[], ids: any[]) => any[];

function createFrame

createFrame: (object: any) => any;

function escapeExpression

escapeExpression: (str: string) => string;

function extend

extend: (obj: any, ...source: any[]) => any;

function isArray

isArray: (obj: any) => boolean;

function isEmpty

isEmpty: (obj: any) => boolean;

function isFunction

isFunction: (obj: any) => boolean;

function toString

toString: (obj: any) => string;

namespace handlebars/runtime.VM

namespace handlebars/runtime.VM {}

function resolvePartial

resolvePartial: <T = any>(
    partial: HandlebarsTemplateDelegate<T> | undefined,
    context: any,
    options: ResolvePartialOptions
) => HandlebarsTemplateDelegate<T>;

Deprecated

namespace hbs

namespace hbs {}

type SafeString

type SafeString = Handlebars.SafeString;

type Utils

type Utils = typeof Handlebars.Utils;

namespace hbs.AST

namespace hbs.AST {}

interface BlockStatement

interface BlockStatement extends Statement {}

property closeStrip

closeStrip: StripFlags;

property hash

hash: Hash;

property inverse

inverse: Program;

property inverseStrip

inverseStrip: StripFlags;

property openStrip

openStrip: StripFlags;

property params

params: Expression[];

property path

path: PathExpression;

property program

program: Program;

property type

type: 'BlockStatement';

interface BooleanLiteral

interface BooleanLiteral extends Literal {}

property original

original: boolean;

property type

type: 'BooleanLiteral';

property value

value: boolean;

interface CommentStatement

interface CommentStatement extends Statement {}

property strip

strip: StripFlags;

property type

type: 'CommentStatement';

property value

value: string;

interface ContentStatement

interface ContentStatement extends Statement {}

property original

original: StripFlags;

property type

type: 'ContentStatement';

property value

value: string;

interface Decorator

interface Decorator extends MustacheStatement {}

interface DecoratorBlock

interface DecoratorBlock extends BlockStatement {}

interface Expression

interface Expression extends Node {}

interface Hash

interface Hash extends Node {}

property pairs

pairs: HashPair[];

property type

type: 'Hash';

interface HashPair

interface HashPair extends Node {}

property key

key: string;

property type

type: 'HashPair';

property value

value: Expression;

interface helpers

interface helpers {}

method helperExpression

helperExpression: (node: Node) => boolean;

method scopeId

scopeId: (path: PathExpression) => boolean;

method simpleId

simpleId: (path: PathExpression) => boolean;

interface Literal

interface Literal extends Expression {}

interface MustacheStatement

interface MustacheStatement extends Statement {}

property escaped

escaped: boolean;

property hash

hash: Hash;

property params

params: Expression[];

property path

path: PathExpression | Literal;

property strip

strip: StripFlags;

property type

type: 'MustacheStatement';

interface Node

interface Node {}

property loc

loc: SourceLocation;

property type

type: string;

interface NullLiteral

interface NullLiteral extends Literal {}

property type

type: 'NullLiteral';

interface NumberLiteral

interface NumberLiteral extends Literal {}

property original

original: number;

property type

type: 'NumberLiteral';

property value

value: number;

interface PartialBlockStatement

interface PartialBlockStatement extends Statement {}

property closeStrip

closeStrip: StripFlags;

property hash

hash: Hash;

property name

name: PathExpression | SubExpression;

property openStrip

openStrip: StripFlags;

property params

params: Expression[];

property program

program: Program;

property type

type: 'PartialBlockStatement';

interface PartialStatement

interface PartialStatement extends Statement {}

property hash

hash: Hash;

property indent

indent: string;

property name

name: PathExpression | SubExpression;

property params

params: Expression[];

property strip

strip: StripFlags;

property type

type: 'PartialStatement';

interface PathExpression

interface PathExpression extends Expression {}

property data

data: boolean;

property depth

depth: number;

property original

original: string;

property parts

parts: string[];

property type

type: 'PathExpression';

interface Position

interface Position {}

property column

column: number;

property line

line: number;

interface Program

interface Program extends Node {}

property blockParams

blockParams: string[];

property body

body: Statement[];

interface SourceLocation

interface SourceLocation {}

property end

end: Position;

property source

source: string;

property start

start: Position;

interface Statement

interface Statement extends Node {}

interface StringLiteral

interface StringLiteral extends Literal {}

property original

original: string;

property type

type: 'StringLiteral';

property value

value: string;

interface StripFlags

interface StripFlags {}

property close

close: boolean;

property open

open: boolean;

interface SubExpression

interface SubExpression extends Expression {}

property hash

hash: Hash;

property params

params: Expression[];

property path

path: PathExpression;

property type

type: 'SubExpression';

interface UndefinedLiteral

interface UndefinedLiteral extends Literal {}

property type

type: 'UndefinedLiteral';

Package Files (1)

types/index.d.ts

Dependencies (5)

Peer Dependencies (0)

No peer dependencies.

Badge

To add a badge like this oneto your package's README, use the codes available below.

You may also use Shields.io to create a custom badge linking to https://www.jsdocs.io/package/handlebars.

Markdown

[![jsDocs.io](https://img.shields.io/badge/jsDocs.io-reference-blue)](https://www.jsdocs.io/package/handlebars)

HTML

<a href="https://www.jsdocs.io/package/handlebars"><img src="https://img.shields.io/badge/jsDocs.io-reference-blue" alt="jsDocs.io"></a>

Updated 1 year ago.
Package analyzed in 7999 ms.
Missing or incorrect documentation? Open an issue for this package.