liquidjs

liquidjs

Version 10.21.0
Published 2 months ago
1.76 MB
1 dependency
MIT license

Install

npm i liquidjs

yarn add liquidjs

pnpm add liquidjs

Overview

A simple, expressive and safe Shopify / Github Pages compatible template engine in pure JavaScript.

Index

Variables

variable defaultOperators

const defaultOperators: Operators;

variable defaultOptions

const defaultOptions: NormalizedFullOptions;

variable filters

const filters: Record<string, FilterImplOptions>;

variable tags

const tags: Record<string, TagClass>;

variable version

const version: string;

Functions

function analyze

analyze: (
    template: Template[],
    options?: StaticAnalysisOptions
) => Promise<StaticAnalysis>;

Statically analyze a template and report variable usage.

function analyzeSync

analyzeSync: (
    template: Template[],
    options?: StaticAnalysisOptions
) => StaticAnalysis;

Statically analyze a template and report variable usage.

function assert

assert: <T>(
    predicate: T | null | undefined,
    message?: string | (() => string)
) => void;

function createTrie

createTrie: <T = any>(input: TrieInput<T>) => Trie<T>;

function evalQuotedToken

evalQuotedToken: (token: QuotedToken) => string;

function evalToken

evalToken: (
    token: Token | undefined,
    ctx: Context,
    lenient?: boolean
) => IterableIterator<unknown>;

function isFalsy

isFalsy: (val: any, ctx: Context) => boolean;

function isTruthy

isTruthy: (val: any, ctx: Context) => boolean;

function toPromise

toPromise: <T>(
    val: Generator<unknown, T, unknown> | Promise<T> | T
) => Promise<T>;

function toValue

toValue: (value: any) => any;

function toValueSync

toValueSync: <T>(val: Generator<unknown, T, unknown> | T) => T;

Classes

class AssertionError

class AssertionError extends Error {}

constructor

constructor(message: string);

class AssignTag

class extends Tag {}

constructor

constructor(token: TagToken, remainTokens: TopLevelToken[], liquid: Liquid);

method arguments

arguments: () => Arguments;

method localScope

localScope: () => Iterable<IdentifierToken>;

method render

render: (ctx: Context) => Generator<unknown, void, unknown>;

class BlockTag

class extends Tag {}

constructor

constructor(
    token: TagToken,
    remainTokens: TopLevelToken[],
    liquid: Liquid,
    parser: Parser
);

property block

block: string;

property templates

templates: Template[];

method blockScope

blockScope: () => Iterable<string>;

method children

children: () => Generator<unknown, Template[]>;

method render

render: (ctx: Context, emitter: Emitter) => Generator<any, void, unknown>;

class BreakTag

class extends Tag {}

method render

render: (ctx: Context, _emitter: Emitter) => void;

class CaptureTag

class extends Tag {}

constructor

constructor(
    tagToken: TagToken,
    remainTokens: TopLevelToken[],
    liquid: Liquid,
    parser: Parser
);

property identifier

identifier: QuotedToken | IdentifierToken;

property templates

templates: Template[];

property variable

variable: string;

method children

children: () => Generator<unknown, Template[]>;

method localScope

localScope: () => Iterable<string | IdentifierToken | QuotedToken>;

method render

render: (ctx: Context) => Generator<unknown, void, string>;

class CaseTag

class extends Tag {}

constructor

constructor(
    tagToken: TagToken,
    remainTokens: TopLevelToken[],
    liquid: Liquid,
    parser: Parser
);

property branches

branches: { values: ValueToken[]; templates: Template[] }[];

property elseTemplates

elseTemplates: Template[];

property value

value: Value;

method arguments

arguments: () => Arguments;

method children

children: () => Generator<unknown, Template[]>;

method render

render: (ctx: Context, emitter: Emitter) => Generator<unknown, void, unknown>;

class CommentTag

class extends Tag {}

constructor

constructor(tagToken: TagToken, remainTokens: TopLevelToken[], liquid: Liquid);

method render

render: () => void;

class Context

class Context {}

constructor

constructor(
    env?: {},
    opts?: NormalizedFullOptions,
    renderOptions?: RenderOptions,
    { memoryLimit, renderLimit }?: { [key: string]: Limiter }
);

property breakCalled

breakCalled: boolean;

property continueCalled

continueCalled: boolean;

property environments

environments: Scope;

user passed in scope {% increment %}, {% decrement %} changes this scope, whereas {% capture %}, {% assign %} only hide this scope

property globals

globals: Scope;

global scope used as fallback for missing variables

property memoryLimit

memoryLimit: Limiter;

property opts

opts: NormalizedFullOptions;

The normalized liquid options object

property ownPropertyOnly

ownPropertyOnly: boolean;

property renderLimit

renderLimit: Limiter;

