@types/ejs

Variables

• cache
• closeDelimiter
• delimiter
• fileLoader
• localsName
• name
• openDelimiter
• promiseImpl
• VERSION

Functions

• clearCache()
• compile()
• escapeXML()
• render()
• renderFile()
• resolveInclude()

Classes

• Template

  • compile()
  • source
  • templateText

Interfaces

• Cache

  • get()
  • reset()
  • set()
• Data
• Options

  • async
  • beautify
  • cache
  • client
  • closeDelimiter
  • compileDebug
  • context
  • debug
  • delimiter
  • destructuredLocals
  • escape
  • filename
  • includer
  • localsName
  • openDelimiter
  • outputFunctionName
  • rmWhitespace
  • root
  • strict
  • views

Type Aliases

• AsyncClientFunction
• AsyncTemplateFunction
• ClientFunction
• EscapeCallback
• fileLoader
• IncludeCallback
• IncluderCallback
• IncluderResult
• RenderFileCallback
• RethrowCallback
• TemplateFunction

Namespaces

• Template

  • modes

variable cache

let cache: Cache;

• EJS template function cache. This can be a LRU object from lru-cache NPM module. By default, it is utils.cache, a simple in-process cache that grows continuously.

variable closeDelimiter

let closeDelimiter: string;

• The closing delimiter for all statements. This allows to to clearly delinate the difference between template code and existing delimiters. (It is recommended to synchronize this with the openDelimiter property.)

  '>'

variable delimiter

let delimiter: string;

• The delimiter used in template compilation.

  '%'

variable fileLoader

let fileLoader: fileLoader;

variable localsName

let localsName: string;

• Name of the object containing the locals.

  This variable is overridden by Options.localsName if it is not undefined.

  'locals'

variable name

const name: string;

• Name for detection of EJS.

variable openDelimiter

let openDelimiter: string;

• The opening delimiter for all statements. This allows you to clearly delinate the difference between template code and existing delimiters. (It is recommended to synchronize this with the closeDelimiter property.)

  '<'

variable promiseImpl

let promiseImpl: PromiseConstructorLike;

• Promise implementation -- defaults to the native implementation if available This is mostly just for testability

  Promise

variable VERSION

const VERSION: string;

• Version of EJS.

function clearCache

clearCache: () => void;

• Clear intermediate JavaScript cache. Calls Cache#reset.

function compile

compile: {
    (
        template: string,
        opts: Options & { async: true; client?: false | undefined }
    ): AsyncTemplateFunction;
    (
        template: string,
        opts: Options & { async: true; client: true }
    ): AsyncClientFunction;
    (
        template: string,
        opts?: Options & { async?: false; client?: false }
    ): TemplateFunction;
    (
        template: string,
        opts?: Options & { async?: false; client: true }
    ): ClientFunction;
    (template: string, opts?: Options): AsyncTemplateFunction | TemplateFunction;
};

• Compile the given str of ejs into a template function.

function escapeXML

escapeXML: (markup?: any) => string;

• Escape characters reserved in XML.

  This is simply an export of utils.escapeXML.

  If markup is undefined or null, the empty string is returned.

function render

render: {
    (template: string, data?: Data, opts?: Options & { async: false }): string;
    (template: string, data: Data, opts: Options & { async: true }): Promise<string>;
    (template: string, data: Data, opts: Options & { async?: undefined }): string;
    (template: string, data?: Data, opts?: Options): string | Promise<string>;
};

• Render the given template of ejs.

  If you would like to include options but not data, you need to explicitly call this function with data being an empty object or null.

function renderFile

renderFile: {
    <T>(path: string, cb: RenderFileCallback<T>): T;
    <T>(path: string, data: Data, cb: RenderFileCallback<T>): T;
    <T>(path: string, data: Data, opts: Options, cb: RenderFileCallback<T>): T;
    (path: string, data?: Data, opts?: Options): Promise<string>;
};

