@glimmer/runtime
- Version 0.84.3
- Published
- 4.28 MB
- 13 dependencies
- MIT license
Install
npm i @glimmer/runtime
yarn add @glimmer/runtime
pnpm add @glimmer/runtime
Overview
Minimal runtime needed to render Glimmer templates
Index
Variables
Functions
- clear()
- clientBuilder()
- createCapturedArgs()
- curry()
- dynamicAttribute()
- inTransaction()
- invokeHelper()
- isSerializationFirstNode()
- isWhitespace()
- normalizeProperty()
- rehydrationBuilder()
- reifyArgs()
- reifyNamed()
- reifyPositional()
- renderComponent()
- renderMain()
- renderSync()
- resetDebuggerCallback()
- runtimeContext()
- setDebuggerCallback()
- templateOnlyComponent()
Classes
LowLevelVM
- [ARGS]
- [CONSTANTS]
- [INNER_VM]
- associateDestroyable()
- beginCacheGroup()
- bindDynamicScope()
- call()
- capture()
- captureState()
- commitCacheGroup()
- compile()
- context
- dynamicScope()
- elements()
- empty()
- enter()
- enterItem()
- enterList()
- env
- execute()
- exit()
- exitList()
- fetch()
- fetchValue()
- getOwner()
- getSelf()
- goto()
- initial()
- listBlock()
- load()
- loadValue()
- next()
- pc
- popDynamicScope()
- popFrame()
- popScope()
- popUpdating()
- program
- pushChildScope()
- pushDynamicScope()
- pushFrame()
- pushRootScope()
- pushScope()
- pushUpdating()
- referenceForSymbol()
- registerItem()
- return()
- returnTo()
- runtime
- s0
- s1
- scope()
- stack
- t0
- t1
- tryUpdating()
- updateWith()
- updating()
- v0
NewElementBuilder
- [CURSOR_STACK]
- appendComment()
- appendDynamicFragment()
- appendDynamicHTML()
- appendDynamicNode()
- appendDynamicText()
- appendText()
- block()
- closeElement()
- constructing
- debugBlocks()
- didAppendBounds()
- didAppendNode()
- didOpenElement()
- dom
- element
- flushElement()
- forInitialRender()
- hasBlocks
- initialize()
- nextSibling
- openElement()
- operations
- popBlock()
- popElement()
- popRemoteElement()
- pushBlockList()
- pushElement()
- pushLiveBlock()
- pushRemoteElement()
- pushSimpleBlock()
- pushUpdatableBlock()
- resume()
- setDynamicAttribute()
- setStaticAttribute()
- updateOperations
- willCloseElement()
Interfaces
InternalVM
- [ARGS]
- [CONSTANTS]
- associateDestroyable()
- beginCacheGroup()
- bindDynamicScope()
- call()
- commitCacheGroup()
- compile()
- context
- dynamicScope()
- elements()
- enter()
- enterItem()
- enterList()
- env
- execute()
- exit()
- exitList()
- fetch()
- fetchValue()
- getOwner()
- getSelf()
- goto()
- load()
- loadValue()
- next()
- popDynamicScope()
- popScope()
- pushChildScope()
- pushDynamicScope()
- pushFrame()
- pushRootScope()
- pushScope()
- pushUpdating()
- referenceForSymbol()
- registerItem()
- runtime
- scope()
- stack
- updateWith()
Type Aliases
Variables
variable array
const array: {};
variable concat
const concat: {};
variable DOMChanges
let DOMChanges: typeof DOMChangesImpl;
variable DOMTreeConstruction
const DOMTreeConstruction: typeof DOM.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: {};
variable get
const get: {};
variable hash
const hash: {};
variable on
const on: {};
variable SERIALIZATION_FIRST_NODE_STRING
const SERIALIZATION_FIRST_NODE_STRING: string;
variable TEMPLATE_ONLY_COMPONENT_MANAGER
const TEMPLATE_ONLY_COMPONENT_MANAGER: TemplateOnlyComponentManager;
Functions
function clear
clear: (bounds: Bounds) => Option<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: Option<AttrNamespace>, isTrusting?: boolean) => DynamicAttribute;
function inTransaction
inTransaction: (env: Environment, cb: () => 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: string; type: string };
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: Option<SimpleNode>);
property element
element: SimpleElement;
property nextSibling
nextSibling: Option<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]: Option<TransactionImpl>;
property appendOperations
protected appendOperations: GlimmerTreeConstruction;
property debugRenderTree
debugRenderTree: DebugRenderTree<object>;
property isInteractive
isInteractive: boolean;
property updateOperations
protected updateOperations?: GlimmerTreeChanges;
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: Option<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]
readonly [ARGS]: 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: () => Option<UpdatingOpcode[]>;
method updateWith
updateWith: (opcode: UpdatingOpcode) => void;
method updating
updating: () => UpdatingOpcode[];
class NewElementBuilder
class NewElementBuilder implements ElementBuilder {}
constructor
constructor( env: Environment, parentNode: SimpleElement, nextSibling: Option<SimpleNode>);
property [CURSOR_STACK]
[CURSOR_STACK]: Stack<Cursor>;
property constructing
constructing: Option<SimpleElement>;
property dom
dom: GlimmerTreeConstruction;
property element
readonly element: SimpleElement;
property hasBlocks
readonly hasBlocks: boolean;
property nextSibling
readonly nextSibling: Option<SimpleNode>;
property operations
operations: Option<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: () => Option<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: Option<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: () => void;
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>) => Option<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: Option<AttrNamespace>) => DynamicAttribute;
method setStaticAttribute
setStaticAttribute: ( name: string, value: string, namespace: Option<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: Option<ScopeBlock>) => void;
method bindCallerScope
bindCallerScope: (scope: Option<Scope>) => void;
method bindEvalScope
bindEvalScope: (map: Option<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) => Option<ScopeBlock>;
method getCallerScope
getCallerScope: () => Option<Scope>;
method getEvalScope
getEvalScope: () => Option<Dict<ScopeSlot>>;
method getPartialMap
getPartialMap: () => Option<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 | undefined, owner: Owner) => PartialScope;
method sized
static sized: (size: number | undefined, owner: Owner) => Scope;
class RehydrateBuilder
class RehydrateBuilder extends NewElementBuilder implements ElementBuilder {}
constructor
constructor( env: Environment, parentNode: SimpleElement, nextSibling: Option<SimpleNode>);
property [CURSOR_STACK]
[CURSOR_STACK]: Stack<RehydratingCursor>;
property blockDepth
blockDepth: number;
property candidate
candidate: Option<SimpleNode>;
property currentCursor
readonly currentCursor: Option<RehydratingCursor>;
property startingBlockOffset
startingBlockOffset: number;
method didAppendBounds
didAppendBounds: (bounds: Bounds) => Bounds;
method disableRehydration
disableRehydration: (nextSibling: Option<SimpleNode>) => void;
method enableRehydration
enableRehydration: (candidate: Option<SimpleNode>) => void;
method getMarker
getMarker: (element: HTMLElement, guid: string) => Option<SimpleNode>;
method pushElement
pushElement: ( this: | RehydrateBuilder | (NewElementBuilder & Partial<Pick<RehydrateBuilder, 'blockDepth' | 'candidate'>>), element: SimpleElement, nextSibling?: Maybe<SimpleNode>) => void;
method remove
protected remove: (node: SimpleNode) => Option<SimpleNode>;
method willCloseElement
willCloseElement: () => void;
class RemoteLiveBlock
class RemoteLiveBlock extends SimpleLiveBlock {}
constructor
constructor(parent: SimpleElement);
class SimpleDynamicAttribute
class SimpleDynamicAttribute extends DynamicAttribute {}
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: () => Option<SimpleNode>;
class UpdatingVM
class UpdatingVMImpl implements UpdatingVM {}
constructor
constructor( env: Environment, { alwaysRevalidate }: { alwaysRevalidate?: boolean | undefined });
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: Option<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]
readonly [ARGS]: 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 = DOM.DOMTreeConstruction;
type IteratorResult
type IteratorResult<T> = RichIteratorResult<null, T>;
Package Files (24)
- dist/types/index.d.ts
- dist/types/lib/bounds.d.ts
- dist/types/lib/compiled/opcodes/debugger.d.ts
- dist/types/lib/component/template-only.d.ts
- dist/types/lib/curried-value.d.ts
- dist/types/lib/dom/helper.d.ts
- dist/types/lib/dom/props.d.ts
- dist/types/lib/environment.d.ts
- dist/types/lib/helpers/array.d.ts
- dist/types/lib/helpers/concat.d.ts
- dist/types/lib/helpers/fn.d.ts
- dist/types/lib/helpers/get.d.ts
- dist/types/lib/helpers/hash.d.ts
- dist/types/lib/helpers/invoke.d.ts
- dist/types/lib/modifiers/on.d.ts
- dist/types/lib/render.d.ts
- dist/types/lib/scope.d.ts
- dist/types/lib/upsert.d.ts
- dist/types/lib/vm/append.d.ts
- dist/types/lib/vm/arguments.d.ts
- dist/types/lib/vm/attributes/dynamic.d.ts
- dist/types/lib/vm/element-builder.d.ts
- dist/types/lib/vm/rehydrate-builder.d.ts
- dist/types/lib/vm/update.d.ts
Dependencies (13)
Dev Dependencies (4)
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[](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 .
Package analyzed in 7105 ms. - Missing or incorrect documentation? Open an issue for this package.