Class ScopeObserver

src/core/scope_observer.ts:12–86

}

export class ScopeObserver implements ValueListObserverDelegate<Scope> {
  readonly element: Element
  readonly schema: Schema
  private delegate: ScopeObserverDelegate
  private valueListObserver: ValueListObserver<Scope>
  private scopesByIdentifierByElement: WeakMap<Element, Map<string, Scope>>
  private scopeReferenceCounts: WeakMap<Scope, number>

  constructor(element: Element, schema: Schema, delegate: ScopeObserverDelegate) {
    this.element = element
    this.schema = schema
    this.delegate = delegate
    this.valueListObserver = new ValueListObserver(this.element, this.controllerAttribute, this)
    this.scopesByIdentifierByElement = new WeakMap()
    this.scopeReferenceCounts = new WeakMap()
  }

  start() {
    this.valueListObserver.start()
  }

  stop() {
    this.valueListObserver.stop()
  }

  get controllerAttribute() {
    return this.schema.controllerAttribute
  }

  // Value observer delegate

  parseValueForToken(token: Token): Scope | undefined {
    const { element, content: identifier } = token
    return this.parseValueForElementAndIdentifier(element, identifier)
  }

  parseValueForElementAndIdentifier(element: Element, identifier: string): Scope | undefined {
    const scopesByIdentifier = this.fetchScopesByIdentifierForElement(element)

    let scope = scopesByIdentifier.get(identifier)
    if (!scope) {
      scope = this.delegate.createScopeForElementAndIdentifier(element, identifier)
      scopesByIdentifier.set(identifier, scope)
    }

    return scope
  }

  elementMatchedValue(element: Element, value: Scope) {
    const referenceCount = (this.scopeReferenceCounts.get(value) || 0) + 1
    this.scopeReferenceCounts.set(value, referenceCount)
    if (referenceCount == 1) {
      this.delegate.scopeConnected(value)
    }
  }

  elementUnmatchedValue(element: Element, value: Scope) {
    const referenceCount = this.scopeReferenceCounts.get(value)