@glimmer/syntax

@glimmer/syntax

Version 0.84.3
Published 2 months ago
4.07 MB
4 dependencies
MIT license

Install

npm i @glimmer/syntax

yarn add @glimmer/syntax

pnpm add @glimmer/syntax

Overview

Overview not available.

Index

Variables

variable builders

const builders: {
    mustache: typeof buildMustache;
    block: typeof buildBlock;
    partial: typeof buildPartial;
    comment: typeof buildComment;
    mustacheComment: typeof buildMustacheComment;
    element: typeof buildElement;
    elementModifier: typeof buildElementModifier;
    attr: typeof buildAttr;
    text: typeof buildText;
    sexpr: typeof buildSexpr;
    concat: typeof buildConcat;
    hash: typeof buildHash;
    pair: typeof buildPair;
    literal: typeof buildLiteral;
    program: typeof buildProgram;
    blockItself: typeof buildBlockItself;
    template: typeof buildTemplate;
    loc: typeof buildLoc;
    pos: typeof buildPosition;
    path: typeof buildPath;
    fullPath: typeof buildCleanPath;
    head: typeof buildHeadFromString;
    at: typeof buildAtName;
    var: typeof buildVar;
    this: typeof buildThis;
    blockName: typeof buildNamedBlockName;
    string: (value: string) => ASTv1.StringLiteral;
    boolean: (value: boolean) => ASTv1.BooleanLiteral;
    number: (value: number) => ASTv1.NumberLiteral;
    undefined(): ASTv1.UndefinedLiteral;
    null(): ASTv1.NullLiteral;
};

variable KEYWORDS_TYPES

const KEYWORDS_TYPES: { [key: string]: KeywordType[] };

This includes the full list of keywords currently in use in the template language, and where their valid usages are.

Functions

function cannotRemoveNode

cannotRemoveNode: (
    node: ASTv1.Node,
    parent: ASTv1.Node,
    key: string
) => TraversalError;

function cannotReplaceNode

cannotReplaceNode: (
    node: ASTv1.Node,
    parent: ASTv1.Node,
    key: string
) => TraversalError;

function generateSyntaxError

generateSyntaxError: (
    message: string,
    location: SourceSpan
) => GlimmerSyntaxError;

function getTemplateLocals

getTemplateLocals: (
    html: string,
    options?: GetTemplateLocalsOptions
) => string[];

Parses and traverses a given handlebars html template to extract all template locals referenced that could possible come from the parent scope. Can exclude known keywords optionally.

function hasSpan

hasSpan: (span: MaybeHasSourceSpan) => span is HasSourceSpan;

function isKeyword

isKeyword: (word: string) => boolean;

function loc

loc: (span: HasSourceSpan) => SourceSpan;

function maybeLoc

maybeLoc: (location: MaybeHasSourceSpan, fallback: SourceSpan) => SourceSpan;

function node

node: {
    (): {
        fields<Fields extends object>(): NodeConstructor<Fields & BaseNodeFields>;
    };
    <T extends string>(name: T): {
        fields<Fields extends object>(): TypedNodeConstructor<
            T,
            Fields & BaseNodeFields
        >;
    };
};

This is a convenience function for creating ASTv2 nodes, with an optional name and the node's options.
export class HtmlText extends node('HtmlText').fields<{ chars: string }>() {}
This creates a new ASTv2 node with the name 'HtmlText' and one field chars: string (in addition to a loc: SourceOffsets field, which all nodes have).
export class Args extends node().fields<{ positional: PositionalArguments; named: NamedArguments }>() {}
This creates a new un-named ASTv2 node with two fields (positional: Positional and `named: Named, in addition to the generic loc: SourceOffsets` field).
Once you create a node using node, it is instantiated with all of its fields (including loc):
new HtmlText({ loc: offsets, chars: someString });

function normalize

normalize: (
    source: Source,
    options?: PrecompileOptions
) => [ast: ASTv2.Template, locals: string[]];

function preprocess

preprocess: (
    input: string | Source | HBS.Program,
    options?: PreprocessOptions
) => ASTv1.Template;

function print

print: (ast: ASTv1.Node, options?: PrinterOptions) => string;

function sortByLoc

sortByLoc: (a: ASTv1.Node, b: ASTv1.Node) => -1 | 0 | 1;

function traverse

traverse: (node: ASTv1.Node, visitor: NodeVisitor) => void;

Classes

class BlockSymbolTable

class BlockSymbolTable extends SymbolTable {}

constructor

constructor(parent: SymbolTable, symbols: string[], slots: number[]);

property locals

readonly locals: string[];

property slots

slots: number[];

property symbols

symbols: string[];

method allocate

allocate: (identifier: string) => number;

method allocateBlock

allocateBlock: (name: string) => number;

method allocateFree

allocateFree: (name: string, resolution: ASTv2.FreeVarResolution) => number;

method allocateNamed

allocateNamed: (name: string) => number;

method get

get: (name: string) => [number, boolean];

method getEvalInfo

getEvalInfo: () => Core.EvalInfo;

method getLocalsMap

getLocalsMap: () => Dict<number>;

method has

has: (name: string) => boolean;

method setHasEval

setHasEval: () => void;

class Path

class Walker {}

constructor

constructor(order?: {});

property order

order?: {};

property stack

stack: unknown[];

method children

children: <N extends ASTv1.Node>(
    node: N & ASTv1.Node,
    callback: NodeCallback<N & ASTv1.Node>
) => void;

method visit

visit: <N extends ASTv1.Node>(
    node: Option<N>,
    callback: NodeCallback<N>
) => void;

class ProgramSymbolTable

class ProgramSymbolTable extends SymbolTable {}

constructor

constructor(
    templateLocals: string[],
    customizeComponentName: (input: string) => string
);

