123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241
import compile from "./compile.ts";import { getConfig } from "./config.ts";import { promiseImpl } from "./polyfills.ts";import EtaErr from "./err.ts";
/* TYPES */
import type { EtaConfig, PartialAsyncConfig, PartialConfig } from "./config.ts";import type { TemplateFunction } from "./compile.ts";import type { CallbackFn } from "./file-handlers.ts";
/* END TYPES */
function handleCache(  template: string | TemplateFunction,  options: EtaConfig,): TemplateFunction {  if (options.cache && options.name && options.templates.get(options.name)) {    return options.templates.get(options.name);  }
  const templateFunc = typeof template === "function"    ? template    : compile(template, options);
  // Note that we don't have to check if it already exists in the cache;  // it would have returned earlier if it had  if (options.cache && options.name) {    options.templates.define(options.name, templateFunc);  }
  return templateFunc;}
/** * Render a template * * If `template` is a string, Eta will compile it to a function and then call it with the provided data. * If `template` is a template function, Eta will call it with the provided data. * * If `config.async` is `false`, Eta will return the rendered template. * * If `config.async` is `true` and there's a callback function, Eta will call the callback with `(err, renderedTemplate)`. * If `config.async` is `true` and there's not a callback function, Eta will return a Promise that resolves to the rendered template. * * If `config.cache` is `true` and `config` has a `name` or `filename` property, Eta will cache the template on the first render and use the cached template for all subsequent renders. * * @param template Template string or template function * @param data Data to render the template with * @param config Optional config options * @param cb Callback function */export default function render(  template: string | TemplateFunction,  data: object,  config: PartialAsyncConfig,  cb: CallbackFn,): void;
/** * Render a template * * If `template` is a string, Eta will compile it to a function and then call it with the provided data. * If `template` is a template function, Eta will call it with the provided data. * * If `config.async` is `false`, Eta will return the rendered template. * * If `config.async` is `true` and there's a callback function, Eta will call the callback with `(err, renderedTemplate)`. * If `config.async` is `true` and there's not a callback function, Eta will return a Promise that resolves to the rendered template. * * If `config.cache` is `true` and `config` has a `name` or `filename` property, Eta will cache the template on the first render and use the cached template for all subsequent renders. * * @param template Template string or template function * @param data Data to render the template with * @param config Optional config options */export default function render(  template: string | TemplateFunction,  data: object,  config: PartialAsyncConfig,): Promise<string>;
/** * Render a template * * If `template` is a string, Eta will compile it to a function and then call it with the provided data. * If `template` is a template function, Eta will call it with the provided data. * * If `config.async` is `false`, Eta will return the rendered template. * * If `config.async` is `true` and there's a callback function, Eta will call the callback with `(err, renderedTemplate)`. * If `config.async` is `true` and there's not a callback function, Eta will return a Promise that resolves to the rendered template. * * If `config.cache` is `true` and `config` has a `name` or `filename` property, Eta will cache the template on the first render and use the cached template for all subsequent renders. * * @param template Template string or template function * @param data Data to render the template with * @param config Optional config options */export default function render(  template: string | TemplateFunction,  data: object,  config?: PartialConfig,): string;
/** * Render a template * * If `template` is a string, Eta will compile it to a function and then call it with the provided data. * If `template` is a template function, Eta will call it with the provided data. * * If `config.async` is `false`, Eta will return the rendered template. * * If `config.async` is `true` and there's a callback function, Eta will call the callback with `(err, renderedTemplate)`. * If `config.async` is `true` and there's not a callback function, Eta will return a Promise that resolves to the rendered template. * * If `config.cache` is `true` and `config` has a `name` or `filename` property, Eta will cache the template on the first render and use the cached template for all subsequent renders. * * @param template Template string or template function * @param data Data to render the template with * @param config Optional config options * @param cb Callback function */export default function render(  template: string | TemplateFunction,  data: object,  config?: PartialConfig,  cb?: CallbackFn,): string | Promise<string> | void;
export default function render(  template: string | TemplateFunction,  data: object,  config?: PartialConfig,  cb?: CallbackFn,): string | Promise<string> | void {  const options = getConfig(config || {});
  if (options.async) {    if (cb) {      // If user passes callback      try {        // Note: if there is an error while rendering the template,        // It will bubble up and be caught here        const templateFn = handleCache(template, options);        templateFn(data, options, cb);      } catch (err) {        return cb(err as Error);      }    } else {      // No callback, try returning a promise      if (typeof promiseImpl === "function") {        return new promiseImpl(function (resolve: Function, reject: Function) {          try {            resolve(handleCache(template, options)(data, options));          } catch (err) {            reject(err);          }        });      } else {        throw EtaErr(          "Please provide a callback function, this env doesn't support Promises",        );      }    }  } else {    return handleCache(template, options)(data, options);  }}
/** * Render a template asynchronously * * If `template` is a string, Eta will compile it to a function and call it with the provided data. * If `template` is a function, Eta will call it with the provided data. * * If there is a callback function, Eta will call it with `(err, renderedTemplate)`. * If there is not a callback function, Eta will return a Promise that resolves to the rendered template * * @param template Template string or template function * @param data Data to render the template with * @param config Optional config options */export function renderAsync(  template: string | TemplateFunction,  data: object,  config?: PartialConfig,): Promise<string>;
/** * Render a template asynchronously * * If `template` is a string, Eta will compile it to a function and call it with the provided data. * If `template` is a function, Eta will call it with the provided data. * * If there is a callback function, Eta will call it with `(err, renderedTemplate)`. * If there is not a callback function, Eta will return a Promise that resolves to the rendered template * * @param template Template string or template function * @param data Data to render the template with * @param config Optional config options * @param cb Callback function */export function renderAsync(  template: string | TemplateFunction,  data: object,  config: PartialConfig,  cb: CallbackFn,): void;
/** * Render a template asynchronously * * If `template` is a string, Eta will compile it to a function and call it with the provided data. * If `template` is a function, Eta will call it with the provided data. * * If there is a callback function, Eta will call it with `(err, renderedTemplate)`. * If there is not a callback function, Eta will return a Promise that resolves to the rendered template * * @param template Template string or template function * @param data Data to render the template with * @param config Optional config options * @param cb Callback function */export function renderAsync(  template: string | TemplateFunction,  data: object,  config?: PartialConfig,  cb?: CallbackFn,): string | Promise<string> | void;
export function renderAsync(  template: string | TemplateFunction,  data: object,  config?: PartialConfig,  cb?: CallbackFn,): string | Promise<string> | void {  // Using Object.assign to lower bundle size, using spread operator makes it larger because of typescript injected polyfills  return render(template, data, Object.assign({}, config, { async: true }), cb);}