scrivito_sdk 1.6.0.rc1 → 1.6.0.rc2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 2b0e676d1b60bfaefb2cb7f1d834b911fef7a0a0
-  data.tar.gz: 167e175b7b07e320f9ec8cf3763284cb7b2a20f3
+  metadata.gz: a07db261fd27ce4542a3d20b26f3f595d9c6d5cd
+  data.tar.gz: f0fc7c93e359eb47f33f615dfe7b367647947be0
 SHA512:
-  metadata.gz: 7d9ef307e260bec317b69030c2d6f85ca0d3c6d41d43c53173ec1bf19272d14821de9d63ffc6f120d77ba96cb6fd2796344c0b3b845f4c4a761eedb843dc6d31
-  data.tar.gz: fc082d95b5b78a3269e5e5ff3c4fc0e7b0abaeacd6d53a7075e705082a193ba1f1328d32575f2aa2a83e467a68da33ad810ab41d248fdead6ec5f277dbe53f53
+  metadata.gz: 9c987515511317e614303106d47f6043850a884d5089d22661d8dbbe9f341c6a0817c4956c38fa5ffe4a82a62f9d81b497c989dcd22b4af73e2c6bf94a2414e8
+  data.tar.gz: 07959bf736757a1533661e6185695c2bb33dd45146acad7645143b7d236d37e53ba27a23e7f16761c5488bd8228597146ade57d4d9a218c6013897779c272e13

data/README.md

@@ -8,7 +8,7 @@ searches, etc. For more information about Scrivito, please visit https://scrivit
 
 ## License
 
