{"version":3,"sources":["https://lively-kernel.org/lively4/lively4-synctool/src/client/reactive/active-expression/active-expression.js"],"names":["EventTarget","Annotations","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","MATCHER_MAP","NO_VALUE_YET","Symbol","aeCounter","eventCounter","identitiySymbolProvider","BaseActiveExpression","constructor","func","params","match","errorMode","disabled","location","sourceCode","isDataBinding","dataBindingContext","dataBindingIdentifier","id","loggingMode","DEFAULT","completeHistory","_eventTarget","_isEnabled","setupMatcher","callbacks","_isDisposed","_shouldDisposeOnLastCallbackDetached","_annotations","meta","identifierSymbol","next","initializeEvents","addToRegistry","_initLastValue","logEvent","stack","lively","value","lastValue","updateLastValue","isError","evaluateToCurrentValue","storeResult","addAExpr","hasCallbacks","length","getCurrentValue","addToEvaluationStack","returnValue","popEvaluationStack","e","eventPromise","error","on","type","callback","addEventListener","off","removeEventListener","emit","dispatchEvent","getEventListeners","onChange","originalSource","push","updateAExpr","offChange","index","indexOf","splice","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","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","getName","getSourceCode","cutoff","oneLine","startsWith","replace","trim","supportsDependencies","isMeta","timestamp","Date","overallID","resolvedValue","eventListeners","listener","shift","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 { 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\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;\nlet eventCounter = 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\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({ isDataBinding });\n      this.meta({ dataBindingContext });\n      this.meta({ dataBindingIdentifier });\n    }\n\n    this.initializeEvents();\n\n    this.addToRegistry();\n    this._initLastValue();\n    this.logEvent('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('evaluation failed', {error: e});\n      return { value: e, isError: true, eventPromise };\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('callback added', { 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('callback removed', { 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('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.meta().get('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  getName() {\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  isDataBinding() {\n    if (this.meta().has('isDataBinding')) {\n      return this.meta().get('isDataBinding');\n    }\n    return false;\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  logEvent(type, value) {\n    if (this.isMeta()) return;\n    if(!this.shouldLogEvents()) {\n      this.completeHistory = false;\n      return Promise.resolve({});\n    }\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 overallID = eventCounter;\n    eventCounter++;\n    return Promise.resolve(value).then(resolvedValue => {\n      const event = { timestamp, overallID, ae: this, type, value: resolvedValue, 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      return event;\n    });\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.meta().get('events');\n    let events = this.meta().get('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"]}