property hasEval

readonly hasEval: boolean;

property symbols

symbols: string[];

property upvars

upvars: string[];

method allocate

allocate: (identifier: string) => number;

method allocateBlock

allocateBlock: (name: string) => number;

method allocateFree

allocateFree: (name: string, resolution: ASTv2.FreeVarResolution) => number;

method allocateNamed

allocateNamed: (name: string) => number;

method get

get: (name: string) => [number, boolean];

method getEvalInfo

getEvalInfo: () => Core.EvalInfo;

method getLocalsMap

getLocalsMap: () => Dict<number>;

method getUsedTemplateLocals

getUsedTemplateLocals: () => string[];

method has

has: (name: string) => boolean;

method setHasEval

setHasEval: () => void;

class Source

class Source {}

constructor

constructor(source: string, module?: string);

property module

readonly module: string;

property source

readonly source: string;

method charPosFor

charPosFor: (position: SourcePosition) => number | null;

method check

check: (offset: number) => boolean;

Validate that the character offset represents a position in the source string.

method hbsPosFor

hbsPosFor: (offset: number) => Option<SourcePosition>;

method offsetFor

offsetFor: (line: number, column: number) => SourceOffset;

method slice

slice: (start: number, end: number) => string;

method spanFor

spanFor: ({ start, end }: Readonly<SourceLocation>) => SourceSpan;

class SourceSlice

class SourceSlice<Chars extends string = string> {}

constructor

constructor(options: { loc: SourceSpan; chars: Chars });

property chars

readonly chars: string;

property loc

readonly loc: SourceSpan;

method getString

getString: () => string;

method load

static load: (
    source: Source,
    slice: SerializedSourceSlice<string>
) => SourceSlice;

method serialize

serialize: () => SerializedSourceSlice<Chars>;

method synthetic

static synthetic: <S extends string>(chars: S) => SourceSlice<S>;

class SourceSpan

class SourceSpan implements SourceLocation {}

A SourceSpan object represents a span of characters inside of a template source.
There are three kinds of SourceSpan objects:
- ConcreteSourceSpan, which contains byte offsets - LazySourceSpan, which contains SourceLocations from the Handlebars AST, which can be converted to byte offsets on demand. - InvisibleSourceSpan, which represent source strings that aren't present in the source, because: - they were created synthetically - their location is nonsensical (the span is broken) - they represent nothing in the source (this currently happens only when a bug in the upstream Handlebars parser fails to assign a location to empty blocks)
At a high level, all SourceSpan objects provide:
- byte offsets - source in column and line format
And you can do these operations on SourceSpans:
- collapse it to a SourceSpan representing its starting or ending position - slice out some characters, optionally skipping some characters at the beginning or end - create a new SourceSpan with a different starting or ending offset
All SourceSpan objects implement SourceLocation, for compatibility. All SourceSpan objects have a toJSON that emits SourceLocation, also for compatibility.
For compatibility, subclasses of AbstractSourceSpan must implement locDidUpdate, which happens when an AST plugin attempts to modify the start or end of a span directly.
The goal is to avoid creating any problems for use-cases like AST Explorer.

constructor

constructor(data: SpanData & AnySpan);

property end

end: SourcePosition;

For compatibility with SourceLocation in AST plugins
Deprecated
use endPosition instead

property endPosition

readonly endPosition: SourcePosition;

Get the ending SourcePosition for this SourceSpan, lazily computing it if needed.

property isInvisible

readonly isInvisible: boolean;

property loc

readonly loc: SourceLocation;

property module

readonly module: string;

property NON_EXISTENT

static readonly NON_EXISTENT: SourceSpan;

property source

readonly source: string;

For compatibility with SourceLocation in AST plugins
Deprecated
use module instead

property start

start: SourcePosition;

For compatibility with SourceLocation in AST plugins
Deprecated
use startPosition instead

property startPosition

readonly startPosition: SourcePosition;

Get the starting SourcePosition for this SourceSpan, lazily computing it if needed.

method asString

asString: () => string;

method broken

static broken: (pos?: SourceLocation) => SourceSpan;

method collapse

collapse: (where: 'start' | 'end') => SourceSpan;

method extend

extend: (other: SourceSpan) => SourceSpan;

method forCharPositions

static forCharPositions: (
    source: Source,
    startPos: number,
    endPos: number
) => SourceSpan;

method forHbsLoc

static forHbsLoc: (source: Source, loc: SourceLocation) => SourceSpan;

method getEnd

getEnd: () => SourceOffset;

method getStart

getStart: () => SourceOffset;

method load

static load: (source: Source, serialized: SerializedSourceSpan) => SourceSpan;

method serialize

serialize: () => SerializedSourceSpan;

method slice

slice: ({
    skipStart,
    skipEnd,
}: {
    skipStart?: number;
    skipEnd?: number;
}) => SourceSpan;

method sliceEndChars

sliceEndChars: ({
    skipEnd,
    chars,
}: {
    skipEnd?: number;
    chars: number;
}) => SourceSpan;

method sliceStartChars

sliceStartChars: ({
    skipStart,
    chars,
}: {
    skipStart?: number;
    chars: number;
}) => SourceSpan;

method synthetic

static synthetic: (chars: string) => SourceSpan;

method toJSON

toJSON: () => SourceLocation;

Support converting ASTv1 nodes into a serialized format using JSON.stringify.

method toSlice

toSlice: (expected?: string) => SourceSlice;

Convert this SourceSpan into a SourceSlice. In debug mode, this method optionally checks that the byte offsets represented by this SourceSpan actually correspond to the expected string.

method withEnd

withEnd: (this: SourceSpan, other: SourceOffset) => SourceSpan;

Create a new span with the current span's beginning and a new ending.