property strictVariables

strictVariables: boolean;

Throw when accessing undefined variable?

property sync

sync: boolean;

method bottom

bottom: () => Scope;

method get

get: (paths: PropertyKey[]) => unknown;

Deprecated
use _get() or getSync() instead

method getAll

getAll: () => Scope;

method getFromScope

getFromScope: (
    scope: unknown,
    paths: PropertyKey[] | string
) => IterableIterator<unknown>;

Deprecated
use _get() instead

method getRegister

getRegister: (key: string) => any;

method getSync

getSync: (paths: PropertyKey[]) => unknown;

method pop

pop: () => Scope | undefined;

method push

push: (ctx: object) => number;

method restoreRegister

restoreRegister: (keyValues: [string, any][]) => void;

method saveRegister

saveRegister: (...keys: string[]) => [string, any][];

method setRegister

setRegister: (key: string, value: any) => any;

method spawn

spawn: (scope?: {}) => Context;

class ContinueTag

class extends Tag {}

method render

render: (ctx: Context, _emitter: Emitter) => void;

class CycleTag

class extends Tag {}

constructor

constructor(token: TagToken, remainTokens: TopLevelToken[], liquid: Liquid);

method arguments

arguments: () => Arguments;

method render

render: (ctx: Context, emitter: Emitter) => Generator<unknown, unknown, unknown>;

class DecrementTag

class extends Tag {}

constructor

constructor(token: TagToken, remainTokens: TopLevelToken[], liquid: Liquid);

method localScope

localScope: () => Iterable<string | IdentifierToken>;

method render

render: (context: Context, emitter: Emitter) => void;

class Drop

abstract class Drop {}

method liquidMethodMissing

liquidMethodMissing: (key: string | number) => Promise<any> | any;

class EchoTag

class extends Tag {}

constructor

constructor(token: TagToken, remainTokens: TopLevelToken[], liquid: Liquid);

method arguments

arguments: () => Arguments;

method render

render: (ctx: Context, emitter: Emitter) => Generator<unknown, void, unknown>;

class Expression

class Expression {}

constructor

constructor(tokens: IterableIterator<Token>);

property postfix

readonly postfix: Token[];

method evaluate

evaluate: (
    ctx: Context,
    lenient?: boolean
) => Generator<unknown, unknown, unknown>;

method valid

valid: () => boolean;

class Filter

class Filter {}

constructor

constructor(token: FilterToken, options: FilterImplOptions, liquid: Liquid);

property args

args: FilterArg[];

property name

name: string;

property raw

readonly raw: boolean;

method render

render: (value: any, context: Context) => IterableIterator<unknown>;

class ForTag

class extends Tag {}

constructor

constructor(
    token: TagToken,
    remainTokens: TopLevelToken[],
    liquid: Liquid,
    parser: Parser
);

property collection

collection: ValueToken;

property elseTemplates

elseTemplates: Template[];

property hash

hash: Hash;

property templates

templates: Template[];

property variable

variable: string;

method arguments

arguments: () => Arguments;

method blockScope

blockScope: () => Iterable<string>;

method children

children: () => Generator<unknown, Template[]>;

method render

render: (
    ctx: Context,
    emitter: Emitter
) => Generator<unknown, void | string, Template[]>;

class Hash

class Hash {}

Key-Value Pairs Representing Tag Arguments Example: For the markup , foo:'bar', coo:2 reversed %}, hash['foo'] === 'bar' hash['coo'] === 2 hash['reversed'] === undefined

constructor

constructor(input: string | Tokenizer, jekyllStyle?: string | boolean);

property hash

hash: HashValueTokens;

method render

render: (ctx: Context) => Generator<unknown, Record<string, any>, unknown>;

class IfTag

class extends Tag {}

constructor

constructor(
    tagToken: TagToken,
    remainTokens: TopLevelToken[],
    liquid: Liquid,
    parser: Parser
);

property branches

branches: { value: Value; templates: Template[] }[];

property elseTemplates

elseTemplates: Template[];

method arguments

arguments: () => Arguments;

method children

children: () => Generator<unknown, Template[]>;

method render

render: (ctx: Context, emitter: Emitter) => Generator<unknown, void, string>;

class IncludeTag

class extends Tag {}

constructor

constructor(
    token: TagToken,
    remainTokens: TopLevelToken[],
    liquid: Liquid,
    parser: Parser
);

method arguments

arguments: () => Arguments;

method children

children: (partials: boolean, sync: boolean) => Generator<unknown, Template[]>;

method partialScope

partialScope: () => PartialScope | undefined;

method render

render: (ctx: Context, emitter: Emitter) => Generator<unknown, void, unknown>;

class IncrementTag

class extends Tag {}

constructor

constructor(token: TagToken, remainTokens: TopLevelToken[], liquid: Liquid);

