{"version":3,"sources":["https://lively-kernel.org/lively4/lively4-stable//src/client/ContextJS/src/Layers.js"],"names":["activeLayers","activeImplicitLayers","dynamicLayers","globalLayers","aysncLayers","structuralLayers","collectWithoutLayersIn","collectWithLayersIn","getActiveImplicitLayers","invokeNextPartialMethod","proceed","disableLayer","enableLayer","uninstallLayersInObject","makeFunctionLayerUnaware","makePropertyLayerAware","makeFunctionLayerAware","invokeLayeredMethodThenPopProceedStack","makeSlotLayerAwareWithNormalLookup","pvtMakeFunctionOrPropertyLayerAware","lookupLayeredFunctionForObject","invalidateLayerComposition","currentLayers","resetLayerStack","composeLayers","computeLayersFor","layerPropertyWithShadow","layerProperty","layerSetterMethod","layerGetterMethod","layerMethod","ensurePartialLayer","getLayerDefinitionForObject","withLogLayerCode","log","Config","ignoreDeprecatedProceed","log_layer_code","string","console","self","proceedStack","GlobalLayers","AsyncLayerStack","object_id_counter","func","old","LayerObjectID","Symbol","layer","object","result","prototype","e","error","PartialLayer","constructor","layeredObject","layeredProperties","setLayeredPropertyValue","name","value","defineGetter","propertyName","getter","Object","defineProperty","get","configurable","defineSetter","setter","set","getterMethod","desc","getOwnPropertyDescriptor","setterMethod","property","hasOwnProperty","reinstall","getOwnPropertyNames","forEach","eachProperty","Error","enumerable","writable","displayName","String","type","isHidden","defs","defProperty","layeredPropSymbol","layeredGetter","undefined","layeredSetter","v","obj","stack","slice","i","length","current","withLayers","filter","l","includes","concat","withoutLayers","LayerStack","isStatic","toString","composition","ea","function_name","methodType","n","partialFunction","partialLayerForObject","superclass","getPrototypeOf","slotName","baseValue","isLayerAware","tmpObj","wrapped_function","PartialLayerComposition","push","apply","arguments","isContextJSWrapper","getOriginal","originalFunction","newFunction","pop","base_obj","base_function","baseObj","baseObjProperty","propName","prevFunction","currentFunction","Function","globalContextForNamedLayers","indexOf","wasAlreadyActive","_emitActivateCallbacks","idx","_emitDeactivateCallbacks","splice","args","warn","partialMethodIndex","partialMethods","index","partialMethod","COPError","Layer","context","_name","_context","_activateCallbacks","_deactivateCallbacks","fullName","layeredObjects","map","_layered_object","layeredClasses","remove","isGlobal","beNotGlobal","implicitLayers","delete","AExprForILA","dispose","uninstall","eachLayeredObj","refineClass","classObject","methods","refineObject","unrefineObject","id","unrefineClass","classObj","reinstallInClass","reinstallInObject","partialLayer","beGlobal","hide","isLayer","onActivate","callback","_fallbackToReactiveTrackingOfILA","onDeactivate","cb","activeWhile","condition","aexprConstructor","implicitlyActivated","add","_shouldUseReactiveTracking","_setupReactiveILA","onBecomeTrue","onBecomeFalse","Set","layers","unshift","owner","j","LayerableObjectTrait","defaultActiveLayersFunc","setWithLayers","addWithLayer","getWithLayers","removeWithLayer","addWithoutLayer","getWithoutLayers","include","setWithoutLayers","removeWithoutLayer","getWithoutLayer","LayerableObject","message","_msg","functionName","baseFunction","_partialMethods","_object"],"mappings":"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","file":"Layers.js","sourcesContent":["/*\n * Copyright (c) 2008-2016 Hasso Plattner Institute\n *\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in\n * all copies or substantial portions of the Software.\n\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n * THE SOFTWARE.\n */\n\n/* \n * Private Helpers for Development\n */\n\nexport const Config = {};\nConfig.ignoreDeprecatedProceed = true;\n\nexport let log_layer_code = false;\nexport function log(string) {\n  if (log_layer_code) console.log(string);\n}\n\n\n/* \n * Private State\n */\n\n// #HACK #TODO\nself.proceedStack = []\nself.GlobalLayers = []\nself.AsyncLayerStack = []\n\n// export const proceedStack = [];\n// export const GlobalLayers = [];\n\n// hack, to work around absence of identity dictionaries in JavaScript\n// we could perhaps limit ourselfs to layer only those objects that respond to object.id()\n// because working with objects is a serialization problem in itself, perhaps we should\n// restrict ourself in working with classes\n// So classes have names and names can be used as keys in dictionaries :-)\nlet object_id_counter = 0;\n\n/* \n * Private Methods\n */\n\n// for debugging ContextJS itself\nexport function withLogLayerCode(func) {\n  try {\n    var old = log_layer_code;\n    log_layer_code = true;\n    func();\n  } finally {\n    log_layer_code = old;\n  }\n}\n\nconst LayerObjectID = self.Symbol(\"layerObjectID\");\n\nexport function getLayerDefinitionForObject(layer, object) {\n  // log(\"cop getLayerDefinitionForObject(\" + layer + \", \" + object + \")\");\n  if (!layer || !object) {\n    return;\n  }\n  var result = layer[object[LayerObjectID]];\n  // #BUG Maximum call stack size exceeded\n  try {\n    return result ? result : getLayerDefinitionForObject(layer, object.prototype);\n  } catch(e) {\n    debugger\n    console.error('getLayerDefinitionForObject', e)\n    return;\n  }\n}\n\n/**\n * Stores partial definitions for a single layered object and layer.\n */\nclass PartialLayer {\n  constructor(layeredObject) {\n    this.layeredObject = layeredObject;\n    this.layeredProperties = {};\n  }\n\n  setLayeredPropertyValue(name, value) {\n    this.layeredProperties[name] = value;\n  }\n\n  defineGetter(propertyName, getter) {\n    return Object.defineProperty(this.layeredProperties, propertyName,\n                          {get: getter, configurable: true});\n  }\n\n  defineSetter(propertyName, setter) {\n    return Object.defineProperty(this.layeredProperties, propertyName,\n                          {set: setter, configurable: true});\n  }\n\n  getterMethod(propertyName) {\n    var desc = Object.getOwnPropertyDescriptor(this.layeredProperties, propertyName);\n    if (desc)\n      return desc.get;\n  }\n\n  setterMethod(propertyName) {\n    var desc = Object.getOwnPropertyDescriptor(this.layeredProperties, propertyName);\n    if (desc)\n      return desc.set;\n  }\n\n  property(propertyName) {\n    if (this.layeredProperties.hasOwnProperty(propertyName)) {\n      return this.layeredProperties[propertyName];\n    }\n  }\n\n  reinstall() {\n    Object.getOwnPropertyNames(this.layeredProperties).forEach(eachProperty => {\n      const property = Object.getOwnPropertyDescriptor(this.layeredProperties, eachProperty);\n      if (typeof property.get !== 'undefined' || typeof property.set !== 'undefined') {\n        makePropertyLayerAware(this.layeredObject, eachProperty);\n      } else {\n        makeFunctionLayerAware(this.layeredObject, eachProperty);\n      }\n    });\n  }\n}\n\nexport function ensurePartialLayer(layer, object) {\n  if (!layer) {\n    throw new Error(\"in ensurePartialLayer: layer is nil\");\n  }\n  if (!object.hasOwnProperty(LayerObjectID)) {\n    Object.defineProperty(object, LayerObjectID, {\n      value: object_id_counter++,\n      enumerable: false,\n      configurable: false,\n      writable: false\n    });\n  }\n  if (!layer[object[LayerObjectID]]) {\n    layer[object[LayerObjectID]] = new PartialLayer(object);\n  }\n  return layer[object[LayerObjectID]];\n}\n\n// TODO(mariannet) : Find out if ES6 constructor also has type\nexport function layerMethod(layer, object, property, func) {\n  ensurePartialLayer(layer, object).setLayeredPropertyValue(property, func);\n  func.displayName = \"layered \" + String(layer.name) + \" \"\n                   + (object.constructor ? (object.constructor.type + \"$\") : \"\")\n                   + property;\n  makeFunctionLayerAware(object, property, layer.isHidden);\n  \n  // Bookkeeping for layer uninstall\n  // typeof object.getName === 'function'\n  //    && (layer._layeredFunctionsList[object][property] = true);\n}\n\nfunction layerGetterMethod(layer, object, property, getter) {\n  ensurePartialLayer(layer, object).defineGetter(property, getter);\n}\n\nfunction layerSetterMethod(layer, object, property, setter) {\n  ensurePartialLayer(layer, object).defineSetter(property, setter);\n}\n\nexport function layerProperty(layer, object, property, defs) {\n  var defProperty = Object.getOwnPropertyDescriptor(defs, property);\n  var getter = defProperty && defProperty.get;\n  if (getter) {\n    layerGetterMethod(layer, object, property, getter);\n  }\n  var setter = defProperty && defProperty.set;\n  if (setter) {\n    layerSetterMethod(layer, object, property, setter);\n  }\n  if (getter || setter) {\n    makePropertyLayerAware(object, property);\n  } else {\n    layerMethod(layer, object, property, defs[property]);\n  }\n}\n\nexport function layerPropertyWithShadow(layer, object, property) {\n  // shadowing does not work with current implementation\n  // see the shadow tests in LayersTest\n  // TODO: the tests are green, what is the above comment about?\n  var defs = {};\n  // var baseValue = object[property];\n  const layeredPropSymbol = self.Symbol(property + ' ' +\n      (typeof layer.name === 'string'\n       ? 'for Layer ' + layer.name\n       : 'for anonymous Layer'));\n  Object.defineProperty(defs, property, {\n    get: function layeredGetter() {\n      return this[layeredPropSymbol] === undefined ?\n          proceed() : this[layeredPropSymbol];\n    },\n    set: function layeredSetter(v) {\n      this[layeredPropSymbol] = v;\n    },\n    configurable: true\n  });\n  layerProperty(layer, object, property, defs);\n}\n\nexport function computeLayersFor(obj) {\n  return obj && obj.activeLayers ?\n      obj.activeLayers(activeLayers) : activeLayers();\n}\n\nexport function composeLayers(stack) {\n  var result = self.GlobalLayers.slice(0); // copy the array, #TODO: use `Array.from`\n  // duplicate of dynamicLayers, #TODO: use LayerableObjectTrait.dynamicLayers\n  for (var i = 0; i < stack.length; i++) {\n    var current = stack[i];\n    if (current.withLayers) {\n      result = result.filter(l => !current.withLayers.includes(l)).concat(current.withLayers);\n    } else if (current.withoutLayers) {\n      result = result.filter(l => !current.withoutLayers.includes(l));\n    }\n  }\n  return result;\n}\n\nexport let LayerStack;\n\nexport function resetLayerStack() {\n  LayerStack = [{\n    isStatic: true,\n    toString: function() { return \"BaseLayer\"; },\n    composition: null\n  }];\n  invalidateLayerComposition();\n}\n\n\nexport function currentLayers() {\n  return activeLayers()\n  // if (LayerStack.length == 0) {\n  //   throw new Error(\"The default layer is missing\");\n  // }\n  // // NON OPTIMIZED VERSION FOR STATE BASED LAYER ACTIVATION \n  // // #TODO check if this still hold for #async\n  // var current = LayerStack[LayerStack.length - 1];\n  // if (!current.composition) {\n  //   current.composition = composeLayers(LayerStack) ;\n  // }\n  // return current.composition.concat(getActiveImplicitLayers());\n}\n\n// clear cached layer compositions\nexport function invalidateLayerComposition() {\n  LayerStack.forEach(\n    function(ea) {\n      ea.composition = null;\n    });\n}\n\nexport function lookupLayeredFunctionForObject(\n    self, layer, function_name, methodType, n) {\n  if (!layer) {\n    return undefined; \n  }\n  let partialFunction;\n  const partialLayerForObject = getLayerDefinitionForObject(layer, self);\n  if (partialLayerForObject) {\n    // log(\"  found layer definitions for object\");\n    if (methodType == 'getter') {\n      partialFunction = partialLayerForObject.getterMethod(function_name);\n    } else if (methodType == 'setter'){\n      partialFunction = partialLayerForObject.setterMethod(function_name);\n    } else {\n      partialFunction = partialLayerForObject.property(function_name);\n    }\n  }\n  if (!partialFunction && !self.hasOwnProperty(function_name)) {\n    // this method was probably added by a layer\n    // so try to look it up in the superclass hierachy\n    const superclass = Object.getPrototypeOf(self);\n    if (superclass) {\n      return lookupLayeredFunctionForObject(\n          superclass, layer, function_name, methodType);\n    }\n  }\n  return partialFunction;\n}\n\nfunction pvtMakeFunctionOrPropertyLayerAware(obj, slotName, baseValue, type, isHidden) {\n  // install in obj[slotName] a cop wrapper that weaves partial methods\n  // into real method (baseValue)\n  if (baseValue.isLayerAware) {\n    return;\n  }\n  makeSlotLayerAwareWithNormalLookup(obj, slotName, baseValue, type, isHidden);\n}\n\nfunction makeSlotLayerAwareWithNormalLookup(\n    obj, slotName, baseValue, type, isHidden) {\n  var tmpObj = {}\n  if (baseValue && baseValue.isLayerAware) {\n    debugger\n  }\n  let wrapped_function = function() {\n    'use strict';\n    \n    var composition =\n        new PartialLayerComposition(this, slotName, baseValue, type);\n    self.proceedStack.push(composition);\n    return invokeLayeredMethodThenPopProceedStack.apply(this, arguments);\n  };\n  wrapped_function.displayName = \"wrapped_\" + slotName    \n  wrapped_function.isLayerAware = true;\n  // this is more declarative outside of COP context\n  wrapped_function.isContextJSWrapper = true;\n  if (isHidden) {\n    wrapped_function.toString = function () {\n      return this.getOriginal().toString()\n    };\n  }\n  // For wrapped_function.getOriginal()\n  wrapped_function.originalFunction = baseValue;\n  if (type == \"getter\") {\n    Object.defineProperty(obj, slotName, {get: wrapped_function});\n  } else if (type == \"setter\") {\n    Object.defineProperty(obj, slotName, {set: wrapped_function});\n  } else {\n    Object.defineProperty(obj, slotName, {\n      get() { return wrapped_function; },\n      set(newFunction) {\n        if (newFunction.isLayerAware) {\n          // when someone reasigns an already layered method.... Example Bug. Dexie modifies Promise.then\n          // #Paper #ContextJS \n        } else {\n          makeSlotLayerAwareWithNormalLookup(this, slotName, newFunction);\n        }\n      }\n    });\n  }\n}\n\nfunction invokeLayeredMethodThenPopProceedStack() {\n  'use strict';\n  try {\n    return proceed.apply(void 0 /* undefined */, arguments);\n  } finally {\n    self.proceedStack.pop()\n  }\n}\n\nfunction makeFunctionLayerAware(base_obj, function_name, isHidden) {\n  if (!base_obj) {\n    throw new Error(\"can't layer an non existent object\");\n  }\n  /* ensure base function */\n  var base_function = base_obj[function_name];\n  if (!base_function) {\n    // console.log(\"WARNING can't layer an non existent function\" + function_name +\n    // \" , so do nothing\")\n    // return;\n    base_function = () => null;\n  }\n  pvtMakeFunctionOrPropertyLayerAware(base_obj, function_name, base_function,\n                                            undefined, isHidden)\n}\n\nfunction makePropertyLayerAware(baseObj, property) {\n  if (!baseObj) {\n    throw new Error(\"can't layer a non existent object\");\n  }  \n  // ensure base getter and setter\n  var baseObjProperty = Object.getOwnPropertyDescriptor(baseObj, property);\n  var propName = \"__layered_\" + property + \"__\";\n  var getter = baseObjProperty && baseObjProperty.get;\n  if (!getter) {\n    // does not work when dealing with classes and instances...\n    baseObj[propName] = baseObj[property]; // take over old value\n    getter = function() { return this[propName] };\n    Object.defineProperty(baseObj, property, {get: getter, configurable: true});\n  }\n  var setter = baseObjProperty && baseObjProperty.set;\n  if (!setter) {\n    setter = function(value) { return this[propName] = value };\n    Object.defineProperty(baseObj, property, {set: setter, configurable: true});\n  }\n  pvtMakeFunctionOrPropertyLayerAware(baseObj, property, getter, 'getter');\n  pvtMakeFunctionOrPropertyLayerAware(baseObj, property, setter, 'setter');\n}\n\nfunction makeFunctionLayerUnaware(base_obj, function_name) {\n  if (!base_obj) {\n    throw new Error(\"need object to makeFunctionLayerUnaware\");\n  }\n  var prevFunction;\n  var currentFunction = base_obj[function_name];\n  if (currentFunction === undefined) {\n    return; // nothing to do here\n  }  \n  while (typeof currentFunction.originalFunction == 'function'\n      && !currentFunction.isLayerAware) {\n    prevFunction = currentFunction;\n    currentFunction = currentFunction.originalFunction\n  }\n  if (!(currentFunction.isLayerAware)) {\n    return; // nothing to do here\n  }\n  var originalFunction = currentFunction.originalFunction\n  if (!(originalFunction instanceof Function)) {\n    throw new Error(\"makeFunctionLayerUnaware Error: no orignal function\");\n  }\n  if (prevFunction instanceof Function) {\n    prevFunction.originalFunction = originalFunction\n  } else {\n    // need to use defineProperty because the setter keeps the function wrapped\n    Object.defineProperty(base_obj, function_name, {\n      value: originalFunction,\n      configurable: true\n    });\n  }\n}\n\nexport function uninstallLayersInObject(object) {\n  Object.getOwnPropertyNames(object).forEach(ea => {\n    if (typeof object[ea] === 'function')\n      makeFunctionLayerUnaware(object, ea);\n  });\n}\n\n/* \n * PUBLIC COP Layer Definition\n */\n\nvar globalContextForNamedLayers = {};\n\nexport { globalContextForNamedLayers as GlobalNamedLayers };\n\n// Gloabl Layer Activation\nexport function enableLayer(layer) {\n  if (self.GlobalLayers.indexOf(layer) !== -1) {\n    return;\n  }\n  const wasAlreadyActive = currentLayers().includes(layer);\n  self.GlobalLayers.push(layer);\n  invalidateLayerComposition();\n  if(!wasAlreadyActive) {\n    layer._emitActivateCallbacks();\n  }\n}\n\nexport function disableLayer(layer) {\n  var idx = self.GlobalLayers.indexOf(layer);\n  if (idx < 0) {\n    return;\n  }\n  layer._emitDeactivateCallbacks();\n  self.GlobalLayers.splice(idx, 1);\n  invalidateLayerComposition();\n}\n\nexport function proceed(...args) {\n  // COP Proceed Function\n  var composition = self.proceedStack[self.proceedStack.length - 1];\n  if (!composition) {\n    console.warn('ContextJS: no composition to proceed (stack is empty) ');\n    return;\n  }\n  if (composition.partialMethodIndex == undefined) {\n    composition.partialMethodIndex = composition.partialMethods.length - 1;\n  }  \n  var index = composition.partialMethodIndex;\n  var partialMethod = composition.partialMethods[index];\n  if (!partialMethod) {\n    if (!partialMethod) {\n      throw new COPError('no partialMethod to proceed');\n    }\n  } else {\n    composition.partialMethodIndex = index - 1;\n    try {\n      if (self.proceedStack.length > 1000) {\n        debugger // #Debug\n      }\n      \n      return invokeNextPartialMethod(partialMethod, index, composition, args);\n    } catch(e) {\n      console.error(\"proceed \" + self.proceedStack.length, e)\n      debugger // #TODO debug endless recursion!\n      return \n    }\n  }\n}\n\nfunction invokeNextPartialMethod(partialMethod, index, composition, args) {\n  try {\n    return partialMethod.apply(composition.object, args);\n  } finally {\n    composition.partialMethodIndex = index;\n  }\n}\n\n/* \n * Layer Class\n */\nexport class Layer {\n  constructor (name, context) {\n    this._name = name;\n    if (typeof name === 'undefined') {\n      this._name = self.Symbol('COP Layer');\n    }\n    this._context = context;\n    // this._layeredFunctionsList = {};\n    \n    this._activateCallbacks = [];\n    this._deactivateCallbacks = [];\n  }\n  \n  // Accessing\n  get name () {\n    return this._name;\n  }\n  fullName () {\n    return '' + this._context + '.' + this._name;\n  }\n  layeredObjects () {\n    return Object.getOwnPropertyNames(this)\n      .map(ea => this[ea] && this[ea]._layered_object)\n      .filter(ea => ea); // filters falsy things\n  }\n  // TODO: doesn't differentiate between functions and classes - necessary?\n  layeredClasses () {\n    return this.layeredObjects().map(ea => ea.constructor);\n  }\n  \n  // Removing\n  remove () {\n    // Deletes the LayerClass, but keeps the layered Functions.\n    if (this.isGlobal()) {\n      this.beNotGlobal();\n    }\n    implicitLayers.delete(this);\n    if(this.AExprForILA) {\n      this.AExprForILA.dispose();\n    }\n\n    var context = this._context;\n    if (typeof context !== 'undefined')\n      delete context[this.name];\n  }\n  uninstall () {\n    // Uninstalls just this Layer.\n    // functions that are layered by other Layers will not be reset.\n    var layer = this;\n    this.layeredObjects().forEach(\n      function(eachLayeredObj) {\n        // var layerIdx = typeof eachLayeredObj.activeLayers === 'function'\n        //     ? eachLayeredObj.activeLayers().indexOf(layer) : -1;\n        \n        // #Special Lively Webwerkstatt code.... General Case? #Jens\n        // #TODO if we have of gloabal list of all layers... we can look there\n        \n        // Properties.own(layer._layeredFunctionsList[eachLayeredObj]).each(\n        //   function(eachLayeredFunc) {\n        //     var newerLayer = eachLayeredObj.activeLayers().find(\n        //       function(eachOtherLayer) {\n        //         var eachOtherLayerIdx\n        //             = eachLayeredObj.activeLayers().indexOf(eachOtherLayer);\n        //         var isNewer = (eachOtherLayerIdx !== -1)\n        //             && (eachOtherLayerIdx < layerIdx);\n        //         return isNewer &&\n        //             eachOtherLayer._layeredFunctionsList[eachLayeredObj][eachLayeredFunc];\n        //       });\n        //       if (!newerLayer) {\n        //         makeFunctionLayerUnaware(eachLayeredObj, eachLayeredFunc);\n        //       }\n        //   });\n      });\n      this.remove();\n  }\n  \n  // Layer installation\n  refineClass (classObject, methods) {\n    if (!classObject || !classObject.prototype) {\n      throw new Error(\"ContextJS: can not refine class '\" + classObject + \"' in \" + this);\n    }\n    this.refineObject(classObject.prototype, methods);\n    return this;\n  }\n\n  // Layering objects may be a garbage collection problem, because the layers keep strong\n  // reference to the objects\n  refineObject (object, methods) {\n    // log(\"cop refineObject\");\n\n    // Bookkeeping:\n    // typeof object.getName === 'function' && (layer._layeredFunctionsList[object] = {});\n    Object.getOwnPropertyNames(methods).forEach(function_name => {\n      // log(\" layer property: \" + function_name)\n      layerProperty(this, object, function_name, methods);\n    });\n    return this;\n  }\n  unrefineObject (obj) {\n    var id = obj[LayerObjectID];\n    if (id !== undefined) {\n      delete this[id];\n    }\n  }\n  unrefineClass (classObj) {\n    this.unrefineObject(classObj.prototype);\n  }\n\n  reinstallInClass (constructor) {\n    this.reinstallInObject(constructor.prototype);\n  }\n\n  reinstallInObject (object) {\n    const partialLayer = ensurePartialLayer(this, object);\n    partialLayer.reinstall();\n  }\n  \n  // Layer activation\n  beGlobal () {\n    enableLayer(this);\n    return this;\n  }\n  beNotGlobal () {\n    disableLayer(this);\n    return this;\n  }\n  hide () {\n    // Hidden Layers do not appear when evaluating the sourcecode of a function\n    // TODO: this function has to be called BEFORE the layer refines any class,\n    // due to problems in unrefining classes.\n    this.isHidden = true;\n    return this;\n  }\n  \n  // Testing\n  isLayer() {\n    return true;\n  }\n  isGlobal () {\n    return self.GlobalLayers.indexOf(this) !== -1;\n  }\n  \n  // Debugging\n  toString () {\n    return String(this.name); // could be a symbol\n  }\n  \n  // Life-cycle callbacks\n  onActivate(callback) {\n    this._activateCallbacks.push(callback);\n    this._fallbackToReactiveTrackingOfILA();\n    return this;\n  }\n  onDeactivate(callback) {\n    this._deactivateCallbacks.push(callback);\n    this._fallbackToReactiveTrackingOfILA();\n    return this;\n  }\n  _emitActivateCallbacks() {\n    this._activateCallbacks.forEach(cb => cb());\n  }\n  _emitDeactivateCallbacks() {\n    this._deactivateCallbacks.forEach(cb => cb());\n  }\n  \n  // Implicit Layer Activation\n  activeWhile(condition, aexprConstructor) {\n    this.implicitlyActivated = condition;\n    this.aexprConstructor = aexprConstructor;\n    \n    implicitLayers.add(this);\n    this._fallbackToReactiveTrackingOfILA();\n\n    return this;\n  }\n  _fallbackToReactiveTrackingOfILA() {\n    if(this._shouldUseReactiveTracking()) {\n      this._setupReactiveILA()\n    }\n  }\n  _shouldUseReactiveTracking() {\n    return this.implicitlyActivated &&\n      this.aexprConstructor &&\n      (this._activateCallbacks.length + this._deactivateCallbacks.length > 0);\n  }\n  _setupReactiveILA() {\n    implicitLayers.delete(this);\n    \n    if(!this.AExprForILA) {\n      this.AExprForILA = this.aexprConstructor(this.implicitlyActivated)\n          .onBecomeTrue(() => this.beGlobal())\n          .onBecomeFalse(() => this.beNotGlobal());\n    }\n  }\n}\n\nconst implicitLayers = new Set();\nfunction getActiveImplicitLayers ( ) {\n  return [...implicitLayers]\n    .filter(layer => layer.implicitlyActivated());\n}\n\nexport function collectWithLayersIn (layers, result) {\n  for (var i = layers.length - 1; i >= 0 ; i--) {\n    var ea = layers[i]\n    if ((result.withLayers.indexOf(ea) === -1)\n        && (result.withoutLayers.indexOf(ea) === -1)) {\n      result.withLayers.unshift(ea)\n    }\n  }\n}\n\nexport function collectWithoutLayersIn (layers, result) {\n  for (var i = 0; i < layers.length; i++) {\n    var ea = layers[i]\n    if (result.withoutLayers.indexOf(ea) === -1) {\n      result.withoutLayers.push(ea)\n    }\n  }\n}\n\nexport function structuralLayers (result, obj) {\n  // var allLayers = result.withLayers;\n  // var allWithoutLayers = result.withoutLayers;\n  // go ownerchain backward and gather all layer activations and deactivations\n  while (obj) {\n    // don't use accessor methods because of speed... (not measured yet)\n    if (obj.withLayers) {\n        collectWithLayersIn(obj.withLayers, result);\n    }\n    if (obj.withoutLayers) {\n        collectWithoutLayersIn(obj.withoutLayers, result);\n    }      \n    // recurse, stop if owner is undefined\n    obj = obj.owner; // || obj.parentElement || obj.parentNode\n  }\n  return result;\n}\n\nexport function aysncLayers (result) {\n  // optimized version, that does not use closures and recursion\n  var stack = self.AsyncLayerStack;\n  // top down, ignore bottom element\n  for (var j = stack.length - 1; j > 0; j--) {\n    var current = stack[j];\n    if (current.withLayers) {\n      collectWithLayersIn(current.withLayers, result);\n    }\n    if (current.withoutLayers) {\n      collectWithoutLayersIn(current.withoutLayers, result);\n    }\n  }\n  return result;\n}\n\nexport function globalLayers (result) {\n  collectWithLayersIn(self.GlobalLayers, result);\n  return result;\n}\n\nexport function dynamicLayers (result) {\n  // optimized version, that does not use closures and recursion\n  var stack = LayerStack;\n  // top down, ignore bottom element\n  for (var j = stack.length - 1; j > 0; j--) {\n    var current = stack[j];\n    if (current.withLayers) {\n      collectWithLayersIn(current.withLayers, result);\n    }\n    if (current.withoutLayers) {\n      collectWithoutLayersIn(current.withoutLayers, result);\n    }\n  }\n  return result;\n}\n\n\n// #TODO #STEFAN rename -> implicitLayers\nexport function activeImplicitLayers(result) {\n  collectWithLayersIn(getActiveImplicitLayers(), result);\n  return result\n}\n\nexport function activeLayers () {\n  var result = {withLayers: [], withoutLayers: []};\n  // go top to bottom in stack... \n  // so the last (dynamically) (de-)activated layers are first...\n  // remember withLayers and withoutLayers in result\n  // this is a bit to \"clever\" to iterate only once...\n  dynamicLayers(result); \n  \n  // #Idea we can implement structural layer for HTMLElements without having to modify prototype...\n  // structuralLayers(result, obj);\n  activeImplicitLayers(result); \n   \n  globalLayers(result);\n  // and the global layers are last\n  return result.withLayers;\n}\n\n/*\n * Example implementation of a layerable object\n */\nexport class LayerableObjectTrait {\n  activeLayers (defaultActiveLayersFunc) {\n    var result = {withLayers: [], withoutLayers: []};\n    // go top to bottom in stack... \n    // so the last (dynamically) (de-)activated layers are first...\n    // remember withLayers and withoutLayers in result\n    // this is a bit to \"clever\" to iterate only once...\n    dynamicLayers(result); \n    structuralLayers(result, this);\n    globalLayers(result);\n    // and the global layers are last\n    return result.withLayers;\n  }\n\n  setWithLayers (layers) {\n    this.withLayers = layers;\n  }\n  addWithLayer (layer) {\n    var layers = this.getWithLayers();\n    if (!layers.includes(layer)) {\n      this.setWithLayers(layers.concat([layer]));\n    }\n  }\n  removeWithLayer (layer) {\n    var layers = this.getWithLayers();\n    if (layers.includes(layer)) {\n      this.setWithLayers(layers.filter(l => l !== layer));\n    }\n  }\n  addWithoutLayer (layer) {\n    var layers = this.getWithoutLayers();\n    if (!layers.include(layer)) {\n      this.setWithoutLayers(layers.concat([layer]));\n    }\n  }\n  removeWithoutLayer (layer) {\n    var layers = this.getWithoutLayers();\n    this.setWithoutLayers(layers.filter(l => l !== layer));\n  }\n  setWithoutLayers (layers) {\n    this.withoutLayers = layers;\n  }\n  getWithLayers () {\n    return this.withLayers || [];\n  }\n  getWithoutLayer () {\n    return this.withoutLayers || [];\n  }\n}\n\nexport class LayerableObject extends LayerableObjectTrait {}\n\nexport class COPError {\n  constructor (message) {\n    this._msg = message;\n  }\n  toString () {\n    return \"COP ERROR: \" + this._msg;\n  }\n}\n\nexport class PartialLayerComposition {\n  constructor (obj, functionName, baseFunction, methodType) {\n    this._partialMethods = [baseFunction];\n    var layers = computeLayersFor(obj);\n    for (var i = 0; i < layers.length; i++) {\n        var layer = layers[i];\n        var partialMethod = lookupLayeredFunctionForObject(\n            obj, layer, functionName, methodType);\n        if (partialMethod) {\n          this._partialMethods.push(partialMethod);\n        }\n    }\n    this._object = obj;\n  }\n\n  get object() {\n    return this._object;\n  }\n  \n  get partialMethods () {\n    return this._partialMethods;\n  }\n}\n\nresetLayerStack();\n\n// vim: sw=2\n"]}