liquidjs
- Version 9.40.0
- Published
- 1.26 MB
- No dependencies
- 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
Functions
Classes
Tokenizer
- advance()
- end()
- file
- input
- match()
- mkError()
- N
- p
- peek()
- peekType()
- readEndrawOrRawContent()
- readExpression()
- readExpressionTokens()
- readFileNameTemplate()
- readFilter()
- readFilterArg()
- readFilters()
- readHash()
- readHashes()
- readHTMLToken()
- readIdentifier()
- readLiquidTagToken()
- readLiquidTagTokens()
- readOperator()
- readOutputToken()
- readQuoted()
- readRange()
- readTagName()
- readTagToken()
- readTo()
- readToDelimiter()
- readTopLevelToken()
- readTopLevelTokens()
- readValue()
- readValueOrThrow()
- readWord()
- remaining()
- rmatch()
- skipBlank()
- snapshot()
Interfaces
Enums
Type Aliases
Namespaces
filters
- abs()
- append()
- atLeast()
- atMost()
- capitalize()
- ceil()
- compact()
- concat()
- date()
- Default()
- dividedBy()
- downcase()
- escape()
- escapeOnce()
- first()
- floor()
- join()
- json()
- last()
- lstrip()
- map()
- minus()
- modulo()
- newlineToBr()
- plus()
- prepend()
- raw
- remove()
- removeFirst()
- replace()
- replaceFirst()
- reverse()
- round()
- rstrip()
- size()
- slice()
- sort()
- sortNatural()
- split()
- strip()
- stripHtml()
- stripNewlines()
- times()
- truncate()
- truncatewords()
- uniq()
- upcase()
- urlDecode()
- urlEncode()
- where()
Variables
variable defaultOperators
const defaultOperators: Operators;
variable defaultOptions
const defaultOptions: NormalizedFullOptions;
variable toThenable
const toThenable: <T>( val: T | Generator<unknown, T, unknown> | Promise<T>) => Promise<T>;
variable version
const version: string;
Functions
function assert
assert: <T>( predicate: T | null | undefined, message?: string | (() => string)) => void;
function createTrie
createTrie: (operators: Operators) => Trie;
function evalQuotedToken
evalQuotedToken: (token: QuotedToken) => string;
function evalToken
evalToken: (token: Token | undefined, ctx: Context, lenient?: boolean) => any;
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 Context
class Context {}
constructor
constructor( env?: {}, opts?: NormalizedFullOptions, renderOptions?: RenderOptions);
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 opts
opts: NormalizedFullOptions;
The normalized liquid options object
property strictVariables
strictVariables: boolean;
Throw when accessing undefined variable?
property sync
sync: boolean;
method bottom
bottom: () => Scope;
method get
get: (paths: PropertyKey[]) => object;
method getAll
getAll: () => Scope;
method getFromScope
getFromScope: (scope: object, paths: PropertyKey[] | string) => object;
method getRegister
getRegister: (key: string) => any;
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;
class Drop
abstract class Drop {}
method liquidMethodMissing
liquidMethodMissing: ( key: string | number) => Promise<string | undefined> | string | undefined;
class Expression
class Expression {}
constructor
constructor(tokens: IterableIterator<Token>);
method evaluate
evaluate: ( ctx: Context, lenient?: boolean) => Generator<unknown, unknown, unknown>;
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(markup: string, jekyllStyle?: boolean);
property hash
hash: HashValue;
method render
render: (ctx: Context) => Generator<unknown, HashValue, unknown>;
class InternalUndefinedVariableError
class InternalUndefinedVariableError extends Error {}
constructor
constructor(variableName: string);
property variableName
variableName: string;
class Liquid
class Liquid {}
constructor
constructor(opts?: LiquidOptions);
property filters
readonly filters: FilterMap;
property options
readonly options: NormalizedFullOptions;
property parser
readonly parser: Parser;
property renderer
readonly renderer: Render;
property tags
readonly tags: TagMap;
method evalValue
evalValue: (str: string, ctx: Context) => Promise<any>;
method evalValueSync
evalValueSync: (str: string, ctx: Context) => any;
method express
express: () => ( this: any, filePath: string, ctx: object, callback: (err: Error | null, rendered: string) => void) => void;
method parse
parse: (html: string, filepath?: string) => Template[];
method parseAndRender
parseAndRender: ( html: string, scope?: object, renderOptions?: RenderOptions) => Promise<any>;
method parseAndRenderSync
parseAndRenderSync: ( html: string, scope?: object, renderOptions?: RenderOptions) => any;
method parseFile
parseFile: (file: string) => Promise<Template[]>;
method parseFileSync
parseFileSync: (file: string) => 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: TagImplOptions) => void;
method render
render: ( tpl: Template[], scope?: object, renderOptions?: RenderOptions) => Promise<any>;
method renderFile
renderFile: ( file: string, ctx?: object, renderOptions?: RenderOptions) => Promise<any>;
method renderFileSync
renderFileSync: ( file: string, ctx?: object, renderOptions?: RenderOptions) => 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;
class LiquidError
abstract class LiquidError extends Error {}
constructor
constructor(err: Error, token: Token);
property context
context: string;
method update
protected update: () => void;
class ParseError
class ParseError extends LiquidError {}
constructor
constructor(err: Error, token: Token);
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 RenderError
class RenderError extends LiquidError {}
constructor
constructor(err: Error, tpl: Template);
method is
static is: (obj: any) => obj is RenderError;
class TagToken
class TagToken extends DelimitedToken {}
constructor
constructor( input: string, begin: number, end: number, options: NormalizedFullOptions, file?: string);
property args
args: string;
property name
name: string;
class TimezoneDate
class TimezoneDate implements LiquidDate {}
A date implementation with timezone info, just like Ruby date
Implementation: - create a Date offset by it's timezone difference, avoiding overriding a bunch of methods - rewrite getTimezoneOffset() to trick strftime
constructor
constructor(init: string | number | Date | TimezoneDate, timezoneOffset: number);
method createDateFixedToTimezone
static createDateFixedToTimezone: (dateString: string) => LiquidDate;
Create a Date object fixed to it's declared Timezone. Both - 2021-08-06T02:29:00.000Z and - 2021-08-06T02:29:00.000+08:00 will always be displayed as - 2021-08-06 02:29:00 regardless timezoneOffset in JavaScript realm
The implementation hack: Instead of calling
.getMonth()
/.getUTCMonth()
respect topreserveTimezones
, we create a different Date to trick strftime, it's both simpler and more performant. Given that a template is expected to be parsed fewer times than rendered.
method getDate
getDate: () => number;
method getDay
getDay: () => number;
method getFullYear
getFullYear: () => number;
method getHours
getHours: () => number;
method getMilliseconds
getMilliseconds: () => number;
method getMinutes
getMinutes: () => number;
method getMonth
getMonth: () => number;
method getSeconds
getSeconds: () => number;
method getTime
getTime: () => number;
method getTimezoneOffset
getTimezoneOffset: () => number;
method toLocaleDateString
toLocaleDateString: (locale?: string) => string;
method toLocaleTimeString
toLocaleTimeString: (locale?: string) => string;
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, trie?: Trie, file?: string);
property file
file: string;
property input
input: string;
property N
N: number;
property p
p: number;
method advance
advance: (i?: number) => void;
method end
end: () => boolean;
method match
match: (word: string) => boolean;
method mkError
mkError: (msg: string, begin: number) => TokenizationError;
method peek
peek: (n?: number) => string;
method peekType
peekType: (n?: number) => number;
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 readFilters
readFilters: () => FilterToken[];
method readHash
readHash: (jekyllStyle?: boolean) => HashToken | undefined;
method readHashes
readHashes: (jekyllStyle?: boolean) => HashToken[];
method readHTMLToken
readHTMLToken: (stopStrings: string[]) => HTMLToken;
method readIdentifier
readIdentifier: () => IdentifierToken;
method readLiquidTagToken
readLiquidTagToken: (options: NormalizedFullOptions) => LiquidTagToken;
method readLiquidTagTokens
readLiquidTagTokens: (options?: NormalizedFullOptions) => LiquidTagToken[];
method readOperator
readOperator: () => OperatorToken | undefined;
method readOutputToken
readOutputToken: (options?: NormalizedFullOptions) => OutputToken;
method readQuoted
readQuoted: () => QuotedToken | undefined;
method readRange
readRange: () => RangeToken | undefined;
method readTagName
readTagName: () => string;
method readTagToken
readTagToken: (options?: NormalizedFullOptions) => TagToken;
method readTo
readTo: (end: string) => number;
method readToDelimiter
readToDelimiter: (delimiter: string) => 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
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 Value
class Value {}
constructor
constructor(str: string, 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>;
Interfaces
interface Emitter
interface Emitter {}
interface FilterImplOptions
interface FilterImplOptions {}
call signature
(this: FilterImpl, value: any, ...args: any[]): any;
interface Operators
interface Operators {}
index signature
[key: string]: (lhs: any, rhs: any, ctx: Context) => boolean;
interface TagImpl
interface TagImpl extends TagImplOptions {}
property liquid
liquid: Liquid;
index signature
[key: string]: any;
interface TagImplOptions
interface TagImplOptions {}
interface Template
interface Template {}
interface Trie
interface Trie {}
index signature
[key: string]: any;
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, Delimited = 12,}
member Delimited
Delimited = 12
member Filter
Filter = 32
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 TopLevelToken
type TopLevelToken = TagToken | OutputToken | HTMLToken;
Namespaces
namespace filters
module 'dist/builtin/filters/index.d.ts' {}
variable raw
const raw: <T>(val: T) => T;
function abs
abs: (x: number) => any;
function append
append: (v: string, arg: string) => string;
function atLeast
atLeast: (...args: number[]) => any;
function atMost
atMost: (...args: number[]) => any;
function capitalize
capitalize: (str: string) => string;
function ceil
ceil: (x: number) => any;
function compact
compact: <T>(this: FilterImpl, arr: T[]) => any[];
function concat
concat: <T1, T2>(v: T1[], arg?: T2[]) => (T1 | T2)[];
function date
date: (this: FilterImpl, v: string | Date, arg: string) => string | Date;
function Default
Default: <T1 extends boolean, T2>( this: FilterImpl, value: T1, defaultValue: T2, ...args: Array<[string, any]>) => T1 | T2;
function dividedBy
dividedBy: (dividend: number, divisor: number, integerArithmetic?: any) => any;
function downcase
downcase: (v: string) => string;
function escape
escape: (str: string) => string;
function escapeOnce
escapeOnce: (str: string) => string;
function first
first: (v: any) => any;
function floor
floor: (x: number) => any;
function join
join: (v: any[], arg: string) => any;
function json
json: (value: any) => string;
function last
last: (v: any) => any;
function lstrip
lstrip: (v: string, chars?: string) => string;
function map
map: (this: FilterImpl, arr: Scope[], property: string) => object[];
function minus
minus: (v: number, arg: number) => any;
function modulo
modulo: (v: number, arg: number) => any;
function newlineToBr
newlineToBr: (v: string) => string;
function plus
plus: (v: number, arg: number) => number;
function prepend
prepend: (v: string, arg: string) => string;
function remove
remove: (v: string, arg: string) => string;
function removeFirst
removeFirst: (v: string, l: string) => string;
function replace
replace: (v: string, pattern: string, replacement: string) => string;
function replaceFirst
replaceFirst: (v: string, arg1: string, arg2: string) => string;
function reverse
reverse: (v: any[]) => any;
function round
round: (v: number, arg?: number) => number;
function rstrip
rstrip: (str: string, chars?: string) => string;
function size
size: (v: string | any[]) => number;
function slice
slice: <T>(v: T[] | string, begin: number, length?: number) => T[] | string;
function sort
sort: <T>(this: FilterImpl, arr: T[], property?: string) => any[];
function sortNatural
sortNatural: <T>(input: T[], property?: string) => any[];
function split
split: (v: string, arg: string) => string[];
function strip
strip: (v: string, chars?: string) => string;
function stripHtml
stripHtml: (v: string) => string;
function stripNewlines
stripNewlines: (v: string) => string;
function times
times: (v: number, arg: number) => any;
function truncate
truncate: (v: string, l?: number, o?: string) => string;
function truncatewords
truncatewords: (v: string, l?: number, o?: string) => string;
function uniq
uniq: <T>(arr: T[]) => T[];
function upcase
upcase: (str: string) => string;
function urlDecode
urlDecode: (x: string) => string;
function urlEncode
urlEncode: (x: string) => string;
function where
where: <T extends object>( this: FilterImpl, arr: T[], property: string, expected?: any) => T[];
namespace tags
module 'dist/builtin/tags/index.d.ts' {}
variable tags
const tags: { [key: string]: TagImplOptions };
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 isWordToken
isWordToken: (val: any) => val is IdentifierToken;
Package Files (36)
- dist/builtin/filters/array.d.ts
- dist/builtin/filters/date.d.ts
- dist/builtin/filters/html.d.ts
- dist/builtin/filters/index.d.ts
- dist/builtin/filters/math.d.ts
- dist/builtin/filters/misc.d.ts
- dist/builtin/filters/string.d.ts
- dist/builtin/filters/url.d.ts
- dist/builtin/tags/index.d.ts
- dist/context/context.d.ts
- dist/drop/drop.d.ts
- dist/emitters/emitter.d.ts
- dist/liquid-options.d.ts
- dist/liquid.d.ts
- dist/parser/parse-stream.d.ts
- dist/parser/token-kind.d.ts
- dist/parser/tokenizer.d.ts
- dist/render/boolean.d.ts
- dist/render/expression.d.ts
- dist/render/operator.d.ts
- dist/template/filter/filter-impl-options.d.ts
- dist/template/tag/hash.d.ts
- dist/template/tag/tag-impl-options.d.ts
- dist/template/tag/tag-impl.d.ts
- dist/template/template.d.ts
- dist/template/value.d.ts
- dist/tokens/tag-token.d.ts
- dist/tokens/token.d.ts
- dist/tokens/toplevel-token.d.ts
- dist/util/assert.d.ts
- dist/util/async.d.ts
- dist/util/error.d.ts
- dist/util/operator-trie.d.ts
- dist/util/timezone-date.d.ts
- dist/util/type-guards.d.ts
- dist/util/underscore.d.ts
Dependencies (0)
No dependencies.
Dev Dependencies (51)
- @commitlint/cli
- @commitlint/config-conventional
- @semantic-release/changelog
- @semantic-release/commit-analyzer
- @semantic-release/git
- @semantic-release/npm
- @semantic-release/release-notes-generator
- @types/benchmark
- @types/chai
- @types/chai-as-promised
- @types/express
- @types/jsdom
- @types/mocha
- @types/sinon
- @types/sinon-chai
- @types/supertest
- @typescript-eslint/eslint-plugin
- @typescript-eslint/parser
- all-contributors-cli
- benchmark
- chai
- chai-as-promised
- coveralls
- cross-env
- eslint
- eslint-config-standard
- eslint-plugin-import
- eslint-plugin-mocha
- eslint-plugin-node
- eslint-plugin-promise
- eslint-plugin-standard
- express
- husky
- jsdom
- mocha
- nyc
- regenerator-runtime
- rollup
- rollup-plugin-replace
- rollup-plugin-typescript2
- rollup-plugin-uglify
- rollup-plugin-version-injector
- semantic-release
- sinon
- sinon-chai
- supertest
- ts-node
- tslib
- typedoc
- typedoc-plugin-markdown
- typescript
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[](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 .
Package analyzed in 5407 ms. - Missing or incorrect documentation? Open an issue for this package.