• Render an EJS file at the given path and callback cb(err, str).

  If you would like to include options but not data, you need to explicitly call this function with data being an empty object or null.

function resolveInclude

resolveInclude: (name: string, filename: string, isDir?: boolean) => string;

• Get the path to the included file from the parent file path and the specified path.

  Parameter name

  specified path

  Parameter filename

  parent file path

  Parameter isDir

  whether the parent file path is a directory

type AsyncClientFunction

type AsyncClientFunction = (
    locals?: Data,
    escape?: EscapeCallback,
    include?: IncludeCallback,
    rethrow?: RethrowCallback
) => Promise<string>;

• This type of function is returned from compile, when Options.client is true.

  This is also used internally to generate a TemplateFunction.

  Parameter locals

  an object of data to be passed into the template. The name of this variable is adjustable through localsName.

  Parameter escape

  callback used to escape variables

  Parameter include

  callback used to include files at runtime with include()

  Parameter rethrow

  callback used to handle and rethrow errors

  Return type depends on Options.async.

type AsyncTemplateFunction

type AsyncTemplateFunction = (data?: Data) => Promise<string>;

• This type of function is returned from compile, when Options.client is false.

  Parameter data

  an object of data to be passed into the template. Return type depends on Options.async.

type ClientFunction

type ClientFunction = (
    locals?: Data,
    escape?: EscapeCallback,
    include?: IncludeCallback,
    rethrow?: RethrowCallback
) => string;

• This type of function is returned from compile, when Options.client is true.

  This is also used internally to generate a TemplateFunction.

  Parameter locals

  an object of data to be passed into the template. The name of this variable is adjustable through localsName.

  Parameter escape

  callback used to escape variables

  Parameter include

  callback used to include files at runtime with include()

  Parameter rethrow

  callback used to handle and rethrow errors

  Return type depends on Options.async.

type EscapeCallback

type EscapeCallback = (markup?: any) => string;

• Escapes a string using HTML/XML escaping rules.

  Returns the empty string for null or undefined.

  Parameter markup

  Input string Escaped string

type fileLoader

type fileLoader = (path: string) => string | { toString(): string };

• Custom file loader. Useful for template preprocessing or restricting access to a certain part of the filesystem.

  Parameter path

  the path of the file to be read the contents of the file as a string or object that implements the toString() method

  fs.readFileSync

type IncludeCallback

type IncludeCallback = (path: string, data?: Data) => string;

• The callback called by ClientFunction to include files at runtime with include()

  Parameter path

  Path to be included

  Parameter data

  Data passed to the template Contents of the file requested

type IncluderCallback

type IncluderCallback = (originalPath: string, parsedPath: string) => IncluderResult;

• Parameter originalPath

  the path as it appears in the include statement

  Parameter parsedPath

  the previously resolved path

  An IncluderResult object containing the filename or template data.

type IncluderResult

type IncluderResult =
    | { filename: string; template?: never }
    | { template: string; filename?: never };

• An object where filename is the final parsed path or template is the content of the included template

type RenderFileCallback

type RenderFileCallback<T> = (err: Error | null, str: string) => T;

• Callback for receiving data from renderFile.

  Parameter err

  error, if any resulted from the rendering process

  Parameter str

  output string, is undefined if there is an error

type RethrowCallback

type RethrowCallback = (
    err: Error,
    str: string,
    filename: string | null | undefined,
    lineno: number,
    esc: EscapeCallback
) => never;

• This type of callback is used when Options.compileDebug is true, and an error in the template is thrown.

  By default it is used to rethrow an error in a better-formatted way.

  Parameter err

  Error object

  Parameter str

  full EJS source

  Parameter filename

  file name of the EJS source

  Parameter lineno

  line number of the error

type TemplateFunction

type TemplateFunction = (data?: Data) => string;

• This type of function is returned from compile, when Options.client is false.

  Parameter data

  an object of data to be passed into the template. Return type depends on Options.async.