method withStart

withStart: (other: SourceOffset) => SourceSpan;

Create a new span with the current span's end and a new beginning.

class SpanList

class SpanList {}

constructor

constructor(span?: SourceSpan[]);

method add

add: (offset: SourceSpan) => void;

method getRangeOffset

getRangeOffset: (fallback: SourceSpan) => SourceSpan;

method range

static range: {
    (span: PresentArray<HasSourceSpan>): SourceSpan;
    (span: HasSourceSpan[], fallback: SourceSpan): SourceSpan;
};

class SymbolTable

abstract class SymbolTable {}

method allocate

abstract allocate: (identifier: string) => number;

method allocateBlock

abstract allocateBlock: (name: string) => number;

method allocateFree

abstract allocateFree: (
    name: string,
    resolution: ASTv2.FreeVarResolution
) => number;

method allocateNamed

abstract allocateNamed: (name: string) => number;

method child

child: (locals: string[]) => BlockSymbolTable;

method get

abstract get: (name: string) => [symbol: number, isRoot: boolean];

method getEvalInfo

abstract getEvalInfo: () => Core.EvalInfo;

method getLocalsMap

abstract getLocalsMap: () => Dict<number>;

method has

abstract has: (name: string) => boolean;

method setHasEval

abstract setHasEval: () => void;

method top

static top: (
    locals: string[],
    customizeComponentName: (input: string) => string
) => ProgramSymbolTable;

class Walker

class Walker {}

constructor

constructor(order?: {});

property order

order?: {};

property stack

stack: unknown[];

method children

children: <N extends ASTv1.Node>(
    node: N & ASTv1.Node,
    callback: NodeCallback<N & ASTv1.Node>
) => void;

method visit

visit: <N extends ASTv1.Node>(
    node: Option<N>,
    callback: NodeCallback<N>
) => void;

class WalkerPath

class WalkerPath<N extends ASTv1.Node> {}

constructor

constructor(
    node: ASTv1.Node,
    parent?: WalkerPath<ASTv1.Node>,
    parentKey?: string
);

property node

node: ASTv1.Node;

property parent

parent: WalkerPath<ASTv1.Node>;

property parentKey

parentKey: string;

property parentNode

readonly parentNode: ASTv1.Node;

method parents

parents: () => Iterable<WalkerPath<ASTv1.Node> | null>;

Interfaces

interface ASTPlugin

interface ASTPlugin {}

property name

name: string;

property visitor

visitor: NodeVisitor;

interface ASTPluginBuilder

interface ASTPluginBuilder<
    TEnv extends ASTPluginEnvironment = ASTPluginEnvironment
> {}

ASTPlugins can make changes to the Glimmer template AST before compilation begins.

call signature

(env: TEnv): ASTPlugin;

interface ASTPluginEnvironment

interface ASTPluginEnvironment {}

property meta

meta?: object;

property syntax

syntax: Syntax;

interface GlimmerSyntaxError

interface GlimmerSyntaxError extends Error {}

property code

code: string | null;

property location

location: SourceSpan | null;

interface PrecompileOptions

interface PrecompileOptions extends PreprocessOptions {}

property id

id?: TemplateIdFn;

method customizeComponentName

customizeComponentName: (input: string) => string;

interface PreprocessOptions

interface PreprocessOptions {}

property locals

locals?: string[];

property meta

meta?: {
    moduleName?: string;
};

property mode

mode?: 'codemod' | 'precompile';

Useful for specifying a group of options together.
When 'codemod' we disable all whitespace control in handlebars (to preserve as much as possible) and we also avoid any escaping/unescaping of HTML entity codes.

property parseOptions

parseOptions?: HandlebarsParseOptions;

property plugins

plugins?: {
    ast?: ASTPluginBuilder[];
};

property strictMode

strictMode?: boolean;

method customizeComponentName

customizeComponentName: (input: string) => string;

interface Syntax

interface Syntax {}

property builders

builders: typeof publicBuilder;

property parse

parse: typeof preprocess;

property print

print: typeof print;

property traverse

traverse: typeof traverse;

property Walker

Walker: typeof Walker;

interface TemplateIdFn

interface TemplateIdFn {}

call signature

(src: string): Option<string>;

Type Aliases

type HasSourceSpan

type HasSourceSpan =
    | {
          loc: SourceSpan;
      }
    | SourceSpan
    | [HasSourceSpan, ...HasSourceSpan[]];

type KeywordType

type KeywordType = 'Call' | 'Modifier' | 'Append' | 'Block';

type MaybeHasSourceSpan

type MaybeHasSourceSpan =
    | {
          loc: SourceSpan;
      }
    | SourceSpan
    | MaybeHasSourceSpan[];

type NodeVisitor

type NodeVisitor = {
    [P in keyof ASTv1.Nodes]?: NodeTraversal<ASTv1.Nodes[P]>;
} & {
    All?: NodeTraversal<ASTv1.Node>;
};

Namespaces

namespace AST

module 'dist/types/lib/v1/api.d.ts' {}

interface AtHead

interface AtHead {}

property loc

loc: SourceLocation;

property name

name: string;

property type

type: 'AtHead';

interface AttrNode

interface AttrNode extends BaseNode {}

property name

name: string;

property type

type: 'AttrNode';

property value

value: TextNode | MustacheStatement | ConcatStatement;

interface BaseNode

interface BaseNode {}

property loc

loc: SourceSpan;

property type

type: NodeType;

interface Block

interface Block extends CommonProgram {}

property type

type: 'Block';

interface BlockStatement

interface BlockStatement extends BaseNode {}

property chained

chained?: boolean;

property closeStrip

closeStrip: StripFlags;

property hash

hash: Hash;

property inverse

inverse?: Option<Block>;

