{"version":3,"sources":["https://lively-kernel.org/lively4/lively4-livelyenergy/src/client/ContextJS/src/Layers.js"],"names":["Config","ignoreDeprecatedProceed","log_layer_code","log","string","console","self","proceedStack","GlobalLayers","AsyncLayerStack","object_id_counter","withLogLayerCode","func","old","LayerObjectID","Symbol","getLayerDefinitionForObject","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","makePropertyLayerAware","makeFunctionLayerAware","ensurePartialLayer","Error","enumerable","writable","layerMethod","displayName","String","type","isHidden","layerGetterMethod","layerSetterMethod","layerProperty","defs","defProperty","layerPropertyWithShadow","layeredPropSymbol","layeredGetter","undefined","proceed","layeredSetter","v","computeLayersFor","obj","activeLayers","composeLayers","stack","slice","i","length","current","withLayers","filter","l","includes","concat","withoutLayers","LayerStack","resetLayerStack","isStatic","toString","composition","invalidateLayerComposition","currentLayers","ea","lookupLayeredFunctionForObject","function_name","methodType","n","partialFunction","partialLayerForObject","superclass","getPrototypeOf","pvtMakeFunctionOrPropertyLayerAware","slotName","baseValue","isLayerAware","makeSlotLayerAwareWithNormalLookup","tmpObj","wrapped_function","PartialLayerComposition","push","invokeLayeredMethodThenPopProceedStack","apply","arguments","isContextJSWrapper","getOriginal","originalFunction","newFunction","pop","base_obj","base_function","baseObj","baseObjProperty","propName","makeFunctionLayerUnaware","prevFunction","currentFunction","Function","uninstallLayersInObject","globalContextForNamedLayers","enableLayer","indexOf","wasAlreadyActive","_emitActivateCallbacks","disableLayer","idx","_emitDeactivateCallbacks","splice","args","warn","partialMethodIndex","partialMethods","index","partialMethod","COPError","invokeNextPartialMethod","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","getActiveImplicitLayers","collectWithLayersIn","layers","unshift","collectWithoutLayersIn","structuralLayers","owner","aysncLayers","j","globalLayers","dynamicLayers","activeImplicitLayers","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"]}