-Copyright (c) 2009 - 2014 Infopark AG (http://www.infopark.com)
+Copyright (c) 2009 - 2016 Infopark AG (http://www.infopark.com)
 
 This software can be used and modified under the LGPL-3.0. Please refer to
 http://www.gnu.org/licenses/lgpl-3.0.html for the license text.

data/app/controllers/scrivito/objs_controller.rb

@@ -1,11 +1,7 @@
 module Scrivito
   class ObjsController < WebserviceController
     around_action :require_selected_workspace_write_authorization, only: [
-      :destroy,
       :restore,
-      :restore_widget,
-      :revert,
-      :revert_widget,
     ]
 
     before_filter :require_identical_selected_and_visible_workspace, only: [
@@ -26,41 +22,11 @@ module Scrivito
       render current_obj.details_view_path, layout: 'scrivito_dialog', formats: :html
     end
 
-    def destroy
-      in_selected_workspace do
-        parent = current_obj.parent
-        @redirect_to = parent ? scrivito_path(parent) : "/"
-        current_obj.destroy
-      end
-    end
-
-    def revert
-      in_selected_workspace { current_obj.revert }
-      render_empty_json
-    end
-
-    def revert_widget
-      in_selected_workspace { current_widget.revert }
-      render_empty_json
-    end
-
     def restore
       in_selected_workspace { Obj.restore(params[:id]) }
       render_empty_json
     end
 
-    def restore_widget
-      in_selected_workspace { current_obj.restore_widget(params[:widget_id]) }
-      render_empty_json
-    end
-
-    def binary_no_cache
-      in_selected_workspace do
-        binary = current_obj[params[:attribute_name]]
-        @no_cache_url = binary.no_cache_url
-      end
-    end
-
     def transfer_modifications
       in_selected_workspace do
         begin

data/app/controllers/scrivito/users_controller.rb

@@ -11,7 +11,11 @@ module Scrivito
     end
 
     def publish_ability
-      @publish_ability = Scrivito::PublishAbility.new(scrivito_user, params[:obj_id])
+      @publish_ability = Scrivito::PublishAbility.new(
+        scrivito_user,
+        editing_context.selected_workspace,
+        params[:obj_id],
+      )
     end
   end
 end

data/config/ca-bundle.crt

@@ -1,20 +1,20 @@
 ##
 ## Bundle of CA Root Certificates
 ##
-## Certificate data from Mozilla as of: Wed Oct 12 11:05:19 2016
+## Certificate data from Mozilla as of: Wed Nov  9 15:47:06 2016 GMT
 ##
 ## This is a bundle of X.509 certificates of public Certificate Authorities
 ## (CA). These were automatically extracted from Mozilla's root certificates
 ## file (certdata.txt).  This file can be found in the mozilla source tree:
-## http://hg.mozilla.org/releases/mozilla-release/raw-file/default/security/nss/lib/ckfw/builtins/certdata.txt
+## https://hg.mozilla.org/releases/mozilla-release/raw-file/default/security/nss/lib/ckfw/builtins/certdata.txt
 ##
 ## It contains the certificates in PEM format and therefore
 ## can be directly used with curl / libcurl / php_curl, or with
 ## an Apache+mod_ssl webserver for SSL client authentication.
 ## Just configure this file as the SSLCACertificateFile.
 ##
-## Conversion done with mk-ca-bundle.pl version 1.25.
-## SHA1: 36aebbcc910dcab8838e6e721523d84f0ed20589
+## Conversion done with mk-ca-bundle.pl version 1.27.
+## SHA256: 17e2a90c8a5cfd6a675b3475d3d467e1ab1fe0d5397e907b08206182389caa08
 ##
 
 
@@ -1764,7 +1764,7 @@ AJw9SDkjOVgaFRJZap7v1VmyHVIsmXHNxynfGyphe3HR3vPA5Q06Sqotp9iGKt0uEA==
 -----END CERTIFICATE-----
 
 NetLock Arany (Class Gold) Főtanúsítvány
-============================================
+========================================
 -----BEGIN CERTIFICATE-----
 MIIEFTCCAv2gAwIBAgIGSUEs5AAQMA0GCSqGSIb3DQEBCwUAMIGnMQswCQYDVQQGEwJIVTERMA8G
 A1UEBwwIQnVkYXBlc3QxFTATBgNVBAoMDE5ldExvY2sgS2Z0LjE3MDUGA1UECwwuVGFuw7pzw610
@@ -2280,7 +2280,7 @@ Zt3hrvJBW8qYVoNzcOSGGtIxQbovvi0TWnZvTuhOgQ4/WwMioBK+ZlgRSssDxLQqKi2WF+A5VLxI
 -----END CERTIFICATE-----
 
 Certinomis - Autorité Racine
-=============================
+============================
 -----BEGIN CERTIFICATE-----
 MIIFnDCCA4SgAwIBAgIBATANBgkqhkiG9w0BAQUFADBjMQswCQYDVQQGEwJGUjETMBEGA1UEChMK
 Q2VydGlub21pczEXMBUGA1UECxMOMDAwMiA0MzM5OTg5MDMxJjAkBgNVBAMMHUNlcnRpbm9taXMg
@@ -3675,7 +3675,7 @@ ekD6819kR5LLU7m7Wc5P/dAVUwHY3+vZ5nbv0CO7O6l5s9UCKc2Jo5YPSjXnTkLAdc0Hz+Ys63su
 -----END CERTIFICATE-----
 
 TÜRKTRUST Elektronik Sertifika Hizmet Sağlayıcısı H5
-=========================================================
+====================================================
 -----BEGIN CERTIFICATE-----
 MIIEJzCCAw+gAwIBAgIHAI4X/iQggTANBgkqhkiG9w0BAQsFADCBsTELMAkGA1UEBhMCVFIxDzAN
 BgNVBAcMBkFua2FyYTFNMEsGA1UECgxEVMOcUktUUlVTVCBCaWxnaSDEsGxldGnFn2ltIHZlIEJp
@@ -3699,7 +3699,7 @@ B59OTj+RdPsnnRHM3eaxynFNExc5JsUpISuTKWqW+qtB4Uu2NQvAmxU=
 -----END CERTIFICATE-----
 
 TÜRKTRUST Elektronik Sertifika Hizmet Sağlayıcısı H6
-=========================================================
+====================================================
 -----BEGIN CERTIFICATE-----
 MIIEJjCCAw6gAwIBAgIGfaHyZeyKMA0GCSqGSIb3DQEBCwUAMIGxMQswCQYDVQQGEwJUUjEPMA0G
 A1UEBwwGQW5rYXJhMU0wSwYDVQQKDERUw5xSS1RSVVNUIEJpbGdpIMSwbGV0acWfaW0gdmUgQmls
@@ -4034,3 +4034,33 @@ BgNVHSMEGDAWgBRHd8MUi2I5DMlv4VBN0BBY3JWIbTAKBggqhkjOPQQDAwNpADBmAjEAj6jcnboM
 BBf6Fek9LykBl7+BFjNAk2z8+e2AcG+qj9uEwov1NcoG3GRvaBbhj5G5AjEA2Euly8LQCGzpGPta
 3U1fJAuwACEl74+nBCZx4nxp5V2a+EEfOzmTk51V6s2N8fvB
 -----END CERTIFICATE-----
+
+ISRG Root X1
+============
+-----BEGIN CERTIFICATE-----
+MIIFazCCA1OgAwIBAgIRAIIQz7DSQONZRGPgu2OCiwAwDQYJKoZIhvcNAQELBQAwTzELMAkGA1UE
+BhMCVVMxKTAnBgNVBAoTIEludGVybmV0IFNlY3VyaXR5IFJlc2VhcmNoIEdyb3VwMRUwEwYDVQQD
+EwxJU1JHIFJvb3QgWDEwHhcNMTUwNjA0MTEwNDM4WhcNMzUwNjA0MTEwNDM4WjBPMQswCQYDVQQG
+EwJVUzEpMCcGA1UEChMgSW50ZXJuZXQgU2VjdXJpdHkgUmVzZWFyY2ggR3JvdXAxFTATBgNVBAMT
+DElTUkcgUm9vdCBYMTCCAiIwDQYJKoZIhvcNAQEBBQADggIPADCCAgoCggIBAK3oJHP0FDfzm54r
+Vygch77ct984kIxuPOZXoHj3dcKi/vVqbvYATyjb3miGbESTtrFj/RQSa78f0uoxmyF+0TM8ukj1
+3Xnfs7j/EvEhmkvBioZxaUpmZmyPfjxwv60pIgbz5MDmgK7iS4+3mX6UA5/TR5d8mUgjU+g4rk8K
+b4Mu0UlXjIB0ttov0DiNewNwIRt18jA8+o+u3dpjq+sWT8KOEUt+zwvo/7V3LvSye0rgTBIlDHCN
+Aymg4VMk7BPZ7hm/ELNKjD+Jo2FR3qyHB5T0Y3HsLuJvW5iB4YlcNHlsdu87kGJ55tukmi8mxdAQ
+4Q7e2RCOFvu396j3x+UCB5iPNgiV5+I3lg02dZ77DnKxHZu8A/lJBdiB3QW0KtZB6awBdpUKD9jf
+1b0SHzUvKBds0pjBqAlkd25HN7rOrFleaJ1/ctaJxQZBKT5ZPt0m9STJEadao0xAH0ahmbWnOlFu
+hjuefXKnEgV4We0+UXgVCwOPjdAvBbI+e0ocS3MFEvzG6uBQE3xDk3SzynTnjh8BCNAw1FtxNrQH
+usEwMFxIt4I7mKZ9YIqioymCzLq9gwQbooMDQaHWBfEbwrbwqHyGO0aoSCqI3Haadr8faqU9GY/r
+OPNk3sgrDQoo//fb4hVC1CLQJ13hef4Y53CIrU7m2Ys6xt0nUW7/vGT1M0NPAgMBAAGjQjBAMA4G
+A1UdDwEB/wQEAwIBBjAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQWBBR5tFnme7bl5AFzgAiIyBpY
+9umbbjANBgkqhkiG9w0BAQsFAAOCAgEAVR9YqbyyqFDQDLHYGmkgJykIrGF1XIpu+ILlaS/V9lZL
+ubhzEFnTIZd+50xx+7LSYK05qAvqFyFWhfFQDlnrzuBZ6brJFe+GnY+EgPbk6ZGQ3BebYhtF8GaV
+0nxvwuo77x/Py9auJ/GpsMiu/X1+mvoiBOv/2X/qkSsisRcOj/KKNFtY2PwByVS5uCbMiogziUwt
+hDyC3+6WVwW6LLv3xLfHTjuCvjHIInNzktHCgKQ5ORAzI4JMPJ+GslWYHb4phowim57iaztXOoJw
+TdwJx4nLCgdNbOhdjsnvzqvHu7UrTkXWStAmzOVyyghqpZXjFaH3pO3JLF+l+/+sKAIuvtd7u+Nx
+e5AW0wdeRlN8NwdCjNPElpzVmbUq4JUagEiuTDkHzsxHpFKVK7q4+63SM1N95R1NbdWhscdCb+ZA
+JzVcoyi3B43njTOQ5yOf+1CceWxG1bQVs5ZufpsMljq4Ui0/1lvh+wjChP4kqKOJ2qxq4RgqsahD
+YVvTH9w7jXbyLeiNdd8XM2w9U/t7y0Ff/9yi0GE44Za4rF2LN9d11TPAmRGunUHBcnWEvgJBQl9n
+JEiU0Zsnvgc/ubhPgXRR4Xq37Z0j4r7g1SgEEzwxA57demyPxgcYxn/eR44/KJ4EBs+lVDR3veyJ
+m+kXQ99b21/+jh5Xos1AnX5iItreGCc=
+-----END CERTIFICATE-----

data/config/precedence_routes.rb

@@ -9,7 +9,7 @@ Scrivito::SdkEngine.routes.draw do
   scope '__scrivito', module: 'scrivito' do
     get ':id', to: 'cms_dispatch#index', as: :base_id, constraints: {id: /\h{16}/}
 
-    resources :objs, controller: 'objs', only: [:show, :destroy], defaults: {format: :json} do
+    resources :objs, controller: 'objs', only: [:show], defaults: {format: :json} do
       collection do
         get :page_class_selection
         get :search
@@ -19,12 +19,8 @@ Scrivito::SdkEngine.routes.draw do
         get :widget
         get :widget_class_selection
         get :widget_modification
-        get :binary_no_cache
 
-        put :revert
         put :restore
-        put :revert_widget
-        put :restore_widget
         put :transfer_modifications
       end
     end

data/lib/assets/javascripts/scrivito_sdk.js

@@ -11985,6 +11985,8 @@ module.exports = ret;
 }.call(this));
 
 
+//
+
 //
 
 "use strict";
@@ -12137,10 +12139,10 @@ if (!window.scrivito) {
 "use strict";
 
 (function () {
-  var CONVERT_TO_CAMELCASE = /_(\w)/g;
+  var CONVERT_TO_CAMELCASE = /(_+)(\w)/g;
   var CONVERT_TO_UNDERSCORE = /([A-Z])/g;
 
-  var TEST_CAMEL_CASE = /^_?[^_]+$/;
+  var TEST_CAMEL_CASE = /^_?(_+[A-Z0-9]|[^_])+$/;
   var TEST_UNDERSCORE = /^[a-z0-9_]+$/;
 
   scrivito.attributeInflection = {
@@ -12159,11 +12161,305 @@ if (!window.scrivito) {
     },
 
     camelCase: function camelCase(name) {
-      return name.replace(CONVERT_TO_CAMELCASE, function (match, group, index) {
-        return index ? group.toUpperCase() : match;
+      return name.replace(CONVERT_TO_CAMELCASE, function (match, underscores, nextChar, index) {
+        if (!index) {
+          return match;
+        }
+        if (nextChar.toUpperCase() === nextChar) {
+          return match;
+        }
+
+        return "" + underscores.substr(1) + nextChar.toUpperCase();
+      });
+    }
+  };
+})();
+'use strict';
+
+var _slicedToArray = (function () { function sliceIterator(arr, i) { var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i['return']) _i['return'](); } finally { if (_d) throw _e; } } return _arr; } return function (arr, i) { if (Array.isArray(arr)) { return arr; } else if (Symbol.iterator in Object(arr)) { return sliceIterator(arr, i); } else { throw new TypeError('Invalid attempt to destructure non-iterable instance'); } }; })();
+
+(function () {
+  scrivito.AttributeSerializer = {
+    serialize: function serialize(attributes) {
+      var serializedAttributes = {};
+      _.each(attributes, function (_ref, name) {
+        var _ref2 = _slicedToArray(_ref, 2);
+
+        var value = _ref2[0];
+        var attrInfo = _ref2[1];
+
+        var serializedName = convertCamelCasedAttributeName(name);
+        if (scrivito.Attribute.isSystemAttribute(serializedName)) {
+          serializedAttributes[serializedName] = value;
+        } else {
+          var _attrInfo = _slicedToArray(attrInfo, 2);
+
+          var attrType = _attrInfo[0];
+          var attrOptions = _attrInfo[1];
+
+          serializedAttributes[serializedName] = [serializeAttributeType(attrType, name), valueOrNull(serializeAttributeValue(attrType, attrOptions, value, name))];
+        }
       });
+
+      return serializedAttributes;
     }
   };
+
+  function convertCamelCasedAttributeName(name) {
+    if (!scrivito.attributeInflection.isCamelCase(name)) {
+      throw new scrivito.ArgumentError('Attribute names have to be in camel case.');
+    }
+
+    return scrivito.attributeInflection.underscore(name);
+  }
+
+  function serializeAttributeType(type, name) {
+    switch (type) {
+      case 'enum':
+        return 'string';
+      case 'float':
+      case 'integer':
+        return 'number';
+      case 'multienum':
+        return 'stringlist';
+      case 'binary':
+      case 'date':
+      case 'html':
+      case 'link':
+      case 'linklist':
+      case 'reference':
+      case 'referencelist':
+      case 'string':
+      case 'stringlist':
+      case 'widgetlist':
+        return type;
+      default:
+        throw new scrivito.ArgumentError('Attribute "' + name + '" is of unsupported type "' + type + '".');
+    }
+  }
+
+  function serializeAttributeValue(type, options, value, name) {
+    if (value === null) {
+      return value;
+    }
+
+    switch (type) {
+      case 'binary':
+        return serializeBinaryAttributeValue(value, name);
+      case 'date':
+        return serializeDateAttributeValue(value, name);
+      case 'enum':
+        return serializeEnumAttributeValue(options, value, name);
+      case 'float':
+        return serializeFloatAttributeValue(value, name);
+      case 'html':
+        return serializeHtmlAttributeValue(value, name);
+      case 'integer':
+        return serializeIntegerAttributeValue(value, name);
+      case 'link':
+        return serializeLinkAttributeValue(value, name);
+      case 'linklist':
+        return serializeLinklistAttributeValue(value, name);
+      case 'multienum':
+        return serializeMultienumAttributeValue(options, value, name);
+      case 'reference':
+        return serializeReferenceAttributeValue(value, name);
+      case 'referencelist':
+        return serializeReferencelistAttributeValue(value, name);
+      case 'string':
+        return serializeStringAttributeValue(value, name);
+      case 'stringlist':
+        return serializeStringlistAttributeValue(value, name);
+      case 'widgetlist':
+        return serializeWidgetlistAttributeValue(value, name);
+      default:
+        throw new scrivito.InternalError('serializeAttributeValue is not implemented for "' + type + '".');
+    }
+  }
+
+  function valueOrNull(value) {
+    if ((_.isString(value) || _.isArray(value)) && _.isEmpty(value)) {
+      return null;
+    }
+    return value;
+  }
+
+  function throwInvalidAttributeValue(value, name, expected) {
+    throw new scrivito.ArgumentError('Unexpected value ' + scrivito.prettyPrint(value) + ' for' + (' attribute "' + name + '". Expected: ' + expected));
+  }
+
+  function serializeBinaryAttributeValue(value, name) {
+    if (value instanceof scrivito.Binary) {
+      return { id: value.id };
+    }
+    throwInvalidAttributeValue(value, name, 'A Binary.');
+  }
+
+  function serializeDateAttributeValue(value, name) {
+    if (_.isDate(value)) {
+      return scrivito.types.formatDateToString(value);
+    }
+    if (scrivito.types.isValidDateString(value)) {
+      return value;
+    }
+    throwInvalidAttributeValue(value, name, 'A Date.');
+  }
+
+  function serializeEnumAttributeValue(_ref3, value, name) {
+    var validValues = _ref3.validValues;
+
+    if (_.contains(validValues, value)) {
+      return value;
+    }
+
+    var e = 'Valid attribute values are contained in its "validValues" array [' + validValues + '].';
+    throwInvalidAttributeValue(value, name, e);
+  }
+
+  function serializeFloatAttributeValue(value, name) {
+    if (scrivito.types.isValidFloat(value)) {
+      return value;
+    }
+
+    var invalidValue = value;
+    if (_.isNumber(value)) {
+      invalidValue = String(value);
+    }
+    throwInvalidAttributeValue(invalidValue, name, 'A Number, that is #isFinite().');
+  }
+
+  function serializeHtmlAttributeValue(value, name) {
+    if (_.isString(value)) {
+      return value;
+    }
+    throwInvalidAttributeValue(value, name, 'A String.');
+  }
+
+  function serializeIntegerAttributeValue(value, name) {
+    if (scrivito.types.isValidInteger(value)) {
+      return value;
+    }
+    throwInvalidAttributeValue(value, name, 'A Number, that is #isSafeInteger().');
+  }
+
+  function serializeLinkAttributeValue(value, name) {
+    if (validLinkObject(value)) {
+      return convertLinkToCmsApi(value);
+    }
+    throwInvalidAttributeValue(value, name, 'A Link instance.');
+  }
+
+  function serializeLinklistAttributeValue(value, name) {
+    if (_.isArray(value) && _.every(value, validLinkObject)) {
+      return _.map(value, convertLinkToCmsApi);
+    }
+    throwInvalidAttributeValue(value, name, 'An array of Link instances.');
+  }
+
+  function validLinkObject(value) {
+    if (value instanceof scrivito.BasicLink) {
+      return true;
+    }
+
+    // check if value is backend compatible
+    if (!_.isObject(value)) {
+      return false;
+    }
+    var invalidKeys = _.without(_.keys(value), 'fragment', 'obj_id', 'query', 'target', 'title', 'url');
+    return _.isEmpty(invalidKeys);
+  }
+
+  function convertLinkToCmsApi(value) {
+    var backendLink = {
+      fragment: value.fragment,
+      query: value.query,
+      target: value.target,
+      title: value.title,
+      url: value.url
+    };
+    backendLink.obj_id = value.objId || value.obj_id;
+
+    return _.mapObject(backendLink, function (v) {
+      return v || null;
+    });
+  }
+
+  function serializeMultienumAttributeValue(_ref4, value, name) {
+    var validValues = _ref4.validValues;
+
+    var errorMessage = 'An array with values from ' + scrivito.prettyPrint(validValues) + '.';
+
+    if (!_.isArray(value) || !_.every(value, _.isString)) {
+      throwInvalidAttributeValue(value, name, errorMessage);
+    }
+
+    var forbiddenValues = _.difference(value, validValues);
+    if (forbiddenValues.length) {
+      var e = errorMessage + ' Forbidden values: ' + scrivito.prettyPrint(forbiddenValues) + '.';
+      throwInvalidAttributeValue(value, name, e);
+    }
+    return value;
+  }
+
+  function serializeReferenceAttributeValue(value, name) {
+    if (isValidReference(value)) {
+      return serializeSingleReferenceValue(value);
+    }
+    throwInvalidAttributeValue(value, name, 'A BasicObj or a String ID.');
+  }
+
+  function serializeReferencelistAttributeValue(value, name) {
+    if (isValidReferencelistValue(value)) {
+      return _.map(value, serializeSingleReferenceValue);
+    }
+    throwInvalidAttributeValue(value, name, 'An array with BasicObjs or String IDs.');
+  }
+
+  function serializeSingleReferenceValue(value) {
+    if (value instanceof scrivito.BasicObj) {
+      return value.id;
+    }
+    return value;
+  }
+
+  function isValidReference(value) {
+    return _.isString(value) || value instanceof scrivito.BasicObj;
+  }
+
+  function isValidReferencelistValue(value) {
+    return _.isArray(value) && _.every(value, function (v) {
+      return isValidReference(v);
+    });
+  }
+
+  function serializeStringAttributeValue(value, name) {
+    if (isValidString(value)) {
+      return value.toString();
+    }
+    throwInvalidAttributeValue(value, name, 'A String.');
+  }
+
+  function serializeStringlistAttributeValue(value, name) {
+    if (_.isArray(value) && _.every(value, function (v) {
+      return isValidString(v);
+    })) {
+      return _.invoke(value, 'toString');
+    }
+    throwInvalidAttributeValue(value, name, 'An array of strings.');
+  }
+
+  function isValidString(value) {
+    return _.isString(value) || _.isNumber(value);
+  }
+
+  function serializeWidgetlistAttributeValue(value, name) {
+    if (_.isArray(value) && _.every(value, function (v) {
+      return v instanceof scrivito.BasicWidget;
+    })) {
+      return _.pluck(value, 'id');
+    }
+    throwInvalidAttributeValue(value, name, 'An array of scrivito.BasicWidget instances.');
+  }
 })();
 "use strict";
 
@@ -12239,6 +12535,43 @@ function _classCallCheck(instance, Constructor) { if (!(instance instanceof Cons
 })();
 "use strict";
 
+(function () {
+  var bufferedUpdates = [];
+
+  var isUpdateScheduled = function isUpdateScheduled() {
+    return bufferedUpdates.length;
+  };
+
+  function add(callback) {
+    if (!isUpdateScheduled()) {
+      scrivito.nextTick(function () {
+        scrivito.modelState.withBatchedUpdates(function () {
+          return performUpdate(bufferedUpdates);
+        });
+      });
+    }
+
+    bufferedUpdates.push(callback);
+  }
+
+  function performUpdate(callbacks) {
+    bufferedUpdates = [];
+
+    try {
+      callbacks.forEach(function (callback) {
+        return callback();
+      });
+    } finally {
+      if (isUpdateScheduled()) {
+        performUpdate(bufferedUpdates);
+      }
+    }
+  }
+
+  scrivito.batchedStateUpdater = { add: add };
+})();
+"use strict";
+
 (function () {
   scrivito.BinaryUtils = {
     isBlob: function isBlob(obj) {
@@ -12713,42 +13046,6 @@ function _inherits(subClass, superClass) { if (typeof superClass !== 'function'
     return NetworkError;
   })(scrivito.CommunicationError);
 
-  /**
-   * A `NotLoadedError` is thrown when data is accessed in a synchronous fashion but is not yet
-   * available locally. For example {@link scrivito.BasicObj.get} throws a `NotLoadedError`
-   * whenever a CMS object is accessed that is not yet cached in the browser.
-   */
-  scrivito.NotLoadedError = (function (_scrivito$ScrivitoError5) {
-    _inherits(NotLoadedError, _scrivito$ScrivitoError5);
-
-    /**
-     * The constructor is not part of the public API and should **not** be used.
-     */
-
-    function NotLoadedError(loader) {
-      _classCallCheck(this, NotLoadedError);
-
-      _get(Object.getPrototypeOf(NotLoadedError.prototype), 'constructor', this).call(this, 'Data is not yet loaded. Call the instance method "load" to load data.');
-      this._loader = loader;
-    }
-
-    _createClass(NotLoadedError, [{
-      key: 'load',
-      value: function load(onLoadingDone) {
-        var loadPromise = this._loader();
-
-        if (onLoadingDone) {
-          var done = function done() {
-            scrivito.nextTick(onLoadingDone);
-          };
-          loadPromise.then(done, done);
-        }
-      }
-    }]);
-
-    return NotLoadedError;
-  })(scrivito.ScrivitoError);
-
   /**
    * An error thrown in case a backend request from the UI
    * exceeds the rate limit of the backend.
@@ -12772,8 +13069,8 @@ function _inherits(subClass, superClass) { if (typeof superClass !== 'function'
   /**
    * An error thrown in case a given Scrivito resource is not found.
    */
-  scrivito.ResourceNotFoundError = (function (_scrivito$ScrivitoError6) {
-    _inherits(ResourceNotFoundError, _scrivito$ScrivitoError6);
+  scrivito.ResourceNotFoundError = (function (_scrivito$ScrivitoError5) {
+    _inherits(ResourceNotFoundError, _scrivito$ScrivitoError5);
 
     /**
      * The constructor is not part of the public API and should **not** be used.
@@ -12833,6 +13130,87 @@ function _inherits(subClass, superClass) { if (typeof superClass !== 'function'
 })();
 'use strict';
 
+var _createClass = (function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ('value' in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; })();
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError('Cannot call a class as a function'); } }
+
+(function () {
+  var VALID_OPTIONS = ['limit', 'includeObjs'];
+
+  var FacetQuery = (function () {
+    function FacetQuery(attribute, options, searchQuery) {
+      var _this = this;
+
+      _classCallCheck(this, FacetQuery);
+
+      assertValidOptions(options);
+
+      this._requestParams = buildRequestParams(attribute, options, searchQuery);
+
+      var subStateKey = scrivito.computeCacheKey(this._requestParams);
+      var modelState = scrivito.modelState.subState('facetQuery').subState(subStateKey);
+
+      this._loadableData = new scrivito.LoadableData({
+        state: modelState,
+        loader: function loader() {
+          return _this._loadData();
+        }
+      });
+    }
+
+    _createClass(FacetQuery, [{
+      key: 'result',
+      value: function result() {
+        var firstFacetResult = _.first(this._loadableData.get().facets);
+
+        return _.map(firstFacetResult, function (rawFacetValue) {
+          var name = rawFacetValue.value;
+          var count = rawFacetValue.total;
+          var includedObjs = _.pluck(rawFacetValue.results, 'id');
+
+          return new scrivito.BasicObjFacetValue(name, count, includedObjs);
+        });
+      }
+    }, {
+      key: '_loadData',
+      value: function _loadData() {
+        var workspaceId = scrivito.currentWorkspaceId();
+        return scrivito.CmsRestApi.get('workspaces/' + workspaceId + '/objs/search', this._requestParams);
+      }
+    }]);
+
+    return FacetQuery;
+  })();
+
+  function assertValidOptions(options) {
+    var _ref;
+
+    var invalidOptions = (_ref = _).without.apply(_ref, [_.keys(options)].concat(VALID_OPTIONS));
+    if (invalidOptions.length) {
+      throw new scrivito.ArgumentError('Invalid options: ' + (scrivito.prettyPrint(invalidOptions) + '. Valid options: ' + VALID_OPTIONS));
+    }
+  }
+
+  function buildRequestParams(attribute, options, searchQuery) {
+    var requestParams = {
+      facets: [{
+        attribute: attribute,
+        limit: options.limit || 20,
+        include_objs: options.includeObjs || 0
+      }],
+      size: 0
+    };
+    if (searchQuery && searchQuery.length) {
+      requestParams.query = searchQuery;
+    }
+
+    return requestParams;
+  }
+
+  scrivito.FacetQuery = FacetQuery;
+})();
+'use strict';
+
 (function () {
   var isDisabled = false;
   var connectionCounter = 0;
@@ -12888,7 +13266,14 @@ function _inherits(subClass, superClass) { if (typeof superClass !== 'function'
     connectionCounter -= 1;
 
     if (request.status >= 200 && request.status < 300) {
-      return resolve(request.response);
+      var responseJSON = request.response;
+
+      if (_.isString(responseJSON)) {
+        // We can't use #response here as IE11 does not handle it correctly
+        responseJSON = JSON.parse(request.responseText);
+      }
+
+      return resolve(responseJSON);
     }
 
     return reject(request.response);
@@ -12957,7 +13342,7 @@ function _toConsumableArray(arr) { if (Array.isArray(arr)) { for (var i = 0, arr
         try {
           resolve(loadableFunction());
         } catch (error) {
-          if (error instanceof scrivito.NotLoadedError) {
+          if (scrivito.isNotLoadedError(error)) {
             error.load(tryToSettle);
           } else {
             reject(error);
@@ -13091,7 +13476,7 @@ function _classCallCheck(instance, Constructor) { if (!(instance instanceof Cons
     }, {
       key: 'setError',
       value: function setError(error) {
-        if (error instanceof scrivito.NotLoadedError) {
+        if (scrivito.isNotLoadedError(error)) {
           // prevent setting a NotLoadedError, since that would
           // unravel the space-time continuum and destroy the world.
           var warning = new scrivito.InternalError('tried to set a Loadable to a NotLoadedError');
@@ -13168,13 +13553,29 @@ function _classCallCheck(instance, Constructor) { if (!(instance instanceof Cons
 
         var versionWhenLoadingStarted = this._currentVersion();
 
-        this._loader().then(function (result) {
+        var pushCallbacks = [];
+        var addPushCallback = function addPushCallback(callback) {
+          return pushCallbacks.push(callback);
+        };
+        var runPushCallbacks = function runPushCallbacks() {
+          return pushCallbacks.forEach(function (callback) {
+            return callback();
+          });
+        };
+
+        this._loader(addPushCallback).then(function (result) {
           return ifUnchanged(function () {
-            return _this2._value.transitionTo(AVAILABLE, result, versionWhenLoadingStarted);
+            return scrivito.batchedStateUpdater.add(function () {
+              _this2._value.transitionTo(AVAILABLE, result, versionWhenLoadingStarted);
+              runPushCallbacks();
+            });
           });
         }, function (error) {
           return ifUnchanged(function () {
-            return _this2._value.transitionTo(ERROR, error, versionWhenLoadingStarted);
+            return scrivito.batchedStateUpdater.add(function () {
+              _this2._value.transitionTo(ERROR, error, versionWhenLoadingStarted);
+              runPushCallbacks();
+            });
           });
         });
 
@@ -13248,6 +13649,8 @@ var _createClass = (function () { function defineProperties(target, props) { for
 function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError('Cannot call a class as a function'); } }
 
 (function () {
+  var loadingState = {};
+
   var EMPTY_STATE = {};
 
   // A wrapper around a value that is retrieved asynchronously.
@@ -13259,7 +13662,14 @@ function _classCallCheck(instance, Constructor) { if (!(instance instanceof Cons
   // * it does not use Promises
 
   var LoadableValue = (function () {
-    // stateContainer is where the LoadableValue should store its state.
+    _createClass(LoadableValue, null, [{
+      key: 'resetLoadingState',
+      value: function resetLoadingState() {
+        loadingState = {};
+      }
+
+      // stateContainer is where the LoadableValue should store its state.
+    }]);
 
     function LoadableValue(stateContainer) {
       _classCallCheck(this, LoadableValue);
@@ -13268,6 +13678,7 @@ function _classCallCheck(instance, Constructor) { if (!(instance instanceof Cons
         throw new scrivito.InternalError('LoadableValue needs stateContainer');
       }
       this._container = stateContainer;
+      this._id = stateContainer.id();
     }
 
     // export
@@ -13280,14 +13691,14 @@ function _classCallCheck(instance, Constructor) { if (!(instance instanceof Cons
     _createClass(LoadableValue, [{
       key: 'setLoading',
       value: function setLoading(loadId) {
-        this._container.set(_.extend({}, this._getState(), { loadId: loadId }));
+        loadingState[this._id] = loadId;
       }
 
       // return the current loadId. should only be called if loading.
     }, {
       key: 'getLoading',
       value: function getLoading() {
-        return this._getState().loadId;
+        return loadingState[this._id];
       }
     }, {
       key: 'subscribe',
@@ -13312,6 +13723,7 @@ function _classCallCheck(instance, Constructor) { if (!(instance instanceof Cons
     }, {
       key: 'transitionTo',
       value: function transitionTo(status, value, version) {
+        delete loadingState[this._id];
         this._container.set({ status: status, value: value, version: version });
       }
     }, {
@@ -13337,7 +13749,7 @@ function _classCallCheck(instance, Constructor) { if (!(instance instanceof Cons
       try {
         results.push(iteratee(item));
       } catch (error) {
-        if (error instanceof scrivito.NotLoadedError) {
+        if (scrivito.isNotLoadedError(error)) {
           errors.push(error);
         } else {
           throw error;
@@ -13367,22 +13779,87 @@ function _classCallCheck(instance, Constructor) { if (!(instance instanceof Cons
 })();
 'use strict';
 
-var _get = function get(_x, _x2, _x3) { var _again = true; _function: while (_again) { var object = _x, property = _x2, receiver = _x3; _again = false; if (object === null) object = Function.prototype; var desc = Object.getOwnPropertyDescriptor(object, property); if (desc === undefined) { var parent = Object.getPrototypeOf(object); if (parent === null) { return undefined; } else { _x = parent; _x2 = property; _x3 = receiver; _again = true; desc = parent = undefined; continue _function; } } else if ('value' in desc) { return desc.value; } else { var getter = desc.get; if (getter === undefined) { return undefined; } return getter.call(receiver); } } };
-
 var _createClass = (function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ('value' in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; })();
 
-function _inherits(subClass, superClass) { if (typeof superClass !== 'function' && superClass !== null) { throw new TypeError('Super expression must either be null or a function, not ' + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
+var _get = function get(_x, _x2, _x3) { var _again = true; _function: while (_again) { var object = _x, property = _x2, receiver = _x3; _again = false; if (object === null) object = Function.prototype; var desc = Object.getOwnPropertyDescriptor(object, property); if (desc === undefined) { var parent = Object.getPrototypeOf(object); if (parent === null) { return undefined; } else { _x = parent; _x2 = property; _x3 = receiver; _again = true; desc = parent = undefined; continue _function; } } else if ('value' in desc) { return desc.value; } else { var getter = desc.get; if (getter === undefined) { return undefined; } return getter.call(receiver); } } };
 
 function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError('Cannot call a class as a function'); } }
 
-(function () {
-  var VALID_KEYS = ['attributes', 'extend', 'name'];
+function _inherits(subClass, superClass) { if (typeof superClass !== 'function' && superClass !== null) { throw new TypeError('Super expression must either be null or a function, not ' + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
 
-  var Schema = (function () {
-    function Schema(definition, parent) {
-      _classCallCheck(this, Schema);
+(function () {
+  /**
+    * A `NotLoadedError` is thrown when data is accessed in a synchronous fashion but is not yet
+    * available locally. For example {@link scrivito.BasicObj.get} throws a `NotLoadedError`
+    * whenever a CMS object is accessed that is not yet cached in the browser.
+    */
 
-      ensureDefinitionIsValid(definition);
+  var NotLoadedError = (function (_scrivito$ScrivitoError) {
+    _inherits(NotLoadedError, _scrivito$ScrivitoError);
+
+    /**
+      * The constructor is not part of the public API and should **not** be used.
+      */
+
+    function NotLoadedError(loader) {
+      _classCallCheck(this, NotLoadedError);
+
+      _get(Object.getPrototypeOf(NotLoadedError.prototype), 'constructor', this).call(this, 'Data is not yet loaded.');
+      this._loader = loader;
+    }
+
+    _createClass(NotLoadedError, [{
+      key: 'load',
+      value: function load(onLoadingDone) {
+        var loadPromise = this._loader();
+
+        if (onLoadingDone) {
+          var done = function done() {
+            scrivito.nextTick(onLoadingDone);
+          };
+          loadPromise.then(done, done);
+        }
+      }
+
+      // this getter has an extravagant name, in order to avoid name clashes
+    }, {
+      key: 'scrivitoPrivateIsNotLoadedError',
+      get: function get() {
+        return true;
+      }
+    }]);
+
+    return NotLoadedError;
+  })(scrivito.ScrivitoError);
+
+  function isNotLoadedError(error) {
+    // using duck-typing instead of "instanceof", so that these errors
+    // can be recognized across javascript (iframe) boundaries.
+    return error.scrivitoPrivateIsNotLoadedError;
+  }
+
+  // export
+  scrivito.NotLoadedError = NotLoadedError;
+  scrivito.isNotLoadedError = isNotLoadedError;
+})();
+'use strict';
+
+var _get = function get(_x, _x2, _x3) { var _again = true; _function: while (_again) { var object = _x, property = _x2, receiver = _x3; _again = false; if (object === null) object = Function.prototype; var desc = Object.getOwnPropertyDescriptor(object, property); if (desc === undefined) { var parent = Object.getPrototypeOf(object); if (parent === null) { return undefined; } else { _x = parent; _x2 = property; _x3 = receiver; _again = true; desc = parent = undefined; continue _function; } } else if ('value' in desc) { return desc.value; } else { var getter = desc.get; if (getter === undefined) { return undefined; } return getter.call(receiver); } } };
+
+var _createClass = (function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ('value' in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; })();
+
+function _inherits(subClass, superClass) { if (typeof superClass !== 'function' && superClass !== null) { throw new TypeError('Super expression must either be null or a function, not ' + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError('Cannot call a class as a function'); } }
+
+(function () {
+  var VALID_KEYS = ['attributes', 'extend', 'name'];
+
+  var Schema = (function () {
+    function Schema(definition, parent) {
+      _classCallCheck(this, Schema);
+
+      ensureDefinitionIsValid(definition);
 
       if (parent._scrivitoPrivateSchema) {
         definition.attributes = _.extend({}, parent._scrivitoPrivateSchema.attributes, definition.attributes);
@@ -14154,6 +14631,11 @@ function _inherits(subClass, superClass) { if (typeof superClass !== 'function'
       value: function fetch(_id) {
         scrivito.asyncMethodStub();
       }
+    }, {
+      key: 'fetchIncludingDeleted',
+      value: function fetchIncludingDeleted(_id) {
+        scrivito.asyncMethodStub();
+      }
     }, {
       key: 'get',
       value: function get(idOrList) {
@@ -14479,7 +14961,7 @@ function _inherits(subClass, superClass) { if (typeof superClass !== 'function'
       key: 'lastChanged',
       get: function get() {
         if (this._current._last_changed) {
-          return scrivito.parseDate(this._current._last_changed);
+          return scrivito.types.parseStringToDate(this._current._last_changed);
         }
 
         return null;
@@ -14522,8 +15004,8 @@ function _inherits(subClass, superClass) { if (typeof superClass !== 'function'
       key: 'children',
       get: function get() {
         if (this.path) {
-          var iterator = scrivito.BasicObj.where('_parent_path', 'equals', this.path).iterator();
-          return scrivito.iterable.collectValuesFromIterator(iterator);
+          var iterable = scrivito.BasicObj.all().and('_parent_path', 'equals', this.path);
+          return scrivito.iterable.collectValuesFromIterator(iterable.iterator());
         }
 
         return [];
@@ -14583,7 +15065,8 @@ function _inherits(subClass, superClass) { if (typeof superClass !== 'function'
   })(scrivito.BasicAttributeContent);
 
   scrivito.provideAsyncClassMethods(scrivito.BasicObj, {
-    get: 'fetch'
+    get: 'fetch',
+    getIncludingDeleted: 'fetchIncludingDeleted'
   });
 
   scrivito.provideAsyncInstanceMethods(scrivito.BasicObj, {
@@ -14660,6 +15143,44 @@ function _inherits(subClass, superClass) { if (typeof superClass !== 'function'
     throw new scrivito.ResourceNotFoundError('Obj with id "' + id + '" not found.');
   }
 })();
+"use strict";
+
+var _createClass = (function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; })();
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+(function () {
+  var BasicObjFacetValue = (function () {
+    function BasicObjFacetValue(name, count, includedObjs) {
+      _classCallCheck(this, BasicObjFacetValue);
+
+      this._name = name;
+      this._count = count;
+      this._includedObjs = includedObjs;
+    }
+
+    _createClass(BasicObjFacetValue, [{
+      key: "includedObjs",
+      value: function includedObjs() {
+        return scrivito.BasicObj.get(this._includedObjs);
+      }
+    }, {
+      key: "name",
+      get: function get() {
+        return this._name;
+      }
+    }, {
+      key: "count",
+      get: function get() {
+        return this._count;
+      }
+    }]);
+
+    return BasicObjFacetValue;
+  })();
+
+  scrivito.BasicObjFacetValue = BasicObjFacetValue;
+})();
 'use strict';
 
 var _createClass = (function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ('value' in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; })();
@@ -14806,6 +15327,14 @@ function _classCallCheck(instance, Constructor) { if (!(instance instanceof Cons
       value: function getBatchSize() {
         return this._batchSize;
       }
+    }, {
+      key: 'facet',
+      value: function facet(attribute) {
+        var options = arguments.length <= 1 || arguments[1] === undefined ? {} : arguments[1];
+
+        var facetQuery = new scrivito.FacetQuery(attribute, options, this._query);
+        return facetQuery.result();
+      }
     }, {
       key: 'params',
       get: function get() {
@@ -15704,6 +16233,77 @@ function _classCallCheck(instance, Constructor) { if (!(instance instanceof Cons
     });
   }
 })();
+"use strict";
+
+var _createClass = (function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; })();
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+(function () {
+  /**
+   * Instances of this class represent the result of a faceted search.
+   */
+
+  var ObjFacetValue = (function () {
+    function ObjFacetValue(registry, basicObjFacetValue) {
+      _classCallCheck(this, ObjFacetValue);
+
+      this._registry = registry;
+      this._basicObjFacetValue = basicObjFacetValue;
+    }
+
+    /**
+     * The name of this ObjFacetValue, i.e. the value of the attribute.
+     *
+     * Example: If you do faceting using the attribute `color`,
+     * you might receive an `ObjFacetValue` with the name `yellow`,
+     * another one with the name `green` and so on.
+     *
+     * @type {String}
+     */
+
+    _createClass(ObjFacetValue, [{
+      key: "includedObjs",
+
+      /**
+       * The Objs that were included in this search.
+       *
+       * If you did not specify `includeObjs` in your facet options, an empty array is returned.
+       * The Objs are ordered by relevance.
+       *
+       * @throws {scrivito.NotLoadedError} If some of the data is not yet loaded.
+       * @return {Array<Obj>}
+       */
+      value: function includedObjs() {
+        var response = this._basicObjFacetValue.includedObjs();
+        return scrivito.wrapInAppClass(this._registry, response);
+      }
+    }, {
+      key: "name",
+      get: function get() {
+        return this._basicObjFacetValue.name;
+      }
+
+      /**
+       * Total number of Objs available that have this value.
+       *
+       * Note that this refers to all Objs, not just the Objs included in this search.
+       * Also note that the count is approximate.
+       *
+       * @type {Number}
+       */
+    }, {
+      key: "count",
+      get: function get() {
+        return this._basicObjFacetValue.count;
+      }
+    }]);
+
+    return ObjFacetValue;
+  })();
+
+  scrivito.ObjFacetValue = ObjFacetValue;
+})();
 'use strict';
 
 var _createClass = (function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ('value' in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; })();
@@ -15725,6 +16325,10 @@ function _inherits(subClass, superClass) { if (typeof superClass !== 'function'
       return iterable;
     }
 
+    function wrap(response) {
+      return scrivito.wrapInAppClass(registry, response);
+    }
+
     /**
      * The base class for CMS objects.
      *
@@ -15749,11 +16353,28 @@ function _inherits(subClass, superClass) { if (typeof superClass !== 'function'
       }
 
       _createClass(Obj, [{
-        key: 'destroy',
+        key: 'isBinary',
+
+        /**
+         * This method indicates whether the Obj represents binary data. Binaries are
+         * handled differently in that they are not rendered using the normal layout
+         * but sent as a file. Examples of binary resources are Images or PDFs.
+         *
+         * Every Obj that has a `blob` attribute of the `binary` type is
+         * considered a binary
+         *
+         * @returns {Boolean} `true` if this Obj represents a binary resource.
+         */
+        value: function isBinary() {
+          var blobTypeInfo = this.constructor._scrivitoPrivateSchema.attributes.blob;
+          return blobTypeInfo === 'binary';
+        }
 
         /**
          * Destroy this CMS object in the current Workspace.
          */
+      }, {
+        key: 'destroy',
         value: function destroy() {
           this._scrivitoPrivateContent.destroy();
         }
@@ -15761,17 +16382,26 @@ function _inherits(subClass, superClass) { if (typeof superClass !== 'function'
         /**
          * Access widgets by their ids
          *
+         * Returns `null` if no matching Widget exists.
+         *
          * @param {String} id - the widget's id
-         * @returns {scrivito.Widget}
+         * @returns {?Widget}
          */
       }, {
         key: 'widget',
         value: function widget(id) {
-          var widget = this._scrivitoPrivateContent.widget(id);
+          return wrap(this._scrivitoPrivateContent.widget(id));
+        }
 
-          if (widget) {
-            return scrivito.wrapInAppClass(registry, widget);
-          }
+        /**
+         * Returns all {@link Widget widgets} of the given CMS object.
+         *
+         * @returns {Widget[]}
+         */
+      }, {
+        key: 'widgets',
+        value: function widgets() {
+          return wrap(this._scrivitoPrivateContent.widgets());
         }
       }, {
         key: 'lastChanged',
@@ -15795,6 +16425,65 @@ function _inherits(subClass, superClass) { if (typeof superClass !== 'function'
           return this._scrivitoPrivateContent.path;
         }
 
+        /**
+         * Returns the {@link Obj} that is the parent of this Obj.
+         * Returns `null` if the obj has no `path` or is the root Obj.
+         *
+         * Throws a {@link scrivito.NotLoadedError} if the parent is not yet loaded.
+         *
+         * @type {?Obj}
+         */
+      }, {
+        key: 'parent',
+        get: function get() {
+          return wrap(this._scrivitoPrivateContent.parent);
+        }
+
+        /**
+         * Returns an Array of all the ancestor {@link Obj Objs}, starting at the
+         * root and ending at the parent of this object.
+         *
+         * Throws a {@link scrivito.NotLoadedError} if the ancestors have not yet been loaded.
+         *
+         * @type {Obj[]}
+         */
+      }, {
+        key: 'ancestors',
+        get: function get() {
+          return wrap(this._scrivitoPrivateContent.ancestors);
+        }
+
+        /**
+         * Returns a list of all {@link Obj Objs} that link to this Obj.
+         *
+         * This includes all CMS objects in which at least one `html`,
+         * `link`, `linklist`, `reference` or `referencelist` attribute links to this CMS object.
+         *
+         * Attributes inside {@link Widget Widgets} are considered, too.
+         *
+         * Throws a {@link scrivito.NotLoadedError} if the backlinks have not yet been loaded.
+         *
+         * @type {Obj[]}
+         */
+      }, {
+        key: 'backlinks',
+        get: function get() {
+          return wrap(this._scrivitoPrivateContent.backlinks);
+        }
+
+        /**
+         * Returns a list of all child {@link Obj Objs}.
+         *
+         * Throws a {@link scrivito.NotLoadedError} if the children have not yet been loaded.
+         *
+         * @type {Obj[]}
+         */
+      }, {
+        key: 'children',
+        get: function get() {
+          return wrap(this._scrivitoPrivateContent.children);
+        }
+
         /**
          * The permalink of the CMS object
          * @type {?String}
@@ -15827,6 +16516,34 @@ function _inherits(subClass, superClass) { if (typeof superClass !== 'function'
           return scrivito.wrapInAppClass(registry, instance);
         }
 
+        /**
+         * Get a given Obj by its `path`.
+         *
+         * Returns `null` if no matching Obj exists.
+         *
+         * @param {String} path - The path of the Obj
+         * @returns {?Obj}
+         */
+      }, {
+        key: 'getByPath',
+        value: function getByPath(path) {
+          return wrap(scrivito.BasicObj.getByPath(path));
+        }
+
+        /**
+         * Get a given Obj by its `permalink`.
+         *
+         * Returns `null` if no matching Obj exists.
+         *
+         * @param {String} permalink - The permalink of the Obj
+         * @returns {?Obj}
+         */
+      }, {
+        key: 'getByPermalink',
+        value: function getByPermalink(permalink) {
+          return wrap(scrivito.BasicObj.getByPermalink(permalink));
+        }
+
         /**
          * Returns an {@link ObjSearchIterable} of all {@link Obj}s.
          * @return {ObjSearchIterable}
@@ -15893,9 +16610,7 @@ function _inherits(subClass, superClass) { if (typeof superClass !== 'function'
           attributes._objClass = appClassName;
           var attributesWithTypeInfo = scrivito.AttributeContentFactory.prepareAttributes(attributes, schema, appClassName);
 
-          var basicObj = scrivito.BasicObj.create(attributesWithTypeInfo);
-
-          return scrivito.wrapInAppClass(registry, basicObj);
+          return wrap(scrivito.BasicObj.create(attributesWithTypeInfo));
         }
       }]);
 
@@ -15911,7 +16626,7 @@ function _inherits(subClass, superClass) { if (typeof superClass !== 'function'
 
 var _createClass = (function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; })();
 
-var _get = function get(_x2, _x3, _x4) { var _again = true; _function: while (_again) { var object = _x2, property = _x3, receiver = _x4; _again = false; if (object === null) object = Function.prototype; var desc = Object.getOwnPropertyDescriptor(object, property); if (desc === undefined) { var parent = Object.getPrototypeOf(object); if (parent === null) { return undefined; } else { _x2 = parent; _x3 = property; _x4 = receiver; _again = true; desc = parent = undefined; continue _function; } } else if ("value" in desc) { return desc.value; } else { var getter = desc.get; if (getter === undefined) { return undefined; } return getter.call(receiver); } } };
+var _get = function get(_x3, _x4, _x5) { var _again = true; _function: while (_again) { var object = _x3, property = _x4, receiver = _x5; _again = false; if (object === null) object = Function.prototype; var desc = Object.getOwnPropertyDescriptor(object, property); if (desc === undefined) { var parent = Object.getPrototypeOf(object); if (parent === null) { return undefined; } else { _x3 = parent; _x4 = property; _x5 = receiver; _again = true; desc = parent = undefined; continue _function; } } else if ("value" in desc) { return desc.value; } else { var getter = desc.get; if (getter === undefined) { return undefined; } return getter.call(receiver); } } };
 
 function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
 
@@ -15988,7 +16703,7 @@ function _inherits(subClass, superClass) { if (typeof superClass !== "function"
      *
      * **`starts_with`**
      *
-     * The `starts_with` is intended for programmatic comparions of string values.
+     * The `starts_with` is intended for programmatic comparisons of string values.
      *
      * The `starts_with` operator has a precision limit:
      * Only prefixes of up to 20 characters are guaranteed to be matched.
@@ -16234,6 +16949,45 @@ function _inherits(subClass, superClass) { if (typeof superClass !== "function"
           var unwrappedValue = scrivito.unwrapAppClassValues(value);
           return _get(Object.getPrototypeOf(ObjSearchIterable.prototype), "andNot", this).call(this, field, operator, unwrappedValue);
         }
+
+        /**
+         * Perform a faceted search over one attribute to retrieve structured results for
+         * individual values of this attribute.
+         *
+         * Applicable to attributes of the following types: `string`, `stringlist`, `enum` and
+         * `multienum`.
+         *
+         * Please note that there is a precision limit for faceting: Only the first 50 characters
+         * of a string are guaranteed to be considered for faceting. If two string values have the
+         * same first 50 characters, they may be grouped into the same facet value.
+         *
+         * @param {String} attribute The name of an attribute.
+         * @param {Object} [option={}] - The options to facet a request with.
+         * @param {Number} option.limit - The maximum number of unique values to return.
+         *     Defaults to `20`.
+         * @param {Number} option.includeObjs - The number of Objs to fetch for each unique value.
+         *     Defaults to `0`.
+         *
+         * @throws {scrivito.ArgumentError} If an invalid option is given.
+         * @throws {scrivito.NotLoadedError} If some of the data is not yet loaded.
+         * @throws {scrivito.ClientError} If the maximum number of results has been exceeded.
+         *   The number of results is limited to 100 with respect to the facets themselves
+         *   and the included Objs.
+         *
+         * @return {Array<scrivito.ObjFacetValue>} A list of unique values that were found for the
+         *   given attribute name. The list is ordered by frequency, i.e. values occurring more
+         *   frequently come first.
+         */
+      }, {
+        key: "facet",
+        value: function facet(attribute) {
+          var options = arguments.length <= 1 || arguments[1] === undefined ? {} : arguments[1];
+
+          var result = _get(Object.getPrototypeOf(ObjSearchIterable.prototype), "facet", this).call(this, attribute, options);
+          return _.map(result, function (facetValue) {
+            return new scrivito.ObjFacetValue(registry, facetValue);
+          });
+        }
       }]);
 
       return ObjSearchIterable;
@@ -16246,6 +17000,8 @@ function _inherits(subClass, superClass) { if (typeof superClass !== "function"
 })();
 'use strict';
 
+var _createClass = (function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ('value' in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; })();
+
 var _get = function get(_x, _x2, _x3) { var _again = true; _function: while (_again) { var object = _x, property = _x2, receiver = _x3; _again = false; if (object === null) object = Function.prototype; var desc = Object.getOwnPropertyDescriptor(object, property); if (desc === undefined) { var parent = Object.getPrototypeOf(object); if (parent === null) { return undefined; } else { _x = parent; _x2 = property; _x3 = receiver; _again = true; desc = parent = undefined; continue _function; } } else if ('value' in desc) { return desc.value; } else { var getter = desc.get; if (getter === undefined) { return undefined; } return getter.call(receiver); } } };
 
 function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError('Cannot call a class as a function'); } }
@@ -16309,6 +17065,37 @@ function _inherits(subClass, superClass) { if (typeof superClass !== 'function'
         this._scrivitoPrivateContent = new scrivito.BasicWidget(attributesWithTypeInfo);
       }
 
+      /**
+       * The CMS object the widget is contained in
+       * @type {Obj}
+       */
+
+      _createClass(Widget, [{
+        key: 'copy',
+
+        /**
+         * Create a copy of a {@link Widget}.
+         *
+         * The copy will have all the attributes of the original widget including its widgets.
+         * Its attributes can be accessed only after it has been stored in a `widgetlist` field
+         * of an {@link Obj}, since initially the copy is not stored in such a field.
+         *
+         * @return {Widget} a copy of the widget
+         */
+        value: function copy() {
+          var appClass = registry.widgetClassFor(this.objClass);
+          var basicWidget = this._scrivitoPrivateContent.copy();
+
+          return scrivito.buildAppClassInstance(basicWidget, appClass);
+        }
+      }, {
+        key: 'obj',
+        get: function get() {
+          var basicObj = this._scrivitoPrivateContent.obj;
+          return scrivito.wrapInAppClass(registry, basicObj);
+        }
+      }]);
+
       return Widget;
     })(scrivito.AttributeContentFactory(registry));
 
@@ -16374,9 +17161,11 @@ function _classCallCheck(instance, Constructor) { if (!(instance instanceof Cons
 
       this._loadableData = new scrivito.LoadableData({
         state: state,
-        loader: function loader() {
+        loader: function loader(push) {
           return scrivito.ObjRetrieval.retrieveObj(_this._id).then(function (data) {
-            scrivito.ObjReplication.get(_this._id).notifyBackendState(data);
+            push(function () {
+              return _this._replication().notifyBackendState(data);
+            });
             return data;
           });
         }
@@ -16566,10 +17355,38 @@ function _classCallCheck(instance, Constructor) { if (!(instance instanceof Cons
 
 (function () {
   scrivito.ObjQueryBatch = (function () {
+    _createClass(ObjQueryBatch, null, [{
+      key: "firstBatchFor",
+      value: function firstBatchFor(params, batchSize) {
+        return new ObjQueryBatch(params, batchSize);
+      }
+
+      // the constructor should only be called internally,
+      // i.e. by ObjQueryBatch itself
+    }]);
+
+    function ObjQueryBatch(params, batchSize) {
+      var previousBatch = arguments.length <= 2 || arguments[2] === undefined ? undefined : arguments[2];
+
+      _classCallCheck(this, ObjQueryBatch);
+
+      this._params = params;
+      this._batchSize = batchSize;
+
+      if (previousBatch) {
+        this._index = previousBatch.index + 1;
+        this._continuation = previousBatch.continuationForNextBatch();
+        this._previousBatch = previousBatch;
+      } else {
+        // First batch
+        this._index = 0;
+      }
+    }
+
+    // throws NotLoadedError if not available
+
     _createClass(ObjQueryBatch, [{
       key: "objIds",
-
-      // throws NotLoadedError if not available
       value: function objIds() {
         return this._response().results;
       }
@@ -16579,31 +17396,16 @@ function _classCallCheck(instance, Constructor) { if (!(instance instanceof Cons
     }, {
       key: "nextBatch",
       value: function nextBatch() {
-        var continuation = this._response().continuation;
-
-        if (continuation) {
-          return new ObjQueryBatch(this._params, this._batchSize, continuation);
+        if (this.continuationForNextBatch()) {
+          return new ObjQueryBatch(this._params, this._batchSize, this);
         }
       }
-
-      // the constructor should only be called internally,
-      // i.e. by ObjQueryBatch itself
-    }], [{
-      key: "firstBatchFor",
-      value: function firstBatchFor(params, batchSize) {
-        return new ObjQueryBatch(params, batchSize);
+    }, {
+      key: "continuationForNextBatch",
+      value: function continuationForNextBatch() {
+        return this._response().continuation;
       }
-    }]);
-
-    function ObjQueryBatch(params, batchSize, continuation) {
-      _classCallCheck(this, ObjQueryBatch);
-
-      this._params = params;
-      this._continuation = continuation;
-      this._batchSize = batchSize;
-    }
-
-    _createClass(ObjQueryBatch, [{
+    }, {
       key: "_response",
       value: function _response() {
         return this._data().get();
@@ -16613,9 +17415,8 @@ function _classCallCheck(instance, Constructor) { if (!(instance instanceof Cons
       value: function _data() {
         var _this = this;
 
-        var paramsWithContinuation = _.extend({}, this._params, { continuation: this._continuation });
-
-        var key = scrivito.ObjQueryStore.computeCacheKey(paramsWithContinuation);
+        var paramsWithIndex = _.extend({}, this._params, { index: this._index });
+        var key = scrivito.ObjQueryStore.computeCacheKey(paramsWithIndex);
 
         return new scrivito.LoadableData({
           state: scrivito.ObjQueryStore.stateContainer().subState(key),
@@ -16623,26 +17424,50 @@ function _classCallCheck(instance, Constructor) { if (!(instance instanceof Cons
             return _this._load();
           },
           invalidation: function invalidation() {
-            return scrivito.ObjReplication.getWorkspaceVersion();
+            return _this._version();
           }
         });
       }
     }, {
       key: "_load",
       value: function _load() {
-        var batchSpecificParams = {
-          size: this._batchSize,
-          continuation: this._continuation
-        };
+        var _this2 = this;
 
-        var requestParams = _.extend({}, this._params, batchSpecificParams);
+        return this._fetchContinuation().then(function (continuation) {
+          var batchSpecificParams = { size: _this2._batchSize, continuation: continuation };
 
-        return scrivito.ObjQueryRetrieval.retrieve(requestParams).then(function (response) {
-          preloadObjData(response.results);
+          var requestParams = _.extend({}, _this2._params, batchSpecificParams);
 
-          return response;
+          return scrivito.ObjQueryRetrieval.retrieve(requestParams).then(function (response) {
+            preloadObjData(response.results);
+
+            return response;
+          });
         });
       }
+    }, {
+      key: "_fetchContinuation",
+      value: function _fetchContinuation() {
+        var _this3 = this;
+
+        if (this._previousBatch) {
+          return scrivito.loadAsync(function () {
+            return _this3._previousBatch.continuationForNextBatch();
+          });
+        }
+
+        return scrivito.Promise.resolve();
+      }
+    }, {
+      key: "_version",
+      value: function _version() {
+        return this._continuation + "|" + scrivito.ObjReplication.getWorkspaceVersion();
+      }
+    }, {
+      key: "index",
+      get: function get() {
+        return this._index;
+      }
     }]);
 
     return ObjQueryBatch;
@@ -16788,6 +17613,8 @@ function _classCallCheck(instance, Constructor) { if (!(instance instanceof Cons
     }]);
 
     function ObjReplication(id) {
+      var _this = this;
+
       _classCallCheck(this, ObjReplication);
 
       this._id = id;
@@ -16795,6 +17622,9 @@ function _classCallCheck(instance, Constructor) { if (!(instance instanceof Cons
       this._scheduledReplication = false;
       this._currentRequestDeferred = null;
       this._nextRequestDeferred = null;
+      this._performThrottledReplication = scrivito.throttle(function () {
+        return _this._performReplication();
+      }, 1000);
     }
 
     _createClass(ObjReplication, [{
@@ -16858,7 +17688,7 @@ function _classCallCheck(instance, Constructor) { if (!(instance instanceof Cons
     }, {
       key: '_startReplication',
       value: function _startReplication() {
-        var _this = this;
+        var _this2 = this;
 
         if (!_.isEmpty(diff(this._backendState, this._localState))) {
           if (!this._replicationActive) {
@@ -16868,7 +17698,7 @@ function _classCallCheck(instance, Constructor) { if (!(instance instanceof Cons
 
               writeStarted(this._currentRequestDeferred.promise);
               scrivito.nextTick(function () {
-                return _this._performReplication();
+                return _this2._performThrottledReplication();
               });
             }
           } else {
@@ -16886,7 +17716,7 @@ function _classCallCheck(instance, Constructor) { if (!(instance instanceof Cons
     }, {
       key: '_performReplication',
       value: function _performReplication() {
-        var _this2 = this;
+        var _this3 = this;
 
         var localState = this._localState;
         var patch = diff(this._backendState, this._localState);
@@ -16895,16 +17725,16 @@ function _classCallCheck(instance, Constructor) { if (!(instance instanceof Cons
         this._replicationActive = true;
 
         this._replicatePatchToBackend(patch).then(function (backendState) {
-          _this2._handleBackendUpdate(localState, backendState);
-          _this2._currentRequestDeferred.resolve(_this2._id);
-          _this2._currentRequestDeferred = null;
-          _this2._replicationActive = false;
+          _this3._handleBackendUpdate(localState, backendState);
+          _this3._currentRequestDeferred.resolve(_this3._id);
+          _this3._currentRequestDeferred = null;
+          _this3._replicationActive = false;
 
-          _this2._startReplication();
+          _this3._startReplication();
         }, function (error) {
-          _this2._currentRequestDeferred.reject(error);
-          _this2._currentRequestDeferred = null;
-          _this2._replicationActive = false;
+          _this3._currentRequestDeferred.reject(error);
+          _this3._currentRequestDeferred = null;
+          _this3._replicationActive = false;
         });
       }
     }, {
@@ -17532,6 +18362,8 @@ function _defineProperty(obj, key, value) { if (key in obj) { Object.definePrope
 function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError('Cannot call a class as a function'); } }
 
 (function () {
+  var treeIdCounter = 0;
+
   // abstract interface for managing state
 
   var AbstractStateStore = (function () {
@@ -17557,6 +18389,13 @@ function _classCallCheck(instance, Constructor) { if (!(instance instanceof Cons
         throw scrivito.InternalError('implement in subclass');
       }
 
+      // get a string that uniquely identifies this state
+    }, {
+      key: 'id',
+      value: function id() {
+        throw scrivito.InternalError('implement in subclass');
+      }
+
       // subscribe to changes to state
       // the listener will be called at least once after each state change.
       // returns a function that should be invoked to unsubscribe.
@@ -17623,7 +18462,9 @@ function _classCallCheck(instance, Constructor) { if (!(instance instanceof Cons
       _classCallCheck(this, StateTree);
 
       _get(Object.getPrototypeOf(StateTree.prototype), 'constructor', this).call(this);
+      this._id = (treeIdCounter++).toString();
       this._listeners = Immutable.Set();
+      this._batchUpdates = false;
     }
 
     // a node of a state tree.
@@ -17639,9 +18480,17 @@ function _classCallCheck(instance, Constructor) { if (!(instance instanceof Cons
       key: 'set',
       value: function set(newState) {
         this._state = newState;
-        this._listeners.forEach(function (listener) {
-          return listener();
-        });
+
+        if (!this._batchUpdates) {
+          this._listeners.forEach(function (listener) {
+            return listener();
+          });
+        }
+      }
+    }, {
+      key: 'id',
+      value: function id() {
+        return this._id;
       }
     }, {
       key: 'subscribe',
@@ -17658,6 +18507,27 @@ function _classCallCheck(instance, Constructor) { if (!(instance instanceof Cons
           _this._listeners = _this._listeners.remove(listener);
         };
       }
+    }, {
+      key: 'withBatchedUpdates',
+      value: function withBatchedUpdates(fn) {
+        if (this._batchUpdates) {
+          throw new scrivito.InternalError('#withBatchedUpdates can not be nested');
+        }
+
+        var stateBeforeBatchUpdate = this._state;
+
+        try {
+          this._batchUpdates = true;
+          fn();
+        } finally {
+          this._batchUpdates = false;
+          if (stateBeforeBatchUpdate !== this._state) {
+            this._listeners.forEach(function (listener) {
+              return listener();
+            });
+          }
+        }
+      }
 
       // For test purpose only.
     }, {
@@ -17705,6 +18575,15 @@ function _classCallCheck(instance, Constructor) { if (!(instance instanceof Cons
       value: function set(newState) {
         this._parentState.setSubState(this._key, newState);
       }
+    }, {
+      key: 'id',
+      value: function id() {
+        // first convert backslash to double-backslash
+        // then convert slash to backslash-slash
+        var escapedKey = this._key.replace(/\\/g, '\\\\').replace(/\//g, '\\/');
+
+        return this._parentState.id() + '/' + escapedKey;
+      }
     }, {
       key: 'subscribe',
       value: function subscribe(listener) {
@@ -17735,6 +18614,22 @@ function _classCallCheck(instance, Constructor) { if (!(instance instanceof Cons
   // singleton instance, to be used by the data layer
   scrivito.modelState = new StateTree();
 })();
+"use strict";
+
+(function () {
+  var shouldBypassThrottle = false;
+
+  function throttle(fn, ms, options) {
+    return shouldBypassThrottle ? fn : _.throttle(fn, ms, options);
+  }
+
+  function bypassThrottle() {
+    shouldBypassThrottle = true;
+  }
+
+  scrivito.throttle = throttle;
+  scrivito.bypassThrottle = bypassThrottle;
+})();
 'use strict';
 
 var _slicedToArray = (function () { function sliceIterator(arr, i) { var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i['return']) _i['return'](); } finally { if (_d) throw _e; } } return _arr; } return function (arr, i) { if (Array.isArray(arr)) { return arr; } else if (Symbol.iterator in Object(arr)) { return sliceIterator(arr, i); } else { throw new TypeError('Invalid attempt to destructure non-iterable instance'); } }; })();
@@ -17817,7 +18712,7 @@ var _slicedToArray = (function () { function sliceIterator(arr, i) { var _arr =
         throw new scrivito.InternalError("The value is not a valid ISO date time: \"" + value + "\"");
       }
 
-      return scrivito.parseDate(value);
+      return scrivito.types.parseStringToDate(value);
     },
 
     parseStringToDate: function parseStringToDate(dateString) {
@@ -17918,4 +18813,480 @@ var _slicedToArray = (function () { function sliceIterator(arr, i) { var _arr =
 
   scrivito.wrapInAppClass = wrapInAppClass;
   scrivito.unwrapAppClassValues = unwrapAppClassValues;
+  scrivito.buildAppClassInstance = buildAppClassInstance;
+})();
+"use strict";
+
+(function () {
+  scrivito.React = {};
+})();
+'use strict';
+
+(function () {
+  var PropTypes = {
+    oneOfRealmType: function oneOfRealmType() {
+      for (var _len = arguments.length, typeNames = Array(_len), _key = 0; _key < _len; _key++) {
+        typeNames[_key] = arguments[_key];
+      }
+
+      return function (props, propName, componentName) {
+        var propValue = props[propName];
+        var realm = scrivito.currentRealm();
+
+        if (!_.any(typeNames, function (name) {
+          return propValue instanceof (realm[name] || scrivito[name]);
+        })) {
+          return new scrivito.ArgumentError('Component "' + componentName + '" received prop "' + propName + '"' + (' with invalid value "' + propValue + '".') + (' Valid are instances of ' + formatRealmTypes(typeNames) + '.'));
+        }
+      };
+    }
+  };
+
+  function formatRealmTypes(typeNames) {
+    return _.map(typeNames, function (typeName) {
+      return '"scrivito.' + typeName + '"';
+    }).join(', ');
+  }
+
+  scrivito.PropTypes = PropTypes;
+})();
+(function () {
+  function createReactClass(params) {
+    var shouldRenderLoader = params.shouldRenderLoader;
+    var render = params.render;
+    var componentDidMount = params.componentDidMount;
+    var componentWillUnmount = params.componentWillUnmount;
+
+    var unsubscribeModelState = undefined;
+
+    return React.createClass(_.extend(params, {
+      componentDidMount: function () {
+        var _this = this;
+
+        unsubscribeModelState = scrivito.modelState.subscribe(function () {
+          if (_this.isMounted()) {
+            _this.forceUpdate();
+          }
+        });
+
+        if (componentDidMount) {
+          componentDidMount.apply(this);
+        }
+      },
+
+      componentWillUnmount: function () {
+        unsubscribeModelState();
+
+        if (componentWillUnmount) {
+          componentWillUnmount.apply(this);
+        }
+      },
+
+      render: function () {
+        var _this2 = this;
+
+        var handleError = function (error) {
+          scrivito.nextTick(function () {
+            throw error;
+          });
+          return shouldRenderLoader ? React.createElement(scrivito.LoaderError, null) : null;
+        };
+
+        try {
+          return scrivito.LoadableData.withEventualConsistency(function () {
+            return render.apply(_this2);
+          });
+        } catch (error) {
+          if (error instanceof scrivito.NotLoadedError) {
+            try {
+              error.load();
+            } catch (error) {
+              return handleError(error);
+            }
+
+            if (this.renderWhileLoading) {
+              return this.renderWhileLoading();
+            }
+
+            return shouldRenderLoader ? React.createElement(scrivito.Loader, null) : null;
+          }
+
+          return handleError(error);
+        }
+      }
+    }));
+  }
+
+  scrivito.createReactClass = createReactClass;
+})();
+"use strict";
+
+(function () {
+  function changeLocation(newLocation) {
+    window.location = newLocation;
+  }
+
+  // For test purpose only.
+  scrivito.changeLocation = changeLocation;
+})();
+"use strict";
+
+(function () {
+  var registry = {};
+
+  var componentRegistry = {
+    provideComponentClass: function provideComponentClass(appClass, componentClass) {
+      registry[appClass._scrivitoPrivateSchema.name] = componentClass;
+    },
+
+    getComponentClass: function getComponentClass(appClass) {
+      return registry[appClass._scrivitoPrivateSchema.name];
+    },
+
+    // For test purpose only.
+    clear: function clear() {
+      registry = {};
+    }
+  };
+
+  scrivito.componentRegistry = componentRegistry;
+})();
+(function () {
+  var Content = scrivito.createReactClass({
+    displayName: 'scrivito.React.Content',
+
+    propTypes: {
+      content: scrivito.PropTypes.oneOfRealmType('Obj', 'Widget'),
+
+      attribute: function (props, propName, componentName) {
+        var validationError = React.PropTypes.string.isRequired(props, propName, componentName);
+
+        if (validationError) {
+          return validationError;
+        }
+
+        var attributeName = props[propName];
+
+        if (/^_/.test(attributeName)) {
+          return new scrivito.ArgumentError('Component "scrivito.React.Content" received prop "attribute" with invalid value: ' + ('"' + attributeName + '" is a system attribute. Only custom attributes are allowed.'));
+        }
+      },
+
+      tag: React.PropTypes.string
+    },
+
+    getDefaultProps: function () {
+      return { tag: 'div' };
+    },
+
+    render: function () {
+      var schema = this.props.content.constructor._scrivitoPrivateSchema;
+
+      var attributeName = this.props.attribute;
+      var attributeType = schema.attributes[attributeName];
+
+      if (!attributeType) {
+        throw new scrivito.ArgumentError('Component "scrivito.React.Content" received prop "attribute" with invalid value: ' + ('Attribute "' + attributeName + '" is not defined for content specified in prop "content".'));
+      }
+
+      var attributeValue = this.props.content.get(attributeName);
+
+      switch (attributeType) {
+        case 'html':
+          return this._renderHtml(attributeValue);
+        case 'string':
+          return this._renderString(attributeValue);
+        case 'widgetlist':
+          return this._renderWidgetlist(attributeValue);
+      }
+
+      return this._renderContent({ children: this.props.children });
+    },
+
+    _renderHtml: function (attributeValue) {
+      if (this.props.children) {
+        return this._renderContent({ children: this.props.children });
+      }
+
+      var props = { dangerouslySetInnerHTML: { __html: attributeValue } };
+      return this._renderContent({ props: props });
+    },
+
+    _renderString: function (attributeValue) {
+      return this._renderContent({ children: this.props.children || attributeValue });
+    },
+
+    _renderWidgetlist: function (attributeValue) {
+      var children = attributeValue.map(function (widget) {
+        return React.createElement(Widget, { key: widget.id, widget: widget });
+      });
+      return this._renderContent({ children: children });
+    },
+
+    _renderContent: function (_ref) {
+      var props = _ref.props;
+      var children = _ref.children;
+
+      return React.createElement(this.props.tag, _.extend(this._customProps(), props), children);
+    },
+
+    _customProps: function () {
+      return _.omit(this.props, 'content', 'attribute', 'tag');
+    }
+  });
+
+  var Widget = scrivito.createReactClass({
+    render: function () {
+      var widget = this.props.widget;
+      var componentClass = scrivito.componentRegistry.getComponentClass(widget.constructor);
+
+      if (!componentClass) {
+        throw new scrivito.ArgumentError('No component registered for widget class "' + widget.objClass + '".');
+      }
+
+      return React.createElement(
+        'div',
+        null,
+        React.createElement(componentClass, { widget: this.props.widget })
+      );
+    }
+  });
+
+  scrivito.React.Content = Content;
+})();
+(function () {
+  var CurrentPage = scrivito.createReactClass({
+    displayName: 'scrivito.React.CurrentPage',
+
+    render: function () {
+      var currentPage = scrivito.currentPage();
+
+      if (!currentPage) {
+        return null;
+      }
+
+      var appClass = currentPage.constructor;
+      var componentClass = scrivito.componentRegistry.getComponentClass(appClass);
+
+      if (!componentClass) {
+        return null;
+      }
+
+      return React.createElement(componentClass, { page: currentPage });
+    }
+  });
+
+  scrivito.React.CurrentPage = CurrentPage;
+})();
+var _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };
+
+(function () {
+  var Image = scrivito.createReactClass({
+    displayName: 'scrivito.React.Image',
+
+    propTypes: {
+      src: scrivito.PropTypes.oneOfRealmType('Obj', 'Binary'),
+      attribute: React.PropTypes.string
+    },
+
+    getDefaultProps: function () {
+      return { attribute: 'blob' };
+    },
+
+    render: function () {
+      var url = this._binary().url;
+      var htmlOptions = _.omit(this.props, 'src', 'attribute');
+
+      return React.createElement('img', _extends({ src: url }, htmlOptions));
+    },
+
+    _binary: function () {
+      if (this.props.src instanceof scrivito.Binary) {
+        return this.props.src;
+      }
+
+      var schema = this.props.src.constructor._scrivitoPrivateSchema;
+      var attributeType = schema.attributes[this.props.attribute];
+
+      if (!attributeType) {
+        throw new scrivito.ScrivitoError('Component "scrivito.React.Image" received prop "src"' + (' with an instance of "scrivito.Obj" missing attribute "' + this.props.attribute + '".'));
+      }
+
+      if (attributeType === 'reference') {
+        var target = this.props.src.get(this.props.attribute);
+
+        if (target) {
+          return target.get('blob');
+        }
+      }
+
+      if (attributeType === 'binary') {
+        return this.props.src.get(this.props.attribute);
+      }
+
+      throw new scrivito.ScrivitoError('Component "scrivito.React.Image" received prop "src"' + (' with an instance of "scrivito.Obj", whose attribute "' + this.props.attribute + '"') + (' is of invalid type "' + attributeType + '".') + ' Valid attribute types are "binary" and "reference".');
+    }
+  });
+
+  scrivito.React.Image = Image;
+})();
+var _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };
+
+(function () {
+  var Link = scrivito.createReactClass({
+    displayName: 'scrivito.React.Link',
+
+    propTypes: {
+      to: scrivito.PropTypes.oneOfRealmType('Obj', 'Link')
+    },
+
+    render: function () {
+      var htmlOptions = _.omit(this.props, 'to');
+
+      return React.createElement(
+        'a',
+        _extends({ href: '#', onClick: this._onClick }, htmlOptions),
+        this.props.children
+      );
+    },
+
+    _onClick: function (e) {
+      e.preventDefault();
+      scrivito.navigateTo(this.props.to);
+    }
+  });
+
+  scrivito.React.Link = Link;
+})();
+'use strict';
+
+(function () {
+  var state = scrivito.modelState.subState('currentPage');
+
+  function currentPage() {
+    var objId = state.get();
+
+    if (objId) {
+      try {
+        return scrivito.currentRealm().Obj.get(objId);
+      } catch (error) {
+        if (error instanceof scrivito.NotLoadedError) {
+          error.load();
+          return null;
+        }
+
+        throw error;
+      }
+    }
+
+    return null;
+  }
+
+  function navigateTo(target) {
+    if (!target) {
+      throw new scrivito.ArgumentError('Missing target.');
+    }
+
+    if (target instanceof scrivito.currentRealm().Obj) {
+      if (target.isBinary()) {
+        scrivito.changeLocation(target.get('blob').url);
+      } else {
+        state.set(target.id);
+      }
+
+      return;
+    }
+
+    if (target instanceof scrivito.currentRealm().Link) {
+      if (target.isExternal()) {
+        scrivito.changeLocation(target.url);
+      } else {
+        state.set(target.obj.id);
+      }
+
+      return;
+    }
+
+    throw new scrivito.ArgumentError('Target is invalid. Valid targets are instances of "scrivito.Obj" or "scrivito.Link".');
+  }
+
+  scrivito.currentPage = currentPage;
+  scrivito.navigateTo = navigateTo;
+})();
+"use strict";
+
+(function () {
+  var currentRealm = undefined;
+
+  function getCurrentRealm() {
+    return currentRealm || window.scrivito;
+  }
+
+  function setCurrentRealm(realm) {
+    currentRealm = realm;
+  }
+
+  scrivito.currentRealm = getCurrentRealm;
+  scrivito.setCurrentRealm = setCurrentRealm;
+})();
+'use strict';
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+(function () {
+  function createComponent(componentSpec) {
+    if (typeof componentSpec === 'function') {
+      return scrivito.createReactClass({
+        render: function render() {
+          return componentSpec(this.props);
+        }
+      });
+    }
+
+    return scrivito.createReactClass(componentSpec);
+  }
+
+  function provideComponent(appClass, componentSpec) {
+    if (componentSpec.propTypes) {
+      throw new scrivito.ArgumentError('Custom props is not allowed when providing a component.');
+    }
+
+    var componentClass = createComponentForAppClass(appClass, componentSpec);
+    scrivito.componentRegistry.provideComponentClass(appClass, componentClass);
+  }
+
+  function createComponentForAppClass(appClass, componentSpec) {
+    var Obj = scrivito.currentRealm().Obj;
+    var Widget = scrivito.currentRealm().Widget;
+
+    var propName = undefined;
+    var propType = undefined;
+
+    if (appClass.prototype instanceof Obj) {
+      propName = 'page';
+      propType = Obj;
+    } else if (appClass.prototype instanceof Widget) {
+      propName = 'widget';
+      propType = Widget;
+    } else {
+      throw new scrivito.ArgumentError(appClass + ' is not a valid application class.');
+    }
+
+    var propTypes = _defineProperty({}, propName, React.PropTypes.instanceOf(propType).isRequired);
+
+    if (typeof componentSpec === 'function') {
+      return scrivito.createReactClass({
+        propTypes: propTypes,
+
+        render: function render() {
+          return componentSpec(this.props[propName]);
+        }
+      });
+    }
+
+    return scrivito.createReactClass(_.extend(componentSpec, { propTypes: propTypes }));
+  }
+
+  scrivito.createComponent = createComponent;
+  scrivito.provideComponent = provideComponent;
 })();