property inverseStrip

inverseStrip: StripFlags;

property openStrip

openStrip: StripFlags;

property params

params: Expression[];

property path

path: Expression;

property program

program: Block;

property type

type: 'BlockStatement';

interface BlockSymbols

interface BlockSymbols extends Symbols {}

property slots

slots: number[];

interface BooleanLiteral

interface BooleanLiteral extends BaseNode {}

property original

original: boolean;

property type

type: 'BooleanLiteral';

property value

value: boolean;

interface Call

interface Call extends BaseNode {}

property hash

hash: Hash;

property name

name?: Expression;

property params

params: Expression[];

property path

path: Expression;

interface CallParts

interface CallParts {}

property hash

hash: Hash;

property params

params: Expression[];

property path

path: Expression;

interface CommentStatement

interface CommentStatement extends BaseNode {}

property type

type: 'CommentStatement';

property value

value: string;

interface CommonProgram

interface CommonProgram extends BaseNode {}

property blockParams

blockParams: string[];

property body

body: Statement[];

property chained

chained?: boolean;

interface ConcatStatement

interface ConcatStatement extends BaseNode {}

property parts

parts: PresentArray<TextNode | MustacheStatement>;

property type

type: 'ConcatStatement';

interface ElementModifierStatement

interface ElementModifierStatement extends BaseNode {}

property hash

hash: Hash;

property params

params: Expression[];

property path

path: Expression;

property type

type: 'ElementModifierStatement';

interface ElementName

interface ElementName {}

property loc

loc: SourceLocation;

property name

name: string;

property type

type: 'ElementName';

interface ElementNode

interface ElementNode extends BaseNode {}

property attributes

attributes: AttrNode[];

property blockParams

blockParams: string[];

property children

children: Statement[];

property comments

comments: MustacheCommentStatement[];

property modifiers

modifiers: ElementModifierStatement[];

property selfClosing

selfClosing: boolean;

property tag

tag: string;

property type

type: 'ElementNode';

interface FreeVarHead

interface FreeVarHead {}

property loc

loc: SourceLocation;

property name

name: string;

property type

type: 'FreeVarHead';

interface Hash

interface Hash extends BaseNode {}

property pairs

pairs: HashPair[];

property type

type: 'Hash';

interface HashPair

interface HashPair extends BaseNode {}

property key

key: string;

property type

type: 'HashPair';

property value

value: Expression;

interface LocalVarHead

interface LocalVarHead {}

property loc

loc: SourceLocation;

property name

name: string;

property type

type: 'LocalVarHead';

interface MinimalPathExpression

interface MinimalPathExpression extends BaseNode {}

property head

head: PathHead;

property tail

tail: string[];

property type

type: 'PathExpression';

interface MustacheCommentStatement

interface MustacheCommentStatement extends BaseNode {}

property type

type: 'MustacheCommentStatement';

property value

value: string;

interface MustacheStatement

interface MustacheStatement extends BaseNode {}

property escaped

escaped: boolean;

Deprecated

property hash

hash: Hash;

property params

params: Expression[];

property path

path: Expression;

property strip

strip: StripFlags;

property trusting

trusting: boolean;

property type

type: 'MustacheStatement';

interface NamedBlockName

interface NamedBlockName {}

property loc

loc: SourceLocation;

property name

name: string;

property type

type: 'NamedBlockName';

interface NullLiteral

interface NullLiteral extends BaseNode {}

property original

original: null;

property type

type: 'NullLiteral';

property value

value: null;

interface NumberLiteral

interface NumberLiteral extends BaseNode {}

property original

original: number;

property type

type: 'NumberLiteral';

property value

value: number;

interface PartialStatement

interface PartialStatement extends BaseNode {}

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 MinimalPathExpression {}

property data

data: boolean;