method localScope

localScope: () => Iterable<string | IdentifierToken>;

method render

render: (context: Context, emitter: Emitter) => void;

class InlineCommentTag

class extends Tag {}

constructor

constructor(tagToken: TagToken, remainTokens: TopLevelToken[], liquid: Liquid);

method render

render: () => void;

class LayoutTag

class extends Tag {}

constructor

constructor(
    token: TagToken,
    remainTokens: TopLevelToken[],
    liquid: Liquid,
    parser: Parser
);

property args

args: Hash;

property file

file?: ParsedFileName;

property templates

templates: Template[];

method arguments

arguments: () => Arguments;

method children

children: (partials: boolean) => Generator<unknown, Template[]>;

method partialScope

partialScope: () => PartialScope | undefined;

method render

render: (ctx: Context, emitter: Emitter) => Generator<unknown, unknown, unknown>;

class Liquid

class Liquid {}

constructor

constructor(opts?: LiquidOptions);

property filters

readonly filters: Record<string, FilterImplOptions>;

property options

readonly options: NormalizedFullOptions;

property parser

readonly parser: Parser;

Deprecated
will be removed. In tags use this.parser instead

property renderer

readonly renderer: Render;

property tags

readonly tags: Record<string, TagClass>;

method analyze

analyze: (
    template: Template[],
    options?: StaticAnalysisOptions
) => Promise<StaticAnalysis>;

method analyzeSync

analyzeSync: (
    template: Template[],
    options?: StaticAnalysisOptions
) => StaticAnalysis;

method evalValue

evalValue: (str: string, scope?: object | Context) => Promise<any>;

method evalValueSync

evalValueSync: (str: string, scope?: object | Context) => any;

method express

express: () => (
    this: any,
    filePath: string,
    ctx: object,
    callback: (err: Error | null, rendered: string) => void
) => void;

method fullVariables

fullVariables: (
    template: string | Template[],
    options?: StaticAnalysisOptions
) => Promise<string[]>;

Return an array of all variables including their properties/paths.

method fullVariablesSync

fullVariablesSync: (
    template: string | Template[],
    options?: StaticAnalysisOptions
) => string[];

Return an array of all variables including their properties/paths.

method globalFullVariables

globalFullVariables: (
    template: string | Template[],
    options?: StaticAnalysisOptions
) => Promise<string[]>;

Return an array of all expected context variables including their properties/paths.

method globalFullVariablesSync

globalFullVariablesSync: (
    template: string | Template[],
    options?: StaticAnalysisOptions
) => string[];

Return an array of all expected context variables including their properties/paths.

method globalVariables

globalVariables: (
    template: string | Template[],
    options?: StaticAnalysisOptions
) => Promise<string[]>;

Return an array of all expected context variables without their properties.

method globalVariableSegments

globalVariableSegments: (
    template: string | Template[],
    options?: StaticAnalysisOptions
) => Promise<Array<SegmentArray>>;

Return an array of all expected context variables, each as an array of properties/segments.

method globalVariableSegmentsSync

globalVariableSegmentsSync: (
    template: string | Template[],
    options?: StaticAnalysisOptions
) => Array<SegmentArray>;

Return an array of all expected context variables, each as an array of properties/segments.

method globalVariablesSync

globalVariablesSync: (
    template: string | Template[],
    options?: StaticAnalysisOptions
) => string[];

Return an array of all expected context variables without their properties.

method parse

parse: (html: string, filepath?: string) => Template[];

method parseAndAnalyze

parseAndAnalyze: (
    html: string,
    filename?: string,
    options?: StaticAnalysisOptions
) => Promise<StaticAnalysis>;

method parseAndAnalyzeSync

parseAndAnalyzeSync: (
    html: string,
    filename?: string,
    options?: StaticAnalysisOptions
) => StaticAnalysis;

method parseAndRender

parseAndRender: (
    html: string,
    scope?: Context | object,
    renderOptions?: RenderOptions
) => Promise<any>;

method parseAndRenderSync

parseAndRenderSync: (
    html: string,
    scope?: Context | object,
    renderOptions?: RenderOptions
) => any;

method parseFile

parseFile: (file: string, lookupType?: LookupType) => Promise<Template[]>;

method parseFileSync

parseFileSync: (file: string, lookupType?: LookupType) => Template[];

method plugin

plugin: (plugin: (this: Liquid, L: typeof Liquid) => void) => void;

method registerFilter

registerFilter: (name: string, filter: FilterImplOptions) => void;

method registerTag

registerTag: (name: string, tag: TagClass | TagImplOptions) => void;

method render

render: (
    tpl: Template[],
    scope?: object,
    renderOptions?: RenderOptions
) => Promise<any>;

method renderFile

