{"version":3,"sources":["https://lively-kernel.org/lively4/lively4-portal/src/client/reactive/active-expression/active-expression.js"],"names":["EventTarget","Annotations","Event","default","EventTypes","shallowEqualsArray","shallowEqualsSet","shallowEqualsMap","shallowEquals","deepEquals","isString","clone","cloneDeep","pluralize","Preferences","sourcemap","IdentitySymbolProvider","AExprRegistry","LoggingModes","aexpr","HACK","window","__compareAExprResults__","DefaultMatcher","compare","lastResult","newResult","Array","isArray","Set","Map","Number","isNaN","store","result","prototype","slice","call","IdentityMatcher","ShallowMatcher","DeepMatcher","DebugConceptType","AE","SIGNAL","DB","ILA","ROQ","MATCHER_MAP","NO_VALUE_YET","Symbol","aeCounter","identitiySymbolProvider","BaseActiveExpression","constructor","func","params","match","errorMode","disabled","location","sourceCode","isDataBinding","dataBindingContext","dataBindingIdentifier","isILA","ila","id","loggingMode","DEFAULT","completeHistory","_eventTarget","_isEnabled","setupMatcher","callbacks","_isDisposed","_shouldDisposeOnLastCallbackDetached","_annotations","meta","identifierSymbol","next","conceptType","conceptInfo","context","identifier","initializeEvents","addToRegistry","_initLastValue","logEvent","CREATED","stack","lively","value","lastValue","updateLastValue","isError","evaluateToCurrentValue","storeResult","addAExpr","hasCallbacks","length","getCurrentValue","addToEvaluationStack","returnValue","popEvaluationStack","e","eventPromise","EVALFAIL","error","on","type","callback","addEventListener","off","removeEventListener","emit","dispatchEvent","getEventListeners","onChange","originalSource","push","CBADDED","updateAExpr","offChange","index","indexOf","splice","CBREMOVED","dispose","checkAndNotify","infoPromises","callbackStackTop","callbackStack","then","event","Promise","all","triggers","parentAE","ae","compareResults","notify","expr","findCallee","frames","frame","file","includes","getSourceLocBabelStyle","undefined","extractSourceMap","code","m","sourceMappingURL","fetch","json","extractSourceURL","matchConfig","has","Error","matcher","get","hasOwnProperty","args","forEach","addToCallbackStack","popCallbackStack","updateDependencies","setExpression","checkImmediately","Function","TypeError","onBecomeTrue","bool","onBecomeFalse","dataflow","orignalSource","removeAllCallbacks","removeAExpr","DISPOSED","isDisposed","disposeOnLastCallbackDetached","gotDisposed","_disposedPromise","resolve","enable","check","disable","isEnabled","isDisabled","shouldLogEvents","shouldLog","start","line","ALL","toggleLogging","setLogging","NONE","logState","events","annotation","add","getSymbol","getLocationText","substring","lastIndexOf","getIdentifier","getDataBinding","getLayer","name","getSourceCode","getName","getType","getTypeShort","cutoff","oneLine","startsWith","replace","trim","supportsDependencies","markTimestamp","reason","CUSTOM","addEvent","overallID","sort","e1","e2","shift","overrideTimestamp","isMeta","ensureResolved","migrateEvents","other","otherEvents","unshift","nextValue","values","valueQueue","gotNewValue","waitForValue","resetWaitForValue","v","temp","asyncIterator","done","race"],"mappings":"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","file":"active-expression.js","sourcesContent":["import EventTarget from '../utils/event-target.js';\nimport Annotations from '../utils/annotations.js';\nimport { default as Event, EventTypes } from './events/event.js';\nimport { shallowEqualsArray, shallowEqualsSet, shallowEqualsMap, shallowEquals, deepEquals } from '../utils/equality.js';\nimport { isString, clone, cloneDeep, pluralize } from 'utils';\nimport Preferences from 'src/client/preferences.js';\n\nimport sourcemap from 'src/external/source-map.min.js';\nimport { IdentitySymbolProvider } from 'src/babylonian-programming-editor/utils/tracker.js';\n\nimport { AExprRegistry, LoggingModes } from 'src/client/reactive/active-expression/ae-registry.js';\n\n// #TODO: this is use to keep SystemJS from messing up scoping\n// (BaseActiveExpression would not be defined in aexpr)\nconst HACK = {};\n\nwindow.__compareAExprResults__ = false;\n/*MD # Equality Matchers MD*/\nclass DefaultMatcher {\n  static compare(lastResult, newResult) {\n    // array\n    if (Array.isArray(lastResult) && Array.isArray(newResult)) {\n      return shallowEqualsArray(lastResult, newResult);\n    }\n\n    // set\n    if (lastResult instanceof Set && newResult instanceof Set) {\n      return shallowEqualsSet(lastResult, newResult);\n    }\n\n    // map\n    if (lastResult instanceof Map && newResult instanceof Map) {\n      return shallowEqualsMap(lastResult, newResult);\n    }\n\n    // Workaround for NaN === NaN -> false\n    if (Number.isNaN(lastResult) && Number.isNaN(newResult)) {\n      return true;\n    }\n\n    return lastResult === newResult;\n  }\n\n  static store(result) {\n    // array\n    if (Array.isArray(result)) {\n      return Array.prototype.slice.call(result);\n    }\n\n    // set\n    if (result instanceof Set) {\n      return new Set(result);\n    }\n\n    // map\n    if (result instanceof Map) {\n      return new Map(result);\n    }\n\n    return result;\n  }\n}\n\nclass IdentityMatcher {\n  static compare(lastResult, newResult) {\n    return lastResult === newResult;\n  }\n\n  static store(result) {\n    return result;\n  }\n}\n\nclass ShallowMatcher {\n  static compare(lastResult, newResult) {\n    // array\n    if (Array.isArray(lastResult) && Array.isArray(newResult)) {\n      return shallowEqualsArray(lastResult, newResult);\n    }\n\n    // set\n    if (lastResult instanceof Set && newResult instanceof Set) {\n      return shallowEqualsSet(lastResult, newResult);\n    }\n\n    // map\n    if (lastResult instanceof Map && newResult instanceof Map) {\n      return shallowEqualsMap(lastResult, newResult);\n    }\n\n    // Workaround for NaN === NaN -> false\n    if (Number.isNaN(lastResult) && Number.isNaN(newResult)) {\n      return true;\n    }\n\n    return shallowEquals(lastResult, newResult);\n  }\n\n  static store(result) {\n    return clone.call(result);\n  }\n}\n\nclass DeepMatcher {\n  static compare(lastResult, newResult) {\n    return deepEquals(lastResult, newResult);\n  }\n\n  static store(result) {\n    return cloneDeep.call(result);\n  }\n}\n\nexport const DebugConceptType = {\n  AE: \"AE\",\n  SIGNAL: \"Signal\",\n  DB: \"DB\",\n  ILA: \"ILA\",\n  ROQ: \"ROQ\",\n}\n\nconst MATCHER_MAP = new Map([['default', DefaultMatcher], ['identity', IdentityMatcher], ['shallow', ShallowMatcher], ['deep', DeepMatcher]]);\n\nconst NO_VALUE_YET = Symbol('No value yet');\n\nlet aeCounter = 0;\n\nconst identitiySymbolProvider = new IdentitySymbolProvider();\n/*MD # ACTIVE EXPRESSIONS MD*/\nexport class BaseActiveExpression {\n\n  /**\n   *\n   * @param func (Function) the expression to be observed\n   * #TODO: incorrect parameter list, how to specify spread arguments in jsdoc?\n   * @param ...params (Objects) the instances bound as parameters to the expression\n   */\n  constructor(func, {\n    params = [], match,\n    errorMode = 'silent',\n    disabled = false,\n    location,\n    sourceCode,\n    isDataBinding,\n    dataBindingContext,\n    dataBindingIdentifier,\n    isILA,\n    ila\n\n  } = {}) {\n    this.id = aeCounter;\n    aeCounter++;\n    this.loggingMode = LoggingModes.DEFAULT;\n    this.completeHistory = true;\n    \n    this._eventTarget = new EventTarget(), this.func = func;\n    this.params = params;\n    this.errorMode = errorMode;\n    this._isEnabled = !disabled;\n    this.setupMatcher(match);\n    this.callbacks = [];\n\n    this._isDisposed = false;\n    this._shouldDisposeOnLastCallbackDetached = false;\n\n    this._annotations = new Annotations();\n    if (location) {\n      this.meta({ location });\n    }\n    \n    this.identifierSymbol = identitiySymbolProvider.next();\n    if (sourceCode) {\n      this.meta({ sourceCode });\n    }\n\n    if(isDataBinding) {\n      this.meta({ conceptType: DebugConceptType.DB });\n      this.meta({ conceptInfo: {context: dataBindingContext, identifier: dataBindingIdentifier}});      \n    } else if (isILA) {\n      this.meta({ conceptType: DebugConceptType.ILA });\n      this.meta({ conceptInfo: ila});      \n    } else {      \n      this.meta({ conceptType: DebugConceptType.AE });\n    }\n\n    this.initializeEvents();\n\n    this.addToRegistry();\n    this._initLastValue();\n    this.logEvent(EventTypes.CREATED, { stack: lively.stack(), value: this.lastValue });\n  }\n\n  _initLastValue() {\n    this.lastValue = NO_VALUE_YET;\n    this.updateLastValue();\n  }\n\n  updateLastValue() {\n    const { value, isError } = this.evaluateToCurrentValue();\n    if (!isError) {\n      this.storeResult(value);\n    }\n  }\n\n  addToRegistry() {\n    AExprRegistry.addAExpr(this);\n  }\n\n  hasCallbacks() {\n    return this.callbacks.length !== 0;\n  }\n\n  /**\n   * Executes the encapsulated expression with the given parameters.\n   * aliases with 'now' (#TODO: caution, consider ambigous terminology: 'now' as in 'give me the value' or as in 'dataflow'?)\n   * @private\n   * @returns {*} the current value of the expression\n   */\n  getCurrentValue() {\n    AExprRegistry.addToEvaluationStack(this);\n    let returnValue;\n    try {\n      returnValue = this.func(...this.params);\n    } finally {\n      AExprRegistry.popEvaluationStack();\n    }\n    return returnValue;\n  }\n\n  /**\n   * Safely executes the encapsulated expression with the given parameters.\n   * @public\n   * @returns {{ value: *, isError: Boolean}} the current value of the expression, or the thrown error if any\n   */\n  evaluateToCurrentValue() {\n    try {\n      const result = this.getCurrentValue();\n      return { value: result, isError: false };\n    } catch (e) {\n      const eventPromise = this.logEvent(EventTypes.EVALFAIL, {error: e});\n      return { value: e, isError: true, eventPromise };\n    }\n  }\n\n  /*MD ## EventTarget Interface MD*/\n  // #TODO: additional callbacks\n  // - 'change-complete' for tail end of notification\n  // - 'dependency-changed' for reflection\n  on(type, callback) {\n    this._eventTarget.addEventListener(type, callback);\n    return this;\n  }\n\n  off(type, callback) {\n    this._eventTarget.removeEventListener(type, callback);\n    return this;\n  }\n\n  emit(type, ...params) {\n    this._eventTarget.dispatchEvent(type, ...params);\n  }\n\n  getEventListeners(type) {\n    return this._eventTarget.getEventListeners(type);\n  }\n\n  /*MD ## Basic Interface MD*/\n  /**\n   * @public\n   * @param callback\n   * @returns {BaseActiveExpression} this very active expression (for chaining)\n   */\n  onChange(callback, originalSource) {\n    this.callbacks.push(callback);\n    this.logEvent(EventTypes.CBADDED, { callback, originalSource });\n    AExprRegistry.updateAExpr(this);\n    return this;\n  }\n  /**\n   * @public\n   * @param callback\n   * @returns {BaseActiveExpression} this very active expression (for chaining)\n   */\n  // #TODO: should this remove all occurences of the callback?\n  offChange(callback, originalSource) {\n    const index = this.callbacks.indexOf(callback);\n    if (index > -1) {\n      this.callbacks.splice(index, 1);\n      this.logEvent(EventTypes.CBREMOVED, { callback, originalSource });\n      AExprRegistry.updateAExpr(this);\n    }\n    if (this._shouldDisposeOnLastCallbackDetached && this.callbacks.length === 0) {\n      this.dispose();\n    }\n\n    return this;\n  }\n\n  /**\n   * Signals the active expression that a state change might have happened.\n   * Mainly for implementation strategies.\n   * @public\n   */\n  checkAndNotify(infoPromises = []) {\n    if (!this._isEnabled) {\n      return;\n    }\n\n    const { value, isError, eventPromise } = this.evaluateToCurrentValue();\n    const callbackStackTop = AExprRegistry.callbackStack[AExprRegistry.callbackStack.length - 1];\n    if (isError) {\n      eventPromise.then(event => {\n        if(!event.value) return;\n        Promise.all(infoPromises).then(triggers => {\n          event.value.triggers = triggers;\n          event.value.parentAE = callbackStackTop && callbackStackTop.ae;\n          event.value.callback = callbackStackTop && callbackStackTop.callback;\n        });\n      });\n      return;\n    } else if (this.compareResults(this.lastValue, value)) {\n      return;\n    }\n    const lastValue = this.lastValue;\n    this.storeResult(value);\n    this.logEvent('changed value', Promise.all(infoPromises).then(triggers => {\n      /*if(dependency) {\n        if(dependency.context instanceof HTMLElement) {\n          if(!dependency.context.changedAEs) {\n            dependency.context.changedAEs = new Set();\n          }\n          dependency.context.changedAEs.add(this);\n        }\n      }*/\n      return {\n        value,\n        triggers,\n        lastValue,\n        parentAE: callbackStackTop && callbackStackTop.ae,\n        callback: callbackStackTop && callbackStackTop.callback };\n    }));\n\n    this.notify(value, {\n      lastValue,\n      expr: this.func,\n      aexpr: this\n    });\n  }\n\n  async findCallee() {\n    const stack = lively.stack();\n    const frames = stack.frames;\n\n    for (let frame of frames) {\n      if (!frame.file.includes(\"active-expression\") && frame.file !== \"<anonymous>\") {\n        return await frame.getSourceLocBabelStyle();\n      }\n    }\n    return undefined;\n  }\n\n  async extractSourceMap(code) {\n    var m = code.match(/\\/\\/# sourceMappingURL=(.*)(\\n|$)/);\n    if (!m) return false;\n    var sourceMappingURL = m[1];\n    return (await fetch(sourceMappingURL)).json();\n  }\n\n  extractSourceURL(code) {\n    var m = code.match(/\\/\\/# sourceURL=(.*)(\\n|$)/);\n    if (!m) return false;\n    return m[1];\n  }\n\n  setupMatcher(matchConfig) {\n    // configure using existing matcher\n    if (matchConfig && isString.call(matchConfig)) {\n      if (!MATCHER_MAP.has(matchConfig)) {\n        throw new Error(`No matcher of type '${matchConfig}' registered.`);\n      }\n      this.matcher = MATCHER_MAP.get(matchConfig);\n      return;\n    }\n\n    // configure using a custom matcher\n    if (typeof matchConfig === 'object') {\n      if (matchConfig.hasOwnProperty('compare') && matchConfig.hasOwnProperty('store')) {\n        this.matcher = matchConfig;\n        return;\n      }\n      throw new Error(`Given matcher object does not provide 'compare' and 'store' methods.`);\n    }\n\n    // use smart default matcher\n    this.matcher = DefaultMatcher;\n  }\n\n  // #TODO: extract into CompareAndStore classes\n  compareResults(lastResult, newResult) {\n    try {\n      window.__compareAExprResults__ = true;\n      return this.matcher.compare(lastResult, newResult);\n    } finally {\n      window.__compareAExprResults__ = false;\n    }\n  }\n\n  storeResult(result) {\n    try {\n      window.__compareAExprResults__ = true;\n      this.lastValue = this.matcher.store(result);\n    } finally {\n      window.__compareAExprResults__ = false;\n    }\n  }\n\n  notify(...args) {\n    this.callbacks.forEach(callback => {\n      AExprRegistry.addToCallbackStack(this, callback);\n      callback(...args);\n      AExprRegistry.popCallbackStack();\n    });\n    AExprRegistry.updateAExpr(this);\n  }\n\n  updateDependencies() {}\n\n  /**\n   * Change the expression to be monitored.\n   * @public\n   * @param func (Function) the new function to be monitored.\n   * @param options ({ checkImmediately = true }) whether `notify` will be executed if the current value of the expression is different from the last on, defaults to true.\n   * @returns {BaseActiveExpression} this very active expression (for chaining)\n   */\n  setExpression(func, { checkImmediately = true } = {}) {\n    if (!(func instanceof Function)) {\n      throw new TypeError('no function given to .setExpression');\n    }\n\n    this.func = func;\n    this.updateDependencies();\n    if (checkImmediately) {\n      this.checkAndNotify();\n    }\n\n    return this;\n  }\n\n  /*MD ## Convenience Methods MD*/\n  onBecomeTrue(callback) {\n    // setup dependency\n    this.onChange(bool => {\n      if (bool) {\n        callback();\n      }\n    });\n\n    // check initial state\n    const { value, isError } = this.evaluateToCurrentValue();\n    if (!isError && value) {\n      this.storeResult(value);\n      callback();\n    }\n\n    return this;\n  }\n\n  onBecomeFalse(callback) {\n    // setup dependency\n    this.onChange(bool => {\n      if (!bool) {\n        callback();\n      }\n    });\n\n    // check initial state\n    const { value, isError } = this.evaluateToCurrentValue();\n    if (!isError && !value) {\n      this.storeResult(value);\n      callback();\n    }\n\n    return this;\n  }\n\n  dataflow(callback, orignalSource) {\n    // setup dependency\n    this.onChange(callback, orignalSource);\n\n    // call immediately\n    // #TODO: duplicated code: we should extract this call\n    const { value, isError } = this.evaluateToCurrentValue();\n    if (!isError) {\n      this.storeResult(value);\n      callback(value, {});\n    }\n\n    return this;\n  }\n\n  /*MD ## Disposing MD*/\n  dispose() {\n    if (!this._isDisposed) {\n      this._isDisposed = true;\n      this.removeAllCallbacks();\n      AExprRegistry.removeAExpr(this);\n      this.emit('dispose');\n      this.logEvent(EventTypes.DISPOSED);\n    }\n  }\n\n  removeAllCallbacks() {\n    for (const callback of this.callbacks) {\n      this.offChange(callback);\n    }\n  }\n\n  isDisposed() {\n    return this._isDisposed;\n  }\n\n  /**\n   * #TODO: implement\n   * disposeOnLastCallbackDetached\n   * chainable\n   * for some auto-cleanup\n   * (only triggers, when a callback is detached; not initially, if there are no callbacks)\n   */\n  disposeOnLastCallbackDetached() {\n    this._shouldDisposeOnLastCallbackDetached = true;\n    return this;\n  }\n\n  gotDisposed() {\n    if (this._disposedPromise) {\n      return this._disposedPromise;\n    }\n\n    return this._disposedPromise = new Promise(resolve => {\n      if (this.isDisposed()) {\n        resolve();\n      } else {\n        this.on('dispose', resolve);\n      }\n    });\n  }\n\n  /*MD ## Scoping: Enable, Disable \n  \n    In contrast to scoping with respect to applying a single expression to multiple subjects\n  MD*/\n\n  enable({ check = true } = {}) {\n    if (!this._isEnabled) {\n      this._isEnabled = true;\n      this.emit('enable');\n\n      this.updateDependencies();\n      if (check) {\n        this.checkAndNotify();\n      } else {\n        this.updateLastValue();\n      }\n    }\n  }\n\n  disable() {\n    if (this._isEnabled) {\n      this._isEnabled = false;\n      this.emit('disable');\n    }\n  }\n\n  isEnabled() {\n    return this._isEnabled;\n  }\n\n  isDisabled() {\n    return !this._isEnabled;\n  }\n\n  /*MD ## Reflection Information MD*/\n  shouldLogEvents() {\n    if(this.loggingMode === LoggingModes.DEFAULT) {\n      const location = this.meta().get(\"location\");\n      if(location) {\n        return AExprRegistry.shouldLog(location.file, location.start.line) \n      }\n    }\n    return this.loggingMode === LoggingModes.ALL;\n  }\n  \n  toggleLogging() {\n    this.setLogging(!this.shouldLogEvents());\n  }\n  \n  setLogging(enable) {\n    this.loggingMode = enable ? LoggingModes.ALL : LoggingModes.NONE;\n  }\n  \n  logState() {\n    let events = this.events;\n    return (this.shouldLogEvents() ? \"logged: \" : \"not logged: \") + (this.completeHistory ? \"complete \" : \"incomplete \") + pluralize(events.length, \"event\")\n  }\n  \n  meta(annotation) {\n    if (annotation) {\n      this._annotations.add(annotation);\n      return this;\n    } else {\n      return this._annotations;\n    }\n  }\n\n  getSymbol() {\n    return this.identifierSymbol;\n  }\n\n  getLocationText() {\n    const location = this.meta().get(\"location\");\n    if (location) {\n      return location.file.substring(location.file.lastIndexOf(\"/\") + 1) + \" line \" + location.start.line;\n    } else {\n      return \"unknown location\";\n    }\n  }\n  \n  getIdentifier() {\n    if(this.isDataBinding()) {\n      return this.getDataBinding().identifier;\n    }\n    if(this.isILA()) {\n      return this.getLayer().name;\n    }\n    return this.getSourceCode(60);\n  }\n\n  getName() {\n    if(this.isDataBinding()) {\n      return this.identifierSymbol + \" \" + this.getDataBinding().identifier;\n    }\n    if(this.isILA()) {\n      return this.identifierSymbol + \" \" + this.getLayer().name;\n    }\n    const location = this.meta().get(\"location\");\n    if (location) {\n      return this.identifierSymbol + \" \" + this.getLocationText();\n    } else {\n      return this.identifierSymbol + \" \" + this.meta().get(\"id\");\n    }\n  }\n  \n  get events() {\n    return this.meta().get('events')\n  }\n\n  isDataBinding() {\n    return this.meta().get('conceptType') === DebugConceptType.DB;\n  }\n\n  isILA() {\n    return this.meta().get('conceptType') === DebugConceptType.ILA;\n  }\n  \n  getType() {\n    if(this.isDataBinding()) {\n      return \"Signal\";\n    }\n    if(this.isILA()) {\n      return \"Implicit Layer\";\n    }\n    return \"Active Expression\";\n  }\n  \n  getTypeShort() {\n    if(this.isDataBinding()) {\n      return \"SI\";\n    } \n    if(this.isILA()) {\n      return \"IL\";\n    }\n    return \"AE\";\n  }\n  \n  getLayer() {\n    if(!this.isILA()) return undefined;\n    return this.meta().get('conceptInfo');\n  }\n  \n  getDataBinding() {\n    if(!this.isDataBinding()) return undefined;\n    return this.meta().get('conceptInfo');\n  }\n\n  getSourceCode(cutoff = -1, oneLine = true) {\n    let code;\n    if (this.meta().has('sourceCode')) {\n      code = this.meta().get('sourceCode');\n    } else {\n      code = \"unknown code\";\n    }\n    if (code.startsWith(\"() =>\")) {\n      code = code.substring(5);\n    }\n    if (oneLine) {\n      code = code.replace(/\\s+/g, \" \");\n    }\n    code = code.trim();\n    if (cutoff < 0) return code;\n    if (code.length > cutoff + 3) {\n      return code.substring(0, cutoff) + \"...\";\n    }\n    return code;\n  }\n\n  supportsDependencies() {\n    return false;\n  }\n\n  initializeEvents() {\n    this.meta({ events: new Array() });\n  }\n  \n  markTimestamp(reason) {\n    this.logEvent(EventTypes.CUSTOM, reason);\n  }\n  \n  addEvent(event) {\n    const events = this.events;\n    events.push(event);\n    if(events.length !== 1 && events[events.length - 2].overallID > event.overallID) {\n      events.sort((e1, e2) => e1.overallID - e2.overallID);\n    }\n    if (events.length > 5000) events.shift();\n    return events.length; //IDs are broken after 5000 events.\n  }\n\n  logEvent(type, value, overrideTimestamp = undefined) {\n    if (this.isMeta()) return;\n    if(!this.shouldLogEvents()) {\n      this.completeHistory = false;\n      return Promise.resolve({});\n    }\n    if(type == EventTypes.CBADDED && (this.isILA() || this.isDataBinding())) {\n      return; //We do not need to log callbacks for signals and layers\n    }\n    const e = new Event(this, value, type, overrideTimestamp);\n    return e.ensureResolved();\n  }\n\n  // Migrates the events from another event to this one. \n  // It is advisable to only call this, when we know that this AE replaces \"other\" and when other was disposed before this AE was created..\n  migrateEvents(other) {\n    let otherEvents = other.events;\n    let events = this.events;\n\n    events.unshift(...otherEvents);\n  }\n\n  isMeta(value) {\n    if (value !== undefined) this.meta({ isMeta: value });else return this.meta().has('isMeta') && this.meta().get('isMeta');\n  }\n\n  /*MD ## Iterators and Utility Methods MD*/\n\n  // #Discussion: should this reject, if the aexpr gets disposed?\n  nextValue() {\n    return new Promise(resolve => {\n      const callback = value => {\n        this.offChange(callback);\n        resolve(value);\n      };\n      this.onChange(callback);\n    });\n  }\n\n  values() {\n    const gotDisposed = this.gotDisposed();\n\n    const valueQueue = [];\n\n    let gotNewValue;\n    let waitForValue;\n    function resetWaitForValue() {\n      waitForValue = new Promise(resolve => {\n        gotNewValue = resolve;\n      });\n    }\n    resetWaitForValue();\n\n    this.onChange(v => {\n      valueQueue.push(v);\n      const temp = gotNewValue;\n      resetWaitForValue();\n      temp();\n    });\n\n    return {\n      [Symbol.asyncIterator]() {\n        return {\n          next() {\n            if (valueQueue.length > 0) {\n              return {\n                value: valueQueue.shift(),\n                done: false\n              };\n            } else {\n              return Promise.race([waitForValue.then(() => this.next()), gotDisposed.then(() => ({ done: true }))]);\n            }\n          }\n        };\n      }\n    };\n  }\n}\n\nexport function aexpr(func, ...args) {\n  return new BaseActiveExpression(func, ...args);\n}\n\nexport default BaseActiveExpression;\n\n// #TODO: migrate aexpr object to new/reloaded classes"]}