Deprecated
use `head.type' instead

property head

head: PathHead;

property original

original: string;

property parts

parts: string[];

Deprecated
use head and tail instead

property tail

tail: string[];

property this

this: boolean;

Deprecated
use head.type instead

property type

type: 'PathExpression';

interface Position

interface SourcePosition {}

property column

column: number;

>= 0

property line

line: number;

>= 1

interface Program

interface Program extends CommonProgram {}

property symbols

symbols?: Symbols;

property type

type: 'Program';

interface ProgramSymbols

interface ProgramSymbols extends Symbols {}

property freeVariables

freeVariables: string[];

interface SourceLocation

interface SourceLocation {}

property end

end: SourcePosition;

property start

start: SourcePosition;

interface SourcePosition

interface SourcePosition {}

property column

column: number;

>= 0

property line

line: number;

>= 1

interface StringLiteral

interface StringLiteral extends BaseNode {}

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 Call {}

property hash

hash: Hash;

property params

params: Expression[];

property path

path: Expression;

property type

type: 'SubExpression';

interface Symbols

interface Symbols {}

property symbols

symbols: string[];

method allocate

allocate: (identifier: string) => number;

method allocateBlock

allocateBlock: (name: string) => number;

method allocateFree

allocateFree: (name: string) => number;

method allocateNamed

allocateNamed: (name: string) => number;

method child

child: (locals: string[]) => BlockSymbols;

method get

get: (name: string) => number;

method getEvalInfo

getEvalInfo: () => WireFormat.Core.EvalInfo;

method getLocalsMap

getLocalsMap: () => Dict<number>;

method has

has: (name: string) => boolean;

interface Template

interface Template extends CommonProgram {}

property type

type: 'Template';

interface TextNode

interface TextNode extends BaseNode {}

property chars

chars: string;

property type

type: 'TextNode';

interface ThisHead

interface ThisHead {}

property loc

loc: SourceLocation;

property type

type: 'ThisHead';

interface UndefinedLiteral

interface UndefinedLiteral extends BaseNode {}

property original

original: undefined;

property type

type: 'UndefinedLiteral';

property value

value: undefined;

interface VarHead

interface VarHead {}

property loc

loc: SourceLocation;

property name

name: string;

property type

type: 'VarHead';

type AttrValue

type AttrValue = TextNode | MustacheStatement | ConcatStatement;

type CallNode

type CallNode =
    | MustacheStatement
    | BlockStatement
    | ElementModifierStatement
    | SubExpression;

type EntityEncodingState

type EntityEncodingState = 'transformed' | 'raw';

type Expression

type Expression = Nodes[ExpressionName];

type ExpressionName

type ExpressionName = 'SubExpression' | 'PathExpression' | LiteralName;

type Expressions

type Expressions = Pick<Nodes, ExpressionName>;

type Literal

type Literal = Nodes[LiteralName];

type LiteralName

type LiteralName =
    | 'StringLiteral'
    | 'BooleanLiteral'
    | 'NumberLiteral'
    | 'UndefinedLiteral'
    | 'NullLiteral';

type Node

type Node = Nodes[NodeType];

type Nodes

type Nodes = SharedNodes & {
    Program: Program;
    Template: Template;
    Block: Block;
    BlockStatement: BlockStatement;
    ElementNode: ElementNode;
    SubExpression: SubExpression;
    PathExpression: PathExpression;
    Hash: Hash;
    HashPair: HashPair;
};

type NodeType

type NodeType = keyof Nodes;

type PathHead

type PathHead = ThisHead | AtHead | VarHead;

type PossiblyDeprecatedBlock

type PossiblyDeprecatedBlock = Block | Template;

type SharedNodes

type SharedNodes = {
    CommentStatement: CommentStatement;
    MustacheCommentStatement: MustacheCommentStatement;
    TextNode: TextNode;
    StringLiteral: StringLiteral;
    BooleanLiteral: BooleanLiteral;
    NumberLiteral: NumberLiteral;
    NullLiteral: NullLiteral;
    UndefinedLiteral: UndefinedLiteral;
    MustacheStatement: MustacheStatement;
    ElementModifierStatement: ElementModifierStatement;
    PartialStatement: PartialStatement;
    AttrNode: AttrNode;
    ConcatStatement: ConcatStatement;
};

type Statement

type Statement = Nodes[StatementName];

type StatementName

type StatementName =
    | 'MustacheStatement'
    | 'CommentStatement'
    | 'BlockStatement'
    | 'PartialStatement'
    | 'MustacheCommentStatement'
    | 'TextNode'
    | 'ElementNode';

type Statements

type Statements = Pick<Nodes, StatementName>;

type TopLevelStatement

type TopLevelStatement = Statement | Nodes['Block'];

namespace ASTv1

module 'dist/types/lib/v1/api.d.ts' {}

interface AtHead

interface AtHead {}

property loc

loc: SourceLocation;

property name

name: string;

property type

type: 'AtHead';

interface AttrNode

interface AttrNode extends BaseNode {}

property name

name: string;

property type

type: 'AttrNode';

property value

value: TextNode | MustacheStatement | ConcatStatement;

interface BaseNode

interface BaseNode {}

property loc

loc: SourceSpan;

property type

type: NodeType;

interface Block

interface Block extends CommonProgram {}

property type

type: 'Block';

interface BlockStatement

interface BlockStatement extends BaseNode {}

property chained

chained?: boolean;

property closeStrip

closeStrip: StripFlags;

property hash

hash: Hash;

property inverse

inverse?: Option<Block>;

property inverseStrip

inverseStrip: StripFlags;

property openStrip

openStrip: StripFlags;

property params

params: Expression[];

property path

path: Expression;

property program

program: Block;

property type

type: 'BlockStatement';

interface BlockSymbols

interface BlockSymbols extends Symbols {}

property slots

slots: number[];

interface BooleanLiteral

interface BooleanLiteral extends BaseNode {}

property original

original: boolean;

property type

type: 'BooleanLiteral';

property value

value: boolean;

interface Call

interface Call extends BaseNode {}

property hash

hash: Hash;

property name

name?: Expression;

property params

params: Expression[];

property path

path: Expression;

interface CallParts

interface CallParts {}

property hash

hash: Hash;

property params

params: Expression[];

property path

path: Expression;

interface CommentStatement

interface CommentStatement extends BaseNode {}

property type

type: 'CommentStatement';

property value

value: string;

interface CommonProgram

interface CommonProgram extends BaseNode {}

property blockParams

blockParams: string[];

property body

body: Statement[];

property chained

chained?: boolean;

interface ConcatStatement

interface ConcatStatement extends BaseNode {}

property parts

parts: PresentArray<TextNode | MustacheStatement>;

property type

type: 'ConcatStatement';

interface ElementModifierStatement

interface ElementModifierStatement extends BaseNode {}

property hash

hash: Hash;

property params

params: Expression[];

property path

path: Expression;

property type

type: 'ElementModifierStatement';

interface ElementName

interface ElementName {}

property loc

loc: SourceLocation;

property name

name: string;

property type

type: 'ElementName';

interface ElementNode

interface ElementNode extends BaseNode {}

property attributes

attributes: AttrNode[];

property blockParams

blockParams: string[];

property children

children: Statement[];

property comments

comments: MustacheCommentStatement[];

property modifiers

modifiers: ElementModifierStatement[];

property selfClosing

selfClosing: boolean;

property tag

tag: string;

property type

type: 'ElementNode';

interface FreeVarHead

interface FreeVarHead {}

property loc

loc: SourceLocation;

property name

name: string;

property type

type: 'FreeVarHead';

interface Hash

interface Hash extends BaseNode {}

property pairs

pairs: HashPair[];

property type

type: 'Hash';

interface HashPair

interface HashPair extends BaseNode {}

property key

key: string;

property type

type: 'HashPair';

property value

value: Expression;

interface LocalVarHead

interface LocalVarHead {}

property loc

loc: SourceLocation;

property name

name: string;

property type

type: 'LocalVarHead';

interface MinimalPathExpression

interface MinimalPathExpression extends BaseNode {}

property head

head: PathHead;

property tail

tail: string[];

property type

type: 'PathExpression';

interface MustacheCommentStatement

interface MustacheCommentStatement extends BaseNode {}

property type

type: 'MustacheCommentStatement';

property value

value: string;

interface MustacheStatement

interface MustacheStatement extends BaseNode {}

property escaped

escaped: boolean;

Deprecated

property hash

hash: Hash;

property params

params: Expression[];

property path

path: Expression;

property strip

strip: StripFlags;

property trusting

trusting: boolean;

property type

type: 'MustacheStatement';

interface NamedBlockName

interface NamedBlockName {}

property loc

loc: SourceLocation;

property name

name: string;

property type

type: 'NamedBlockName';

interface NullLiteral

interface NullLiteral extends BaseNode {}

property original

original: null;

property type

type: 'NullLiteral';

property value

value: null;

interface NumberLiteral

interface NumberLiteral extends BaseNode {}

property original

original: number;

property type

type: 'NumberLiteral';

property value

value: number;

interface PartialStatement

interface PartialStatement extends BaseNode {}

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 MinimalPathExpression {}

property data

data: boolean;

Deprecated
use `head.type' instead