renderFile: (
    file: string,
    ctx?: Context | object,
    renderFileOptions?: RenderFileOptions
) => Promise<any>;

method renderFileSync

renderFileSync: (
    file: string,
    ctx?: Context | object,
    renderFileOptions?: RenderFileOptions
) => any;

method renderFileToNodeStream

renderFileToNodeStream: (
    file: string,
    scope?: object,
    renderOptions?: RenderOptions
) => Promise<NodeJS.ReadableStream>;

method renderSync

renderSync: (
    tpl: Template[],
    scope?: object,
    renderOptions?: RenderOptions
) => any;

method renderToNodeStream

renderToNodeStream: (
    tpl: Template[],
    scope?: object,
    renderOptions?: RenderOptions
) => NodeJS.ReadableStream;

method variables

variables: (
    template: string | Template[],
    options?: StaticAnalysisOptions
) => Promise<string[]>;

Return an array of all variables without their properties.

method variableSegments

variableSegments: (
    template: string | Template[],
    options?: StaticAnalysisOptions
) => Promise<Array<SegmentArray>>;

Return an array of all variables, each as an array of properties/segments.

method variableSegmentsSync

variableSegmentsSync: (
    template: string | Template[],
    options?: StaticAnalysisOptions
) => Array<SegmentArray>;

Return an array of all variables, each as an array of properties/segments.

method variablesSync

variablesSync: (
    template: string | Template[],
    options?: StaticAnalysisOptions
) => string[];

Return an array of all variables without their properties.

class LiquidError

abstract class LiquidError extends Error {}

constructor

constructor(err: string | Error, token: Token);

property context

context: string;

property originalError

originalError?: Error;

property token

token: Token;

method is

static is: (obj: unknown) => obj is LiquidError;

method update

protected update: () => void;

class LiquidTag

class extends Tag {}

constructor

constructor(
    token: TagToken,
    remainTokens: TopLevelToken[],
    liquid: Liquid,
    parser: Parser
);

property templates

templates: Template[];

method children

children: () => Generator<unknown, Template[]>;

method render

render: (ctx: Context, emitter: Emitter) => Generator<unknown, void, unknown>;

class Output

class Output extends TemplateImpl<OutputToken> implements Template {}

constructor

constructor(token: OutputToken, liquid: Liquid);

property value

value: Value;

method arguments

arguments: () => Arguments;

method render

render: (ctx: Context, emitter: Emitter) => IterableIterator<unknown>;

class ParseError

class ParseError extends LiquidError {}

constructor

constructor(err: Error, token: Token);

class Parser

class Parser {}

constructor

constructor(liquid: Liquid);

property parseFile

parseFile: (
    file: string,
    sync?: boolean,
    type?: LookupType,
    currentFile?: string
) => Generator<unknown, Template[], Template[] | string>;

method parse

parse: (html: string, filepath?: string) => Template[];

method parseStream

parseStream: (tokens: TopLevelToken[]) => ParseStream<TopLevelToken>;

method parseToken

parseToken: (
    token: TopLevelToken,
    remainTokens: TopLevelToken[]
) => import('../template').Tag | Output | HTML;

method parseTokens

parseTokens: (tokens: TopLevelToken[]) => Template[];

class ParseStream

class ParseStream<T extends Token = TopLevelToken> {}

constructor

constructor(tokens: T[], parseToken: ParseToken<T>);

method on

on: <T2 extends Template | T>(
    name: string,
    cb: (this: ParseStream, arg: T2) => void
) => ParseStream<T>;

method start

start: () => this;

method stop

stop: () => this;

class RawTag

class extends Tag {}

constructor

constructor(tagToken: TagToken, remainTokens: TopLevelToken[], liquid: Liquid);

method render

render: () => string;

class RenderError

class RenderError extends LiquidError {}

constructor

constructor(err: Error, tpl: Template);

method is

static is: (obj: any) => obj is RenderError;

class RenderTag

class extends Tag {}

constructor

constructor(
    token: TagToken,
    remainTokens: TopLevelToken[],
    liquid: Liquid,
    parser: Parser
);

method arguments

arguments: () => Arguments;

method children

children: (partials: boolean, sync: boolean) => Generator<unknown, Template[]>;

method partialScope

partialScope: () => PartialScope | undefined;

method render

render: (ctx: Context, emitter: Emitter) => Generator<unknown, void, unknown>;

class TablerowTag

class extends Tag {}

constructor

constructor(
    tagToken: TagToken,
    remainTokens: TopLevelToken[],
    liquid: Liquid,
    parser: Parser
);

property args

args: Hash;

property collection

collection: ValueToken;

property templates

templates: Template[];

property variable

variable: string;

method arguments

arguments: () => Arguments;

method blockScope

blockScope: () => string[];

method children

children: () => Generator<unknown, Template[]>;

