{"version":3,"sources":["https://lively-kernel.org/lively4/lively4-tom/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","addAExpr","add","buildIdFor","dispatchEvent","removeAExpr","deleted","delete","updateAExpr","on","type","callback","addEventListener","off","removeEventListener","addToCallbackStack","ae","push","popCallbackStack","pop","callbackStack","locationId","meta","has","location","get","file","replace","lively4url","start","line","column","set","id","purge","each","_isDisposed","callbacks","clear","allAsArray","Array","from","reference","listeners","eventListeners","filter","listener","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","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__ || [];\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  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  eventListeners() {\n    if(!this.listeners) return [];\n    this.listeners = this.listeners.filter(listener => listener.reference);\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    return this.func(...this.params);\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"]}