property head

head: PathHead;

property original

original: string;

property parts

parts: string[];

Deprecated
use head and tail instead

property tail

tail: string[];

property this

this: boolean;

Deprecated
use head.type instead

property type

type: 'PathExpression';

interface Position

interface SourcePosition {}

property column

column: number;

>= 0

property line

line: number;

>= 1

interface Program

interface Program extends CommonProgram {}

property symbols

symbols?: Symbols;

property type

type: 'Program';

interface ProgramSymbols

interface ProgramSymbols extends Symbols {}

property freeVariables

freeVariables: string[];

interface SourceLocation

interface SourceLocation {}

property end

end: SourcePosition;

property start

start: SourcePosition;

interface SourcePosition

interface SourcePosition {}

property column

column: number;

>= 0

property line

line: number;

>= 1

interface StringLiteral

interface StringLiteral extends BaseNode {}

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 Call {}

property hash

hash: Hash;

property params

params: Expression[];

property path

path: Expression;

property type

type: 'SubExpression';

interface Symbols

interface Symbols {}

property symbols

symbols: string[];

method allocate

allocate: (identifier: string) => number;

method allocateBlock

allocateBlock: (name: string) => number;

method allocateFree

allocateFree: (name: string) => number;

method allocateNamed

allocateNamed: (name: string) => number;

method child

child: (locals: string[]) => BlockSymbols;

method get

get: (name: string) => number;

method getEvalInfo

getEvalInfo: () => WireFormat.Core.EvalInfo;

method getLocalsMap

getLocalsMap: () => Dict<number>;

method has

has: (name: string) => boolean;

interface Template

interface Template extends CommonProgram {}

property type

type: 'Template';

interface TextNode

interface TextNode extends BaseNode {}

property chars

chars: string;

property type

type: 'TextNode';

interface ThisHead

interface ThisHead {}

property loc

loc: SourceLocation;

property type

type: 'ThisHead';

interface UndefinedLiteral

interface UndefinedLiteral extends BaseNode {}

property original

original: undefined;

property type

type: 'UndefinedLiteral';

property value

value: undefined;

interface VarHead

interface VarHead {}

property loc

loc: SourceLocation;

property name

name: string;

property type

type: 'VarHead';

type AttrValue

type AttrValue = TextNode | MustacheStatement | ConcatStatement;

type CallNode

type CallNode =
    | MustacheStatement
    | BlockStatement
    | ElementModifierStatement
    | SubExpression;

type EntityEncodingState

type EntityEncodingState = 'transformed' | 'raw';

type Expression

type Expression = Nodes[ExpressionName];

type ExpressionName

type ExpressionName = 'SubExpression' | 'PathExpression' | LiteralName;

type Expressions

type Expressions = Pick<Nodes, ExpressionName>;

type Literal

type Literal = Nodes[LiteralName];

type LiteralName

type LiteralName =
    | 'StringLiteral'
    | 'BooleanLiteral'
    | 'NumberLiteral'
    | 'UndefinedLiteral'
    | 'NullLiteral';

type Node

type Node = Nodes[NodeType];

type Nodes

type Nodes = SharedNodes & {
    Program: Program;
    Template: Template;
    Block: Block;
    BlockStatement: BlockStatement;
    ElementNode: ElementNode;
    SubExpression: SubExpression;
    PathExpression: PathExpression;
    Hash: Hash;
    HashPair: HashPair;
};

type NodeType

type NodeType = keyof Nodes;

type PathHead

type PathHead = ThisHead | AtHead | VarHead;

type PossiblyDeprecatedBlock

type PossiblyDeprecatedBlock = Block | Template;

type SharedNodes

type SharedNodes = {
    CommentStatement: CommentStatement;
    MustacheCommentStatement: MustacheCommentStatement;
    TextNode: TextNode;
    StringLiteral: StringLiteral;
    BooleanLiteral: BooleanLiteral;
    NumberLiteral: NumberLiteral;
    NullLiteral: NullLiteral;
    UndefinedLiteral: UndefinedLiteral;
    MustacheStatement: MustacheStatement;
    ElementModifierStatement: ElementModifierStatement;
    PartialStatement: PartialStatement;
    AttrNode: AttrNode;
    ConcatStatement: ConcatStatement;
};

