{"version":3,"sources":["https://lively-kernel.org/lively4/lively4-eventsourcing/src/client/reactive/active-expression/active-expression.js"],"names":["Annotations","EventTarget","shallowEqualsArray","shallowEqualsSet","shallowEqualsMap","shallowEquals","deepEquals","isString","clone","cloneDeep","sourcemap","aexpr","HACK","window","__compareAExprResults__","self","__aexprRegistry_eventTarget__","__aexprRegistry_aexprs__","Set","__aexprRegistry_idCounters__","Map","__aexprRegistry_callbackStack__","__aexprRegistry_evaluationStack__","AExprRegistry","addAExpr","add","buildIdFor","dispatchEvent","removeAExpr","deleted","delete","updateAExpr","on","type","callback","addEventListener","off","removeEventListener","addToCallbackStack","ae","push","popCallbackStack","pop","callbackStack","addToEvaluationStack","popEvaluationStack","evaluationStack","locationId","meta","has","location","get","file","replace","lively4url","start","line","column","set","id","purge","each","_isDisposed","callbacks","clear","allAsArray","Array","from","reference","listeners","filter","listener","eventListeners","DefaultMatcher","compare","lastResult","newResult","isArray","store","result","prototype","slice","call","IdentityMatcher","ShallowMatcher","DeepMatcher","MATCHER_MAP","NO_VALUE_YET","Symbol","BaseActiveExpression","constructor","func","params","match","errorMode","disabled","sourceCode","_eventTarget","_isEnabled","setupMatcher","_initLastValue","_shouldDisposeOnLastCallbackDetached","_annotations","initializeEvents","addToRegistry","logEvent","stack","lively","value","lastValue","updateLastValue","isError","evaluateToCurrentValue","storeResult","hasCallbacks","length","getCurrentValue","returnValue","e","emit","getEventListeners","onChange","originalSource","offChange","index","indexOf","splice","dispose","checkAndNotify","dependency","hook","compareResults","parentAE","Promise","resolve","then","trigger","notify","expr","findCallee","frames","frame","includes","getSourceLocBabelStyle","undefined","extractSourceMap","code","m","sourceMappingURL","fetch","json","extractSourceURL","matchConfig","Error","matcher","hasOwnProperty","args","forEach","updateDependencies","setExpression","checkImmediately","Function","TypeError","onBecomeTrue","bool","onBecomeFalse","dataflow","orignalSource","isDisposed","disposeOnLastCallbackDetached","gotDisposed","_disposedPromise","enable","check","disable","isEnabled","isDisabled","annotation","supportsDependencies","events","isMeta","timestamp","Date","event","shift","nextValue","values","valueQueue","gotNewValue","waitForValue","resetWaitForValue","v","temp","asyncIterator","next","done","race"],"mappings":"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","file":"active-expression.js","sourcesContent":["import Annotations from '../utils/annotations.js';\nimport EventTarget from '../utils/event-target.js';\nimport { shallowEqualsArray, shallowEqualsSet, shallowEqualsMap, shallowEquals, deepEquals } from '../utils/equality.js';\nimport { isString, clone, cloneDeep } from 'utils';\n\nimport sourcemap from 'src/external/source-map.min.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\nself.__aexprRegistry_eventTarget__ = self.__aexprRegistry_eventTarget__ || new EventTarget();\nself.__aexprRegistry_aexprs__ = self.__aexprRegistry_aexprs__ || new Set();\nself.__aexprRegistry_idCounters__ = self.__aexprRegistry_idCounters__ || new Map();\nself.__aexprRegistry_callbackStack__ = self.__aexprRegistry_callbackStack__ || [];\nself.__aexprRegistry_evaluationStack__ = self.__aexprRegistry_evaluationStack__ || [];\n\n/*MD ## Registry of Active Expressions MD*/\nexport const AExprRegistry = {\n\n  /**\n   * Handling membership\n   */\n  addAExpr(aexpr) {\n    self.__aexprRegistry_aexprs__.add(aexpr);\n    this.buildIdFor(aexpr);\n    self.__aexprRegistry_eventTarget__.dispatchEvent('add', aexpr);\n  },\n  removeAExpr(aexpr) {\n    const deleted = self.__aexprRegistry_aexprs__.delete(aexpr);\n    if (deleted) {\n      self.__aexprRegistry_eventTarget__.dispatchEvent('remove', aexpr);\n    }\n  },\n  updateAExpr(aexpr) {\n    self.__aexprRegistry_eventTarget__.dispatchEvent('update', aexpr);\n  },\n\n  on(type, callback) {\n    return self.__aexprRegistry_eventTarget__.addEventListener(type, callback);\n  },\n  off(type, callback) {\n    return self.__aexprRegistry_eventTarget__.removeEventListener(type, callback);\n  },\n  \n  addToCallbackStack(ae) {\n    self.__aexprRegistry_callbackStack__.push(ae);\n  },\n\n  popCallbackStack() {\n    self.__aexprRegistry_callbackStack__.pop();  \n  },  \n  \n  callbackStack() {\n    return self.__aexprRegistry_callbackStack__;\n  },\n  \n  \n  addToEvaluationStack(ae) {\n    self.__aexprRegistry_evaluationStack__.push(ae);\n  },  \n\n  popEvaluationStack() {\n    self.__aexprRegistry_evaluationStack__.pop();  \n  },\n  \n  evaluationStack() {\n    return self.__aexprRegistry_evaluationStack__;\n  },\n  \n  buildIdFor(ae) {\n    let locationId;\n    if (ae.meta().has('location')) {\n      let location = ae.meta().get('location');\n      let file = location.file.replace(lively4url + '/', '');\n      locationId = file + '@' + location.start.line + ':' + location.start.column;\n    } else {\n      locationId = 'unknown_location';\n    }\n    self.__aexprRegistry_idCounters__.set(locationId, self.__aexprRegistry_idCounters__.get(locationId) + 1 || 0);\n    ae.meta({ id: locationId + '#' + self.__aexprRegistry_idCounters__.get(locationId) });\n  },\n\n  /**\n   * For Development purpose if the registry gets into inconsistent state\n   */\n  purge() {\n    for (let each of self.__aexprRegistry_aexprs__) {\n      each._isDisposed = true;\n    }\n    self.__aexprRegistry_eventTarget__.callbacks.clear();\n    self.__aexprRegistry_aexprs__.clear();\n    self.__aexprRegistry_idCounters__.clear();\n  },\n\n  /**\n   * Access\n   */\n  allAsArray() {\n    return Array.from(self.__aexprRegistry_aexprs__);\n  },\n\n  addEventListener(reference, callback) {\n    if(!this.listeners) this.listeners = []\n    this.listeners.push({ reference, callback });\n  },\n\n  removeEventListener(reference) {\n    if(!this.listeners) return;\n    this.listeners = this.listeners.filter(listener => listener.reference !== reference);\n  },\n\n  eventListeners() {\n    if(!this.listeners) return [];\n    return this.listeners;\n  }\n};\n\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    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    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\nconst MATCHER_MAP = new Map([['default', DefaultMatcher], ['identity', IdentityMatcher], ['shallow', ShallowMatcher], ['deep', DeepMatcher]]);\n\nconst NO_VALUE_YET = Symbol('No value yet');\n\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  } = {}) {\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._initLastValue();\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    if (sourceCode) {\n      this.meta({ sourceCode });\n    }\n\n    this.initializeEvents();\n\n    this.addToRegistry();\n    this.logEvent('created', {ae: this, stack: lively.stack(), value: \"no value yet\"});\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    const returnValue = this.func(...this.params);\n    AExprRegistry.popEvaluationStack();\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      return { value: e, isError: true };\n    }\n  }\n\n  /*MD ## EventTarget Interface MD*/\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 ## --- 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('callbacks changed', 'Added: ' + (originalSource ? originalSource.sourceCode : callback));\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('callbacks', 'Removed: ' + (originalSource ? originalSource.sourceCode : callback));\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(location, dependency, hook) {\n    if (!this._isEnabled) {\n      return;\n    }\n\n    const { value, isError } = this.evaluateToCurrentValue();\n    if (isError || this.compareResults(this.lastValue, value)) {\n      return;\n    }\n    const lastValue = this.lastValue;\n    this.storeResult(value);\n    const parentAE = AExprRegistry.callbackStack()[AExprRegistry.callbackStack().length - 1];\n    Promise.resolve(location)\n      .then(trigger => this.logEvent('changed value', { value, trigger, dependency, hook, lastValue, parentAE}));\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    AExprRegistry.addToCallbackStack(this);\n    this.callbacks.forEach(callback => callback(...args));\n    AExprRegistry.popCallbackStack();\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      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      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      callback(value, {});\n    }\n\n    return this;\n  }\n\n  /*MD ## Disposing MD*/\n  dispose() {\n    if (!this._isDisposed) {\n      this._isDisposed = true;\n      AExprRegistry.removeAExpr(this);\n      this.emit('dispose');\n      this.logEvent('disposed');\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  meta(annotation) {\n    if (annotation) {\n      this._annotations.add(annotation);\n      return this;\n    } else {\n      return this._annotations;\n    }\n  }\n\n  supportsDependencies() {\n    return false;\n  }\n\n  initializeEvents() {\n    this.meta({ events: new Array() });\n  }\n\n  logEvent(type, value) {\n    if (this.isMeta()) return;\n    //if(!this.meta().has('events'))this.meta({events : new Array()});\n    let events = this.meta().get('events');\n    const timestamp = new Date();\n    const event = { timestamp , type, value, id: this.meta().get('id') + \"-\" + events.length };\n    AExprRegistry.eventListeners().forEach(listener => listener.callback(this, event));\n    events.push(event);\n    if (events.length > 5000) events.shift();\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"]}