Use the {{array}} helper to create an array to pass as an option to your components.
```handlebars <MyComponent @people={{array 'Tom Dale' 'Yehuda Katz' this.myOtherPerson}} /> ``` or ```handlebars {{my-component people=(array 'Tom Dale' 'Yehuda Katz' this.myOtherPerson) }} ```
Would result in an object such as:
```js ['Tom Dale', 'Yehuda Katz', this.get('myOtherPerson')] ```
Where the 3rd item in the array is bound to updates of the myOtherPerson property.
array
Parameter options
{Array} Array
Modifiers
- @public

variable concat

const concat: {};

Concatenates the given arguments into a string.
Example:
```handlebars {{some-component name=(concat firstName " " lastName)}}
{{! would pass name="<first name value> <last name value>" to the component}} ```
or for angle bracket invocation, you actually don't need concat at all.
```handlebars <SomeComponent @name="{{firstName}} {{lastName}}" /> ```
concat
Modifiers
- @public

variable CONSTANTS

const CONSTANTS: Symbol;

variable CURSOR_STACK

const CURSOR_STACK: CursorStackSymbol;

variable DESTROYABLE_STACK

const DESTROYABLE_STACK: Symbol;

variable DOMChanges

const DOMChanges: typeof DOMChangesImpl;

variable DOMTreeConstruction

const DOMTreeConstruction: typeof TreeConstruction;

variable EMPTY_ARGS

const EMPTY_ARGS: CapturedArguments;

variable EMPTY_NAMED

const EMPTY_NAMED: CapturedNamedArguments;

variable EMPTY_POSITIONAL

const EMPTY_POSITIONAL: CapturedPositionalArguments;

variable fn

const fn: {};

