{"version":3,"sources":["https://lively-kernel.org/lively4/lively4-drawio/src/client/reactive/active-group/select.js"],"names":["View","default","pushIfMissing","removeIfExisting","Stack","isPrimitive","identity","BaseActiveExpression","aexpr","cop","PausableLoop","HACK","baseViewByClass","WeakMap","ensureBaseViewForClass","Class","has","set","get","baseViewForClass","trackInstance","instance","safeAdd","untrackInstance","safeRemove","trackInitializeAndDestroy","layer","refineClass","initialize","args","result","proceed","call","destroy","beGlobal","Operator","IdentityOperator","newItemFromUpstream","item","downstream","destroyItemFromUpstream","FilterOperator","constructor","upstream","expression","selectionItems","push","now","forEach","onNewInstance","params","onBecomeTrue","add","onBecomeFalse","remove","indexOf","addDueToFilterExpression","removeDueToFilterExpression","MapOperator","mapFunction","items","outputItemsByItems","Map","wasNewItem","outputItem","gotRemoved","delete","UnionOperator","upstream1","upstream2","concat","itemAlreadyExists","includes","itemStillExists","FlowToFunction","create","Pair","first","second","CrossOperator","trackedItems","pairs","bind","index","forEachPairWithDo","pair","callback","zeroes","ones","zeroElement","oneElement","getOrCreatePairForCombination","zero","one","map","DelayOperator","delayTime","delays","setInterval","clearTimeout","ReduceOperator","reducer","initialValue","reduce","checkAndNotify","Object","assign","prototype","filter","iterator","context","newSelection","union","otherView","cross","delay","stack","current","top","withOnStack","el","pop","selectorByAnimationName","selectors","animationCount","styles","document","createElement","keyframes","head","getElementsByTagName","startName","startEvent","event","selector","animationName","fn","roots","Set","startListenerByRoot","type","appendChild","addSelectorListener","root","key","listeners","replace","node","createTextNode","sheet","insertRule","addEventListener","stopMatchingDetectors","removeObsoleteListeners","Array","from","detector","matchesSelector","removeElement","size","pause","stopMatchingLoop","trackSelector","view","element","target","inDOM","getRootNode","composed","matches","ensureRunning","__unload__","removeEventListener","select","options"],"mappings":"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","file":"select.js","sourcesContent":["export { default as View} from './view.js';\nimport View from './view.js';\nimport { pushIfMissing, removeIfExisting, Stack, isPrimitive, identity } from './utils.js';\nimport { BaseActiveExpression } from 'active-expression';\nimport aexpr from 'active-expression-rewriting';\nimport * as cop  from \"src/client/ContextJS/src/contextjs.js\";\nimport { PausableLoop } from 'utils';\n\n// TODO: this is use to keep SystemJS from messing up scoping\n// (FilterOperation would not be defined in select)\nconst HACK = {};\n\n/**\n * #TODO: this is from withlogging.js\n */\n// #TODO: can we make this easier, e.g. automatically identifying the class to adapt from the very instance? What about superclasses?\nexport const baseViewByClass = new WeakMap();\n\nfunction ensureBaseViewForClass(Class) {\n  if(!baseViewByClass.has(Class)) {\n    baseViewByClass.set(Class, new View());\n  }\n  return baseViewByClass.get(Class);\n}\n\nexport function baseViewForClass(Class) {\n  return ensureBaseViewForClass(Class);\n}\n\nexport function trackInstance(instance) {\n  baseViewForClass(this).safeAdd(instance);\n}\n\nexport function untrackInstance(instance) {\n  baseViewForClass(this).safeRemove(instance);\n}\n\n// #TODO: ideally, we would track the constructor, maybe with **decorators**?\n// #TODO: unused, maybe use cop instead of a functional mixin\n// #TODO: use cop here\nexport function trackInitializeAndDestroy(Class) {\n  cop.layer().refineClass(Class, {\n    initialize(...args) {\n      const result = cop.proceed(...args);\n      trackInstance.call(Class, this);\n      return result;\n    },\n    destroy(...args) {\n      untrackInstance.call(Class, this);\n      return cop.proceed(...args);\n    }\n  }).beGlobal();\n}\n\nclass Operator {}\nclass IdentityOperator extends Operator {\n  // constructor(upstream, downstream) {\n  //     super();\n  //     this.downstream = downstream;\n  //     upstream.downstream.push(this);\n  //     upstream.now().forEach(function(item) {\n  //         downstream.safeAdd(item);\n  //     });\n  // }\n  newItemFromUpstream(item) {\n    this.downstream.safeAdd(item);\n  }\n  destroyItemFromUpstream(item) {\n    this.downstream.safeRemove(item);\n  }\n}\n\nclass FilterOperator extends IdentityOperator {\n  constructor(upstream, downstream, expression) {\n    super();\n    this.expression = expression;\n\n    this.selectionItems = [];\n\n    this.upstream = upstream;\n    this.downstream = downstream;\n    upstream.downstream.push(this);\n    upstream.now().forEach(item => this.newItemFromUpstream(item));\n  }\n  newItemFromUpstream(item) {\n    this.onNewInstance(item);\n  }\n  onNewInstance(item) {\n    aexpr(this.expression, { params: [item] })\n        .onBecomeTrue(() => this.add(item))\n        .onBecomeFalse(() => this.remove(item));\n  }\n  add(item) {\n    if(this.upstream.now().indexOf(item) >= 0) {\n      this.addDueToFilterExpression(item);\n    }\n  }\n  remove(item) {\n    this.removeDueToFilterExpression(item);\n  }\n  addDueToFilterExpression(item) {\n    this.downstream.safeAdd(item);\n  }\n  removeDueToFilterExpression(item) {\n    this.downstream.safeRemove(item);\n  }\n  destroyItemFromUpstream(item) {\n    this.remove(item);\n  }\n}\n\nclass MapOperator extends IdentityOperator {\n  constructor(upstream, downstream, mapFunction) {\n    super();\n    this.mapFunction = mapFunction || identity;\n    this.items = [];\n    this.outputItemsByItems = new Map();\n\n    this.downstream = downstream;\n    upstream.downstream.push(this);\n    upstream.now().forEach(item => this.newItemFromUpstream(item));\n  }\n  newItemFromUpstream(item) {\n    var wasNewItem = pushIfMissing(this.items, item);\n    if(wasNewItem) {\n      var outputItem = this.mapFunction(item);\n      this.outputItemsByItems.set(item, outputItem);\n      this.downstream.safeAdd(outputItem);\n    }\n  }\n  destroyItemFromUpstream(item) {\n    var gotRemoved = removeIfExisting(this.items, item);\n    if(gotRemoved) {\n      var outputItem = this.outputItemsByItems.get(item);\n      this.outputItemsByItems.delete(item);\n      this.downstream.safeRemove(outputItem);\n    }\n  }\n}\n\n// #TODO: allow for more than 2 upstreams to merge\nclass UnionOperator extends IdentityOperator {\n  constructor(downstream, upstream1, upstream2) {\n    super();\n    this.upstream1 = upstream1;\n    this.upstream2 = upstream2;\n    this.downstream = downstream;\n    upstream1.downstream.push(this);\n    upstream2.downstream.push(this);\n\n    upstream1.now().concat(upstream2.now()).forEach(function(item) {\n        this.newItemFromUpstream(item);\n    }, this);\n  }\n  newItemFromUpstream(item) {\n    var itemAlreadyExists = this.downstream.now().includes(item);\n    if(!itemAlreadyExists) {\n      this.downstream.safeAdd(item);\n    }\n  }\n  destroyItemFromUpstream(item) {\n    var itemStillExists = this.upstream1.now().includes(item) || this.upstream2.now().includes(item);\n    if(!itemStillExists) {\n      this.downstream.safeRemove(item);\n    }\n  }\n}\n\n// TODO: make this reusable\nclass FlowToFunction {\n    constructor(upstream, create, destroy) {\n        this.create = create;\n        this.destroy = destroy;\n        upstream.downstream.push(this);\n    }\n    newItemFromUpstream(item) {\n        this.create(item);\n    }\n    destroyItemFromUpstream(item) {\n        this.destroy(item);\n    }\n}\n\n/**\n *\n * @class Pair\n * @classdesc This is used by the {@link View#cross} operator.\n * @property {Object} first\n * @property {Object} second\n */\nclass Pair {\n    constructor(first, second) {\n        this.first = first;\n        this.second = second;\n    }\n}\n\nclass CrossOperator {\n    constructor(upstream1, upstream2, downstream) {\n        this.upstream1 = upstream1;\n        this.upstream2 = upstream2;\n        this.downstream = downstream;\n\n        this.trackedItems = [[], []];\n        this.pairs = new Map();\n\n        new FlowToFunction(upstream1, this.newItemFromUpstream.bind(this, 0), this.destroyItemFromUpstream.bind(this, 0));\n        new FlowToFunction(upstream2, this.newItemFromUpstream.bind(this, 1), this.destroyItemFromUpstream.bind(this, 1));\n        upstream1.now().forEach(this.newItemFromUpstream.bind(this, 0));\n        upstream2.now().forEach(this.newItemFromUpstream.bind(this, 1));\n    }\n    newItemFromUpstream(index, item) {\n        var wasNewItem = pushIfMissing(this.trackedItems[index], item);\n        if(wasNewItem) {\n            this.forEachPairWithDo(index, item, function(pair) {\n                this.downstream.safeAdd(pair);\n            });\n        }\n    }\n    destroyItemFromUpstream(index, item) {\n        var gotRemoved = removeIfExisting(this.trackedItems[index], item);\n        if(gotRemoved) {\n            this.forEachPairWithDo(index, item, function(pair) {\n                this.downstream.safeRemove(pair);\n            });\n        }\n    }\n    forEachPairWithDo(index, item, callback) {\n        var zeroes = index === 0 ? [item] : this.trackedItems[0];\n        var ones = index === 1 ? [item] : this.trackedItems[1];\n\n        zeroes.forEach(function(zeroElement) {\n            ones.forEach(function(oneElement) {\n                var pair = this.getOrCreatePairForCombination(zeroElement, oneElement);\n                callback.call(this, pair);\n            }, this);\n        }, this);\n    }\n    getOrCreatePairForCombination(zero, one) {\n        if(!this.pairs.has(zero)) {\n            this.pairs.set(zero, new Map());\n        }\n        var map = this.pairs.get(zero);\n        if(!map.has(one)) {\n            map.set(one, new Pair(zero, one));\n        }\n        return map.get(one);\n    }\n}\n\nclass DelayOperator extends IdentityOperator {\n    constructor(upstream, downstream, delayTime) {\n        super(upstream, downstream);\n        this.upstream = upstream;\n        this.downstream = downstream;\n        this.delayTime = delayTime;\n        upstream.downstream.push(this);\n\n        this.delays = new Map();\n\n        upstream.now().forEach(function(item) {\n            this.newItemFromUpstream(item);\n        }, this);\n    }\n    newItemFromUpstream(item) {\n        if(!this.delays.has(item)) {\n            this.delays.set(item, setInterval(\n              () => this.downstream.safeAdd(item),\n              this.delayTime));\n        }\n    }\n    destroyItemFromUpstream(item) {\n        this.downstream.safeRemove(item);\n        if(this.delays.has(item)) {\n            clearTimeout(this.delays.get(item));\n            this.delays.delete(item);\n        }\n    }\n}\n\nclass ReduceOperator {\n    constructor(upstream, reducer, initialValue) {\n        this.upstream = upstream;\n        upstream.downstream.push(this);\n        this.aexpr = new BaseActiveExpression(() =>\n          this.upstream.now().reduce(reducer, initialValue)\n        );\n    }\n    newItemFromUpstream() {\n        this.aexpr.checkAndNotify();\n    }\n    destroyItemFromUpstream() {\n        this.newItemFromUpstream();\n    }\n}\n\nObject.assign(View.prototype, {\n    /**\n     * Takes an additional filter function and returns a reactive object set. That set only contains the objects of the original set that also match the given filter function.\n     * @function View#filter\n     * @param {View~filterIterator} iterator\n     * @return {View} The callee of this method.\n     */\n    filter(iterator, context) {\n        var newSelection = new View();\n\n        new FilterOperator(this, newSelection, iterator, context);\n\n        return newSelection;\n    },\n    /**\n     * Takes a mapping function and returns another reactive object set. That set always contains the mapped objects corresponding to the objects in the original set.\n     * @function View#map\n     * @param {View~mapIterator} iterator\n     * @return {View} The callee of this method.\n     */\n    map(iterator) {\n        var newSelection = new View();\n\n        new MapOperator(this, newSelection, iterator);\n\n        return newSelection;\n    },\n    /**\n     * Create a new {@link View} containing all elements of the callee and the argument.\n     * @function View#union\n     * @param {View} otherView {@link View}\n     * @return {View} Contains every object of both input Views.\n     */\n    union(otherView) {\n        var newSelection = new View();\n\n        new UnionOperator(newSelection, this, otherView);\n\n        return newSelection;\n    },\n    /**\n     * Create a new {@link View} containing all elements of the cartesian product of the callee and the argument as {@link Pair}.\n     * @function View#cross\n     * @param {View} otherView {@link View}\n     * @return {View} Contains every combination of both input Views as two-element Array.\n     */\n    cross(otherView) {\n        var newSelection = new View();\n\n        new CrossOperator(this, otherView, newSelection);\n\n        return newSelection;\n    },\n\n    /**\n     * Delays the propagation of items of the callee.\n     * Items are propagated to the returned {@link View} in {@link View#delay.delayTime} milliseconds,\n     * if they are not removed from the callee before the timeout.\n     * @function View#delay\n     * @param {Number} delayTime - the time to delay given in milliSeconds.\n     * @returns {View}\n     */\n    delay(delayTime) {\n        var newSelection = new View();\n\n        new DelayOperator(this, newSelection, delayTime);\n\n        return newSelection;\n    },\n\n    /**\n     * Whenever the callee is modified, the returned Active Expression gets notified.\n     * @function View#reduce\n     * @param {View~reducer} reducer\n     * @param initialValue - the initial value passed to the {@View~reducer}.\n     * @returns {ActiveExpression} changing with the callee\n     */\n    reduce(reducer, initialValue) {\n        const reduce = new ReduceOperator(this, reducer, initialValue);\n\n        return reduce.aexpr;\n    }\n});\n\n/**\n * The callback function to determine whether an Object should be part of the resulting derived {@link View}.\n * @callback View~filterIterator\n * @param {Object} item - item from the original {@link View}.\n * @return {Boolean}\n */\n\n/**\n * The callback that computes the item to be added to the mapped {@link View}.\n * @callback View~mapIterator\n * @param {Object} item - item from the original {@link View}.\n * @return {Object} mapped item\n */\n\n/**\n * The callback that computes the aggregation of the modified {@link View}.\n * @callback View~reducer\n * @param {Object} accumulator\n * @param {Object} item\n * @return {Object}\n */\n\nView.stack = new Stack();\nView.current = function() { return View.stack.top(); };\nView.withOnStack = function(el, callback, context) {\n    View.stack.push(el);\n    try {\n        callback.call(context);\n    } finally {\n        View.stack.pop();\n    }\n};\n\n/**\n * ################## CSS SELECTORS ##################\n */\nconst selectorByAnimationName = new Map();\nconst selectors = {};\nlet animationCount = 0;\nconst styles = document.createElement('style');\nconst keyframes = document.createElement('style');\nconst head = document.getElementsByTagName('head')[0];\nconst startName = 'animationstart';\nconst startEvent = function(event) {\n  event.selector = selectorByAnimationName.get(event.animationName);\n  ((startListenerByRoot.get(this) || {})[event.animationName] || []).forEach(fn => {\n    fn.call(this, event);\n  });\n};\nconst roots = new Set();\nconst startListenerByRoot = new Map();\n\nstyles.type = keyframes.type = 'text/css';\nhead.appendChild(styles);\nhead.appendChild(keyframes);\n\nfunction addSelectorListener(root, selector, fn) {\n  var key = selectors[selector];\n  if(!startListenerByRoot.has(root)) {\n    startListenerByRoot.set(root, {});\n  }\n  var listeners = startListenerByRoot.get(root);\n\n  if (!key) {\n    key = selectors[selector] = 'SelectorListener-' + animationCount++ + '-' + selector.replace(/[^0-9a-zA-Z]/gi, '');\n    let node = document.createTextNode(`@keyframes ${key} {\n  from { outline-color: #fff; }\n  to { outline-color: #000; }\n}`);\n    keyframes.appendChild(node);\n    styles.sheet.insertRule(`${selector} {\n  animation-duration: 0.001s;\n  animation-name: ${key} !important;\n}`, 0);\n    selectorByAnimationName.set(key, selector);\n  }\n\n  if(!roots.has(root)) {\n    roots.add(root);\n    root.addEventListener(startName, startEvent, false);\n  }\n\n  (listeners[key] = listeners[key] || []).push(fn);\n}\n\n/**\n * chrome does not support the animationcancel event, so we have to resort back to other means, namely polling\n */\nconst stopMatchingDetectors = new Set();\n\nfunction removeObsoleteListeners() {\n  Array.from(stopMatchingDetectors).forEach(detector => {\n    if(!detector.matchesSelector()) {\n      detector.removeElement();\n      stopMatchingDetectors.delete(detector);\n    }\n  });\n  if(stopMatchingDetectors.size === 0) {\n    stopMatchingLoop.pause();\n  }\n}\n\nconst stopMatchingLoop = new PausableLoop(() => {\n  // lively.warn('check stop matching');\n  removeObsoleteListeners();\n});\n\nfunction trackSelector(selector, { root = document }) {\n  const view = new View();\n  addSelectorListener(root, selector, event => {\n    const element = event.target;\n    view.safeAdd(element);\n    \n    stopMatchingDetectors.add({\n      matchesSelector() {\n        const inDOM = element.getRootNode({ composed: true }) === document;\n        return inDOM && element.matches(selector);\n      },\n      removeElement() { view.safeRemove(element); }\n    });\n    stopMatchingLoop.ensureRunning();\n  });\n  return view;\n}\n\nexport function __unload__() {\n  styles.remove();\n  keyframes.remove();\n  roots.forEach(root => root.removeEventListener(startName, startEvent, false));\n  \n  stopMatchingLoop.pause();\n}\n\n/**\n * @function select\n * @param {Class} Class\n * @return {View}\n */\nexport default function select(Class, options) {\n  // css selector given?\n  if(typeof Class === 'string') {\n    return trackSelector(Class, options || {})\n  }\n\n  // fall back to track all instances of a class\n  return baseViewForClass(Class);\n}\n"]}