type Statement

type Statement = Nodes[StatementName];

type StatementName

type StatementName =
    | 'MustacheStatement'
    | 'CommentStatement'
    | 'BlockStatement'
    | 'PartialStatement'
    | 'MustacheCommentStatement'
    | 'TextNode'
    | 'ElementNode';

type Statements

type Statements = Pick<Nodes, StatementName>;

type TopLevelStatement

type TopLevelStatement = Statement | Nodes['Block'];

namespace ASTv2

module 'dist/types/lib/v2-a/api.d.ts' {}

variable ARGUMENT_RESOLUTION

const ARGUMENT_RESOLUTION: LooseModeResolution;

variable STRICT_RESOLUTION

const STRICT_RESOLUTION: StrictResolution;

function isLiteral

isLiteral: <K extends keyof LiteralTypes = keyof LiteralTypes>(
    node: ExpressionNode,
    kind?: K
) => node is StringLiteral;

Returns true if an input is a literal.

function loadResolution

loadResolution: (resolution: SerializedResolution) => FreeVarResolution;

function node

node: {
    (): {
        fields<Fields extends object>(): NodeConstructor<Fields & BaseNodeFields>;
    };
    <T extends string>(name: T): {
        fields<Fields extends object>(): TypedNodeConstructor<
            T,
            Fields & BaseNodeFields
        >;
    };
};

This is a convenience function for creating ASTv2 nodes, with an optional name and the node's options.
export class HtmlText extends node('HtmlText').fields<{ chars: string }>() {}
This creates a new ASTv2 node with the name 'HtmlText' and one field chars: string (in addition to a loc: SourceOffsets field, which all nodes have).
export class Args extends node().fields<{ positional: PositionalArguments; named: NamedArguments }>() {}
This creates a new un-named ASTv2 node with two fields (positional: Positional and `named: Named, in addition to the generic loc: SourceOffsets` field).
Once you create a node using node, it is instantiated with all of its fields (including loc):
new HtmlText({ loc: offsets, chars: someString });

class AppendContent

class AppendContent extends AppendContent_base {}

property args

readonly args: Args;

property callee

readonly callee: ExpressionNode;

class ArgReference

class ArgReference extends ArgReference_base {}

Corresponds to @<ident> at the beginning of an expression.

class Args

class Args extends Args_base {}

Corresponds to syntaxes with positional and named arguments:
- SubExpression - Invoking Append - Invoking attributes - InvokeBlock
If Args is empty, the SourceOffsets for this node should be the collapsed position immediately after the parent call node's callee.

method empty

static empty: (loc: SourceSpan) => Args;

method get

get: (name: string) => ExpressionNode | null;

method isEmpty

isEmpty: () => boolean;

method named

static named: (named: NamedArguments) => Args;

method nth

nth: (offset: number) => ExpressionNode | null;

class Block

class Block extends Block_base {}

Represents a block. In principle this could be merged with NamedBlock, because all cases involving blocks have at least a notional name.

class CallExpression

class CallExpression extends CallExpression_base {}

Corresponds to a parenthesized call expression.
(x) (x.y) (x y) (x.y z)

class ComponentArg

class ComponentArg extends ComponentArg_base {}

Corresponds to an argument passed by a component (@x=<value>)

method toNamedArgument

toNamedArgument: () => NamedArgument;

Convert the component argument into a named argument node

class DeprecatedCallExpression

class DeprecatedCallExpression extends DeprecatedCallExpression_base {}

Corresponds to a possible deprecated helper call. Must be:
1. A free variable (not this.foo, not @foo, not local). 2. Argument-less. 3. In a component invocation's named argument position. 4. Not parenthesized (not @bar={{(helper)}}). 5. Not interpolated (not @bar="{{helper}}").
<Foo @bar={{helper}} />

class ElementModifier

class ElementModifier extends ElementModifier_base {}

An ElementModifier is just a normal call node in modifier position.

class FreeVarReference

class FreeVarReference extends FreeVarReference_base {}

Corresponds to <ident> at the beginning of an expression, when <ident> is *not* in the current block's scope.
The resolution: FreeVarResolution field describes how to resolve the free variable.
Note: In strict mode, it must always be a variable that is in a concrete JavaScript scope that the template will be installed into.

class GlimmerComment

class GlimmerComment extends GlimmerComment_base {}

class HtmlAttr

class HtmlAttr extends HtmlAttr_base {}

HtmlAttr nodes are valid HTML attributes, with or without a value.
Exceptions:
- ...attributes is SplatAttr - @x=<value> is ComponentArg

class HtmlComment

class HtmlComment extends HtmlComment_base {}

class HtmlText

class HtmlText extends HtmlText_base {}

class InterpolateExpression

class InterpolateExpression extends InterpolateExpression_base {}

Corresponds to an interpolation in attribute value position.
<a href="{{url}}.html"

class InvokeBlock

class InvokeBlock extends InvokeBlock_base {}

class InvokeComponent

class InvokeComponent extends InvokeComponent_base {}

Corresponds to a component invocation. When the content of a component invocation contains no named blocks, blocks contains a single named block named "default". When a component invocation is self-closing, blocks is empty.

property args

readonly args: Args;

class LiteralExpression

class LiteralExpression extends LiteralExpression_base {}

Corresponds to a Handlebars literal.
See Also
- {LiteralValue}

method toSlice

toSlice: (this: StringLiteral) => SourceSlice;

class LocalVarReference

class LocalVarReference extends LocalVarReference_base {}

Corresponds to <ident> at the beginning of an expression, when <ident> is in the current block's scope.

class LooseModeResolution

class LooseModeResolution {}

