@glimmer/runtime
Version:
Minimal runtime needed to render Glimmer templates
214 lines (175 loc) • 16.7 kB
JavaScript
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.default = exports.Ref = void 0;
var _env = require("@glimmer/env");
var _util = require("@glimmer/util");
var _arguments = require("./vm/arguments");
let GUID = 0;
class Ref {
constructor(value) {
this.id = GUID++;
this.value = value;
}
get() {
return this.value;
}
release() {
if (_env.DEBUG && this.value === null) {
throw new Error('BUG: double release?');
}
this.value = null;
}
toString() {
let label = `Ref ${this.id}`;
if (this.value === null) {
return `${label} (released)`;
} else {
try {
return `${label}: ${this.value}`;
} catch (_a) {
return label;
}
}
}
}
exports.Ref = Ref;
class DebugRenderTreeImpl {
constructor() {
this.stack = new _util.Stack();
this.refs = new WeakMap();
this.roots = new Set();
this.nodes = new WeakMap();
}
begin() {
this.reset();
}
create(state, node) {
let internalNode = (0, _util.assign)({}, node, {
bounds: null,
refs: new Set()
});
this.nodes.set(state, internalNode);
this.appendChild(internalNode, state);
this.enter(state);
}
update(state) {
this.enter(state);
}
didRender(state, bounds) {
if (_env.DEBUG && this.stack.current !== state) {
throw new Error(`BUG: expecting ${this.stack.current}, got ${state}`);
}
this.nodeFor(state).bounds = bounds;
this.exit();
}
willDestroy(state) {
this.refs.get(state).release();
}
commit() {
this.reset();
}
capture() {
return this.captureRefs(this.roots);
}
reset() {
if (this.stack.size !== 0) {
// We probably encountered an error during the rendering loop. This will
// likely trigger undefined behavior and memory leaks as the error left
// things in an inconsistent state. It is recommended that the user
// refresh the page.
// TODO: We could warn here? But this happens all the time in our tests?
// Clean up the root reference to prevent errors from happening if we
// attempt to capture the render tree (Ember Inspector may do this)
let root = this.stack.toArray()[0];
let ref = this.refs.get(root);
if (ref !== undefined) {
this.roots.delete(ref);
}
while (!this.stack.isEmpty()) {
this.stack.pop();
}
}
}
enter(state) {
this.stack.push(state);
}
exit() {
if (_env.DEBUG && this.stack.size === 0) {
throw new Error('BUG: unbalanced pop');
}
this.stack.pop();
}
nodeFor(state) {
return this.nodes.get(state);
}
appendChild(node, state) {
if (_env.DEBUG && this.refs.has(state)) {
throw new Error('BUG: child already appended');
}
let parent = this.stack.current;
let ref = new Ref(state);
this.refs.set(state, ref);
if (parent) {
let parentNode = this.nodeFor(parent);
parentNode.refs.add(ref);
node.parent = parentNode;
} else {
this.roots.add(ref);
}
}
captureRefs(refs) {
let captured = [];
refs.forEach(ref => {
let state = ref.get();
if (state) {
captured.push(this.captureNode(`render-node:${ref.id}`, state));
} else {
refs.delete(ref);
}
});
return captured;
}
captureNode(id, state) {
let node = this.nodeFor(state);
let {
type,
name,
args,
instance,
refs
} = node;
let template = this.captureTemplate(node);
let bounds = this.captureBounds(node);
let children = this.captureRefs(refs);
return {
id,
type,
name,
args: (0, _arguments.reifyArgs)(args),
instance,
template,
bounds,
children
};
}
captureTemplate({
template
}) {
return template || null;
}
captureBounds(node) {
let bounds = node.bounds;
let parentElement = bounds.parentElement();
let firstNode = bounds.firstNode();
let lastNode = bounds.lastNode();
return {
parentElement,
firstNode,
lastNode
};
}
}
exports.default = DebugRenderTreeImpl;
//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../../../packages/@glimmer/runtime/lib/debug-render-tree.ts"],"names":[],"mappings":"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","sourcesContent":["import { DEBUG } from '@glimmer/env';\nimport {\n  Bounds,\n  CapturedRenderNode,\n  DebugRenderTree,\n  Option,\n  RenderNode,\n} from '@glimmer/interfaces';\nimport { expect, assign, Stack } from '@glimmer/util';\nimport { reifyArgs } from './vm/arguments';\n\ninterface InternalRenderNode<T extends object> extends RenderNode {\n  bounds: Option<Bounds>;\n  refs: Set<Ref<T>>;\n  parent?: InternalRenderNode<T>;\n}\n\nlet GUID = 0;\n\nexport class Ref<T extends object> {\n  readonly id: number = GUID++;\n  private value: Option<T>;\n\n  constructor(value: T) {\n    this.value = value;\n  }\n\n  get(): Option<T> {\n    return this.value;\n  }\n\n  release(): void {\n    if (DEBUG && this.value === null) {\n      throw new Error('BUG: double release?');\n    }\n\n    this.value = null;\n  }\n\n  toString(): String {\n    let label = `Ref ${this.id}`;\n\n    if (this.value === null) {\n      return `${label} (released)`;\n    } else {\n      try {\n        return `${label}: ${this.value}`;\n      } catch {\n        return label;\n      }\n    }\n  }\n}\n\nexport default class DebugRenderTreeImpl<TBucket extends object>\n  implements DebugRenderTree<TBucket> {\n  private stack = new Stack<TBucket>();\n\n  private refs = new WeakMap<TBucket, Ref<TBucket>>();\n  private roots = new Set<Ref<TBucket>>();\n  private nodes = new WeakMap<TBucket, InternalRenderNode<TBucket>>();\n\n  begin(): void {\n    this.reset();\n  }\n\n  create(state: TBucket, node: RenderNode): void {\n    let internalNode: InternalRenderNode<TBucket> = assign({}, node, {\n      bounds: null,\n      refs: new Set<Ref<TBucket>>(),\n    });\n    this.nodes.set(state, internalNode);\n    this.appendChild(internalNode, state);\n    this.enter(state);\n  }\n\n  update(state: TBucket): void {\n    this.enter(state);\n  }\n\n  didRender(state: TBucket, bounds: Bounds): void {\n    if (DEBUG && this.stack.current !== state) {\n      throw new Error(`BUG: expecting ${this.stack.current}, got ${state}`);\n    }\n\n    this.nodeFor(state).bounds = bounds;\n    this.exit();\n  }\n\n  willDestroy(state: TBucket): void {\n    expect(this.refs.get(state), 'BUG: missing ref').release();\n  }\n\n  commit(): void {\n    this.reset();\n  }\n\n  capture(): CapturedRenderNode[] {\n    return this.captureRefs(this.roots);\n  }\n\n  private reset(): void {\n    if (this.stack.size !== 0) {\n      // We probably encountered an error during the rendering loop. This will\n      // likely trigger undefined behavior and memory leaks as the error left\n      // things in an inconsistent state. It is recommended that the user\n      // refresh the page.\n\n      // TODO: We could warn here? But this happens all the time in our tests?\n\n      // Clean up the root reference to prevent errors from happening if we\n      // attempt to capture the render tree (Ember Inspector may do this)\n      let root = expect(this.stack.toArray()[0], 'expected root state when resetting render tree');\n      let ref = this.refs.get(root);\n\n      if (ref !== undefined) {\n        this.roots.delete(ref);\n      }\n\n      while (!this.stack.isEmpty()) {\n        this.stack.pop();\n      }\n    }\n  }\n\n  private enter(state: TBucket): void {\n    this.stack.push(state);\n  }\n\n  private exit(): void {\n    if (DEBUG && this.stack.size === 0) {\n      throw new Error('BUG: unbalanced pop');\n    }\n\n    this.stack.pop();\n  }\n\n  private nodeFor(state: TBucket): InternalRenderNode<TBucket> {\n    return expect(this.nodes.get(state), 'BUG: missing node');\n  }\n\n  private appendChild(node: InternalRenderNode<TBucket>, state: TBucket): void {\n    if (DEBUG && this.refs.has(state)) {\n      throw new Error('BUG: child already appended');\n    }\n\n    let parent = this.stack.current;\n    let ref = new Ref(state);\n\n    this.refs.set(state, ref);\n\n    if (parent) {\n      let parentNode = this.nodeFor(parent);\n      parentNode.refs.add(ref);\n      node.parent = parentNode;\n    } else {\n      this.roots.add(ref);\n    }\n  }\n\n  private captureRefs(refs: Set<Ref<TBucket>>): CapturedRenderNode[] {\n    let captured: CapturedRenderNode[] = [];\n\n    refs.forEach((ref) => {\n      let state = ref.get();\n\n      if (state) {\n        captured.push(this.captureNode(`render-node:${ref.id}`, state));\n      } else {\n        refs.delete(ref);\n      }\n    });\n\n    return captured;\n  }\n\n  private captureNode(id: string, state: TBucket): CapturedRenderNode {\n    let node = this.nodeFor(state);\n    let { type, name, args, instance, refs } = node;\n    let template = this.captureTemplate(node);\n    let bounds = this.captureBounds(node);\n    let children = this.captureRefs(refs);\n    return { id, type, name, args: reifyArgs(args), instance, template, bounds, children };\n  }\n\n  private captureTemplate({ template }: InternalRenderNode<TBucket>): Option<string> {\n    return template || null;\n  }\n\n  private captureBounds(node: InternalRenderNode<TBucket>): CapturedRenderNode['bounds'] {\n    let bounds = expect(node.bounds, 'BUG: missing bounds');\n    let parentElement = bounds.parentElement();\n    let firstNode = bounds.firstNode();\n    let lastNode = bounds.lastNode();\n    return { parentElement, firstNode, lastNode };\n  }\n}\n"],"sourceRoot":""}