{"version":3,"sources":["https://lively-kernel.org/lively4/lively4-mpm-debugging/src/client/reactive/active-expression/active-expression.js"],"names":["Annotations","EventTarget","shallowEqualsArray","shallowEqualsSet","shallowEqualsMap","shallowEquals","deepEquals","isString","clone","cloneDeep","HACK","window","__compareAExprResults__","AExprRegistry","_eventTarget","_aexprs","Set","_idCounters","Map","addAExpr","aexpr","add","buildIdFor","dispatchEvent","removeAExpr","deleted","delete","updateAExpr","on","type","callback","addEventListener","off","removeEventListener","ae","locationId","meta","has","location","get","file","replace","lively4url","start","line","column","set","id","purge","each","_isDisposed","callbacks","clear","allAsArray","Array","from","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","setupMatcher","_initLastValue","_shouldDisposeOnLastCallbackDetached","_annotations","initializeEvents","logEvent","new","target","addToRegistry","value","isError","evaluateToCurrentValue","storeResult","lastValue","hasCallbacks","length","getCurrentValue","e","emit","getEventListeners","onChange","push","offChange","index","indexOf","splice","dispose","checkAndNotify","compareResults","notify","expr","matchConfig","Error","matcher","hasOwnProperty","args","forEach","onBecomeTrue","bool","onBecomeFalse","dataflow","isDisposed","disposeOnLastCallbackDetached","annotation","supportsDependencies","events","isMeta","timestamp","Date","shift","undefined"],"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\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\n/*MD ## Registry of Active Expressions MD*/\nexport const AExprRegistry = {\n\n  _eventTarget: new EventTarget(),\n  _aexprs: new Set(),\n  _idCounters: new Map(),\n\n  /**\n   * Handling membership\n   */\n  addAExpr(aexpr) {\n    this._aexprs.add(aexpr);\n    this.buildIdFor(aexpr);\n    this._eventTarget.dispatchEvent('add', aexpr);\n  },\n  removeAExpr(aexpr) {\n    const deleted = this._aexprs.delete(aexpr);\n    if (deleted) {\n      this._eventTarget.dispatchEvent('remove', aexpr);\n    }\n  },\n  updateAExpr(aexpr) {\n      this._eventTarget.dispatchEvent('update', aexpr);\n  },\n  \n  on(type, callback) {\n    return this._eventTarget.addEventListener(type, callback);\n  },\n  off(type, callback) {\n    return this._eventTarget.removeEventListener(type, callback);\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    this._idCounters.set(locationId, this._idCounters.get(locationId) + 1 || 0);\n    ae.meta({id : locationId+'#'+this._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 this._aexprs)each._isDisposed = true;\n    this._eventTarget.callbacks.clear();\n    this._aexprs.clear();\n    this._idCounters.clear();\n  },\n\n  /**\n   * Access\n   */\n  allAsArray() {\n    return Array.from(this._aexprs);\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([\n  ['default', DefaultMatcher],\n  ['identity', IdentityMatcher],\n  ['shallow', ShallowMatcher],\n  ['deep', DeepMatcher]\n]);\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, { params = [], match, errorMode = 'silent', location } = {}) {\n    this._eventTarget = new EventTarget(),\n    this.func = func;\n    this.params = params;\n    this.errorMode = errorMode;\n    this.setupMatcher(match);\n    this._initLastValue();\n    this.callbacks = [];\n    // this.allCallbacks = new Map();\n    this._isDisposed = false;\n    this._shouldDisposeOnLastCallbackDetached = false;\n\n    this._annotations = new Annotations();\n    if(location){this.meta({location})};\n    this.initializeEvents();\n    this.logEvent('created');\n\n    if(new.target === BaseActiveExpression) {\n      this.addToRegistry();\n    }\n  }\n  \n  _initLastValue() {\n    const { value, isError } = this.evaluateToCurrentValue();\n    if (!isError) {\n      this.storeResult(value);\n    } else {\n      this.lastValue = NO_VALUE_YET;\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) {\n    this.callbacks.push(callback);\n    this.logEvent('dependencies changed', 'Added: '+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) {\n    const index = this.callbacks.indexOf(callback);\n    if (index > -1) {\n      this.callbacks.splice(index, 1);\n      this.logEvent('dependencies changed', 'Removed: '+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() {\n    const { value, isError } = this.evaluateToCurrentValue();\n    if(isError || this.compareResults(this.lastValue, value)) { return; }\n    const lastValue = this.lastValue;\n    this.storeResult(value);\n    \n    this.logEvent('changed value', value);\n\n    this.notify(value, {\n      lastValue,\n      expr: this.func ,\n      aexpr: this\n    });\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 => callback(...args));\n    AExprRegistry.updateAExpr(this);\n  }\n\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) { callback(); }\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) { callback(); }\n\n    return this;\n  }\n\n  dataflow(callback) {\n    // setup dependency\n    this.onChange(callback);\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  /*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    events.push({timestamp: new Date(), type, value});\n    if(events.length > 5000)events.shift();\n  }\n  \n  isMeta(value) {\n    if(value !== undefined)this.meta({isMeta : value});\n    else return this.meta().has('isMeta') && this.meta().get('isMeta');\n  }\n}\n\nexport function aexpr(func, ...args) {\n  return new BaseActiveExpression(func, ...args);\n}\n\nexport default BaseActiveExpression;\n"]}