method render

render: (ctx: Context, emitter: Emitter) => Generator<unknown, void, unknown>;

class Tag

abstract class Tag extends TemplateImpl<TagToken> implements Template {}

constructor

constructor(token: TagToken, remainTokens: TopLevelToken[], liquid: Liquid);

property liquid

liquid: Liquid;

property name

name: string;

property tokenizer

protected tokenizer: Tokenizer;

method render

abstract render: (ctx: Context, emitter: Emitter) => TagRenderReturn;

class TagToken

class TagToken extends DelimitedToken {}

constructor

constructor(
    input: string,
    begin: number,
    end: number,
    options: NormalizedFullOptions,
    file?: string
);

property args

readonly args: string;

property name

name: string;

property tokenizer

tokenizer: Tokenizer;

class Token

abstract class Token {}

constructor

constructor(
    kind: TokenKind,
    input: string,
    begin: number,
    end: number,
    file?: string
);

property begin

begin: number;

property end

end: number;

property file

file?: string;

property input

input: string;

property kind

kind: TokenKind;

method getPosition

getPosition: () => number[];

method getText

getText: () => string;

method size

size: () => number;

class TokenizationError

class TokenizationError extends LiquidError {}

constructor

constructor(message: string, token: Token);

class Tokenizer

class Tokenizer {}

constructor

constructor(
    input: string,
    operators?: Operators,
    file?: string,
    range?: [number, number]
);

property file

file?: string;

property input

input: string;

property N

N: number;

property p

p: number;

method advance

advance: (step?: number) => void;

method assert

assert: (pred: unknown, msg: string | (() => string), pos?: number) => void;

method end

end: () => boolean;

method error

error: (msg: string, pos?: number) => TokenizationError;

method match

match: (word: string) => boolean;

method matchTrie

matchTrie: <T>(trie: Trie<T>) => number;

method peek

peek: (n?: number) => string;

method peekType

peekType: (n?: number) => number;

method read

read: () => string;

method readEndrawOrRawContent

readEndrawOrRawContent: (options: NormalizedFullOptions) => HTMLToken | TagToken;

method readExpression

readExpression: () => Expression;

method readExpressionTokens

readExpressionTokens: () => IterableIterator<Token>;

method readFileNameTemplate

readFileNameTemplate: (
    options: NormalizedFullOptions
) => IterableIterator<TopLevelToken>;

method readFilter

readFilter: () => FilterToken | null;

method readFilterArg

readFilterArg: () => FilterArg | undefined;

method readFilteredValue

readFilteredValue: () => FilteredValueToken;

method readFilters

readFilters: () => FilterToken[];

method readHash

readHash: (jekyllStyle?: boolean | string) => HashToken | undefined;

method readHashes

readHashes: (jekyllStyle?: boolean | string) => HashToken[];

method readHTMLToken

readHTMLToken: (stopStrings: string[]) => HTMLToken;

method readIdentifier

readIdentifier: () => IdentifierToken;

method readLiquidTagToken

readLiquidTagToken: (
    options: NormalizedFullOptions
) => LiquidTagToken | undefined;

method readLiquidTagTokens

readLiquidTagTokens: (options?: NormalizedFullOptions) => LiquidTagToken[];

method readLiteral

readLiteral: () => LiteralToken | undefined;

method readNonEmptyIdentifier

readNonEmptyIdentifier: () => IdentifierToken | undefined;

method readNumber

readNumber: () => NumberToken | undefined;

method readOperator

readOperator: () => OperatorToken | undefined;

method readOutputToken

readOutputToken: (options?: NormalizedFullOptions) => OutputToken;

method readQuoted

readQuoted: () => QuotedToken | undefined;

method readRange

readRange: () => RangeToken | undefined;

method readScopeValue

readScopeValue: () => ValueToken | undefined;

method readTagName

readTagName: () => string;

method readTagToken

readTagToken: (options: NormalizedFullOptions) => TagToken;

method readTo

readTo: (end: string) => number;

method readToDelimiter

readToDelimiter: (delimiter: string, respectQuoted?: boolean) => number;

method readTopLevelToken

readTopLevelToken: (options: NormalizedFullOptions) => TopLevelToken;

method readTopLevelTokens

readTopLevelTokens: (options?: NormalizedFullOptions) => TopLevelToken[];

method readValue

readValue: () => ValueToken | undefined;

method readValueOrThrow

readValueOrThrow: () => ValueToken;

method readWord

readWord: () => IdentifierToken;

Deprecated
use #readIdentifier instead

method remaining

remaining: () => string;

method rmatch

rmatch: (pattern: string) => boolean;

method skipBlank

skipBlank: () => void;

method snapshot

snapshot: (begin?: number) => string;

class UndefinedVariableError