A LooseModeResolution includes:
- 0 or more namespaces to resolve the variable in - optional fallback behavior
In practice, there are a limited number of possible combinations of these degrees of freedom, and they are captured by the Ambiguity union below.

constructor

constructor(ambiguity: Ambiguity, isAngleBracket?: boolean);

property ambiguity

readonly ambiguity: Ambiguity;

property isAngleBracket

readonly isAngleBracket: boolean;

method append

static append: ({ invoke }: { invoke: boolean }) => LooseModeResolution;

Append resolution is used when the variable should be resolved in both the component and helper namespaces. Fallback resolution is optional.
{{x}}
^ x should be resolved in the component and helper namespaces with fallback resolution.
{{x y}}
^ x should be resolved in the component and helper namespaces without fallback resolution.
See Also
- {ComponentOrHelperAmbiguity}

method attr

static attr: () => LooseModeResolution;

Attribute resolution is used when the variable should be resolved as a helper with fallback resolution.
<a href={{x}} /> <a href="{{x}}.html" />
^ resolved in the helper namespace with fallback
See Also
- {HelperAmbiguity}

method fallback

static fallback: () => LooseModeResolution;

Fallback resolution is used when no namespaced resolutions are possible, but fallback resolution is still allowed.
{{x.y}}
See Also
- {FallbackAmbiguity}

method namespaced

static namespaced: (
    namespace: FreeVarNamespace,
    isAngleBracket?: boolean
) => LooseModeResolution;

Namespaced resolution is used in an unambiguous syntax position:
1. (sexp) (namespace: Helper) 2. {{#block}} (namespace: Component) 3. <a {{modifier}}> (namespace: Modifier) 4. <Component /> (namespace: Component)
See Also
- {NamespacedAmbiguity}

method resolution

resolution: () => GetContextualFreeOp;

method serialize

serialize: () => SerializedResolution;

method trustingAppend

static trustingAppend: ({ invoke }: { invoke: boolean }) => LooseModeResolution;

Trusting append resolution is used when the variable should be resolved in both the component and helper namespaces. Fallback resolution is optional.
{{{x}}}
^ x should be resolved in the component and helper namespaces with fallback resolution.
{{{x y}}}
^ x should be resolved in the component and helper namespaces without fallback resolution.
See Also
- {HelperAmbiguity}

class NamedArgument

class NamedArgument {}

Corresponds to a single named argument.
x=<expr>

constructor

constructor(options: { name: SourceSlice; value: ExpressionNode });

property loc

readonly loc: SourceSpan;

property name

readonly name: SourceSlice<string>;

property value

readonly value: ExpressionNode;

class NamedArguments

class NamedArguments extends NamedArguments_base {}

Corresponds to named arguments.
If PositionalArguments and NamedArguments are empty, the SourceOffsets for this node should be the same as the Args node that contains this node.
If PositionalArguments is not empty but NamedArguments is empty, the SourceOffsets for this node should be the collapsed position immediately after the last positional argument.

property size

readonly size: number;

method empty

static empty: (loc: SourceSpan) => NamedArguments;

method get

get: (name: string) => ExpressionNode | null;

method isEmpty

isEmpty: () => boolean;

class NamedBlock

class NamedBlock extends NamedBlock_base {}

Corresponds to a single named block. This is used for anonymous named blocks (default and else).

property args

readonly args: Args;

class NamedBlocks

class NamedBlocks extends NamedBlocks_base {}

Corresponds to a collection of named blocks.

method get

get: { (name: 'default'): NamedBlock; (name: string): NamedBlock };

Get the NamedBlock for a given name.

class PathExpression

class PathExpression extends PathExpression_base {}

Corresponds to a path in expression position.
this this.x @x @x.y x x.y

class PositionalArguments

class PositionalArguments extends PositionalArguments_base {}

Corresponds to positional arguments.
If PositionalArguments is empty, the SourceOffsets for this node should be the collapsed position immediately after the parent call node's callee.

property size

readonly size: number;

method empty

static empty: (loc: SourceSpan) => PositionalArguments;

method isEmpty

isEmpty: () => boolean;

method nth

nth: (offset: number) => ExpressionNode | null;

class SimpleElement

class SimpleElement extends SimpleElement_base {}

Corresponds to a simple HTML element. The AST allows component arguments and modifiers to support future extensions.

property args

readonly args: Args;

class SplatAttr

class SplatAttr extends SplatAttr_base {}

class StrictResolution

class StrictResolution {}

Strict resolution is used:
1. in a strict mode template 2. in an unambiguous invocation with dot paths

property isAngleBracket

readonly isAngleBracket: boolean;

method resolution

resolution: () => GetContextualFreeOp;

method serialize

serialize: () => SerializedResolution;

class Template

class Template extends Template_base {}

Corresponds to an entire template.

class ThisReference

class ThisReference extends ThisReference_base {}

Corresponds to this at the head of an expression.

interface AttrNodeOptions

interface AttrNodeOptions {}

property name

name: SourceSlice;

property trusting

trusting: boolean;

property value

value: ExpressionNode;

interface BaseNodeFields

interface BaseNodeFields {}

property loc

loc: SourceSpan;

interface CallFields

interface CallFields extends BaseNodeFields {}

property args

args: Args;

property callee

callee: ExpressionNode;

interface GlimmerParentNodeOptions

interface GlimmerParentNodeOptions extends BaseNodeFields {}

property body

body: readonly ContentNode[];

interface LiteralTypes

interface LiteralTypes {}

property boolean

boolean: boolean;

property null

null: null;

property number

number: number;

property string

string: string;

property undefined

undefined: undefined;

interface NamedBlockFields

interface NamedBlockFields extends BaseNodeFields {}

property attrs

attrs: readonly HtmlOrSplatAttr[];

property block

block: Block;