{"version":3,"sources":["https://lively-kernel.org/lively4/lively4-theresa/src/client/reactive/active-expression/active-expression.js"],"names":["Annotations","shallowEqualsArray","shallowEqualsSet","shallowEqualsMap","shallowEquals","deepEquals","isString","clone","cloneDeep","HACK","window","__compareAExprResults__","AExprRegistry","_aexprs","Set","addAExpr","aexpr","add","removeAExpr","delete","allAsArray","Array","from","DefaultMatcher","compare","lastResult","newResult","isArray","Map","store","result","prototype","slice","call","IdentityMatcher","ShallowMatcher","DeepMatcher","MATCHER_MAP","NO_VALUE_YET","Symbol","BaseActiveExpression","constructor","func","params","match","errorMode","setupMatcher","_initLastValue","callbacks","_isDisposed","_shouldDisposeOnLastCallbackDetached","_annotations","new","target","addToRegistry","value","isError","evaluateToCurrentValue","storeResult","lastValue","getCurrentValue","e","onChange","callback","push","offChange","index","indexOf","splice","length","dispose","checkAndNotify","compareResults","notify","expr","matchConfig","has","Error","matcher","get","hasOwnProperty","args","forEach","applyOn","items","onBecomeTrue","bool","onBecomeFalse","dataflow","isDisposed","disposeOnLastCallbackDetached","name","meta","annotation","supportsDependencies"],"mappings":"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","file":"active-expression.js","sourcesContent":["import Annotations from '../utils/annotations.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\nexport const AExprRegistry = {\n\n  _aexprs: new Set(),\n\n  /**\n   * Handling membership\n   */\n  addAExpr(aexpr) {\n    this._aexprs.add(aexpr);\n  },\n  removeAExpr(aexpr) {\n    this._aexprs.delete(aexpr);\n  },\n\n  /**\n   * Access\n   */\n  allAsArray() {\n    return Array.from(this._aexprs);\n  }\n};\n\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\nexport class BaseActiveExpression {\n\n  /**\n   *\n   * @param func (Function) the expression to be observed\n   * @param ...params (Objects) the instances bound as parameters to the expression\n   */\n  constructor(func, { params = [], match, errorMode = 'silent' } = {}) {\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\n    if(new.target === BaseActiveExpression) {\n      this.addToRegistry();\n    }\n  }\n  \n//   addEventListener(type, callback) {\n    \n//   }\n  \n//   removeEventListener(type, callback) {\n    \n//   }\n  \n//   dispatchEvent() {\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  /**\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   * @public\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  /**\n   * @public\n   * @param callback\n   * @returns {BaseActiveExpression} this very active expression (for chaining)\n   */\n  onChange(callback) {\n    this.callbacks.push(callback);\n\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    }\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.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  }\n\n  /**\n   * TODO\n   * like a bind for AExpr\n   * @param items\n   */\n  applyOn(...items) {\n    throw new Error('Not yet implemented');\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  dispose() {\n    this._isDisposed = true;\n    AExprRegistry.removeAExpr(this);\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  /**\n   * Reflection information\n   */\n\n  name(...args) {\n    if(args.length > 0) {\n      this._annotations.add({ name: args[0] });\n      return this;\n    } else {\n      return this._annotations.get('name');\n    }\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  supportsDependencies() {\n    return false;\n  }\n}\n\nexport function aexpr(func, ...args) {\n  return new BaseActiveExpression(func, ...args);\n}\n\nexport default BaseActiveExpression;\n"]}