brew-js-react 0.1.3 → 0.1.6

package/dist/brew-js-react.js

@@ -170,6 +170,7 @@ __webpack_require__.d(src_namespaceObject, {
   "useFocusStateMixin": () => (useFocusStateMixin),
   "useLanguage": () => (useLanguage),
   "useLoadingStateMixin": () => (useLoadingStateMixin),
+  "useMixin": () => (useMixin),
   "useMixinRef": () => (useMixinRef),
   "useRouteParam": () => (useRouteParam),
   "useScrollableMixin": () => (useScrollableMixin)
@@ -182,6 +183,7 @@ var external_commonjs_brew_js_commonjs2_brew_js_amd_brew_js_root_brew_ = __webpa
 var _defaultExport = external_commonjs_brew_js_commonjs2_brew_js_amd_brew_js_root_brew_;
 /* harmony default export */ const app = (_defaultExport);
 var install = external_commonjs_brew_js_commonjs2_brew_js_amd_brew_js_root_brew_.install,
+    addExtension = external_commonjs_brew_js_commonjs2_brew_js_amd_brew_js_root_brew_.addExtension,
     addDetect = external_commonjs_brew_js_commonjs2_brew_js_amd_brew_js_root_brew_.addDetect;
 
 ;// CONCATENATED MODULE: ./src/include/brew-js/app.js
@@ -327,6 +329,7 @@ var _lib$dom = external_commonjs_zeta_dom_commonjs2_zeta_dom_amd_zeta_dom_root_z
     focusable = _lib$dom.focusable,
     focused = _lib$dom.focused,
     setModal = _lib$dom.setModal,
+    releaseModal = _lib$dom.releaseModal,
     retainFocus = _lib$dom.retainFocus,
     releaseFocus = _lib$dom.releaseFocus,
     dom_focus = _lib$dom.focus;
@@ -505,6 +508,23 @@ if (toPrimitive) {
   };
 }
 
+function createCallback(translate) {
+  var callback = function callback(key, data) {
+    return translate(key, data, true);
+  };
+
+  return extend(callback, {
+    html: function html(id, data) {
+      return {
+        __html: translate(id, data)
+      };
+    },
+    lazy: function lazy(id, data) {
+      return new TString(translate.bind(0, id, data, true));
+    }
+  });
+}
+
 function useLanguage() {
   return (0,external_zeta_dom_react_.useObservableProperty)(app_app, 'language');
 }
@@ -512,28 +532,22 @@ function makeTranslation(resources, defaultLang) {
   var re = new RegExp('^(' + Object.keys(resources[defaultLang]).join('|') + ')\\.');
   var cache = {};
 
-  function getTranslation(prefix, name, data) {
+  function getTranslation(prefix, name, data, noEncode) {
     var str = ((resources[app_app.language] || empty)[prefix] || empty)[name] || ((resources[defaultLang] || empty)[prefix] || empty)[name] || '';
-    return str && data !== undefined ? waterpipe(str, data) : str;
-  }
 
-  function createCallback(translate) {
-    return extend(translate, {
-      html: function html(id, data) {
-        return {
-          __html: translate(id, data)
-        };
-      },
-      lazy: function lazy(id, data) {
-        return new TString(this.bind(0, id, data));
-      }
-    });
+    if (str && (!noEncode || data !== undefined)) {
+      return waterpipe(str, data, {
+        noEncode: noEncode
+      });
+    }
+
+    return str;
   }
 
-  function translate(key, data) {
+  function translate(key, data, noEncode) {
     var prefix = re.test(key) ? RegExp.$1 : '';
     var name = prefix ? key.slice(RegExp.lastMatch.length) : key;
-    return getTranslation(prefix, name, data) || key;
+    return getTranslation(prefix, name, data, noEncode) || key;
   }
 
   function useTranslation() {
@@ -543,9 +557,9 @@ function makeTranslation(resources, defaultLang) {
 
     if (prefix[0]) {
       var key = prefix.join(' ');
-      t = cache[key] || (cache[key] = createCallback(function (key, data) {
+      t = cache[key] || (cache[key] = createCallback(function (key, data, noEncode) {
         return single(prefix, function (v) {
-          return getTranslation(v, key, data);
+          return getTranslation(v, key, data, noEncode);
         }) || key;
       }));
     }
@@ -640,6 +654,8 @@ util_define(Mixin, {
 
 
 
+var _ = createPrivateStore();
+
 function MixinRefImpl(mixin) {
   this.mixin = mixin;
 }
@@ -651,29 +667,34 @@ definePrototype(MixinRefImpl, {
 });
 function StatefulMixin() {
   Mixin.call(this);
-  this.states = {};
-  this.prefix = '';
-  this.counter = 0;
+
+  _(this, {
+    states: {},
+    prefix: '',
+    counter: 0
+  });
 }
 definePrototype(StatefulMixin, Mixin, {
   get ref() {
-    var state = this.state;
-    this.next();
-    return state.ref || (state.ref = new MixinRefImpl(this.clone()));
+    var self = this;
+    var state = self.state;
+    self.next();
+    return state.ref || (state.ref = new MixinRefImpl(self.clone()));
   },
 
   get state() {
-    var self = this;
-    var key = self.prefix + self.counter;
-    return self.states[key] || (self.states[key] = self.initState());
+    var obj = _(this);
+
+    var key = obj.prefix + obj.counter;
+    return obj.states[key] || (obj.states[key] = this.initState());
   },
 
   reset: function reset() {
-    this.counter = 0;
+    _(this).counter = 0;
     return this;
   },
   next: function next() {
-    this.counter++;
+    _(this).counter++;
     return this;
   },
   getRef: function getRef() {
@@ -687,7 +708,7 @@ definePrototype(StatefulMixin, Mixin, {
     };
   },
   elements: function elements() {
-    return values(this.states).map(function (v) {
+    return values(_(this).states).map(function (v) {
       return v.element;
     }).filter(function (v) {
       return v;
@@ -700,11 +721,15 @@ definePrototype(StatefulMixin, Mixin, {
   },
   initElement: function initElement(element, state) {},
   clone: function clone() {
-    return inherit(Object.getPrototypeOf(this), {
-      states: this.states,
+    var clone = inherit(Object.getPrototypeOf(this));
+
+    _(clone, {
+      states: _(this).states,
       prefix: randomId() + '.',
       counter: 0
     });
+
+    return clone;
   }
 });
 ;// CONCATENATED MODULE: ./src/mixins/ClassNameMixin.js
@@ -757,23 +782,26 @@ function AnimateMixin() {
 }
 definePrototype(AnimateMixin, ClassNameMixin, {
   next: function next() {
-    this.effects = undefined;
-    this.trigger = undefined;
-    return AnimateMixinSuper.next.call(this);
+    var self = this;
+    self.effects = undefined;
+    self.trigger = undefined;
+    return AnimateMixinSuper.next.call(self);
   },
   "with": function _with(props) {
-    this.effects = props.effects;
-    this.trigger = props.trigger;
-    return this;
+    var self = this;
+    self.effects = props.effects;
+    self.trigger = props.trigger;
+    return self;
   },
   withEffects: function withEffects() {
     this.effects = makeArray(arguments);
     return this;
   },
   getCustomAttributes: function getCustomAttributes() {
-    return extend({}, AnimateMixinSuper.getCustomAttributes.call(this), {
-      'animate-in': (this.effects || []).join(' '),
-      'animate-on': this.trigger || 'show'
+    var self = this;
+    return extend({}, AnimateMixinSuper.getCustomAttributes.call(self), {
+      'animate-in': (self.effects || []).join(' '),
+      'animate-on': self.trigger || 'show'
     });
   }
 });
@@ -797,9 +825,10 @@ definePrototype(AnimateSequenceItemMixin, ClassNameMixin, {
 var AnimateSequenceMixinSuper = AnimateMixin.prototype;
 var animateSequenceMixinCounter = 0;
 function AnimateSequenceMixin() {
-  AnimateMixin.call(this);
-  this.className = 'brew-anim-' + ++animateSequenceMixinCounter;
-  this.item = new AnimateSequenceItemMixin(this.className);
+  var self = this;
+  AnimateMixin.call(self);
+  self.className = 'brew-anim-' + ++animateSequenceMixinCounter;
+  self.item = new AnimateSequenceItemMixin(self.className);
 }
 definePrototype(AnimateSequenceMixin, AnimateMixin, {
   reset: function reset() {
@@ -872,12 +901,33 @@ definePrototype(ErrorHandlerMixin, StatefulMixin, {
 
 var FlyoutMixinSuper = ClassNameMixin.prototype;
 var flyoutMixinCounter = 0;
+
+function FlyoutToggleMixin(mixin) {
+  ClassNameMixin.call(this, ['target-opened']);
+  this.flyoutMixin = mixin;
+}
+
+definePrototype(FlyoutToggleMixin, ClassNameMixin, {
+  getCustomAttributes: function getCustomAttributes() {
+    var element = this.flyoutMixin.elements()[0];
+    return extend({}, FlyoutMixinSuper.getCustomAttributes.call(this), {
+      'toggle': element && '#' + element.id
+    });
+  },
+  clone: function clone() {
+    return extend(FlyoutMixinSuper.clone.call(this), {
+      flyoutMixin: this.flyoutMixin
+    });
+  }
+});
 function FlyoutMixin() {
-  ClassNameMixin.call(this, ['open', 'closing', 'tweening-in', 'tweening-out']);
-  this.isFlyoutOpened = false;
-  this.animating = false;
-  this.visible = false;
-  this.toggle = new ClassNameMixin(['target-opened']);
+  var self = this;
+  ClassNameMixin.call(self, ['open', 'closing', 'tweening-in', 'tweening-out']);
+  self.modal = false;
+  self.isFlyoutOpened = false;
+  self.animating = false;
+  self.visible = false;
+  self.toggle = new FlyoutToggleMixin(self);
 }
 definePrototype(FlyoutMixin, ClassNameMixin, {
   reset: function reset() {
@@ -893,11 +943,14 @@ definePrototype(FlyoutMixin, ClassNameMixin, {
     return this;
   },
   getCustomAttributes: function getCustomAttributes() {
-    return extend({}, FlyoutMixinSuper.getCustomAttributes.call(this), {
+    var self = this;
+    return extend({}, FlyoutMixinSuper.getCustomAttributes.call(self), {
       'is-flyout': ''
-    }, this.effects && {
+    }, self.modal && {
+      'is-modal': ''
+    }, self.effects && {
       'animate-on': 'open',
-      'animate-in': this.effects.join(' '),
+      'animate-in': self.effects.join(' '),
       'animate-out': ''
     });
   },
@@ -937,10 +990,12 @@ definePrototype(FlyoutMixin, ClassNameMixin, {
     });
   },
   clone: function clone() {
-    var mixin = extend(FlyoutMixinSuper.clone.call(this), {
-      toggle: this.toggle.ref.getMixin()
+    var self = this;
+    var mixin = extend(FlyoutMixinSuper.clone.call(self), {
+      toggle: self.toggle.ref.getMixin()
     });
-    defineAliasProperty(mixin, 'isFlyoutOpened', this);
+    defineAliasProperty(mixin, 'isFlyoutOpened', self);
+    defineAliasProperty(mixin, 'modal', self);
     return mixin;
   },
   onClassNameUpdated: function onClassNameUpdated(element, prevState, state) {
@@ -1033,9 +1088,10 @@ definePrototype(LoadingStateMixin, StatefulMixin, {
 
 var ScrollableMixinSuper = ClassNameMixin.prototype;
 function ScrollableMixin() {
-  ClassNameMixin.call(this, ['scrollable-x', 'scrollable-x-l', 'scrollable-x-r', 'scrollable-y', 'scrollable-y-d', 'scrollable-y-u']);
-  this.target = Mixin.scrollableTarget;
-  this.pageIndex = 0;
+  var self = this;
+  ClassNameMixin.call(self, ['scrollable-x', 'scrollable-x-l', 'scrollable-x-r', 'scrollable-y', 'scrollable-y-d', 'scrollable-y-u']);
+  self.target = Mixin.scrollableTarget;
+  self.pageIndex = 0;
 }
 definePrototype(ScrollableMixin, ClassNameMixin, {
   withOptions: function withOptions(options) {
@@ -1086,11 +1142,16 @@ definePrototype(ScrollableMixin, ClassNameMixin, {
 
 
 
+
+function extendSelf(options) {
+  extend(this, options);
+}
+
 function createUseFunction(ctor) {
   return function () {
-    return (0,external_commonjs_react_commonjs2_react_amd_react_root_React_.useState)(function () {
-      return new ctor();
-    })[0].reset();
+    var mixin = useMixin(ctor);
+    (mixin.withOptions || extendSelf).apply(mixin, arguments);
+    return mixin;
   };
 }
 
@@ -1100,11 +1161,14 @@ var useErrorHandlerMixin = createUseFunction(ErrorHandlerMixin);
 var useFlyoutMixin = createUseFunction(FlyoutMixin);
 var useFocusStateMixin = createUseFunction(FocusStateMixin);
 var useLoadingStateMixin = createUseFunction(LoadingStateMixin);
-function useScrollableMixin(options) {
-  return createUseFunction(ScrollableMixin)().withOptions(options);
+var useScrollableMixin = createUseFunction(ScrollableMixin);
+function useMixin(ctor) {
+  return (0,external_commonjs_react_commonjs2_react_amd_react_root_React_.useState)(function () {
+    return new ctor();
+  })[0].reset();
 }
 function useMixinRef(mixin) {
-  return mixin.getMixin().reset();
+  return mixin && mixin.getMixin().reset();
 }
 
 ;// CONCATENATED MODULE: ./tmp/brew-js/anim.js