The fn helper allows you to ensure a function that you are passing off to another component, helper, or modifier has access to arguments that are available in the template.
For example, if you have an each helper looping over a number of items, you may need to pass a function that expects to receive the item as an argument to a component invoked within the loop. Here's how you could use the fn helper to pass both the function and its arguments together:
```app/templates/components/items-listing.hbs {{#each as |item|}} <DisplayItem @item=item @select={{fn this.handleSelected item}} /> {{/each}} ```
```app/components/items-list.js import Component from '@glimmer/component'; import { action } from '@ember/object';
export default class ItemsList extends Component { handleSelected = (item) => { // ...snip... } } ```
In this case the display-item component will receive a normal function that it can invoke. When it invokes the function, the handleSelected function will receive the item and any arguments passed, thanks to the fn helper.
Let's take look at what that means in a couple circumstances:
- When invoked as this.args.select() the handleSelected function will receive the item from the loop as its first and only argument. - When invoked as this.args.select('foo') the handleSelected function will receive the item from the loop as its first argument and the string 'foo' as its second argument.
In the example above, we used an arrow function to ensure that handleSelected is properly bound to the items-list, but let's explore what happens if we left out the arrow function:
```app/components/items-list.js import Component from '@glimmer/component';
export default class ItemsList extends Component { handleSelected(item) { // ...snip... } } ```
In this example, when handleSelected is invoked inside the display-item component, it will **not** have access to the component instance. In other words, it will have no this context, so please make sure your functions are bound (via an arrow function or other means) before passing into fn!
See also [partial application](https://en.wikipedia.org/wiki/Partial_application).
fn
Modifiers
- @public

variable get

const get: {};

Dynamically look up a property on an object. The second argument to {{get}} should have a string value, although it can be bound.
For example, these two usages are equivalent:
```app/components/developer-detail.js import Component from '@glimmer/component'; import { tracked } from '@glimmer/tracking';
export default class extends Component { developer = { name: "Sandi Metz", language: "Ruby" } } ```
```handlebars {{this.developer.name}} {{get this.developer "name"}} ```
If there were several facts about a person, the {{get}} helper can dynamically pick one:
```app/templates/application.hbs <DeveloperDetail @factName="language" /> ```
```handlebars {{get this.developer @factName}} ```
For a more complex example, this template would allow the user to switch between showing the user's height and weight with a click:
```app/components/developer-detail.js import Component from '@glimmer/component'; import { tracked } from '@glimmer/tracking';
export default class extends Component { developer = { name: "Sandi Metz", language: "Ruby" }
currentFact = 'name'
showFact = (fact) => { this.currentFact = fact; } } ```
```app/components/developer-detail.js {{get this.developer this.currentFact}}
<button {{on 'click' (fn this.showFact "name")}}>Show name <button {{on 'click' (fn this.showFact "language")}}>Show language ```
The {{get}} helper can also respect mutable values itself. For example:
```app/components/developer-detail.js <Input @value={{mut (get this.person this.currentFact)}} />
<button {{on 'click' (fn this.showFact "name")}}>Show name <button {{on 'click' (fn this.showFact "language")}}>Show language ```
Would allow the user to swap what fact is being displayed, and also edit that fact via a two-way mutable binding.
get
Modifiers
- @public

variable hash

const hash: {};

Use the {{hash}} helper to create a hash to pass as an option to your components. This is specially useful for contextual components where you can just yield a hash:
```handlebars {{yield (hash name='Sarah' title=office )}} ```
Would result in an object such as:
```js { name: 'Sarah', title: this.get('office') } ```
Where the title is bound to updates of the office property.
Note that the hash is an empty object with no prototype chain, therefore common methods like toString are not available in the resulting hash. If you need to use such a method, you can use the call or apply approach:
```js function toString(obj) { return Object.prototype.toString.apply(obj); } ```
hash
Parameter options
{Object} Hash
Modifiers
- @public

variable HEAP

const HEAP: Symbol;

variable INNER

const INNER: Symbol;

variable INNER_VM

const INNER_VM: Symbol;

variable on

const on: {};

variable OWNER

const OWNER: Symbol;

variable REGISTERS

const REGISTERS: Symbol;

variable RESOLVED

const RESOLVED: Symbol;

variable SERIALIZATION_FIRST_NODE_STRING

const SERIALIZATION_FIRST_NODE_STRING: string;

variable STACKS

const STACKS: Symbol;

variable TEMPLATE_ONLY_COMPONENT_MANAGER

const TEMPLATE_ONLY_COMPONENT_MANAGER: TemplateOnlyComponentManager;

variable TRANSACTION

const TRANSACTION: TransactionSymbol;

variable TYPE

const TYPE: Symbol;

Functions

function clear

clear: (bounds: Bounds) => Nullable<SimpleNode>;

function clientBuilder

clientBuilder: (env: Environment, cursor: CursorImpl) => ElementBuilder;

function createCapturedArgs

createCapturedArgs: (
    named: Dict<Reference>,
    positional: Reference[]
) => CapturedArguments;

function curry

curry: <T extends CurriedType>(
    type: T,
    spec: object | string | CurriedValue<T>,
    owner: Owner,
    args: CapturedArguments | null,
    resolved?: boolean
) => CurriedValue<T>;

function dynamicAttribute

dynamicAttribute: (
    element: SimpleElement,
    attr: string,
    namespace: Nullable<AttrNamespace>,
    isTrusting?: boolean
) => DynamicAttribute;

function inTransaction

inTransaction: (env: Environment, block: () => void) => void;

function invokeHelper

invokeHelper: (
    context: object,
    definition: object,
    computeArgs?: (context: object) => Arguments
) => Cache<unknown>;

function isSerializationFirstNode

isSerializationFirstNode: (node: SimpleNode) => boolean;

function isWhitespace

isWhitespace: (string: string) => boolean;

function normalizeProperty

normalizeProperty: (
    element: SimpleElement,
    slotName: string
) => { normalized: any; type: any };

function rehydrationBuilder

rehydrationBuilder: (env: Environment, cursor: CursorImpl) => ElementBuilder;

function reifyArgs

reifyArgs: (args: CapturedArguments) => {
    named: Dict<unknown>;
    positional: unknown[];
};

function reifyNamed

reifyNamed: (named: CapturedNamedArguments) => Dict<unknown>;

function reifyPositional

reifyPositional: (positional: CapturedPositionalArguments) => unknown[];

function renderComponent

renderComponent: (
    runtime: RuntimeContext,
    treeBuilder: ElementBuilder,
    context: CompileTimeCompilationContext,
    owner: Owner,
    definition: ComponentDefinitionState,
    args?: Record<string, unknown>,
    dynamicScope?: DynamicScope
) => TemplateIterator;

function renderMain

renderMain: (
    runtime: RuntimeContext,
    context: CompileTimeCompilationContext,
    owner: Owner,
    self: Reference,
    treeBuilder: ElementBuilder,
    layout: CompilableProgram,
    dynamicScope?: DynamicScope
) => TemplateIterator;

function renderSync

renderSync: (env: Environment, iterator: TemplateIterator) => RenderResult;

function resetDebuggerCallback

resetDebuggerCallback: () => void;

function runtimeContext

runtimeContext: (
    options: EnvironmentOptions,
    delegate: EnvironmentDelegate,
    artifacts: RuntimeArtifacts,
    resolver: RuntimeResolver
) => RuntimeContext;

function setDebuggerCallback

setDebuggerCallback: (cb: DebugCallback) => void;

function templateOnlyComponent

templateOnlyComponent: (
    moduleName?: string,
    name?: string
) => TemplateOnlyComponentDefinition;

This utility function is used to declare a given component has no backing class. When the rendering engine detects this it is able to perform a number of optimizations. Templates that are associated with templateOnly() will be rendered _as is_ without adding a wrapping <div> (or any of the other element customization behaviors of [@ember/component](/ember/release/classes/Component)). Specifically, this means that the template will be rendered as "outer HTML".
In general, this method will be used by build time tooling and would not be directly written in an application. However, at times it may be useful to use directly to leverage the "outer HTML" semantics mentioned above. For example, if an addon would like to use these semantics for its templates but cannot be certain it will only be consumed by applications that have enabled the template-only-glimmer-components optional feature.
Parameter moduleName
the module name that the template only component represents, this will be used for debugging purposes EMBER_GLIMMER_SET_COMPONENT_TEMPLATE
Example 1
```js import { templateOnlyComponent } from '@glimmer/runtime';
export default templateOnlyComponent(); ```
templateOnly
Modifiers
- @public

Classes

class ConcreteBounds

class ConcreteBounds implements Bounds {}

constructor

constructor(parentNode: SimpleElement, first: SimpleNode, last: SimpleNode);

property parentNode

parentNode: SimpleElement;

method firstNode

firstNode: () => SimpleNode;

method lastNode

lastNode: () => SimpleNode;

method parentElement

parentElement: () => SimpleElement;

class CurriedValue

class CurriedValue<T extends CurriedType = CurriedType> {}

property [ARGS]

[ARGS]: any;

property [INNER]

[INNER]: string | object | CurriedValue<T>;

property [OWNER]

[OWNER]: Owner;

property [RESOLVED]

[RESOLVED]: boolean;

property [TYPE]

[TYPE]: CurriedType;

class CursorImpl

class CursorImpl implements Cursor {}

constructor

constructor(element: SimpleElement, nextSibling: Nullable<SimpleNode>);

property element

element: SimpleElement;

property nextSibling

nextSibling: Nullable<SimpleNode>;

class DynamicAttribute

abstract class DynamicAttribute implements AttributeOperation {}

constructor

constructor(attribute: AttributeCursor);

property attribute

attribute: AttributeCursor;

method set

abstract set: (dom: ElementBuilder, value: unknown, env: Environment) => void;

method update

abstract update: (value: unknown, env: Environment) => void;

class DynamicScopeImpl

class DynamicScopeImpl implements DynamicScope {}

constructor

constructor(bucket?: Dict<Reference>);

method child

child: () => DynamicScopeImpl;

method get

get: (key: string) => Reference;

method set

set: (key: string, reference: Reference) => Reference;

class EnvironmentImpl

class EnvironmentImpl implements Environment {}

constructor

constructor(options: EnvironmentOptions, delegate: EnvironmentDelegate);

property [TRANSACTION]

[TRANSACTION]: Nullable<TransactionImpl>;

property appendOperations

protected appendOperations: GlimmerTreeConstruction;

property debugRenderTree

debugRenderTree: DebugRenderTreeImpl<object>;

property isArgumentCaptureError

isArgumentCaptureError: (error: any) => boolean;

property isInteractive

isInteractive: boolean;

property updateOperations

protected updateOperations?: any;

method begin

begin: () => void;

method commit

commit: () => void;

method didCreate

didCreate: (component: ComponentInstanceWithCreate) => void;

method didUpdate

didUpdate: (component: ComponentInstanceWithCreate) => void;

method getAppendOperations

getAppendOperations: () => GlimmerTreeConstruction;

method getDOM

getDOM: () => GlimmerTreeChanges;

method scheduleInstallModifier

scheduleInstallModifier: (modifier: ModifierInstance) => void;

method scheduleUpdateModifier

scheduleUpdateModifier: (modifier: ModifierInstance) => void;

class IDOMChanges

class DOMChangesImpl extends DOMOperations implements GlimmerTreeChanges {}

constructor

constructor(document: SimpleDocument);

property document

protected document: SimpleDocument;

property namespace

protected namespace: Nullable<string>;

method insertAfter

insertAfter: (
    element: SimpleElement,
    node: SimpleNode,
    reference: SimpleNode
) => void;

method removeAttribute

removeAttribute: (element: SimpleElement, name: string) => void;

method setAttribute

setAttribute: (element: SimpleElement, name: string, value: string) => void;

class LowLevelVM

class VM implements PublicVM, InternalVM {}

constructor

constructor(
    runtime: RuntimeContext,
    { pc, scope, dynamicScope, stack }: VMState,
    elementStack: ElementBuilder,
    context: CompileTimeCompilationContext
);

End of migrated.

property [ARGS$0]

readonly [ARGS$0]: VMArgumentsImpl;

property [CONSTANTS]

readonly [CONSTANTS]: any;

property [INNER_VM]

readonly [INNER_VM]: LowLevelVM;

property context

readonly context: CompileTimeCompilationContext;

property env

readonly env: Environment;

property pc

readonly pc: number;

property program

readonly program: RuntimeProgram;

property runtime

readonly runtime: RuntimeContext;

property s0

s0: {};

property s1

s1: {};

property stack

readonly stack: EvaluationStack;

property t0

t0: {};

property t1

t1: {};

property v0

v0: {};

method associateDestroyable

associateDestroyable: (child: Destroyable) => void;

method beginCacheGroup

beginCacheGroup: (name?: string) => void;

method bindDynamicScope

bindDynamicScope: (names: string[]) => void;

method call

call: (handle: number) => void;

method capture

capture: (args: number, pc?: number) => ResumableVMState;

method captureState

captureState: (args: number, pc?: number) => VMState;

method commitCacheGroup

commitCacheGroup: () => void;

method compile

compile: (block: CompilableTemplate) => number;

method dynamicScope

dynamicScope: () => DynamicScope;

method elements

elements: () => ElementBuilder;

method empty

static empty: (
    runtime: RuntimeContext,
    { handle, treeBuilder, dynamicScope, owner }: MinimalInitOptions,
    context: CompileTimeCompilationContext
) => InternalVM;

method enter

enter: (args: number) => void;

method enterItem

enterItem: ({ key, value, memo }: OpaqueIterationItem) => ListItemOpcode;

method enterList

enterList: (iterableRef: Reference<OpaqueIterator>, offset: number) => void;

method execute

execute: (initialize?: (vm: this) => void) => RenderResult;

method exit

exit: () => void;

method exitList

exitList: () => void;

method fetch

fetch: (register: SyscallRegister) => void;

method fetchValue

fetchValue: { (register: MachineRegister): number; <T>(register: Register): T };

method getOwner

getOwner: () => Owner;

method getSelf

getSelf: () => Reference<any>;

method goto

goto: (offset: number) => void;

method initial

static initial: (
    runtime: RuntimeContext,
    context: CompileTimeCompilationContext,
    { handle, self, dynamicScope, treeBuilder, numSymbols, owner }: InitOptions
) => InternalVM;

method listBlock

listBlock: () => ListBlockOpcode;

method load

load: (register: SyscallRegister) => void;

method loadValue

loadValue: <T>(register: Register | MachineRegister, value: T) => void;

method next

next: () => RichIteratorResult<null, RenderResult>;

method popDynamicScope

popDynamicScope: () => void;

method popFrame

popFrame: () => void;

method popScope

popScope: () => void;

method popUpdating

popUpdating: () => UpdatingOpcode[];

method pushChildScope

pushChildScope: () => void;

method pushDynamicScope

pushDynamicScope: () => DynamicScope;

method pushFrame

pushFrame: () => void;

Migrated to Inner

method pushRootScope

pushRootScope: (size: number, owner: Owner) => PartialScope;

method pushScope

pushScope: (scope: Scope) => void;

method pushUpdating

pushUpdating: (list?: UpdatingOpcode[]) => void;

method referenceForSymbol

referenceForSymbol: (symbol: number) => Reference;

method registerItem

registerItem: (opcode: ListItemOpcode) => void;

method return

return: () => void;

method returnTo

returnTo: (offset: number) => void;

method scope

scope: () => Scope;

method tryUpdating

tryUpdating: () => Nullable<UpdatingOpcode[]>;

method updateWith

updateWith: (opcode: UpdatingOpcode) => void;

method updating

updating: () => UpdatingOpcode[];

class NewElementBuilder

class NewElementBuilder implements ElementBuilder {}

constructor

constructor(
    env: Environment,
    parentNode: SimpleElement,
    nextSibling: Nullable<SimpleNode>
);

property [CURSOR_STACK]

[CURSOR_STACK]: Stack$0<Cursor>;

property constructing

constructing: Nullable<SimpleElement>;

property dom

dom: GlimmerTreeConstruction;

property element

readonly element: SimpleElement;

property hasBlocks

readonly hasBlocks: boolean;

property nextSibling

readonly nextSibling: Nullable<SimpleNode>;

property operations

operations: Nullable<ElementOperations>;

property updateOperations

updateOperations: GlimmerTreeChanges;

method appendComment

appendComment: (string: string) => SimpleComment;

method appendDynamicFragment

appendDynamicFragment: (value: SimpleDocumentFragment) => void;

method appendDynamicHTML

appendDynamicHTML: (value: string) => void;

method appendDynamicNode

appendDynamicNode: (value: SimpleNode) => void;

method appendDynamicText

appendDynamicText: (value: string) => SimpleText;

method appendText

appendText: (string: string) => SimpleText;

method block

protected block: () => LiveBlock;

method closeElement

closeElement: () => Nullable<ModifierInstance[]>;

method debugBlocks

debugBlocks: () => LiveBlock[];

method didAppendBounds

didAppendBounds: (bounds: Bounds) => Bounds;

method didAppendNode

didAppendNode: <T extends SimpleNode>(node: T) => T;

method didOpenElement

didOpenElement: (element: SimpleElement) => SimpleElement;

method flushElement

flushElement: (modifiers: Nullable<ModifierInstance[]>) => void;

method forInitialRender

static forInitialRender: (
    env: Environment,
    cursor: CursorImpl
) => NewElementBuilder;

method initialize

protected initialize: () => this;

method openElement

openElement: (tag: string) => SimpleElement;

method popBlock

popBlock: () => LiveBlock;

method popElement

popElement: () => void;

method popRemoteElement

popRemoteElement: () => RemoteLiveBlock;

method pushBlockList

pushBlockList: (list: LiveBlock[]) => LiveBlockList;

method pushElement

protected pushElement: (
    element: SimpleElement,
    nextSibling?: Maybe<SimpleNode>
) => void;

method pushLiveBlock

protected pushLiveBlock: <T extends LiveBlock>(
    block: T,
    isRemote?: boolean
) => T;

method pushRemoteElement

pushRemoteElement: (
    element: SimpleElement,
    guid: string,
    insertBefore: Maybe<SimpleNode>
) => RemoteLiveBlock;

method pushSimpleBlock

pushSimpleBlock: () => LiveBlock;

method pushUpdatableBlock

pushUpdatableBlock: () => UpdatableBlockImpl;

method resume

static resume: (env: Environment, block: UpdatableBlock) => NewElementBuilder;

method setDynamicAttribute

setDynamicAttribute: (
    name: string,
    value: unknown,
    trusting: boolean,
    namespace: Nullable<AttrNamespace>
) => DynamicAttribute;

method setStaticAttribute

setStaticAttribute: (
    name: string,
    value: string,
    namespace: Nullable<AttrNamespace>
) => void;

method willCloseElement

willCloseElement: () => void;

class PartialScopeImpl

class PartialScopeImpl implements PartialScope {}

constructor

constructor(
    slots: ScopeSlot[],
    owner: Owner,
    callerScope: any,
    evalScope: any,
    partialMap: any
);

property owner

readonly owner: Owner;

property slots

readonly slots: ScopeSlot[];

method bind

bind: (symbol: number, value: ScopeSlot) => void;

method bindBlock

bindBlock: (symbol: number, value: Nullable<ScopeBlock>) => void;

method bindCallerScope

bindCallerScope: (scope: Nullable<Scope>) => void;

method bindEvalScope

bindEvalScope: (map: Nullable<Dict<ScopeSlot>>) => void;

method bindPartialMap

bindPartialMap: (map: Dict<Reference<unknown>>) => void;

method bindSelf

bindSelf: (self: Reference<unknown>) => void;

method bindSymbol

bindSymbol: (symbol: number, value: Reference<unknown>) => void;

method child

child: () => Scope;

method getBlock

getBlock: (symbol: number) => Nullable<ScopeBlock>;

method getCallerScope

getCallerScope: () => Nullable<Scope>;

method getEvalScope

getEvalScope: () => Nullable<Dict<ScopeSlot>>;

method getPartialMap

getPartialMap: () => Nullable<Dict<Reference<unknown>>>;

method getSelf

getSelf: () => Reference<unknown>;

method getSymbol

getSymbol: (symbol: number) => Reference<unknown>;

method init

init: ({ self }: { self: Reference<unknown> }) => this;

method root

static root: (
    self: Reference<unknown>,
    size: number,
    owner: Owner
) => PartialScope;

method sized

static sized: (size: number, owner: Owner) => Scope;

class RehydrateBuilder

class RehydrateBuilder extends NewElementBuilder implements ElementBuilder {}

constructor

constructor(
    env: Environment,
    parentNode: SimpleElement,
    nextSibling: Nullable<SimpleNode>
);

property [CURSOR_STACK]

[CURSOR_STACK]: Stack$0<RehydratingCursor>;

property blockDepth

blockDepth: number;

property candidate

candidate: Nullable<SimpleNode>;

property currentCursor

readonly currentCursor: Nullable<RehydratingCursor>;

property startingBlockOffset

startingBlockOffset: number;

method didAppendBounds

didAppendBounds: (bounds: Bounds) => Bounds;

method disableRehydration

disableRehydration: (nextSibling: Nullable<SimpleNode>) => void;

method enableRehydration

enableRehydration: (candidate: Nullable<SimpleNode>) => void;

method getMarker

getMarker: (element: HTMLElement, guid: string) => Nullable<SimpleNode>;

method pushElement

pushElement: (
    this:
        | RehydrateBuilder
        | (NewElementBuilder &
              Partial<Pick<RehydrateBuilder, 'blockDepth' | 'candidate'>>),
    element: SimpleElement,
    nextSibling?: Maybe<SimpleNode>
) => void;

method remove

protected remove: (node: SimpleNode) => Nullable<SimpleNode>;

method willCloseElement

willCloseElement: () => void;

class RemoteLiveBlock

class RemoteLiveBlock extends SimpleLiveBlock {}

constructor

constructor(parent: SimpleElement);

class SimpleDynamicAttribute

class SimpleDynamicAttribute extends DynamicAttribute {}

method set

set: (dom: ElementBuilder, value: unknown, _env: Environment) => void;

method update

update: (value: unknown, _env: Environment) => void;

class TemplateOnlyComponent

class TemplateOnlyComponentDefinition {}

constructor

constructor(moduleName?: string, name?: string);

property moduleName

moduleName: string;

property name

name: string;

method toString

toString: () => string;

class TemplateOnlyComponentManager

class TemplateOnlyComponentManager implements InternalComponentManager {}

method getCapabilities

getCapabilities: () => InternalComponentCapabilities;

method getDebugName

getDebugName: ({ name }: TemplateOnlyComponentDefinition) => string;

method getDestroyable

getDestroyable: () => null;

method getSelf

getSelf: () => Reference;

class UpdatableBlockImpl

class UpdatableBlockImpl extends SimpleLiveBlock implements UpdatableBlock {}

method reset

reset: () => Nullable<SimpleNode>;

class UpdatingVM

class UpdatingVM implements IUpdatingVM {}

constructor

constructor(
    env: Environment,
    { alwaysRevalidate }: { alwaysRevalidate?: boolean }
);

property alwaysRevalidate

alwaysRevalidate: boolean;

property dom

dom: GlimmerTreeChanges;

property env

env: Environment;

method execute

execute: (opcodes: UpdatingOpcode[], handler: ExceptionHandler) => void;

method goto

goto: (index: number) => void;

method throw

throw: () => void;

method try

try: (ops: UpdatingOpcode[], handler: Nullable<ExceptionHandler>) => void;

Interfaces

interface EnvironmentDelegate

interface EnvironmentDelegate {}

property enableDebugTooling

enableDebugTooling: boolean;

Used to enable debug tooling

property isInteractive

isInteractive: boolean;

Used to determine the the environment is interactive (e.g. SSR is not interactive). Interactive environments schedule modifiers, among other things.

property onTransactionCommit

onTransactionCommit: () => void;

Callback to be called when an environment transaction commits

interface InternalVM

interface InternalVM {}

This interface is used by internal opcodes, and is more stable than the implementation of the Append VM itself.

property [ARGS$0]

readonly [ARGS$0]: VMArgumentsImpl;

property [CONSTANTS]

readonly [CONSTANTS]: RuntimeConstants & ResolutionTimeConstants;

property context

readonly context: CompileTimeCompilationContext;

property env

readonly env: Environment;

property runtime

readonly runtime: RuntimeContext;

property stack

readonly stack: EvaluationStack;

method associateDestroyable

associateDestroyable: (d: Destroyable) => void;

method beginCacheGroup

beginCacheGroup: (name?: string) => void;

method bindDynamicScope

bindDynamicScope: (names: string[]) => void;

method call

call: (handle: number) => void;

method commitCacheGroup

commitCacheGroup: () => void;

method compile

compile: (block: CompilableTemplate) => number;

method dynamicScope

dynamicScope: () => DynamicScope;

method elements

elements: () => ElementBuilder;

method enter

enter: (args: number) => void;

method enterItem

enterItem: (item: OpaqueIterationItem) => ListItemOpcode;

method enterList

enterList: (iterableRef: Reference<OpaqueIterator>, offset: number) => void;

method execute

execute: (initialize?: (vm: this) => void) => RenderResult;

method exit

exit: () => void;

method exitList

exitList: () => void;

method fetch

fetch: (register: Register) => void;

method fetchValue

fetchValue: {
    (register: MachineRegister.ra | MachineRegister.pc): number;
    <T>(register: Register): T;
    (register: Register): unknown;
};

method getOwner

getOwner: () => Owner;

method getSelf

getSelf: () => Reference;

method goto

goto: (pc: number) => void;

method load

load: (register: Register) => void;

method loadValue

loadValue: {
    (register: MachineRegister, value: number): void;
    (register: Register, value: unknown): void;
    (register: any, value: unknown): void;
};

method next

next: () => RichIteratorResult<null, RenderResult>;

method popDynamicScope

popDynamicScope: () => void;

method popScope

popScope: () => void;

method pushChildScope

pushChildScope: () => void;

method pushDynamicScope

pushDynamicScope: () => void;

method pushFrame

pushFrame: () => void;

method pushRootScope

pushRootScope: (size: number, owner: Owner) => PartialScope;

method pushScope

pushScope: (scope: Scope) => void;

method pushUpdating

pushUpdating: (list?: UpdatingOpcode[]) => void;

method referenceForSymbol

referenceForSymbol: (symbol: number) => Reference;

method registerItem

registerItem: (item: ListItemOpcode) => void;

method scope

scope: () => Scope;

method updateWith

updateWith: (opcode: UpdatingOpcode) => void;

interface SafeString

interface SafeString {}

method toHTML

toHTML: () => string;

Type Aliases

type DebugCallback

type DebugCallback = (context: unknown, get: DebugGet) => void;

type DOMTreeConstruction

type DOMTreeConstruction = TreeConstruction;

type IteratorResult

type IteratorResult<T> = RichIteratorResult<null, T>;

Package Files (1)

dist/dev/index.d.ts

Dependencies (12)

Dev Dependencies (9)

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/@glimmer/runtime.

Markdown

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

HTML

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

Updated 15 days ago.
Package analyzed in 6449 ms.
Missing or incorrect documentation? Open an issue for this package.

@glimmer/runtime

Install

Overview

Index

Variables

Functions

Classes

Interfaces

Type Aliases

Variables

variable ARGS

variable ARGS$0

variable array

Parameter options

Modifiers

variable concat

Modifiers

variable CONSTANTS

variable CURSOR_STACK

variable DESTROYABLE_STACK

variable DOMChanges

variable DOMTreeConstruction

variable EMPTY_ARGS

variable EMPTY_NAMED

variable EMPTY_POSITIONAL

variable fn

Modifiers

variable get

Modifiers

variable hash

Parameter options

Modifiers

variable HEAP

variable INNER

variable INNER_VM

variable on

variable OWNER

variable REGISTERS

variable RESOLVED

variable SERIALIZATION_FIRST_NODE_STRING

variable STACKS

variable TEMPLATE_ONLY_COMPONENT_MANAGER

variable TRANSACTION

variable TYPE

Functions

function clear

function clientBuilder

function createCapturedArgs

function curry

function dynamicAttribute

function inTransaction

function invokeHelper

function isSerializationFirstNode

function isWhitespace

function normalizeProperty

function rehydrationBuilder

function reifyArgs

function reifyNamed

function reifyPositional

function renderComponent

function renderMain

function renderSync

function resetDebuggerCallback

function runtimeContext

function setDebuggerCallback

function templateOnlyComponent

Parameter moduleName

Example 1

Modifiers

Classes

class ConcreteBounds

constructor

property parentNode

method firstNode

method lastNode

method parentElement

class CurriedValue

property [ARGS]

property [INNER]

property [OWNER]