class UndefinedVariableError extends LiquidError {}

constructor

constructor(err: Error, token: Token);

class UnlessTag

class extends Tag {}

constructor

constructor(
    tagToken: TagToken,
    remainTokens: TopLevelToken[],
    liquid: Liquid,
    parser: Parser
);

property branches

branches: {
    value: Value;
    test: (val: any, ctx: Context) => boolean;
    templates: Template[];
}[];

property elseTemplates

elseTemplates: Template[];

method arguments

arguments: () => Arguments;

method children

children: () => Generator<unknown, Template[]>;

method render

render: (ctx: Context, emitter: Emitter) => Generator<unknown, unknown, unknown>;

class Value

class Value {}

constructor

constructor(input: string | FilteredValueToken, liquid: Liquid);

Parameter str
the value to be valuated, eg.: "foobar" | truncate: 3

property filters

readonly filters: Filter[];

property initial

readonly initial: Expression;

method value

value: (ctx: Context, lenient?: boolean) => Generator<unknown, unknown, unknown>;

class Variable

class Variable {}

A variable's segments and location, which can be coerced to a string.

constructor

constructor(
    segments: (string | number | Variable)[],
    location: VariableLocation
);

property location

readonly location: VariableLocation;

property segments

readonly segments: (string | number | Variable)[];

method toArray

toArray: () => SegmentArray;

Return this variable's segments as an array, possibly with nested arrays for nested paths.

method toString

toString: () => string;

Interfaces

interface Emitter

interface Emitter {}

property buffer

buffer: string;

Buffered string

method write

write: (html: any) => void;

Write a html value into emitter
Parameter html
string, Drop or other primitive value

interface FS

interface FS {}

property contains

contains?: (root: string, file: string) => boolean;

check if file is contained in root, always return true by default. Warning: not setting this could expose path traversal vulnerabilities.

property dirname

dirname?: (file: string) => string;

required for relative path resolving

property exists

exists: (filepath: string) => Promise<boolean>;

check if a file exists asynchronously

property existsSync

existsSync: (filepath: string) => boolean;

check if a file exists synchronously

property fallback

fallback?: (file: string) => string | undefined;

fallback file for lookup failure

property readFile

readFile: (filepath: string) => Promise<string>;

read a file asynchronously

property readFileSync

readFileSync: (filepath: string) => string;

read a file synchronously

property resolve

resolve: (dir: string, file: string, ext: string) => string;

resolve a file against directory, for given ext option

property sep

sep?: string;

defaults to "/"

interface LiquidOptions

interface LiquidOptions {}

property cache

cache?: boolean | number | LiquidCache;

Whether or not to cache resolved templates. Defaults to false.

property catchAllErrors

catchAllErrors?: boolean;

Catch all errors instead of exit upon one. Please note that render errors won't be reached when parse fails.

property dateFormat

dateFormat?: string;

Default date format to use if the date filter doesn't include a format. Defaults to %A, %B %-e, %Y at %-l:%M %P %z.

property dynamicPartials

dynamicPartials?: boolean;

If set, treat the filepath parameter in {%include filepath %} and {%layout filepath%} as a variable, otherwise as a literal value. Defaults to true.

property extname

extname?: string;

Add a extname (if filepath doesn't include one) before template file lookup. Eg: setting to ".html" will allow including file by basename. Defaults to "".

property fs

fs?: FS;

fs is used to override the default file-system module with a custom implementation.

property globals

globals?: object;

the global scope passed down to all partial and layout templates, i.e. templates included by include, layout and render tags.

property greedy

greedy?: boolean;

Whether trim*Left/trim*Right is greedy. When set to true, all consecutive blank characters including \n will be trimmed regardless of line breaks. Defaults to true.

property jekyllInclude

jekyllInclude?: boolean;

Use jekyll style include, pass parameters to include variable of current scope. Defaults to false.

property jekyllWhere

jekyllWhere?: boolean;

Use jekyll style where filter, enables array item match. Defaults to false.

property jsTruthy

jsTruthy?: boolean;

Use JavaScript Truthiness. Defaults to false.

property keepOutputType

keepOutputType?: boolean;

Whether or not to keep value type when writing the Output, not working for streamed rendering. Defaults to false.

property keyValueSeparator

keyValueSeparator?: string;

keyValue separator

property layouts

layouts?: string | string[];

A directory or an array of directories from where to resolve layout templates. If it's an array, the files are looked up in the order they occur in the array. Defaults to root

property lenientIf

lenientIf?: boolean;

Modifies the behavior of strictVariables. If set, a single undefined variable will *not* cause an exception in the context of the if/elsif/unless tag and the default filter. Instead, it will evaluate to false and null, respectively. Irrelevant if strictVariables is not set. Defaults to false. *

property locale

locale?: string;

Default locale, will be used by date filter. Defaults to system locale.

property memoryLimit

memoryLimit?: number;

For DoS handling, limit new objects creation, including array concat/join/strftime, etc. A typical PC can handle 1e9 (1G) memory without issue.

property operators

operators?: Operators;

An object of operators for conditional statements. Defaults to the regular Liquid operators.

property orderedFilterParameters

orderedFilterParameters?: boolean;

Respect parameter order when using filters like "for ... reversed limit", Defaults to false.

property outputDelimiterLeft

outputDelimiterLeft?: string;

The left delimiter for liquid outputs. *

property outputDelimiterRight

outputDelimiterRight?: string;

The right delimiter for liquid outputs. *

property outputEscape

outputEscape?: OutputEscapeOption;

Default escape filter applied to output values, when set, you'll have to add | raw for values don't need to be escaped. Defaults to undefined.

property ownPropertyOnly

ownPropertyOnly?: boolean;

Hide scope variables from prototypes, useful when you're passing a not sanitized object into LiquidJS or need to hide prototypes from templates.

property parseLimit

parseLimit?: number;

For DoS handling, limit total length of templates parsed in one parse() call. A typical PC can handle 1e8 (100M) characters without issues.

property partials

partials?: string | string[];

A directory or an array of directories from where to resolve included templates. If it's an array, the files are looked up in the order they occur in the array. Defaults to root

property preserveTimezones

preserveTimezones?: boolean;

Whether input strings to date filter preserve the given timezone *

property relativeReference

relativeReference?: boolean;

Allow refer to layouts/partials by relative pathname. To avoid arbitrary filesystem read, paths been referenced also need to be within corresponding root, partials, layouts. Defaults to true.

property renderLimit

renderLimit?: number;

For DoS handling, limit total time (in ms) for each render() call.

property root

root?: string | string[];

A directory or an array of directories from where to resolve layout and include templates, and the filename passed to .renderFile(). If it's an array, the files are looked up in the order they occur in the array. Defaults to ["."]

property strictFilters

strictFilters?: boolean;

Whether or not to assert filter existence. If set to false, undefined filters will be skipped. Otherwise, undefined filters will cause an exception. Defaults to false.

property strictVariables

strictVariables?: boolean;

Whether or not to assert variable existence. If set to false, undefined variables will be rendered as empty string. Otherwise, undefined variables will cause an exception. Defaults to false.

property tagDelimiterLeft

tagDelimiterLeft?: string;

The left delimiter for liquid tags. *

property tagDelimiterRight

tagDelimiterRight?: string;

The right delimiter for liquid tags. *

property templates

templates?: {
    [key: string]: string;
};

Render from in-memory templates mapping instead of file system. File system related options like fs, 'root', and relativeReference will be ignored when templates is specified.

property timezoneOffset

timezoneOffset?: number | string;

JavaScript timezone name or timezoneOffset for date filter, default to local time. That means if you're in Australia (UTC+10), it'll default to -600 or Australia/Lindeman

property trimOutputLeft

trimOutputLeft?: boolean;

Similar to trimOutputRight, whereas the \n is exclusive. Defaults to false. See Whitespace Control for details.

property trimOutputRight

trimOutputRight?: boolean;

Strip blank characters (including , \t, and \r) from the right of values ({{ }}) until \n (inclusive). Defaults to false.

property trimTagLeft

trimTagLeft?: boolean;

Similar to trimTagRight, whereas the \n is exclusive. Defaults to false. See Whitespace Control for details.

property trimTagRight

trimTagRight?: boolean;

Strip blank characters (including , \t, and \r) from the right of tags ({% %}) until \n (inclusive). Defaults to false.

interface PartialScope

interface PartialScope {}

Scope information used when analyzing partial templates.

property isolated

isolated: boolean;

If true, names in scope will be added to a new, isolated scope before analyzing any child templates, without access to the parent template's scope.

property name

name: string;

The name of the partial template. We need this to make sure we only analyze each template once.

property scope

scope: Iterable<string | [string, Argument]>;

A list of names that will be in scope for the child template.
If an item is a [string, Argument] tuple, the string is considered an alias for the argument.

interface StaticAnalysis

interface StaticAnalysis {}

The result of calling analyze() or analyzeSync().

property globals

globals: Variables;

Variables that are not in scope. These could be a "global" variables that are expected to be provided by the application developer, or possible mistakes from the template author.
If a variable is referenced before and after assignment, you should expect that variable to be included in globals, variables and locals, each with a different location.

property locals

locals: Variables;

Template variables that are added to the template local scope using tags like assign, capture or increment.

property variables

variables: Variables;

All variables, whether they are in scope or not. Including references to names such as forloop from the for tag.

interface StaticAnalysisOptions

interface StaticAnalysisOptions {}

property partials

partials?: boolean;

When true (the default), try to load partial templates and analyze them too.

interface Template

interface Template {}

property token

token: Token;

method arguments

arguments: () => Arguments;

method blockScope

blockScope: () => Iterable<string>;

method children

children: (partials: boolean, sync: boolean) => Generator<unknown, Template[]>;

method localScope

localScope: () => Iterable<IdentifierToken | QuotedToken>;

method partialScope

partialScope: () => PartialScope | undefined;

method render

render: (ctx: Context, emitter: Emitter) => any;

interface Trie

interface Trie<T> {}

index signature

[key: string]: Trie<T> | TrieLeafNode<T>;

interface VariableLocation

interface VariableLocation {}

Row, column and file name where a variable was found.

property col

col: number;

property file

file?: string;

property row

row: number;

Enums

enum TokenKind

enum TokenKind {
    Number = 1,
    Literal = 2,
    Tag = 4,
    Output = 8,
    HTML = 16,
    Filter = 32,
    Hash = 64,
    PropertyAccess = 128,
    Word = 256,
    Range = 512,
    Quoted = 1024,
    Operator = 2048,
    FilteredValue = 4096,
    Delimited = 12,
}

member Delimited

Delimited = 12

member Filter

Filter = 32

member FilteredValue

FilteredValue = 4096

member Hash

Hash = 64

member HTML

HTML = 16

member Literal

Literal = 2

member Number

Number = 1

member Operator

Operator = 2048

member Output

Output = 8

member PropertyAccess

PropertyAccess = 128

member Quoted

Quoted = 1024

member Range

Range = 512

member Tag

Tag = 4

member Word

Word = 256

Type Aliases

type Arguments

type Arguments = Iterable<Argument>;

type FilterImplOptions

type FilterImplOptions = FilterHandler | FilterOptions;

type Operators

type Operators = Record<string, OperatorHandler>;

type Scope

type Scope = ScopeObject | Drop;

type TopLevelToken

type TopLevelToken = TagToken | OutputToken | HTMLToken;

type ValueToken

type ValueToken =
    | RangeToken
    | LiteralToken
    | QuotedToken
    | PropertyAccessToken
    | NumberToken;

type Variables

type Variables = {
    [key: string]: Variable[];
};

A mapping of variable names to an array of locations at which the variable was found.

type VariableSegments

type VariableSegments = Array<string | number | Variable>;

Property names and array indexes that make up a path to a variable.

Namespaces

namespace TypeGuards

module 'dist/util/type-guards.d.ts' {}

function isDelimitedToken

isDelimitedToken: (val: any) => val is DelimitedToken;

function isHTMLToken

isHTMLToken: (val: any) => val is HTMLToken;

function isLiteralToken

isLiteralToken: (val: any) => val is LiteralToken;

function isNumberToken

isNumberToken: (val: any) => val is NumberToken;

function isOperatorToken

isOperatorToken: (val: any) => val is OperatorToken;

function isOutputToken

isOutputToken: (val: any) => val is OutputToken;

function isPropertyAccessToken

isPropertyAccessToken: (val: any) => val is PropertyAccessToken;

function isQuotedToken

isQuotedToken: (val: any) => val is QuotedToken;

function isRangeToken

isRangeToken: (val: any) => val is RangeToken;

function isTagToken

isTagToken: (val: any) => val is TagToken;

function isValueToken

isValueToken: (val: any) => val is ValueToken;

function isWordToken

isWordToken: (val: any) => val is IdentifierToken;

Package Files (56)

Dependencies (1)

commander

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/liquidjs.

Markdown

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

HTML

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

Updated 2 months ago.
Package analyzed in 7753 ms.
Missing or incorrect documentation? Open an issue for this package.

liquidjs

Install

Overview

Index

Variables

Functions

Classes

Interfaces

Enums

Type Aliases

Namespaces

Variables

variable defaultOperators

variable defaultOptions

variable filters

variable tags

variable version

Functions

function analyze

function analyzeSync

function assert

function createTrie

function evalQuotedToken

function evalToken

function isFalsy

function isTruthy

function toPromise

function toValue

function toValueSync

Classes

class AssertionError

class AssignTag

method arguments

method localScope

method render

class BlockTag

property block

property templates

method blockScope

method children

method render

class BreakTag

method render

class CaptureTag

property identifier

property templates

property variable

method children

method localScope

method render

class CaseTag

property branches

property elseTemplates

property value

method arguments

method children

method render

class CommentTag

method render

class Context

property breakCalled

property continueCalled

property environments

property globals

property memoryLimit

property opts

property ownPropertyOnly

property renderLimit

property strictVariables

property sync

method bottom

method get

Deprecated

method getAll

method getFromScope

Deprecated

method getRegister

method getSync

method pop

method push